powertrain-build 1.13.1__py3-none-any.whl → 1.13.3.dev3__py3-none-any.whl

powertrain_build/dummy.py

@@ -1,157 +1,157 @@
-# 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")
+# 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")