[api] Move GPIO code from modm to here

Author: salkinium

tools/device/modm_devices/__init__.py

@@ -10,11 +10,19 @@
 from . import device_identifier
 from . import device
 from . import parser
+from . import stm32
 
 from .pkg import naturalkey
 from .exception import ParserException
 
-__all__ = ['exception', 'device_file', 'device_identifier', 'device', 'parser', 'pkg']
+__all__ = [
+	'exception',
+	'device_file',
+	'device_identifier',
+	'device',
+	'parser',
+	'pkg'
+]
 
 __author__ = "Fabian Greif"
 __copyright__ = "Fabian Greif"

tools/device/modm_devices/cache.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import functools
+
+class cached_property(object):
+    def __init__(self, func):
+        self.__doc__ = getattr(func, "__doc__")
+        self.func = func
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        value = obj.__dict__[self.func.__name__] = self.func(obj)
+        return value
+
+cached_function = functools.lru_cache(None)

tools/device/modm_devices/device_file.py

@@ -11,12 +11,19 @@
 from collections import defaultdict
 
 from .device import Device
+from .stm32.device import Stm32Device
 from .device_identifier import DeviceIdentifier
 from .device_identifier import MultiDeviceIdentifier
 from .access import read_only
 
 from .exception import ParserException
 
+def build_device(did, device_file):
+    if did.platform == "stm32":
+        from .stm32.device import Stm32Device
+        return Stm32Device(did, device_file)
+    return Device(did, device_file)
+
 class DeviceFile:
     _PREFIX_ATTRIBUTE = 'attribute-'
     _PREFIX_ATTRIBUTE_DEVICE = 'device-'
@@ -50,7 +57,7 @@ def get_devices(self):
             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]
-        return [Device(did, self) for did in devices]
+        return [build_device(did, self) for did in devices]
 
     @staticmethod
     def is_valid(node, identifier: DeviceIdentifier):

tools/device/modm_devices/stm32/__init__.py

@@ -0,0 +1 @@
+from . import device

tools/device/modm_devices/stm32/adc.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2020, Niklas Hauser
+# All rights reserved.
+
+class DriverAdc:
+    def __init__(self, device):
+        self._device = device
+        self._adc = self._device.get_driver("adc")
+
+    def instances(self, default=None):
+        """
+        :return: a map from int(pin number) to str(name) EXTI{name} interrupt.
+        """
+        if "instance" in self._adc:
+            return list(map(int, self._adc["instance"]))
+        return default
+

tools/device/modm_devices/stm32/device.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2016, Fabian Greif
+# Copyright (c) 2016, Niklas Hauser
+# All rights reserved.
+
+from .gpio import DriverGpio
+from .exti import DriverExti
+from .adc import DriverAdc
+from ..device import Device
+from ..cache import cached_property
+from ..access import copy_keys
+
+
+class Stm32Device(Device):
+    def __init__(self, identifier, device_file):
+        Device.__init__(self, identifier, device_file)
+
+    @cached_property
+    def gpio(self):
+        return DriverGpio(self)
+
+    @cached_property
+    def exti(self):
+        return DriverExti(self)
+
+    @cached_property
+    def adc(self):
+        return DriverAdc(self)
+
+    @cached_property
+    def peripherals(self):
+        all_peripherals = []
+        for s in self.gpio.signals_all:
+            d = copy_keys(s, "driver", "instance")
+            if len(d): all_peripherals.append(d);
+
+        # Signals are not enough, since there are peripherals that don't have signals.
+        # Example: STM32F401RE < 64pins: SPI4 cannot be connected to any pins.
+        for d in self._properties["driver"]:
+            driver = d["name"]
+            if driver in ["gpio", "core"]:
+                continue
+            elif "instance" in d:
+                all_peripherals.extend( {"driver": driver, "instance": int(i)} for i in d["instance"] )
+            else:
+                all_peripherals.append( {"driver": driver} )
+
+        for r in self.gpio._gpio.get("remap", {}):
+            d = copy_keys(r, "driver", "instance")
+            if len(d): all_peripherals.append(d);
+
+        return all_peripherals

tools/device/modm_devices/stm32/exti.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2020, Niklas Hauser
+# All rights reserved.
+
+from ..cache import cached_property
+
+class DriverExti:
+    def __init__(self, device):
+        self._device = device
+        self._core = self._device.get_driver("core")
+
+    @cached_property
+    def vector_map(self):
+        """
+        :return: a map from int(pin number) to str(name) EXTI{name} interrupt.
+        """
+        extimap = {}
+        for vector in [v["name"][4:] for v in self._core["vector"] if "EXTI" in v["name"]]:
+            vrange = sorted(int(d) for d in vector.split("_") if d.isdigit())
+            if len(vrange) == 2:
+                vrange = list(range(vrange[0], vrange[1]+1))
+            for num in vrange:
+                if num in extimap:
+                    raise ValueError("Pin '{}' already in EXTI map!".format(str(num)))
+                extimap[num] = vector
+        return extimap
+

tools/device/modm_devices/stm32/gpio.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2020, Niklas Hauser
+# All rights reserved.
+
+from collections import defaultdict
+from ..cache import *
+from ..access import copy_keys, copy_deep
+
+class DriverGpio:
+    def __init__(self, device):
+        self._device = device
+        self._gpio = self._device.get_driver("gpio")
+        self.type = self._gpio["type"]
+
+    @cached_property
+    def ranges(self):
+        """
+        Computes all port ranges on this device in the form of a map:
+
+        - "name": port.upper()
+        - "start": min(pin)
+        - "width": max(pin) - min(pin)
+
+        :return: a list of port ranges
+        """
+        ports = defaultdict(list)
+        for gpio in self._gpio["gpio"]:
+            ports[gpio["port"]].append(int(gpio["pin"]))
+
+        ports = [{"name": k,
+                  "start": min(v),
+                  "width": max(v) - min(v) + 1}  for k,v in ports.items()]
+        ports.sort(key=lambda p: p["name"])
+        return ports
+
+    @cached_property
+    def ports(self):
+        """
+        Computes all ports on this device.
+
+        :return: a sorted unique list of ports in uppercase letters.
+        """
+        ports = set(p["port"] for p in self._gpio["gpio"])
+        return list(sorted(ports))
+
+    @cached_property
+    def pins(self):
+        """
+        Computes all pins on this device.
+
+        :return: a sorted unique list of (port.upper(), int(pin)) tuples.
+        """
+        pins = set((p["port"], int(p["pin"])) for p in self._gpio["gpio"])
+        return list(sorted(pins))
+
+    def signals(self, port, pin):
+        return self._signals.get((port.lower(), pin))
+
+    # @cached_function
+    def signals_by_name(self, port, pin):
+        signals = self.signals(port, pin)
+        names = defaultdict(list)
+        for s in signals:
+            names[s["name"]].append(s)
+        return dict(names)
+
+    @cached_property
+    def signals_remap(self):
+        return copy_deep(self._gpio.get("remap", []))
+
+    @cached_property
+    def signals_group(self):
+        sgroup = defaultdict(list)
+        if "f1" in self.type:
+            # Convert the map from a list of signals to a list of pins
+            for remap in self._gpio["remap"]:
+                for group in remap["group"]:
+                    for signal in group["signal"]:
+                        key = (signal["port"], int(signal["pin"]))
+
+                        for sig in sgroup[key]:
+                            if ((sig["driver"], sig.get("instance", 0)) ==
+                                    (remap["driver"], int(remap.get("instance", 0))) and
+                                    sig["name"] == signal["name"]):
+                                sig["group"].append(int(group["id"]))
+                                break
+                        else:
+                            sig = copy_keys(remap, "driver", ("instance", int))
+                            sig["name"] = signal["name"]
+                            sig["group"]= [int(group["id"])]
+                            sgroup[key].append(sig)
+        return dict(sgroup)
+
+
+    @cached_property
+    def signals_all(self):
+        asigs = list()
+        for signals in self._signals.values():
+            for s in signals:
+                asigs.append(copy_keys(s, "name", "driver", ("instance", int)))
+        return asigs
+
+    @cached_property
+    def _signals(self):
+        """
+        :return:
+        """
+        signals_map = {}
+        for gpio in self._gpio["gpio"]:
+            key = (gpio["port"], int(gpio["pin"]))
+
+            raw_signals = copy_deep(gpio.get("signal", []))
+            # raw_signals = gpio.get("signal", [])
+            if key in self.signals_group:
+                raw_signals.extend(self.signals_group[key])
+
+            for s in raw_signals:
+                s.update(copy_keys(s, ("af", int), ("instance", int)))
+                s["is_analog"] = any(s.get("driver", "").startswith(p) for p in {"adc", "dac", "comp"})
+                if s.get("driver", "").startswith("adc") and s["name"].startswith("in"):
+                    s["analog_channel"] = int("".join(filter(str.isdigit, s["name"])))
+
+            signals_map[key] = raw_signals
+
+        # print(signals_map)
+        return signals_map
+
+