tests/extmod_hardware/machine_pwm.py: Convert test to use target_wiring.

Signed-off-by: Damien George <damien@micropython.org>

Author: dpgeorge

tests/extmod_hardware/machine_pwm.py

@@ -1,59 +1,42 @@
 # Test machine.PWM, frequency and duty cycle (using machine.time_pulse_us).
 #
 # IMPORTANT: This test requires hardware connections: the PWM-output and pulse-input
-# pins must be wired together (see the variable `pwm_pulse_pins`).
-
-import sys
-import time
+# pins must be wired together (see the variable `pwm_loopback_pins`).
 
 try:
     from machine import time_pulse_us, Pin, PWM
 except ImportError:
     print("SKIP")
     raise SystemExit
 
-import unittest
+import machine, sys, time, unittest
+from target_wiring import pwm_loopback_pins
 
 pwm_freq_limit = 1000000
 freq_margin_per_thousand = 0
 duty_margin_per_thousand = 0
 timing_margin_us = 5
 
-# Configure pins based on the target.
-if "alif" in sys.platform:
-    pwm_pulse_pins = (("P0_4", "P0_5"),)
-elif "esp32" in sys.platform:
-    pwm_pulse_pins = ((4, 5),)
+# Slow MCUs cannot capture short pulses using `time_pulse_us` so limit the maximum PWM
+# frequency tested on such targets.
+if hasattr(machine, "freq"):
+    f = machine.freq()
+    if isinstance(f, tuple):
+        f = f[0]
+    if f <= 48_000_000:
+        pwm_freq_limit = 2_000
+    elif f <= 64_000_000:
+        pwm_freq_limit = 5_000
+
+# Tune test parameters based on the target.
+if "esp32" in sys.platform:
     freq_margin_per_thousand = 2
     duty_margin_per_thousand = 1
     timing_margin_us = 20
 elif "esp8266" in sys.platform:
-    pwm_pulse_pins = ((4, 5),)
     pwm_freq_limit = 1_000
     duty_margin_per_thousand = 3
     timing_margin_us = 50
-elif "mimxrt" in sys.platform:
-    if "Teensy" in sys.implementation._machine:
-        # Teensy 4.x
-        pwm_pulse_pins = (
-            ("D0", "D1"),  # FLEXPWM X and UART 1
-            ("D2", "D3"),  # FLEXPWM A/B
-            ("D11", "D12"),  # QTMR and MOSI/MISO of SPI 0
-        )
-    else:
-        pwm_pulse_pins = (("D0", "D1"),)
-elif "pyboard" in sys.platform:
-    pwm_pulse_pins = ((Pin.cpu.A0, Pin.cpu.A1),)
-elif "rp2" in sys.platform:
-    pwm_pulse_pins = (("GPIO0", "GPIO1"),)
-elif "samd" in sys.platform:
-    pwm_pulse_pins = (("D0", "D1"),)
-    if "SAMD21" in sys.implementation._machine:
-        # MCU is too slow to capture short pulses.
-        pwm_freq_limit = 2_000
-else:
-    print("Please add support for this test on this platform.")
-    raise SystemExit
 
 
 # Test a specific frequency and duty cycle.
@@ -160,7 +143,7 @@ def test_freq_10000(self):
 
 
 # Generate test classes, one for each set of pins to test.
-for pwm, pulse in pwm_pulse_pins:
+for pwm, pulse in pwm_loopback_pins:
     cls_name = "Test_{}_{}".format(pwm, pulse)
     globals()[cls_name] = type(
         cls_name, (TestBase, unittest.TestCase), {"pwm_pin": pwm, "pulse_pin": pulse}

tests/run-tests.py

@@ -291,6 +291,7 @@
     "extmod/machine_uart_tx.py",
     "extmod_hardware/machine_can_timings.py",
     "extmod_hardware/machine_encoder.py",
+    "extmod_hardware/machine_pwm.py",
     "extmod_hardware/machine_uart_irq_break.py",
     "extmod_hardware/machine_uart_irq_rx.py",
     "extmod_hardware/machine_uart_irq_rxidle.py",

tests/target_wiring/NUCLEO_WB55.py

@@ -8,3 +8,5 @@
 uart_loopback_kwargs = {}
 
 spi_standalone_args_list = [(1,), (2,)]
+
+pwm_loopback_pins = [("D1", "D0")]

tests/target_wiring/PYBx.py

@@ -12,3 +12,5 @@
 # CAN args assume no connection for single device tests
 can_args = (1,)
 can_kwargs = {}
+
+pwm_loopback_pins = [("X1", "X2")]

tests/target_wiring/README.md

@@ -48,6 +48,20 @@ SPI instances will be created using:
     for spi_args in spi_standalone_args_list:
         machine.SPI(*spi_args)
 
+### PWM tests
+
+PWM tests require a PWM output to be connected in loopback mode to another GPIO pin
+that will use `machine.time_pulse_us()` to time the PWM output signal.  The variables
+are:
+
+    pwm_loopback_pins: list[tuple[Any, Any]]
+
+The PWM and input Pin instances will be created using:
+
+    for pwm_pin, pulse_pin in pwm_loopback_pins:
+        machine.PWM(pwm_pin)
+        machine.Pin(pulse_pin, Pin.IN)
+
 ### Encoder tests
 
 Encoder tests require one encoder to be connected in loopback mode to two other GPIO

tests/target_wiring/alif.py

@@ -7,3 +7,5 @@
 uart_loopback_kwargs = {}
 
 spi_standalone_args_list = [(0,)]
+
+pwm_loopback_pins = [("P0_4", "P0_5")]

tests/target_wiring/esp32.py

@@ -14,6 +14,8 @@
 else:
     spi_standalone_args_list = [(1,), (2,)]
 
+pwm_loopback_pins = [(4, 5)]
+
 encoder_loopback_id = 0
 encoder_loopback_out_pins = (4, 12)
 encoder_loopback_in_pins = (5, 13)

tests/target_wiring/esp8266.py

@@ -7,3 +7,5 @@
 uart_loopback_kwargs = {}
 
 spi_standalone_args_list = [(1,)]
+
+pwm_loopback_pins = [(4, 5)]

tests/target_wiring/mimxrt.py

@@ -3,11 +3,23 @@
 # Connect:
 # - UART1 TX and RX, usually D0 and D1
 
+import sys
+
 uart_loopback_args = (1,)
 uart_loopback_kwargs = {}
 
 spi_standalone_args_list = [()]
 
+if "Teensy" in sys.implementation._machine:
+    # Teensy 4.x
+    pwm_loopback_pins = [
+        ("D0", "D1"),  # FLEXPWM X and UART 1
+        ("D2", "D3"),  # FLEXPWM A/B
+        ("D11", "D12"),  # QTMR and MOSI/MISO of SPI 0
+    ]
+else:
+    pwm_loopback_pins = [("D0", "D1")]
+
 encoder_loopback_id = 0
 encoder_loopback_out_pins = ("D0", "D2")
 encoder_loopback_in_pins = ("D1", "D3")

tests/target_wiring/rp2.py

@@ -7,3 +7,5 @@
 uart_loopback_kwargs = {"tx": "GPIO0", "rx": "GPIO1"}
 
 spi_standalone_args_list = [(0,), (1,)]
+
+pwm_loopback_pins = [("GPIO0", "GPIO1")]