Support for MCPWM Input Capture in ESP32 port?

[wzab]

I need to precisely measure positions of edges of a digital signal from a sensor.
ESP32 offers the Input Capture functionality in the MCPWM block: https://docs.espressif.com/projects/esp-idf/en/v4.2/esp32/api-reference/peripherals/mcpwm.html#capture .
Unfortunately, it seems that this feature is not supported (yet?) by the PWM driver: https://docs.micropython.org/en/latest/esp32/quickref.html#pwm-pulse-width-modulation .

Of course, I can access it directly via registers, as described in https://github.com/micropython/micropython/blob/master/docs/esp32/tutorial/peripheral_access.rst , but it may be difficult to register multiple edges of a relatively fast input signal that way.

Generally, what I need is Input Capture cooperating with fast IRQ or (better) DMA storing the time positions of consecutive rising and falling edges in a circular buffer.

Can it be easily implemented in micropython on ESP32?

TIA, best regards,
Wojtek

[rkompass]

This sounds like a problem suited for the PIOs of the RP2040.

[wzab]

I can easily solve it with Input Capture functionality in PWM on STM32 as well. I simply set up two Input Capture channels (one for rising edge and another for falling edge) using the same timer. Each channel uses its circular DMA buffer.
However, now I need to implement it in an ESP32-based board...

[wzab]

Indeed I have created a simple code in micropython + PIO for Raspberry Pi Pico (W):

# Demo code for measurement of duration of low and high state on a selected input pin
# The test signal is generated with PWM.
# This is a public domain (or CC0) code written by Wojciech M. Zabolotny ([email protected])
# The code was developed with help of wokwi (https://wokwi.com) simulator
# and tested on real RPi Pico W
import time
import rp2
import machine as m
time.sleep(0.1) # Wait for USB to become ready
print("Pulse duration measurement")
p1=m.Pin(4,m.Pin.OUT)
pw1=m.PWM(p1)
pw1.freq(100)
#pw1.duty_u16(32768//2)
pw1.duty_u16(32768*3//2)

@rp2.asm_pio(in_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=False)
def read_pulse():
    set(y,1)
    in_(y,1)
    in_(null,30)
    #in_(null,1)
    mov(y,isr)
    push()
    wrap_target()
    mov(x, y)
    label("again_0")
    jmp(pin, "is_one")
    jmp(x_dec,"again_0")
    jmp("again_0")
    # Here we jump after rising edge
    label("is_one")
    in_(x,31)
    set(x,0)
    in_(x,1)
    push()
    mov(x,y)
    label("again_1")
    jmp(pin,"is_one_b")
    jmp("is_zero")
    label("is_one_b")
    jmp(x_dec,"again_1")
    label("is_zero")
    in_(x,31)
    set(x,1)
    in_(x,1)
    push()
    wrap()


p2 = m.Pin(2,m.Pin.IN)
if False: # Direct read
  while(True):
    print(p2.value())
if True: # Use PIO
  sm = rp2.StateMachine(0, read_pulse, freq=10000000, jmp_pin=p2)
  sm.active(1)
  print("Started!")
  while(True):
     print("Loop")
     b=sm.get()
     state=b & 1
     duration = (1<<30) - (b >> 1)
     print(state, duration)

It measures the duration of high and low states of the input signal (Pin 2). The test signal is generated with PWN on Pin 4. The duration is measured in units equal to two periods of the PIO statemachine clock.
The LSB of the result encodes whether this is a low state or high state.
So the problem indeed can be easily solved on the RPi Pico, but what I need is a solution for ESP32...

[rkompass]

That's a nice piece of code.
You might not have noted so far, because its not really documented:
One may read the PIO data into an array, which uses DMA under the hood.
Example code is here. Only for the RP2040 of course.

As for the ESP32, we have a feature request and discussion for unified PWM.
The first, although not indicated in the title, relates to BLDC motors.

From my (limited) point of view it would make sense to make a feature request for a special kind of PMW drivers, suited for BLDC motors, another perhaps for a PWM mode suitable for stepper motors. Best would be to have a suggestion/draft of a simple general API too, which is not restricted to ESP32's functionality only. Something which might be called multiPWM, synPWM or phasedPWM, as there are several channels involved which have to have certain phase relations wrt. each other.

Generally, what I need is Input Capture cooperating with fast IRQ or (better) DMA storing the time positions of consecutive rising and falling edges in a circular buffer.

Can it be easily implemented in micropython on ESP32?

Probably not. It rather looks like a lot of work.
Perhaps @robert-hh, the inofficial maintainer of PWM implementations :-) has a more qualified opinion on that?

[robert-hh]

The ESP32 PWM implementation was made by @IhorNehrutsa, who also works at it currently.

[IhorNehrutsa]

ESP32 PMW is based on LED Control (LEDC), not MCPWM

PCNT solution - Best Frequency Meter ever made with ESP32 - awesome!

[IhorNehrutsa]

esp32/MCPWM: Add motor control MCPWM driver. #12345