[wip]

Author: salkinium

modm_devices/device_file.py

@@ -54,9 +54,9 @@ def get_devices(self):
         valid_devices = [node.text for node in device_node.iterfind(self._VALID_DEVICE)]
         devices = identifiers
         if len(invalid_devices):
-            devices = [did for did in devices if did.string not in invalid_devices]
+            devices = (did for did in devices if did.string not in invalid_devices)
         if len(valid_devices):
-            devices = [did for did in devices if did.string in valid_devices]
+            devices = (did for did in devices if did.string in valid_devices)
         return [build_device(did, self) for did in devices]
 
     @staticmethod
@@ -68,9 +68,10 @@ def is_valid(node, identifier: DeviceIdentifier):
         Returns:
             True if the selectors match, False otherwise.
         """
-        device_keys = filter(lambda k: k.startswith(DeviceFile._PREFIX_ATTRIBUTE_DEVICE), node.attrib.keys())
-        properties = {k.replace(DeviceFile._PREFIX_ATTRIBUTE_DEVICE, ''):node.attrib[k].split("|") for k in device_keys}
-        return not any(identifier[key] not in value for key, value in properties.items())
+        device_keys = (k for k in node.attrib.keys() if k.startswith(DeviceFile._PREFIX_ATTRIBUTE_DEVICE))
+        properties = ((k.replace(DeviceFile._PREFIX_ATTRIBUTE_DEVICE, ''), node.attrib[k].split("|"))
+                      for k in device_keys)
+        return all(identifier[key] in value for key, value in properties)
 
     def get_properties(self, identifier: DeviceIdentifier):
         class Converter:
@@ -86,9 +87,9 @@ def is_valid(self, node):
                 return DeviceFile.is_valid(node, self.identifier)
 
             def strip_attrib(self, node):
-                stripped_keys = filter(lambda k: not k.startswith(DeviceFile._PREFIX_ATTRIBUTE_DEVICE), node.attrib.keys())
+                stripped_keys = (k for k in node.attrib.keys() if not k.startswith(DeviceFile._PREFIX_ATTRIBUTE_DEVICE))
                 if node.getparent().getparent() is None and node.tag == 'device':
-                    stripped_keys = filter(lambda k: k not in self.identifier.keys(), stripped_keys)
+                    stripped_keys = (k for k in stripped_keys if k not in self.identifier.keys())
                 return {k:node.attrib[k] for k in stripped_keys}
 
             def to_dict(self, t):
@@ -97,14 +98,13 @@ def to_dict(self, t):
                     return {}
                 attrib = self.strip_attrib(t)
                 d = {t.tag: {} if len(attrib) else None}
-                children = []
-                for c in t:
-                    if self.is_valid(c):
-                        children.append(c)
+                children = filter(self.is_valid, t)
                 if children:
                     dd = defaultdict(list)
                     for dc in map(self.to_dict, children):
+                        # print(dc)
                         for k, v in dc.items():
+                            if k == "signal" and v.get("name") == "seg40": print(v)
                             dd[k].append(v)
                     dk = {}
                     for k, v in dd.items():
@@ -120,8 +120,11 @@ def to_dict(self, t):
                 elif len(attrib):
                     if any(k in d[t.tag] for k in attrib.keys()):
                         raise ParserException("Node children are overwriting attribute '{}'!".format(k))
+                    # print(attrib.items())
                     d[t.tag].update(attrib.items())
                 return read_only({k:read_only(v) for k,v in d.items()})
 
         properties = Converter(identifier).to_dict(self.rootnode.find("device"))
+        # print(properties)
+        # exit(1)
         return properties["device"]

modm_devices/device_identifier.py

@@ -99,12 +99,14 @@ def __init__(self, objs=None):
 
         if isinstance(objs, DeviceIdentifier):
             self._ids = [objs.copy()]
-        if isinstance(objs, (list, set, tuple)):
+        elif isinstance(objs, (list, set, tuple)):
             for obj in objs:
-                if isinstance(objs, DeviceIdentifier):
-                    self._ids.append(objs)
-        if isinstance(objs, MultiDeviceIdentifier):
+                if isinstance(obj, DeviceIdentifier):
+                    self._ids.append(obj)
+        elif isinstance(objs, MultiDeviceIdentifier):
             self._ids = [dev for dev in objs.ids]
+        elif objs is not None:
+            print("No known conversion of '{}' to MultiDeviceIdentifier!".format(objs))
 
     @property
     def ids(self):
@@ -126,13 +128,14 @@ def from_list(device_ids: list):
         mid._ids = [dev for dev in device_ids]
         return mid
 
-    def append(self, did):
-        assert isinstance(did, DeviceIdentifier)
+    def append(self, *dids):
+        for did in dids:
+            assert isinstance(did, DeviceIdentifier)
 
-        self._ids.append(did)
-        self.__dirty = True
-        self.__string = None
-        self.__naming_schema = None
+            self._ids.append(did)
+            self.__dirty = True
+            self.__string = None
+            self.__naming_schema = None
 
     def extend(self, dids):
         assert isinstance(dids, (MultiDeviceIdentifier, list))
@@ -344,4 +347,4 @@ def __str__(self):
         return self.string
 
     def __repr__(self):
-        return self.string
+        return self.string

test/device_file_test.py

@@ -14,14 +14,15 @@ def setUp(self):
         if DEVICE_FILES is None:
             DEVICE_FILES = {}
             device_files = os.path.join(os.path.dirname(__file__), "../../../devices/**/*.xml")
+            device_files = os.path.join(os.path.dirname(__file__), "../../../devices/stm32/stm32l1-51_52_62-c_d_e.xml")
             device_file_names  = glob.glob(device_files)
 
             # Parse the files and build the :target enumeration
             parser = modm_devices.parser.DeviceParser()
             for device_file_name in device_file_names:
                 for device in parser.parse(device_file_name).get_devices():
                     DEVICE_FILES[device.partname] = device
-        self.devices = DEVICE_FILES
+        self.devices = {"stm32l152vdt6": DEVICE_FILES["stm32l152vdt6"]}
 
 
     def tearDown(self):
@@ -69,6 +70,7 @@ def assertIn(key, obj):
                     print("{}: duplicated signals for P{}{}: {}".format(
                             name, gpio["port"].upper(), gpio["pin"], duplicates))
                     failures += 1
+                    # print(gpio)
 
         self.assertEqual(failures, 0, "Found inconsistencies in the device files!")
 

test/device_identifier_test.py

@@ -91,11 +91,191 @@ def test_copy(self):
         self.assertEqual(ident.naming_schema, "{platform}")
 
 
+def id_from_string(string):
+    i = DeviceIdentifier("{platform}{family}{name}{pin}{size}{package}{temperature}{variant}")
+    i.set("platform", string[:5])
+    i.set("family", string[5:7])
+    i.set("name", string[7:9])
+    i.set("pin", string[9])
+    i.set("size", string[10])
+    i.set("package", string[11])
+    i.set("temperature", string[12])
+    if len(string) >= 14:
+        i.set("variant", string[13])
+    else:
+        i.set("variant", "")
+    return i
+
 
 class MultiDeviceIdentifierTest(unittest.TestCase):
 
     def setUp(self):
         self.ident = MultiDeviceIdentifier()
+        self.devices = MultiDeviceIdentifier(list(map(id_from_string, [
+            "stm32l151cct6",
+            "stm32l151cct7",
+            "stm32l151ccu6",
+            "stm32l151ccu7",
+            "stm32l151qch6",
+            "stm32l151qdh6",
+            "stm32l151qeh6",
+            "stm32l151rct6",
+            "stm32l151rct6a",
+            "stm32l151rcy6",
+            "stm32l151rdt6",
+            "stm32l151rdt7",
+            "stm32l151rdy6",
+            "stm32l151rdy7",
+            "stm32l151ret6",
+            "stm32l151ucy6",
+            "stm32l151ucy7",
+            "stm32l151vch6",
+            "stm32l151vct6",
+            "stm32l151vct6a",
+            "stm32l151vdt6",
+            "stm32l151vdt6x",
+            "stm32l151vdy6x",
+            "stm32l151vdy7x",
+            "stm32l151vet6",
+            "stm32l151vet7",
+            "stm32l151vey6",
+            "stm32l151vey7",
+            "stm32l151zct6",
+            "stm32l151zdt6",
+            "stm32l151zet6",
+            "stm32l152cct6",
+            "stm32l152ccu6",
+            "stm32l152qch6",
+            "stm32l152qdh6",
+            "stm32l152qeh6",
+            "stm32l152rct6",
+            "stm32l152rct6a",
+            "stm32l152rdt6",
+            "stm32l152rdy6",
+            "stm32l152ret6",
+            "stm32l152ucy6",
+            "stm32l152vch6",
+            "stm32l152vct6",
+            "stm32l152vct6a",
+            "stm32l152vdt6",
+            "stm32l152vdt6x",
+            "stm32l152vet6",
+            "stm32l152vey6",
+            "stm32l152zct6",
+            "stm32l152zdt6",
+            "stm32l152zet6",
+            "stm32l162qdh6",
+            "stm32l162rct6",
+            "stm32l162rct6a",
+            "stm32l162rdt6",
+            "stm32l162rdy6",
+            "stm32l162ret6",
+            "stm32l162vch6",
+            "stm32l162vct6",
+            "stm32l162vct6a",
+            "stm32l162vdt6",
+            "stm32l162vdy6x",
+            "stm32l162vet6",
+            "stm32l162vey6",
+            "stm32l162zdt6",
+            "stm32l162zet6"
+        ])))
+        self.child_devices = MultiDeviceIdentifier(list(map(id_from_string, [
+            "stm32l152qch6",
+            "stm32l152qdh6",
+            "stm32l152qeh6",
+            "stm32l152vch6",
+            "stm32l152rct6a",
+            "stm32l152rdt6",
+            "stm32l152ret6",
+            "stm32l152vct6a",
+            "stm32l152vct6",
+            "stm32l152vdt6x",
+            "stm32l152vdt6",
+            "stm32l152vet6",
+            "stm32l152zct6",
+            "stm32l152zdt6",
+            "stm32l152zet6",
+            "stm32l152rdy6",
+            "stm32l152vey6",
+            "stm32l162qdh6",
+            "stm32l162vch6",
+            "stm32l162rct6a",
+            "stm32l162rdt6",
+            "stm32l162ret6",
+            "stm32l162vct6a",
+            "stm32l162vct6",
+            "stm32l162vdt6",
+            "stm32l162vet6",
+            "stm32l162zdt6",
+            "stm32l162zet6",
+            "stm32l162rdy6",
+            "stm32l162vdy6x",
+            "stm32l162vey6",
+        ])))
+        self.parent_devices = MultiDeviceIdentifier(list(map(id_from_string, [
+            "stm32l151qch6",
+            "stm32l151qdh6",
+            "stm32l151qeh6",
+            "stm32l151vch6",
+            "stm32l151rct6a",
+            "stm32l151rct6",
+            "stm32l151rdt6",
+            "stm32l151rdt7",
+            "stm32l151ret6",
+            "stm32l151vct6a",
+            "stm32l151vct6",
+            "stm32l151vdt6x",
+            "stm32l151vdt6",
+            "stm32l151vet6",
+            "stm32l151vet7",
+            "stm32l151zct6",
+            "stm32l151zdt6",
+            "stm32l151zet6",
+            "stm32l151rcy6",
+            "stm32l151rdy6",
+            "stm32l151rdy7",
+            "stm32l151ucy6",
+            "stm32l151ucy7",
+            "stm32l151vdy6x",
+            "stm32l151vdy7x",
+            "stm32l151vey6",
+            "stm32l151vey7",
+            "stm32l152qch6",
+            "stm32l152qdh6",
+            "stm32l152qeh6",
+            "stm32l152vch6",
+            "stm32l152rct6a",
+            "stm32l152rct6",
+            "stm32l152rdt6",
+            "stm32l152ret6",
+            "stm32l152vct6a",
+            "stm32l152vct6",
+            "stm32l152vdt6x",
+            "stm32l152vdt6",
+            "stm32l152vet6",
+            "stm32l152zct6",
+            "stm32l152zdt6",
+            "stm32l152zet6",
+            "stm32l152rdy6",
+            "stm32l152ucy6",
+            "stm32l152vey6",
+            "stm32l162qdh6",
+            "stm32l162vch6",
+            "stm32l162rct6a",
+            "stm32l162rct6",
+            "stm32l162rdt6",
+            "stm32l162ret6",
+            "stm32l162vct6a",
+            "stm32l162vct6",
+            "stm32l162vdt6",
+            "stm32l162vet6",
+            "stm32l162zdt6",
+            "stm32l162zet6",
+            "stm32l162rdy6",
+            "stm32l162vdy6x",
+            "stm32l162vey6",
+        ])))
 
     def test_should_construct_empty(self):
         self.assertEqual(self.ident.string, "")
@@ -111,3 +291,13 @@ def test_should_merge_naming_schemas(self):
 
         self.ident.append(DeviceIdentifier("{one}{two}"))
         self.assertEqual(self.ident.naming_schema, "{one}{one}{two}")
+
+    def test_minimal_subtract_set(self):
+        print(self.devices)
+        print(self.parent_devices)
+        print(self.child_devices)
+
+        min_set = self.child_devices.minimal_subtract_set(self.devices, self.parent_devices)
+        for m in min_set:
+            print([(k, m.getAttribute(k)) for k in self.devices.keys() if m.getAttribute(k)])
+        # self.assertEqual(min_set, "[f1]")

tools/generator/dfg/device_tree.py

@@ -119,20 +119,23 @@ def _sortTree(self):
         for ch in self.children:
             ch._sortTree()
 
-    def toString(self, indent=0):
+    def toString(self, indent=0, long_ids=False):
         ind = ' ' * indent
         if indent >= 2:
             ind = ind[:-2] + '. '
         if self.parent is None or self.parent.ids == self.ids:
             ident = ""
         else:
-            ident = self.ids.string
+            if long_ids:
+                ident = " ".join(did.string for did in self.ids)
+            else:
+                ident = self.ids.string
         string = "{}{} {}\n".format(
             ind,
             self._toCompactString(),
             ident)
         for ch in self.children:
-            string += ch.toString(indent + 2)
+            string += ch.toString(indent + 2, long_ids)
         return string
 
     def _toCompactString(self):

tools/generator/dfg/stm32/stm_device_tree.py

@@ -316,10 +316,10 @@ def rv(param, default=[]):
             else:
                 allSignals = gpioFile.compactQuery('//GPIO_Pin[@Name="{}"]/PinSignal/SpecificParameter[@Name="GPIO_AF"]/..'.format(rname))
                 signalMap = { a.get("Name"): a[0][0].text.lower().replace("gpio_af", "")[:2].replace("_", "") for a in allSignals }
-                altFunctions = [ (s.lower(), (signalMap[s] if s in signalMap else "-1")) for s in localSignals ]
+                altFunctions = [ (s.lower(), signalMap.get(s, "-1")) for s in localSignals ]
 
             afs = []
-            for af in altFunctions:
+            for af in set(altFunctions):
                 for raf in split_multi_af(af[0]):
                     naf = {}
                     naf["driver"], naf["instance"], naf["name"] = raf