PWM Signal auswerten

[Nitro]

Hallo

Ich versuche zu verstehen, wie man am einfachsten ein PWM Signal auswerten kann.
Das PWM Signal das ich schlussendlich verarbeiten muss habe ich gemessen und ist so aufgebaut: Periodendauer 5.0ms (200Hz), Duty Cycle ist zwischen 800us und 2200us.
Das Signal ist eigentlich für ein schnelles Digital Servo.

Mich interessiert nur die Zeit wie lange die Flanke oben ist, also das DutyCycle.
Nun habe ich als Anfänger ein Code gebastelt, statt das PWM Signal benutze ich einen Taster. Wenn dieser gedrückt wird, printet es die Zeit in us aus bis ich den Taster loslasse.

Wie aber baue ich das ganze Professionell auf?
Das Programm müsste den Wert jeweils nur einmal als integer speichern pro Periode.
Beim nächsten Zyklus diesen überschreiben.
müsste ich dies als Interrupt bauen?
Existiert eventuell schon eine Funktion dafür?

Anbei ein Bild vom PWM und der Test Code:

https://www.bilder-upload.eu/bild-6a297 ... 1.jpg.html

Code: Alles auswählen

import utime
from time import sleep
import machine

taster = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)

while True:
    if taster.value() == 0:
        timer_start = utime.ticks_us()
    if taster.value() == 1:
        timer_stop = utime.ticks_us()
        print("%.f us" % (timer_start - timer_stop))
        sleep(0.2)

[Nitro]

Eventuell habe ich oben Zuviel geschrieben? :=)
Vereinfacht gesagt, ich suche eine effiziente Lösung wie ich die Zeitdauer einer Flanke messen kann, solange diese auf High steht.

Was denkt Ihr dazu?

[__blackjack__]

@Nitro: Womit denn? Ein Raspi wäre IMHO wohl eher ungeeignet für genaue Messungen. Der gezeigte Code sieht aber auch so ein bisschen nach MicroPython aus‽

[Nitro]

@Nitro: Womit denn? Ein Raspi wäre IMHO wohl eher ungeeignet für genaue Messungen. Der gezeigte Code sieht aber auch so ein bisschen nach MicroPython aus‽

zuerst habe ich mich ab deiner Antwort gewundert, aber jetzt ist mit erst aufgefallen:
Dieses unterforum heisst nicht PICO sondern PI und CO!

In diesem Sinne, ja, ist natürlich MicroPython, da ich den PICO nutze.

[Nitro]

Hmm, so wie es aussieht ist hier MicroPython nicht so verbreitet. :=)

[DeaD_EyE]

Ich würde einfach einen IRQ nehmen, der die steigenden oder fallenden Flanken zählt.

http://docs.micropython.org/en/latest/l ... ne.Pin.irq

Code: Alles auswählen

import machine
import utime


class Handler:
    def __init__(self):
        self.ticks = []
        self.last_tick = utime.ticks_us()
        
    def __call__(self, pin):
        current_tick = utime.ticks_us()
        delta = utime.ticks_diff(current_tick, self.last_tick)
        if len(self.ticks) >= 50:
             self.ticks.pop(0) # popleft
             # nicht so gut, da listen dafür nicht optimiert sind
             # kann bei micropython aber anders sein
             # deque ist anders implementiert
        self.ticks.append(delta)
        self.last_tick = current_tick

    @property
    def delta_us(self):
        return sum(self.ticks) / len(self.ticks)

    @property
    def mhz(self):
    	return 1 / self.delta_us
    
    @property
    def hz(self):
        return 1 / (self.delta_us / 1e6)
        


counter = Handler()
taster = Pin(14, machine.Pin.IN, Pin.PULL_DOWN)
taster.irq(counter, trigger=Pin.IRQ_RISING)


while True:
    utime.sleep(1)
    print(counter.hz)