Zultron/2022 09 19 rebase for PRs: 8 refactor init+hal pin handling

hw_device_mgr/cia_301/command.py

@@ -25,7 +25,9 @@ def scan_bus(self, bus=0):
         """Scan bus, returning list of addresses and IDs for each device."""
 
     @abc.abstractmethod
-    def upload(self, address=None, index=None, subindex=0, datatype=None):
+    def upload(
+        self, address=None, index=None, subindex=0, datatype=None, **kwargs
+    ):
         """Upload a value from a device SDO."""
 
     @abc.abstractmethod
@@ -36,6 +38,7 @@ def download(
         subindex=0,
         value=None,
         datatype=None,
+        **kwargs,
     ):
         """Download a value to a device SDO."""
 

hw_device_mgr/cia_301/config.py

@@ -1,6 +1,8 @@
 from .data_types import CiA301DataType
-from .command import CiA301Command, CiA301SimCommand
+from .command import CiA301Command, CiA301SimCommand, CiA301CommandException
 from .sdo import CiA301SDO
+from ..logging import Logging
+from functools import cached_property
 
 
 class CiA301Config:
@@ -26,13 +28,18 @@ class CiA301Config:
     command_class = CiA301Command
     sdo_class = CiA301SDO
 
+    init_params_nv = True
+
+    logger = Logging(__name__)
+
     # Mapping of model_id to a dict of (index, subindex) to SDO object
     _model_sdos = dict()
+    # Mapping of model_id to a dict of (index, subindex) to DC object
+    _model_dcs = dict()
 
     def __init__(self, address=None, model_id=None):
         self.address = address
         self.model_id = self.format_model_id(model_id)
-        self._config = None
 
     @classmethod
     def format_model_id(cls, model_id):
@@ -98,48 +105,81 @@ def sdo_ix(cls, ix):
         ix = (dtc.uint16(ix[0]), dtc.uint8(ix[1]))
         return ix
 
+    @cached_property
+    def sdos(self):
+        assert self.model_id in self._model_sdos
+        return self._model_sdos[self.model_id].values()
+
     def sdo(self, ix):
         if isinstance(ix, self.sdo_class):
             return ix
         ix = self.sdo_ix(ix)
         return self._model_sdos[self.model_id][ix]
 
+    @classmethod
+    def add_device_dcs(cls, dcs_data):
+        """Add device model distributed clock descriptions."""
+        for model_id, dcs in dcs_data.items():
+            assert isinstance(dcs, list)
+            cls._model_dcs[model_id] = dcs
+        assert None not in cls._model_dcs
+
+    def dcs(self):
+        """Get list of distributed clocks for this device."""
+        return self._model_dcs[self.model_id]
+
+    def dump_param_values(self):
+        res = dict()
+        for sdo in self.sdos:
+            try:
+                res[sdo] = self.upload(sdo, stderr_to_devnull=True)
+            except CiA301CommandException as e:
+                # Objects may not exist, like variable length PDO mappings
+                self.logger.debug(f"Upload {sdo} failed:  {e}")
+                pass
+        return res
+
     #
     # Param read/write
     #
 
-    def upload(self, sdo):
+    def upload(self, sdo, **kwargs):
         # Get SDO object
         sdo = self.sdo(sdo)
         res_raw = self.command().upload(
             address=self.address,
             index=sdo.index,
             subindex=sdo.subindex,
             datatype=sdo.data_type,
+            **kwargs,
         )
         return sdo.data_type(res_raw)
 
-    def download(self, sdo, val, dry_run=False):
+    def download(self, sdo, val, dry_run=False, force=False, **kwargs):
         # Get SDO object
         sdo = self.sdo(sdo)
-        # Check before setting value to avoid unnecessary NVRAM writes
-        res_raw = self.command().upload(
-            address=self.address,
-            index=sdo.index,
-            subindex=sdo.subindex,
-            datatype=sdo.data_type,
-        )
-        if sdo.data_type(res_raw) == val:
-            return  # SDO value already correct
+        if not force:
+            # Check before setting value to avoid unnecessary NVRAM writes
+            res_raw = self.command().upload(
+                address=self.address,
+                index=sdo.index,
+                subindex=sdo.subindex,
+                datatype=sdo.data_type,
+                **kwargs,
+            )
+            if sdo.data_type(res_raw) == val:
+                return  # SDO value already correct
         if dry_run:
             self.logger.info(f"Dry run:  download {val} to {sdo}")
             return
+        self.logger.info(f"{self} param download {sdo} = {val}")
         self.command().download(
             address=self.address,
             index=sdo.index,
             subindex=sdo.subindex,
             value=val,
             datatype=sdo.data_type,
+            **kwargs,
         )
 
     #
@@ -172,8 +212,7 @@ def set_device_config(cls, config):
           - `pdo_mapping`:  PDO mapping SM types only; `dict`:
             - `index`:  Index of PDO mapping object
             - `entries`:  Dictionary objects to be mapped;  `dict`:
-              - `index`:  Index of dictionary object
-              - `subindex`:  Subindex of dictionary object (default 0)
+              - `index`:  Index of dictionary object, e.g. "6041h" or "1A00-03h"
               - `name`:  Name, a handle for the data object
               - `bits`:  Instead of `name`, break out individual bits,
                  names specified by a `list`
@@ -187,52 +226,94 @@ def set_device_config(cls, config):
         cls._device_config.clear()
         cls._device_config.extend(config)
 
-    def munge_config(self, config_raw):
+    @classmethod
+    def munge_config(cls, config_raw, position):
+        config_cooked = config_raw.copy()
+        # Convert model ID ints
+        model_id = (config_raw["vendor_id"], config_raw["product_code"])
+        model_id = cls.format_model_id(model_id)
+        config_cooked["vendor_id"], config_cooked["product_code"] = model_id
         # Flatten out param_values key
-        pv = dict()
+        config_cooked["param_values"] = dict()
         for ix, val in config_raw.get("param_values", dict()).items():
-            ix = self.sdo_class.parse_idx_str(ix)
+            ix = cls.sdo_class.parse_idx_str(ix)
             if isinstance(val, list):
-                pos_ix = config_raw["positions"].index(self.position)
+                pos_ix = config_raw["positions"].index(position)
                 val = val[pos_ix]
-            pv[ix] = val
-        dtc = self.data_type_class
-        config_raw["vendor_id"] = dtc.uint32(config_raw["vendor_id"])
-        config_raw["product_code"] = dtc.uint32(config_raw["product_code"])
-        config_cooked = dict(
-            vendor_id=config_raw["vendor_id"],
-            product_code=config_raw["product_code"],
-            param_values=pv,
-            sync_manager=config_raw.get("sync_manager", dict()),
-        )
+            config_cooked["param_values"][ix] = val
         # Return pruned config dict
         return config_cooked
 
-    @property
+    @classmethod
+    def gen_config(cls, model_id, address):
+        bus, position = address
+        # Find matching config
+        for conf in cls._device_config:
+            if "vendor_id" not in conf:
+                continue  # In tests only
+            if model_id != (conf["vendor_id"], conf["product_code"]):
+                continue
+            if bus != conf["bus"]:
+                continue
+            if position not in conf["positions"]:
+                continue
+            break
+        else:
+            raise KeyError(f"No config for device at {address}")
+        # Prune & return config
+        return cls.munge_config(conf, position)
+
+    @cached_property
     def config(self):
-        if self._config is None:
-            # Find matching config
-            for conf in self._device_config:
-                if "vendor_id" not in conf:
-                    continue  # In tests only
-                if self.model_id != (conf["vendor_id"], conf["product_code"]):
-                    continue
-                if self.bus != conf["bus"]:
-                    continue
-                if self.position not in conf["positions"]:
-                    continue
-                break
-            else:
-                raise KeyError(f"No config for device at {self.address}")
-            # Prune & cache config
-            self._config = self.munge_config(conf)
-
-        # Return cached config
-        return self._config
-
-    def write_config_param_values(self):
+        return self.gen_config(self.model_id, self.address)
+
+    def get_device_params_nv(self):
+        """
+        Return whether device is in non-volatile params mode.
+
+        Drives with parameter volatile/non-volatile mode must overload
+        this.
+        """
+        return False
+
+    def set_device_params_nv(self, nv=True, dry_run=False):
+        """
+        Set device params to non-volatile/volatile mode.
+
+        Drives with parameter volatile/non-volatile mode must overload
+        this.
+        """
+        pass
+
+    def initialize_params(self, dry_run=False):
+        if self.init_params_nv:
+            # To save NVRAM wear, don't write if all params are correct
+            all_correct = True
+            for sdo, value in self.config["param_values"].items():
+                if self.upload(sdo) != value:
+                    all_correct = False
+                    break
+            if all_correct:
+                self.logger.info(f"{self} param values already correct")
+                return
+            # Save current NV mode setting & set NV mode
+            self._old_device_params_nv = self.get_device_params_nv()
+            self.logger.info(f"{self} setting device params in NV mode)")
+            self.set_device_params_nv(dry_run=dry_run)
+        else:
+            self.logger.info(f"{self} setting device params in volatile mode)")
+
+        # Something needs changing
         for sdo, value in self.config["param_values"].items():
-            self.download(sdo, value)
+            self.download(sdo, value, dry_run=dry_run, force=True)
+
+        if self.init_params_nv and not self._old_device_params_nv:
+            self.logger.info(
+                f"{self} returning device params to volatile mode)"
+            )
+            self.set_device_params_nv(
+                nv=self._old_device_params_nv, dry_run=dry_run
+            )
 
     #
     # Scan bus device config factory

hw_device_mgr/cia_301/device.py

@@ -1,6 +1,7 @@
 from ..device import Device, SimDevice
 from .config import CiA301Config, CiA301SimConfig
 from .data_types import CiA301DataType
+from functools import cached_property, lru_cache
 
 
 class CiA301Device(Device):
@@ -19,6 +20,9 @@ class CiA301Device(Device):
     feedback_in_data_types = dict(online="bit", oper="bit")
     feedback_in_defaults = dict(online=False, oper=False)
 
+    feedback_out_data_types = feedback_in_data_types
+    feedback_out_defaults = feedback_in_defaults
+
     def __init__(self, address=None, **kwargs):
         if isinstance(address, self.config_class):
             self.config = address
@@ -30,6 +34,7 @@ def __init__(self, address=None, **kwargs):
         super().__init__(address=address, **kwargs)
 
     @classmethod
+    @lru_cache
     def device_model_id(cls):
         """
         Return unique device model identifier.
@@ -40,7 +45,7 @@ def device_model_id(cls):
         model_id = cls.vendor_id, cls.product_code
         return cls.config_class.format_model_id(model_id)
 
-    @property
+    @cached_property
     def model_id(self):
         return self.device_model_id()
 
@@ -49,8 +54,9 @@ def set_device_config(cls, device_config):
         assert device_config
         cls.config_class.set_device_config(device_config)
 
-    def write_config_param_values(self):
-        self.config.write_config_param_values()
+    def init(self, **kwargs):
+        super().init(**kwargs)
+        self.config.initialize_params()
 
     def get_feedback(self):
         fb_out = super().get_feedback()
@@ -80,8 +86,8 @@ def log_operational_changes(self):
     def munge_sdo_data(cls, sdo_data):
         # Turn per-model name SDO data from YAML into per-model_id SDO data
         res = dict()
-        for model_name, sd in sdo_data.items():
-            device_cls = cls.get_model_by_name(model_name)
+        for model_id, sd in sdo_data.items():
+            device_cls = cls.get_model(model_id)
             model_id = device_cls.device_model_id()
             res[model_id] = sd
         assert res
@@ -98,6 +104,16 @@ def add_device_sdos(cls, sdo_data):
         """
         cls.config_class.add_device_sdos(cls.munge_sdo_data(sdo_data))
 
+    @classmethod
+    def add_device_dcs(cls, dcs_data):
+        """
+        Configure device distributed clocks.
+
+        Pass to the `Config` class the information needed to configure
+        DCs for this `model_id`.
+        """
+        cls.config_class.add_device_dcs(dcs_data)
+
     @classmethod
     def get_device(cls, address=None, **kwargs):
         registry = cls._address_registry.setdefault(cls.name, dict())
@@ -178,10 +194,11 @@ def sim_device_data_address(cls, sim_device_data):
         return model_id
 
     @classmethod
-    def init_sim(cls, *, sim_device_data, sdo_data):
+    def init_sim(cls, *, sim_device_data, sdo_data, dcs_data):
         super().init_sim(sim_device_data=sim_device_data)
         sim_device_data = cls._sim_device_data[cls.category]
         cls.add_device_sdos(sdo_data)
+        cls.add_device_dcs(dcs_data)
         cls.config_class.init_sim(sim_device_data=sim_device_data)
 
     def set_sim_feedback(self, **kwargs):