Precision of machine.time_pulse_us() on different platforms

[rkompass]

In probing the Winner w600 MP port I started to write scripts that test and compare functionality of different boards.
Here is a script that tests the PWM functionality and measures the pulses (positive and negative) with machine.time_pulse_us().
The precision reported varies widely, probably due to (timer?-) interrupt interference.
The pyboard1.1 and mimxrt ports are accurate to the µS both in PWM an time-pulse measurement.
The script:

# Test of precision of machine.time_pulse_us() against internal PWM
#
# Tested on platforms: 'pyboard', 'rp2', 'mimxrt', 'esp8266', 'esp32', 'w600'
# On platform 'esp32' pins 0 and 4 have to be connected,
#   on platform 'w600' pins 0 and 1 have to be connected,
#   on platform 'mimxrt' pins 2 and 3 have to be connected, because after
#   setting a pin in PWM mode there it is not readable anymore (pin.value() = 0 always)

from machine import Pin, time_pulse_us
from sys import platform as Platform

_PWM_FREQ = const(1000)   # PWM frequency.
_PWM_DUTY = const(0.25)   # PWM duty.
_NRUNS = const(1000)      # How many pos. and neg. pulses we do measure.
_OUTL_FR = const(0.01)    # Pulses > +-2 % deviation from ideal pulse width considered outlier.


if Platform in ('rp2', 'esp8266', 'esp32', 'w600', 'mimxrt'):
    if Platform in ('mimxrt'):
        pin = Pin(2, Pin.OUT)
    else:
        pin = Pin(0, Pin.OUT)            #  (0  = Pin.PA_00 on w600)
    from machine import PWM
    pwm = PWM(pin, freq=_PWM_FREQ)
    pwm.duty_u16(round(_PWM_DUTY * 2**16))
elif Platform in ('pyboard'):        # Pyboard 1.1
    pin = Pin('X1', Pin.OUT)
    from pyb import Timer
    tim = Timer(2, freq=_PWM_FREQ)
    pwm_ch = tim.channel(1, Timer.PWM, pin=pin)
    pwm_ch.pulse_width_percent(round(_PWM_DUTY*100))

if Platform in ('w600'):
    tpin = Pin(1, Pin.IN)     # other pin on Winner w600, because PWM pin is not readable anymore
elif Platform in ('esp32'):
    tpin = Pin(4, Pin.IN)     # other pin on esp32, because PWM pin is not readable anymore
elif Platform in ('mimxrt'):
    tpin = Pin(3, Pin.IN)     # other pin on Teensy 4.1, because PWM pin is not readable anymore
else:
    tpin = pin


t_high = [0 for _ in range(_NRUNS)]
t_low  = [0 for _ in range(_NRUNS)]

print('Doing measurements ...', end='')
while tpin() == 0:
    pass
for i in range(_NRUNS):
    if i%20 == 19:
        print('.', end='')   # without this the output may hang (a USB problem on mimxrt port)
    while tpin() == 1:
        pass
    t_high[i] = time_pulse_us(tpin, 1, 2_000_000 // _PWM_FREQ)
    while tpin() == 0:
        pass
    t_low[i] = time_pulse_us(tpin, 0, 2_000_000 // _PWM_FREQ)

print(f' Done.\nPlatform: {Platform}')
print(f'Tested precision of time_pulse_us() against PWM signal at {_PWM_FREQ} Hz with duty {_PWM_DUTY} with {_NRUNS} runs:')
t_high_0 = round(1_000_000 / _PWM_FREQ * _PWM_DUTY)
t_low_0 = round(1_000_000 / _PWM_FREQ *(1- _PWM_DUTY))
t_high_mean = sum(t_high)/_NRUNS
t_low_mean = sum(t_low)/_NRUNS
print(f't_high: Ideal: {t_high_0}  Mean: {t_high_mean} µS  Dev: {100*(t_high_mean-t_high_0)/t_high_0:.3f}%')
print(f't_low: Ideal: {t_low_0}  Mean: {t_low_mean} µS  Dev: {100*(t_low_mean-t_low_0)/t_low_0:.3f}%')
t_high.sort()
t_low.sort()
t_high_outl = tuple(t for t in t_high if t > (1+_OUTL_FR) * t_high_mean or t < (1-_OUTL_FR) * t_high_mean)
t_low_outl = tuple(t for t in t_low if t > (1+_OUTL_FR) * t_low_mean or t < (1-_OUTL_FR) * t_low_mean)
print(f't_high: {len(t_high_outl)} Outliers (>{round(100*_OUTL_FR)}% dev.): {t_high_outl} µS')
print(f't_low: {len(t_low_outl)} Outliers (>{round(100*_OUTL_FR)}% dev.): {t_low_outl} µS')

And the results:

Platform: pyboard
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 250.0 µS  Dev: 0.0%
t_low: Ideal: 750  Mean: 750.0 µS  Dev: 0.0%
t_high: 0 Outliers (>1% dev.): () µS
t_low: 0 Outliers (>1% dev.): () µS

Platform: rp2
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 249.776 µS  Dev: -0.090%
t_low: Ideal: 750  Mean: 750.989 µS  Dev: 0.132%
t_high: 1 Outliers (>1% dev.): (48,) µS
t_low: 2 Outliers (>1% dev.): (762, 1750) µS

Platform: mimxrt
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 250.0 µS  Dev: 0.000%
t_low: Ideal: 750  Mean: 750.0 µS  Dev: 0.000%
t_high: 0 Outliers (>1% dev.): () µS
t_low: 0 Outliers (>1% dev.): () µS

Platform: w600
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 253.739 µS  Dev: 1.496%
t_low: Ideal: 750  Mean: 744.577 µS  Dev: -0.723%
t_high: 12 Outliers (>1% dev.): (242, 246, 250, 250, 260, 260, 263, 263, 272, 276, 303, 394) µS
t_low: 11 Outliers (>1% dev.): (606, 658, 658, 661, 733, 733, 735, 753, 755, 781, 801) µS

Platform: esp8266
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 251.638 µS  Dev: 0.655%
t_low: Ideal: 750  Mean: 752.212 µS  Dev: 0.295%
t_high: 155 Outliers (>1% dev.): (239, 246, 247, 247, 247, 248, .., 248, 249, .., 249) µS
t_low: 0 Outliers (>1% dev.): () µS

Platform: esp32
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 249.446 µS  Dev: -0.222%
t_low: Ideal: 750  Mean: 748.781 µS  Dev: -0.163%
t_high: 1 Outliers (>1% dev.): (259,) µS
t_low: 1 Outliers (>1% dev.): (758,) µS

The outliers are to be taken into account if one wishes to measure distances with an ultrasonic (HC-04) sensor.
Their number is low enough to identify end exclude them in a series of continuous measurements.

Another observation: An inconsistency regarding PWM:
After setting a pin to PWM mode on the platforms w600, esp32 and mimxrt it's value when read will be 0, regardless of the changing PWM activity. On these platforms an external connection to another pin that may be read was necessary.

[robert-hh]

The machine_time_pulse_us() is the same code used by all ports except ESP8266. The difference is in the function mp_hal_ticks_us(), which is port-specific. And yes, none of them disables IRQ during timing. And the boards run at different speed. Even worse, during my tests with bitstream it appeared, that the W600 takes 37.5 ns per ARM instruction, which is 3 clock cycles, effectively running at ~27MHz. The mimxrt and STM32 take one clock cycle/instruction. Whether a port value can be read back when not in Pin mode is hardware-specific. It should be possible with mimxrt. I have to look into it again. Attached is a screen shot of the W600 PWM, taken with the oscilloscope.

[robert-hh]

Tested the same w600 chip with your script:

Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 253.498 µS  Dev: 1.399%
t_low: Ideal: 750  Mean: 744.783 µS  Dev: -0.696%
t_high: 7 Outliers (>1% dev.): (167, 229, 248, 257, 257, 285, 337) µS
t_low: 5 Outliers (>1% dev.): (607, 699, 712, 785, 808) µS

Besides the higher stdDev, the average result matches pretty well the Oscilloscope results. So the noise makes it better. Using the MIMXRT board to sample the PWM of the W600 results in:

Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250  Mean: 253.511 µS  Dev: 1.404%
t_low: Ideal: 750  Mean: 744.904 µS  Dev: -0.679%
t_high: 1 Outliers (>1% dev.): (250,) µS
t_low: 0 Outliers (>1% dev.): () µS

[robert-hh]

Running the test with the proper expected values for the PWM:

Platform: w600
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 253.499  Mean: 253.615 µS  Dev: 0.046%
t_low: Ideal: 744.9  Mean: 744.901 µS  Dev: 0.000%
t_high: 5 Outliers (>1% dev.): (223, 249, 257, 277, 376) µS
t_low: 2 Outliers (>1% dev.): (693, 813) µS

Platform: mimxrt
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 253.499  Mean: 253.496 µS  Dev: -0.001%
t_low: Ideal: 744.9  Mean: 744.888 µS  Dev: -0.002%
t_high: 0 Outliers (>1% dev.): () µS
t_low: 0 Outliers (>1% dev.): () µS

Doing the opposite by probing the MIMXRT PWM with the W600:

MIMXRT PWM results on the oscilloscope:
+width: 250.0017µs
-width: 750.0066µs
A slightly higher jitter than the W600:

Platform: w600
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250.002  Mean: 250.008 µS  Dev: 0.002%
t_low: Ideal: 750.007  Mean: 750.016 µS  Dev: 0.001%
t_high: 0 Outliers (>1% dev.): () µS
t_low: 0 Outliers (>1% dev.): () µS

But on the next run as well:

Platform: w600
Tested precision of time_pulse_us() against PWM signal at 1000 Hz with duty 0.25 with 1000 runs:
t_high: Ideal: 250.002  Mean: 249.273 µS  Dev: -0.292%
t_low: Ideal: 750.007  Mean: 750.6 µS  Dev: 0.079%
t_high: 23 Outliers (>1% dev.): (93, 98, 168, 186, 191, 199, 202, 205, 208, 216, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252) µS
t_low: 11 Outliers (>1% dev.): (743, 785, 789, 792, 795, 802, 806, 809, 811, 813, 918) µS

[rkompass]

So the interrupts are the culprits. Are they so fast on pyboard and mimxrt that there are no microseconds lost in measurement?
Besides, I have to find out how to do the histogram with my scope.

[robert-hh]

So the interrupts are the culprits. Are they so fast on pyboard and mimxrt that there are no microseconds lost in measurement?

There is no RTOS on pyboard or mimxrt. The only interrupts that happen when there is nothing else running is the systick interrupt, which updates the systick counter in a few clock cycles, and sometimes the µs counter overrun interrupt. At 168 or 600Mhz, there are quite a few clock cycles per µs. RTOS and especially WiFi have more tasks to check.