fmu-manipulation-toolbox 1.9.2b4__tar.gz → 1.9.2rc2__tar.gz

{fmu_manipulation_toolbox-1.9.2b4 → fmu_manipulation_toolbox-1.9.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9.2b4
+Version: 1.9.2rc2
 Summary: FMU Manipulation Toolbox is a python package which helps to analyze, modify or combine Functional Mock-up Units (FMUs) without recompilation.
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

fmu_manipulation_toolbox-1.9.2rc2/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.9.2rc2'

{fmu_manipulation_toolbox-1.9.2b4 → fmu_manipulation_toolbox-1.9.2rc2}/fmu_manipulation_toolbox/cli/datalog2pcap.py

@@ -15,6 +15,20 @@ class DatalogConverter:
     def __init__(self, cvs_filename: Union[Path, str]):
         self.csv_filename = Path(cvs_filename)
         self.pcap_filename = self.csv_filename.with_suffix(".pcap")
+        self.opcode_name = {
+            "CAN": {
+            0x0001: "FMI3_LS_BUS_OP_FORMAT_ERROR",
+            0x0010: "FMI3_LS_BUS_CAN_OP_CAN_TRANSMIT",
+            0x0011: "FMI3_LS_BUS_CAN_OP_CANFD_TRANSMIT",
+            0x0012: "FMI3_LS_BUS_CAN_OP_CANXL_TRANSMIT",
+            0x0020: "FMI3_LS_BUS_CAN_OP_CONFIRM",
+            0x0030: "FMI3_LS_BUS_CAN_OP_ARBITRATION_LOST",
+            0x0031: "FMI3_LS_BUS_CAN_OP_BUS_ERROR",
+            0x0040: "FMI3_LS_BUS_CAN_OP_CONFIGURATION",
+            0x0041: "FMI3_LS_BUS_CAN_OP_STATUS",
+            0x0042: "FMI3_LS_BUS_CAN_OP_WAKEUP"
+            }
+        }
 
     def open_pcap(self):
         logger.info(f"Creating PCAP file '{self.pcap_filename}'...")
@@ -31,7 +45,10 @@ class DatalogConverter:
                                                                   # captured from each packet.
 
         file.write(int(227).to_bytes(4, byteorder="big"))         # link type. his field is defined in the Section
-                                                                  # # 8.1 IANA registry.
+                                                                  # 8.1 IANA registry.
+                                                                  # 190: Reserved for Controller Area Network (CAN) v. 2.0B packets
+                                                                  # 210: Reserved for FlexRay automotive bus
+                                                                  # 227: CAN (Controller Area Network) frames, with a pseudo-header followed by the frame payload.
         return file
 
     def open_csv(self):
@@ -42,15 +59,21 @@ class DatalogConverter:
     def decode_hexstring(self, hex_string: bytes, time_s, time_us):
         opcode = int.from_bytes(hex_string[0:4], byteorder="little")
         length = int.from_bytes(hex_string[4:8], byteorder="little")
-        can_id = int.from_bytes(hex_string[8:12], byteorder="little")
+
         if opcode == 0x10:  # TRANSMIT
+            can_id = int.from_bytes(hex_string[8:12], byteorder="little")
             rtr = int.from_bytes(hex_string[13:14], byteorder="little")
             ide = int.from_bytes(hex_string[12:13], byteorder="little")
             data_length = int.from_bytes(hex_string[14:16], byteorder="little")
             raw_data = hex_string[16:]
 
+            raw_str = ""
+            for i, b in enumerate(raw_data):
+                raw_str += f"{i}:{b:d} "
+            logger.info(f"time={time_s}.{time_us:06d} data length {data_length} with data {raw_str}")
+
             logger.debug(f"time={time_s}.{time_us:06d} OP=0x{opcode:04X} len={length} {data_length} id={can_id}"
-                         f" ide={ide} rtr={rtr} len={data_length} {raw_data}")
+                         f" ide={ide} rtr={rtr} len={data_length} raw_len={len(raw_data)} {raw_str}")
 
             # TimeStamp
             self.pcapfile.write(time_s.to_bytes(4, byteorder="big"))
@@ -76,7 +99,14 @@ class DatalogConverter:
             self.pcapfile.write(dlc.to_bytes(1, byteorder="big"))
 
             # PAYLOAD
-            self.pcapfile.write(raw_data)
+            self.pcapfile.write(raw_data[0:data_length])
+
+        elif opcode == 0x40:
+            parameter = int.from_bytes(hex_string[8:9], byteorder="little")
+            logger.debug(f"Config parameter: {parameter}")
+            if (parameter == 1):
+                baudrate = int.from_bytes(hex_string[9:13], byteorder="little")
+                logger.debug(f"baudrate parameter: {baudrate}")
 
     def convert(self):
         with self.open_csv() as self.csvfile, self.open_pcap() as self.pcapfile:

{fmu_manipulation_toolbox-1.9.2b4 → fmu_manipulation_toolbox-1.9.2rc2}/fmu_manipulation_toolbox/container.py

@@ -196,6 +196,7 @@ class EmbeddedFMU(OperationAbstract):
         self.model_identifier = None
         self.guid = None
         self.fmi_version = None
+        self.platforms = set()
         self.ports: Dict[str, EmbeddedFMUPort] = {}
 
         self.has_event_mode = False
@@ -240,6 +241,22 @@ class EmbeddedFMU(OperationAbstract):
         port = EmbeddedFMUPort(fmu_port.fmi_type, fmu_port, fmi_version=self.fmi_version)
         self.ports[port.name] = port
 
+    def closure(self):
+        osname = {
+            "win64": "Windows",
+            "linux64": "Linux",
+            "darwin64": "Darwin",
+            "x86_64-windows": "Windows",
+            "x86_64-linux": "Linux",
+            "aarch64-darwin": "Darwin"
+        }
+        try:
+            for directory in (Path(self.fmu.tmp_directory) / "binaries").iterdir():
+                if directory.is_dir() and str(directory.stem) in osname:
+                    self.platforms.add(osname[str(directory.stem)])
+        except FileNotFoundError:
+            pass  # no binaries
+
     def __repr__(self):
         properties = f"{len(self.ports)} variables, ts={self.step_size}s"
         if len(self.terminals) > 0:
@@ -602,9 +619,13 @@ class FMUContainer:
     canHandleVariableCommunicationStepSize="true"
     canBeInstantiatedOnlyOncePerProcess="{only_once}"
     canNotUseMemoryManagementFunctions="true"
-    canGetAndSetFMUstate="false"
-    canSerializeFMUstate="false"
-    providesDirectionalDerivative="false"
+    canGetAndSetFMUState="false"
+    canSerializeFMUState="false"
+    providesDirectionalDerivatives="false"
+    providesAdjointDerivatives="false"
+    providesPerElementDependencies="false"
+    providesEvaluateDiscreteStates="false"
+    hasEventMode="true"
     needsExecutionTool="{execution_tool}">
   </CoSimulation>
 
@@ -1214,7 +1235,20 @@ class FMUContainer:
         logger.debug(f"Copying {origin} in {destination}")
         shutil.copy(origin, destination)
 
-    def get_bindir_and_suffixe(self) -> Tuple[str, str, str]:
+    def get_bindir_and_suffixe(self) -> Generator[Tuple[str, str, str], Any, None]:
+        fmu_iter = iter(self.involved_fmu.values())
+        try:
+            fmu = next(fmu_iter)
+        except StopIteration:
+            raise FMUContainerError("No fmu declared in this container.")
+
+        os_list = fmu.platforms
+        logger.debug(f"FMU '{fmu.name}' OS support: {', '.join(fmu.platforms)}.")
+
+        for fmu in fmu_iter:
+            logger.debug(f"FMU '{fmu.name}' OS support: {', '.join(fmu.platforms)}.")
+            os_list &= fmu.platforms
+
         suffixes = {
             "Windows": "dll",
             "Linux": "so",
@@ -1236,11 +1270,16 @@ class FMUContainer:
         else:
             target_bindirs = origin_bindirs
 
-        os_name = platform.system()
-        try:
-            return origin_bindirs[os_name], suffixes[os_name], target_bindirs[os_name]
-        except KeyError:
-            raise FMUContainerError(f"OS '{os_name}' is not supported.")
+        if os_list:
+            logger.info(f"Container will be built for {', '.join(os_list)}.")
+        else:
+            logger.critical("No common OS found for embedded FMU. Try to re-run with '-debug'. Container won't be runnable.")
+
+        for os_name in os_list:
+            try:
+                yield origin_bindirs[os_name], suffixes[os_name], target_bindirs[os_name]
+            except KeyError:
+                raise FMUContainerError(f"OS '{os_name}' is not supported.")
 
     def make_fmu_skeleton(self, base_directory: Path) -> Path:
         logger.debug(f"Initialize directory '{base_directory}'")
@@ -1260,14 +1299,14 @@ class FMUContainer:
 
         self.copyfile(origin / "model.png", base_directory)
 
-        origin_bindir, suffixe, target_bindir = self.get_bindir_and_suffixe()
-
-        library_filename = origin / origin_bindir / f"container.{suffixe}"
-        if not library_filename.is_file():
-            raise FMUContainerError(f"File {library_filename} not found")
-        binary_directory = binaries_directory / target_bindir
-        binary_directory.mkdir(exist_ok=True)
-        self.copyfile(library_filename, binary_directory / f"{self.identifier}.{suffixe}")
+        for origin_bindir, suffixe, target_bindir in self.get_bindir_and_suffixe():
+            library_filename = origin / origin_bindir / f"container.{suffixe}"
+            if library_filename.is_file():
+                binary_directory = binaries_directory / target_bindir
+                binary_directory.mkdir(exist_ok=True)
+                self.copyfile(library_filename, binary_directory / f"{self.identifier}.{suffixe}")
+            else:
+                logger.critical(f"File {library_filename} not found.")
 
         for i, fmu in enumerate(self.involved_fmu.values()):
             shutil.copytree(self.long_path(fmu.fmu.tmp_directory),