PWM counter??

[michaelboatboy]

I wrote a program to drive a stepper motor. Every pulse on the PWM pin moves the motor one step. Is there a way to count the total number of pulses the I generated so that I can know the exact position? If not, I can estimate using some math. The chip I am using is the ESP32-D4-PICO. Thanks in advanced!

[robert-hh]

There are a few pull requests outstanding which implement a counter for the ESP32. None of them is merged yet. Until then you could connect the PWM output to another Pin and use Pin.irq() to count pulses in a handler called by a transition at that pin. That should work up to a frequency of about 1 kHz.

[michaelboatboy]

Okay thanks! I,ll do that!

[michaelboatboy]

Is it possible to use the same pin for Pin.irq() and Pin.PWM()?

[robert-hh]

Probably not.

[michaelboatboy]

This code does not:

from machine import Pin, PWM
from time import sleep
total = 0

def handle_interrupt(pin):
global total
print('ping')
total += 1

pir = Pin(2, Pin.IN)

pin = Pin(2, Pin.OUT)

PWM2 = PWM(pin)

PWM2.freq(1)

PWM2.duty(512)

pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

sleep(10)

print(f'done, total = {total}')

[rkompass]

So Robert was right.

[michaelboatboy]

I think so, at least for ESP32

[glenn20]

To make things easier for you and others next time you post code, check out the Welcome (Please read before posting) post pinned at the top of the Discussions page. It explains nicely how to get nicely formatted code in your posts. You can also check by clicking on the Preview tab when you are writing your post.

[michaelboatboy]

Will do

[karfas]

I'm just curious.

Why are you using the PWM output to generate N pulses ? It can't be too complicated to generate (and count) pulses on the GPIO output, either from a python function or using other means - the ULP processor comes to my mind.

[michaelboatboy]

I would like to experiment with 10 kHz but ultimately it is up to how much my motors can handle. I have gotten 2 kHz with a 12v charger but I will use a proper 24v power supply and change some values to hopefully get it running at 10 kHz or more.

[bixb922]

It should be perfectly achievable to produce 10khz or much more just by moving GPIO. That allows to count pulses well. But the CPU will be dedicated to that task only.

[michaelboatboy]

OK, I will try that, although the CPU will have to share it's process with other jobs so the program might be a bit large. If worse comes to worse, I will update my PCB to have a spare pin connected so I can use Pin.irq().

[robert-hh]

As mentioned in my first answer, I expect this to work up to a few kHz. I've set up a small test with a ESP32, code:

from time import sleep_ms
total = 0

def handle_interrupt(pin):
    global total
    total += 1

pir = Pin(2, Pin.IN)
pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

def count(freq=10):
    global total
    total=0
    pwm = PWM(Pin(4), freq=freq, duty=512)
    sleep_ms(1000)
    print(f'freq={freq}, counted = {total}')
    pwm.deinit()

Result:

freq=10, counted = 10
freq=100, counted = 100
freq=500, counted = 500
freq=1000, counted = 998
freq=2000, counted = 1996
freq=4000, counted = 3995
freq=10000, counted = 10004

So it's not that bad. Using a class may be faster. It works good up to 500Hz. It gets worse above that, and even more if the code with the IRQ has to be swapped in from flash. The ESP32 is known for bad IRQ latency.
Above 1 kHz, the time window may not be exactly precise match the PWM counter, and as with all position counters, you may have a drift. So you need a reference position which resets the position counter to a defined value.

[michaelboatboy]

Ok I will try that, thank you!

[michaelboatboy]

Thanks everyone, I have many things I can try now. You guys are super helpful.

[rkompass]

Another idea appeared: The PWM uses a prescaler and a counter base value to achieve the desired frequency. You might use an ordinary timer channel that uses the same prescaler (or a multiple of its value) and a counter base that also hase the same or better a multiple value of the PWM counter base. This way you have synchrony between the PWM and the timer up to multiplicity. In the case of multiplicity your interrupts can better cope with the high PWM frequency.