[modm-devices] Refactor data access

Author: salkinium

README.md

@@ -71,7 +71,7 @@ git clone --recurse-submodules https://github.com/modm-io/modm.git
 ## Targets
 
 modm can generate code for <!--avrcount-->506<!--/avrcount-->
-AVR, <!--samcount-->163<!--/samcount--> SAM and <!--stmcount-->2010<!--/stmcount-->
+AVR, <!--samcount-->163<!--/samcount--> SAM and <!--stmcount-->2110<!--/stmcount-->
 STM32 devices, however, there are different levels of support and testing.
 
 <center>

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

@@ -19,36 +19,22 @@ def prepare(module, options):
     if options[":target"].identifier["platform"] != "stm32":
         return False
 
-    core = options[":target"].get_driver("core:cortex-m*")
+    core = options[":target"].driver("core").type
     # Cortex-M0 doesn't have the DWT->CYCCNT and Cortex-M7 support is broken
-    if not core or "m0" in core["type"] or "m7" in core["type"]:
+    if "m0" in core or "m7" in core:
         return False
 
     module.depends(
         ":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": env[":target"].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"]
 

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

@@ -19,17 +19,17 @@ namespace modm::platform
 	/// @ingroup modm_platform_comp
 	class CompBase
 	{
-	{% if driver.type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
+	{% if type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
 	public:
 		enum class
 		Mode
 		{
-			{% if driver.type in ["stm32-v1.3"] -%}
+			{% if type in ["stm32-v1.3"] -%}
 			UltraLowPower	= 0b00 << 2,
 			LowPower		= 0b01 << 2,
 			MediumSpeed		= 0b10 << 2,
 			HighSpeed		= 0b11 << 2,
-			{% elif driver.type in ["stm32-tsmc90_cube"] -%}
+			{% elif type in ["stm32-tsmc90_cube"] -%}
 			HighSpeed		= 0b00 << 2,
 			MediumSpeed		= 0b01 << 2,
 			//MediumSpeed2	= 0b10 << 2,
@@ -50,7 +50,7 @@ namespace modm::platform
 	protected:
 		static constexpr uint32_t PolarityMask = 0b1 << 15;
 
-	{% if driver.type in ["stm32-v1.3", "stm32-tsmc90_cube"] -%}
+	{% if type in ["stm32-v1.3", "stm32-tsmc90_cube"] -%}
 	public:
 		enum class
 		Hysteresis
@@ -62,7 +62,7 @@ namespace modm::platform
 		};
 	protected:
 		static constexpr uint32_t HysteresisMask = 0b11 << 16;
-	{% elif "g4" in driver.type -%}
+	{% elif "g4" in type -%}
 	public:
 		enum class
 		Hysteresis

src/modm/platform/comp/stm32/base.hpp.in

@@ -234,7 +234,7 @@ namespace modm::platform
 					Output out = Output::NoSelection,
 				{% endif -%}
 					Hysteresis hyst = Hysteresis::NoHysteresis,
-				{% if driver.type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
+				{% if type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
 					Mode mode = Mode::HighSpeed,
 				{% endif -%}
 					Polarity pol = Polarity::NonInverted,
@@ -248,7 +248,7 @@ namespace modm::platform
 			setOutputSelection(out);
 		{% endif -%}
 			setHysteresis(hyst);
-		{% if driver.type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
+		{% if type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
 			setMode(mode);
 		{% endif -%}
 			setPolarity(pol);
@@ -308,7 +308,7 @@ namespace modm::platform
 		}
 	{% endif -%}
 
-	{% if driver.type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
+	{% if type not in ["stm32-tsmc90_g4_rockfish_cube"] -%}
 		/**
 		 * \brief	Sets the mode that determins speed/power consumption.
 		 *