158 lines
6.7 KiB
Python
158 lines
6.7 KiB
Python
# Copyright 2024 Volvo Car Corporation
|
|
# Licensed under Apache 2.0.
|
|
|
|
"""Module for generation of c- and a2l-file with dummy signal declarations."""
|
|
|
|
import powertrain_build.build_defs as bd
|
|
|
|
from powertrain_build.types import byte_size_string, get_bitmask
|
|
from powertrain_build.a2l import A2l
|
|
from powertrain_build.problem_logger import ProblemLogger
|
|
|
|
|
|
class DummyVar(ProblemLogger):
|
|
"""Generate c- and a2l-files which declares all missing variables in the interfaces.
|
|
|
|
TODO: Please remove this file! Only used while testing.
|
|
"""
|
|
|
|
def __init__(self, unit_cfg, ext_dict, res_dict, prj_cfg, user_defined_types):
|
|
"""Initialize instance of class."""
|
|
super().__init__()
|
|
self._unit_cfg = unit_cfg
|
|
self._unit_vars = unit_cfg.get_per_cfg_unit_cfg()
|
|
self._ext_dict = ext_dict
|
|
self._res_dict = res_dict
|
|
self._ext_vars = {}
|
|
self._int_vars = {}
|
|
self._prj_cfg = prj_cfg
|
|
self._enumerations = user_defined_types.get_enumerations()
|
|
self._common_header_files = user_defined_types.common_header_files
|
|
|
|
def _get_byte_size_string(self, data_type):
|
|
"""Get byte size of a data type as string.
|
|
Enumeration byte sizes are derived from the underlying data type.
|
|
|
|
Args:
|
|
data_type (str): Data type.
|
|
Returns:
|
|
byte_size_string(powertrain_build.types.byte_size_string): Return result of
|
|
powertrain_build.types.byte_size_string.
|
|
"""
|
|
if data_type in self._enumerations:
|
|
return byte_size_string(self._enumerations[data_type]["underlying_data_type"])
|
|
return byte_size_string(data_type)
|
|
|
|
def _restruct_input_data(self):
|
|
"""Restructure all the input variables per data-type.
|
|
|
|
This will be used for declaring the variables and generating the
|
|
A2L-file
|
|
"""
|
|
ext_out = {
|
|
var: data
|
|
for ioclass, vardict in self._ext_dict.items()
|
|
if ioclass.endswith("-Output")
|
|
for var, data in vardict.items()
|
|
}
|
|
ext_ = {}
|
|
for var in self._res_dict["sigs"]["ext"]["missing"]:
|
|
self.debug("ext: %s", var)
|
|
if var in ext_out:
|
|
data = ext_out[var]
|
|
self.debug("ext_data: %s", data)
|
|
ext_[var] = data
|
|
int_ = {}
|
|
for unit in self._res_dict["sigs"]["int"]:
|
|
for var in self._res_dict["sigs"]["int"][unit]["missing"]:
|
|
if var not in ext_ and var in self._unit_vars["inports"]:
|
|
data = self._unit_vars["inports"][var][unit]
|
|
int_[var] = data
|
|
for var, data in int_.items():
|
|
data_type_size = self._get_byte_size_string(data["type"])
|
|
self._int_vars.setdefault(data_type_size, {})[var] = data
|
|
for var, data in ext_.items():
|
|
data_type_size = self._get_byte_size_string(data["type"])
|
|
self._ext_vars.setdefault(data_type_size, {})[var] = data
|
|
|
|
def _a2l_dict(self):
|
|
"""Return a dict defining all parameters for a2l-generation."""
|
|
res = {"vars": {}, "function": "VcDummy"}
|
|
for inp in [self._ext_vars]:
|
|
for sizes in inp.values():
|
|
for var, data in sizes.items():
|
|
if data["type"] in self._enumerations:
|
|
data_type = self._enumerations[data["type"]]["underlying_data_type"]
|
|
else:
|
|
data_type = data["type"]
|
|
|
|
resv = res["vars"]
|
|
resv.setdefault(var, {})["a2l_data"] = {
|
|
"bitmask": get_bitmask(data_type),
|
|
"description": data.get("description", ""),
|
|
"lsb": "2^0",
|
|
"max": data.get("max"),
|
|
"min": data.get("min"),
|
|
"offset": "0",
|
|
"unit": data["unit"],
|
|
"x_axis": None,
|
|
"y_axis": None,
|
|
}
|
|
resv[var]["array"] = []
|
|
resv[var]["function"] = ["VcEc"]
|
|
resv[var]["var"] = {"cvc_type": "CVC_DISP", "type": data_type, "var": var}
|
|
return res
|
|
|
|
@classmethod
|
|
def _generate_var_defs(cls, fh_c, vars, enums, comment):
|
|
"""Generate the variable definitions."""
|
|
fh_c.write(f"\n{comment}\n\n")
|
|
for varsize in sorted(vars.keys(), reverse=True):
|
|
fh_c.write(f"/* Variables of size {varsize} bytes */\n\n")
|
|
var_defs = vars[varsize]
|
|
for var in sorted(var_defs.keys()):
|
|
data = var_defs[var]
|
|
if data["type"] in enums:
|
|
if enums[data["type"]]["default_value"] is not None:
|
|
init_value = enums[data["type"]]["default_value"]
|
|
else:
|
|
cls.warning('Initializing enumeration %s to "zero".', data["type"])
|
|
init_value = [k for k, v in enums[data["type"]]["members"].items() if v == 0][0]
|
|
fh_c.write(f"{data['type']} {var} = {init_value};\n")
|
|
else:
|
|
fh_c.write(f"{data['type']} {var} = {0};\n")
|
|
fh_c.write("\n")
|
|
|
|
@classmethod
|
|
def _generate_var_initialization(cls, fh_c, vars, comment):
|
|
"""Generate the variable initializations."""
|
|
fh_c.write(f"\n{comment}\n\n")
|
|
fh_c.write("\nvoid RESTART_VcDummy(void)\n{\n")
|
|
for varsize in sorted(vars.keys(), reverse=True):
|
|
var_defs = vars[varsize]
|
|
for var in sorted(var_defs.keys()):
|
|
fh_c.write(f" {var} = {0};\n")
|
|
fh_c.write("}\n")
|
|
|
|
def _generate_c_file(self, filename):
|
|
"""Generate the c-file defining all missing input variables."""
|
|
general_includes = ""
|
|
general_includes += self._unit_cfg.base_types_headers
|
|
for common_header_file in self._common_header_files:
|
|
general_includes += f'#include "{common_header_file}"\n'
|
|
general_includes += "\n"
|
|
|
|
with open(filename, "w", encoding="utf-8") as fh_c:
|
|
fh_c.write(general_includes)
|
|
fh_c.write(f'#include "{bd.CVC_DISP_START}"\n\n')
|
|
self._generate_var_defs(fh_c, self._ext_vars, self._enumerations, "/** Missing external signals **/")
|
|
fh_c.write(f'\n#include "{bd.CVC_DISP_END}"\n')
|
|
self.info("Generated %s", filename)
|
|
|
|
def generate_file(self, filename):
|
|
"""Generate the files for defining all missing input variables."""
|
|
self._restruct_input_data()
|
|
self._generate_c_file(filename + ".c")
|
|
a2l_dict = self._a2l_dict()
|
|
A2l(a2l_dict, self._prj_cfg).gen_a2l(filename + ".a2l")
|