clean iocontroller wrapper infrastructure

Author: ducky64

edg/abstract_parts/BaseIoControllerWrapped.py

@@ -19,23 +19,38 @@ def _remap_pin_assigns_list(
         pin_assigns: List[str],
         *,
         invert_remapping: bool = False,
-    ) -> Dict[str, str]:
+    ) -> Dict[str, Tuple[Optional[str], Optional[str]]]:
         """Given a remapping dict and a list of pin assigns, returns the mapping as a dict with the remapping applied.
+        The output is (pin name, pin number), with both being optional.
+
         If invert_remapping is True, the remapping dict is inverted before applying.
         Assigns not present in the remapping dict are passed unchanged, eg for non-pin-assigns like bundle containers.
         """
         if invert_remapping:
             remapping = {v: k for k, v in remapping.items()}
 
-        remapped_assigns = {}
+        remapped_assigns: Dict[str, Tuple[Optional[str], Optional[str]]] = {}
         for assign in pin_assigns:
             name, pindef = assign.split("=")
-            pin = pindef.split(",")[0].strip()  # take the first (gpio name) if multiple
-            remapped_pin = remapping.get(pin)
-            if remapped_pin is not None:
-                remapped_assigns[name.strip()] = remapped_pin
+            name = name.strip()
+            split = pindef.split(",")
+            split = [s.strip() for s in split]
+            if len(split) == 1:  # ambiguous, could either be pinname or pinnum
+                pindef = split[0].strip()
+                if pindef in remapping:
+                    if invert_remapping:  # remap pinnum -> pinname
+                        remapped_assigns[name] = (remapping[pindef], None)
+                    else:  # remap pinname -> pinnum
+                        remapped_assigns[name] = (pindef, remapping[pindef])
+                else:  # assume is a pinname or bundle container since it's not remappable
+                    remapped_assigns[name] = (pindef, None)
+            elif len(split) == 2:
+                pinname, pinnum = split[0], split[1]
+                assert pinname in remapping
+                remapped_assigns[name] = (pinname, remapping[pinname])
             else:
-                remapped_assigns[name.strip()] = pindef  # pass unmodified if not remappable, eg bundle containers
+                raise ValueError(f"unable to parse assign {assign}")
+
         return remapped_assigns
 
     def _generator_pin_dict(self) -> Dict[str, Port]:
@@ -73,48 +88,36 @@ def recurse_port(port: Port, prefix: str = "") -> None:
         return pin_dict
 
     def _remap_to_footprint_pinning(
-        self, pin_assigns: Dict[str, str], valid_pins: Iterable[str]
+        self, pin_assigns: Dict[str, Tuple[Optional[str], Optional[str]]], pin_dict: Dict[str, Port]
     ) -> Dict[str, HasPassivePort]:
-        """Given the pin assigns in a dict form as port name -> footprint pin, eg from _remap_pin_assigns_list,
-        returns the footprint-compatible form as footprint pin -> port object.
+        """Generates pinning that can be passed into a footprint, given the pin assign dict from _remap_pin_assigns_list
+        and pin dict from _generator_pin_dict.
 
-        This simplified pin assignment tool requires all pins to be assigned.
-        It does not automatically assign unassigned pins, that is assumed to have happened at a higher level."""
+        This requires all pins to be assigned."""
         pinning: Dict[str, HasPassivePort] = {}
-        seen_names: Set[str] = set()
-
-        def remap_port_recursive(port: Port, prefix: str = "") -> None:
-            """Remaps a port, recursively for bundles"""
-            if isinstance(port, HasPassivePort):
-                pin = pin_assigns.get(prefix)
-                assert pin is not None, f"pin {prefix} not assigned"
-                assert pin in valid_pins, f"pin {pin} not in valid pins {valid_pins}"
-                pinning[pin] = port
-
-            for subport_name, subport in port._ports.items():
-                remap_port_recursive(subport, f"{prefix}.{subport_name}")
 
-        for io_port in self._io_ports:
-            if isinstance(io_port, Vector):
-                io_port.defined()
-                for subport_name in self.get(io_port.requested()):
-                    assert subport_name not in seen_names, f"duplicate pin name {subport_name}"
-                    seen_names.add(subport_name)
-                    subport = io_port.append_elt(io_port._tpe.empty(), subport_name)
-                    remap_port_recursive(subport, subport_name)
-            elif isinstance(io_port, Port):
-                if self.get(io_port.is_connected()):
-                    port_name = io_port._name_from(self)
-                    assert port_name not in seen_names, f"duplicate pin name {port_name}"
-                    seen_names.add(port_name)
-                    remap_port_recursive(io_port, port_name)
-            else:
-                raise NotImplementedError(f"unknown port type {io_port}")
+        for name, assign in pin_assigns.items():
+            assert name in pin_dict
+            port = pin_dict[name]
+            if not isinstance(port, HasPassivePort):
+                continue  # ignore non-leaf ports
+            assert assign[1] is not None, f"pin {name} missing pin number assignment"
+            pinning[assign[1]] = port
 
         return pinning
 
     @staticmethod
-    def _remap_assigns_to_value(assigns: Dict[str, str]) -> List[str]:
+    def _remap_assigns_to_value(assigns: Dict[str, Tuple[Optional[str], Optional[str]]]) -> List[str]:
         """Given a dict of pin assigns from _remap_pinning_assigns, returns a list of assign strings
         for use in self.actual_pin_assigns"""
-        return [f"{name}={assign}" for name, assign in assigns.items()]
+        pin_assigns: List[str] = []
+        for name, assign in assigns.items():
+            if assign[0] is not None and assign[1] is not None:
+                pin_assigns.append(f"{name}={assign[0]}, {assign[1]}")
+            elif assign[0] is not None:
+                pin_assigns.append(f"{name}={assign[0]}")
+            elif assign[1] is not None:
+                pin_assigns.append(f"{name}={assign[1]}")
+            else:
+                raise ValueError(f"invalid assign for {name}: {assign}")
+        return pin_assigns

edg/parts/microcontroller/Rp2040.py

@@ -421,7 +421,8 @@ def generate(self) -> None:
             "14": self.vcc,  # VUsb
         }
         remapped_pin_assigns = self._remap_pin_assigns_list(self._PIN_REMAPPING, self.get(self.pin_assigns))
-        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, self._PIN_REMAPPING.values()))
+        pin_dict = self._generator_pin_dict()
+        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, pin_dict))
         self.assign(self.actual_pin_assigns, self._remap_assigns_to_value(remapped_pin_assigns))
 
         self.footprint(

edg/parts/microcontroller/nRF52840.py

@@ -487,7 +487,8 @@ def generate(self) -> None:
             "21": self.p0_18,
         }
         remapped_pin_assigns = self._remap_pin_assigns_list(self._PIN_REMAPPING, self.get(self.pin_assigns))
-        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, self._PIN_REMAPPING.values()))
+        pin_dict = self._generator_pin_dict()
+        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, pin_dict))
         self.assign(self.actual_pin_assigns, self._remap_assigns_to_value(remapped_pin_assigns))
 
         self.footprint(
@@ -653,7 +654,8 @@ def generate(self) -> None:
             # 'Vbat': '28',
         }
         remapped_pin_assigns = self._remap_pin_assigns_list(self._PIN_REMAPPING, self.get(self.pin_assigns))
-        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, self._PIN_REMAPPING.values()))
+        pin_dict = self._generator_pin_dict()
+        pinning.update(self._remap_to_footprint_pinning(remapped_pin_assigns, pin_dict))
         self.assign(self.actual_pin_assigns, self._remap_assigns_to_value(remapped_pin_assigns))
 
         self.footprint(

edg/parts/microcontroller/test_mcu_wrapper.py

@@ -82,18 +82,19 @@ def test_overallocate(self) -> None:
 
     def test_auto_pins(self) -> None:
         compiled = ScalaCompiler.compile(AutoPinsTest)
-        self.assertEqual(compiled.get_value(["dut", "actual_pin_assigns"]), ["0=7", "1=8"])
+        self.assertEqual(compiled.get_value(["dut", "actual_pin_assigns"]), ["0=GPIO0, 7", "1=GPIO1, 8"])
         self.assertEqual(compiled.get_value(["dut", "model", "actual_pin_assigns"]), ["0=GPIO0, 2", "1=GPIO1, 3"])
 
     def test_assigned_pins(self) -> None:
         compiled = ScalaCompiler.compile(AssignedPinsTest)
-        self.assertEqual(compiled.get_value(["dut", "actual_pin_assigns"]), ["0=1", "1=3"])
+        self.assertEqual(compiled.get_value(["dut", "actual_pin_assigns"]), ["0=GPIO26, 1", "1=GPIO28, 3"])
         self.assertEqual(compiled.get_value(["dut", "model", "actual_pin_assigns"]), ["0=GPIO26, 38", "1=GPIO28, 40"])
 
     def test_assigned_i2c(self) -> None:
         compiled = ScalaCompiler.compile(AssignedI2cTest)
         self.assertEqual(
-            compiled.get_value(["dut", "actual_pin_assigns"]), ["i2c=I2C1_T", "i2c.scl=6", "i2c.sda=5", "0=7", "1=8"]
+            compiled.get_value(["dut", "actual_pin_assigns"]),
+            ["i2c=I2C1_T", "i2c.scl=GPIO7, 6", "i2c.sda=GPIO6, 5", "0=GPIO0, 7", "1=GPIO1, 8"],
         )
         self.assertEqual(
             compiled.get_value(["dut", "model", "actual_pin_assigns"]),