[modm-devices] Refactor data access

Author: salkinium

examples/nucleo_f767zi/ethernet/main.cpp

@@ -188,11 +188,12 @@ main()
 	Leds::setOutput();
 	MODM_LOG_INFO << "\n\nReboot: Ethernet Example" << modm::endl;
 
-	Ethernet::Port::connect<Ethernet::RMII_Ref_Clk::Refclk,
+	Ethernet::Port::connect<
+		Ethernet::RMII_Ref_Clk::RefClk,
 		Ethernet::RMII_Mdc::Mdc,
 		Ethernet::RMII_Mdio::Mdio,
-		Ethernet::RMII_Crs_Dv::Rcccrsdv,
-		Ethernet::RMII_Tx_En::Txen,
+		Ethernet::RMII_Crs_Dv::RccCrsDv,
+		Ethernet::RMII_Tx_En::TxEn,
 		Ethernet::RMII_Tx_D0::Txd0,
 		Ethernet::RMII_Tx_D1::Txd1,
 		Ethernet::RMII_Rx_D0::Rxd0,

ext/modm-devices

@@ -240,6 +240,14 @@ def init(repo):
     repo.add_filter("modm.ord", lambda letter: ord(letter[0].lower()) - ord("a"))
     repo.add_filter("modm.chr", lambda num: chr(num + ord("A")))
 
+    # Global filters for naming things
+    def fmt_str(s):
+        return "".join(p.capitalize() for p in str(s).split("_"))
+    def fmt_driver(d):
+        return fmt_str(d.get("driver", "")) + fmt_str(d.get("instance", ""))
+    repo.add_filter("modm.fmt", fmt_str)
+    repo.add_filter("modm.fmt.driver", fmt_driver)
+
     # Compute the available data from modm-devices
     devices = DevicesCache()
     try:

repo.lb

@@ -219,12 +219,12 @@ initializeUsbHs()
 {
 	usb_hs::Device::initialize<SystemClock>();
 	usb_hs::Device::connect<
-		usb_hs::Ck::Ulpick,	usb_hs::Stp::Ulpistp,
-		usb_hs::Dir::Ulpidir, usb_hs::Nxt::Ulpinxt,
-		usb_hs::D0::Ulpid0, usb_hs::D1::Ulpid1,
-		usb_hs::D2::Ulpid2, usb_hs::D3::Ulpid3,
-		usb_hs::D4::Ulpid4, usb_hs::D5::Ulpid5,
-		usb_hs::D6::Ulpid6, usb_hs::D7::Ulpid7>();
+		usb_hs::Ck::UlpiCk,	usb_hs::Stp::UlpiStp,
+		usb_hs::Dir::UlpiDir, usb_hs::Nxt::UlpiNxt,
+		usb_hs::D0::UlpiD0, usb_hs::D1::UlpiD1,
+		usb_hs::D2::UlpiD2, usb_hs::D3::UlpiD3,
+		usb_hs::D4::UlpiD4, usb_hs::D5::UlpiD5,
+		usb_hs::D6::UlpiD6, usb_hs::D7::UlpiD7>();
 	usb_hs::Overcurrent::setInput();
 
 	// Deactivate VBUS Sensing B

src/modm/board/disco_f746ng/board.hpp

@@ -28,27 +28,13 @@ def prepare(module, options):
         ":platform:gpio",
         ":platform:core",
         ":architecture:interrupt")
+
     return True
 
 
 def build(env):
-    exti_vectors = [v["name"] for v in env[":target"].get_driver("core")["vector"] if "EXTI" in v["name"]]
-    # These are all exti possible vectors: 0, 0_1, 1, 15_10, 2, 2_3, 2_TSC, 3, 4, 4_15, 9_5
-    extimap = {
-        "0": [0], "1": [1], "2": [2], "3": [3], "4": [4],
-        "0_1": [0,1],
-        "2_TSC": [2],
-        "2_3": [2,3],
-        "4_15": [4,5,6,7,8,9,10,11,12,13,14,15],
-        "9_5": [5,6,7,8,9],
-        "15_10": [10,11,12,13,14,15],
-    }
-    extis = OrderedDict()
-    for v in sorted(exti_vectors):
-        extis[v] = extimap[v[4:]]
-
     env.substitutions = {
-        "extis": extis,
+        "extis": device.core.shared_irqs("EXTI"),
         "vectors_location": env.get(":platform:core:vector_table_location", "rom")
     }
     env.outbasepath = "modm/src/modm/driver"

src/modm/driver/gpio/gpio_sampler.lb

@@ -70,25 +70,17 @@ def prepare(module, options):
         return False
     global props
     props = {}
-    driver = device.get_driver("adc")
     props["target"] = target = device.identifier
-    props["driver"] = driver
     props["instances"] = []
 
-    if target["family"] in ["f2", "f4", "f7"]:
-        props["shared_irqs"] = {"ADC": listify(device.get_driver("adc")["instance"])}
-        props["shared_irq_ids"] = props["shared_irqs"]["ADC"]
+    if target["family"] in ["f2", "f4", "f7", "l1", "f1"]:
+        irq_name = next(device.core.vectors(lambda v: v.startswith("ADC")), "ADC")
+        instances = [i.number for i in device.driver("adc").instances()]
+        props["shared_irqs"] = {irq_name: instances}
+        props["shared_irq_ids"] = instances
     else:
-        shared_irqs = [v["name"] for v in device.get_driver("core")["vector"]]
-        shared_irqs = [v for v in shared_irqs if v.startswith("ADC") and "_" in v]
-        props["shared_irqs"] = {}
-        props["shared_irq_ids"] = []
-        for irq in shared_irqs:
-            parts = irq[3:].split("_")
-            shared_irqs_ids = (int(parts[0]), int(parts[1]) )
-            props["shared_irqs"][irq] = shared_irqs_ids
-            props["shared_irq_ids"].extend(shared_irqs_ids)
-
+        props["shared_irqs"] = device.core.shared_irqs("ADC")
+        props["shared_irq_ids"] = list(props["shared_irqs"].values())[0]
 
     module.depends(
         ":architecture:adc",
@@ -99,21 +91,18 @@ def prepare(module, options):
         ":math:algorithm",
         ":utils")
 
-    for instance in listify(device.get_driver("adc").get("instance", [])):
-        module.add_submodule(Instance(int(instance)))
+    for instance in device.driver("adc").instances():
+        module.add_submodule(Instance(instance.number))
 
     return True
 
 def build(env):
     device = env[":target"]
-    driver = device.get_driver("adc")
-
     global props
-
     env.substitutions = props
     env.outbasepath = "modm/src/modm/platform/adc"
 
-    if device.get_driver("adc").get("instance", None) is None:
+    if not device.driver("adc").instances():
         Instance(None).build(env)
 
     if any(i in props["shared_irq_ids"] for i in props["instances"]):

src/modm/platform/adc/stm32/module.lb

@@ -18,8 +18,7 @@ def init(module):
 
 def prepare(module, options):
     device = options[":target"]
-    if not (device.has_driver("adc:stm32-f0") or
-            device.has_driver("adc:stm32-g0")):
+    if not device.has_driver("adc:stm32-[fg]0"):
         return False
     module.depends(
         ":architecture:delay",
@@ -33,11 +32,10 @@ def prepare(module, options):
 
 def build(env):
     device = env[":target"]
-    driver = device.get_driver("adc")
 
     properties = {}
     properties["target"] = target = device.identifier
-    properties["id"] = driver.get("instance", [""])[0]
+    properties["id"] = device.driver("adc").instances([""])[0]
 
     channels = {i:"In{}".format(i) for i in reversed(range(0,19))}
     if target.family in ["g0"]:
@@ -52,10 +50,7 @@ def build(env):
         else:
             channels[18] = "Battery"
     properties["channels"] = channels
-
-    irq = next(v["name"] for v in device.get_driver("core")["vector"]
-               if v["name"].startswith("ADC1"))
-    properties["irq"] = irq
+    properties["irq"] = next(device.core.vectors(lambda v: v.startswith("ADC1")))
 
     env.substitutions = properties
     env.outbasepath = "modm/src/modm/platform/adc"

src/modm/platform/adc/stm32f0/module.lb

@@ -145,8 +145,8 @@ def prepare(module, options):
         ":platform:gpio",
         ":platform:rcc")
 
-    for instance in listify(device.get_driver("adc")["instance"]):
-        module.add_submodule(Instance(int(instance)))
+    for instance in device.driver("adc").instances():
+        module.add_submodule(Instance(instance.number))
 
     return True
 

src/modm/platform/adc/stm32f3/module.lb

@@ -77,9 +77,12 @@ can_map = {
 }
 
 def get_substitutions(env, instance):
-    target = env["target"].identifier
-    driver = env["target"].get_driver("can")
-    instances = map(lambda i: int(i), driver["instance"]) if "instance" in driver else (0,)
+    device = env[":target"]
+    target = device.identifier
+
+    driver = device.get_driver("can")
+    instances = (i.number for i in device.driver("can").instances())
+    instances = instances if instances else [0]
 
     cm = can_map[target.family]
     is_single = (cm[instance].type == CanType.Single) or (cm[instance].associated_instance not in instances)
@@ -140,12 +143,12 @@ def prepare(module, options):
         ":platform:rcc",
         ":utils")
 
-    driver = device.get_driver("can")
+    instances = device.driver("can").instances()
     # If there is only one instance of the peripheral it is not numbered and
     # merged into the generic can module.
-    if "instance" in driver:
-        for instance in listify(driver["instance"]):
-            module.add_submodule(Instance(int(instance)))
+    if instances:
+        for instance in instances:
+            module.add_submodule(Instance(instance.number))
     else:
         load_options(module)
 
@@ -158,7 +161,7 @@ def build(env):
     env.template("can_filter.hpp.in")
     env.template("can_filter.cpp.in")
 
-    if "instance" not in driver:
+    if not env[":target"].driver("can").instances():
         env.substitutions = get_substitutions(env, 0)
         env.template("can.hpp.in")
         env.template("can.cpp.in")

src/modm/platform/can/stm32/module.lb

@@ -21,9 +21,7 @@ def prepare(module, options):
     if not options[":target"].has_driver("rcc:stm32*"):
         return False
 
-    module.depends(":cmsis:device", ":utils", ":platform:clock")
-    # FIXME: Move Peripherals enum somewhere better
-    module.depends(":platform:gpio")
+    module.depends(":cmsis:device", ":utils", ":platform:clock", ":platform:core")
     return True
 
 def build(env):
@@ -67,31 +65,18 @@ def build(env):
     properties["pllsai_p_usb"] = (target["family"] == "f7") or \
         ((target["family"] == "f4") and target["name"] in ["46", "69", "79"])
 
-    flash_latencies = {}
-    for vcore in device.get_driver("flash")["latency"]:
-        flash_latencies[int(vcore["vcore-min"])] = sorted([int(f["hclk-max"]) for f in vcore["wait-state"]])
-
-    properties["table"] = flash_latencies
+    properties["table"] = device.flash.wait_states
     env.substitutions = properties
     env.outbasepath = "modm/src/modm/platform/clock"
 
     env.template("rcc.cpp.in")
     env.template("rcc.hpp.in")
 
-    all_peripherals = set()
-    all_drivers = [d for d in device._properties["driver"] if d["name"] not in ["gpio", "core"]]
-    translate = lambda s: s.replace("_", "").capitalize()
-    for d in all_drivers:
-        dname = translate(d["name"])
-        if "instance" in d:
-            all_peripherals.update(dname + translate(i) for i in d["instance"])
-        else:
-            all_peripherals.add(dname)
-    all_peripherals = sorted(list(all_peripherals))
-
     rcc_map = env.query(":cmsis:device:rcc-map")
     rcc_enable = {}
     rcc_reset = {}
+    all_peripherals = uniquify(map(env.filter("modm.fmt.driver"), env[":target"].peripherals))
+    all_peripherals_lut = {p.lower():p for p in all_peripherals}
 
     for per, mode in rcc_map.items():
         nper = per
@@ -110,14 +95,14 @@ def build(env):
         if "Eth" in all_peripherals and per == "ETHMAC":
             per = "Eth"
         # Fix USBOTG OTG
-        if "Usbotgfs" in all_peripherals and per.startswith("OTG"):
+        if "UsbOtgFs" in all_peripherals and per.startswith("OTG"):
             if per == "OTGH": per = "OTGHS";
             per = "USB"+per
             # print(per, mode)
-        if per.capitalize() not in all_peripherals:
+        if per.lower() not in all_peripherals_lut:
             continue
         if "EN" in mode:
-            rcc_enable[per.capitalize()] = (nper, mode["EN"])
+            rcc_enable[all_peripherals_lut[per.lower()]] = (nper, mode["EN"])
         if "RST" in mode:
             rcc_reset[nper] = mode["RST"]