Signale pro Minute richtig berechnen Python?
Hallo, ich programmiere gerade etwas in Python, um die Geschwindigkeit meines Fahrrades zu messen. Indem ich mit einem Pi Pico die Signale eines Radsensores messe, jedoch währen die Werte ja erst ab einer Minute richtig oder wäre es sinnvoller direkt die Signale pro Sekunde zu berechnen und dann die Kommazahl hochzurechnen?
Also prinzipiell bräuchte ich das Prinzip von einem Tacho, welcher mir schon ab eins zwei Radumdrehungen die Geschwindigkeit kennt und wie ich das Ganze in Python umsetze, falls sich jedoch jemand nicht mit Python auskennt, gerne auch einfach was schlauer wäre.
4 Antworten
Ich kenne von anderen digitalen Messgeräten z.B. für die Motordrehzahl, dass da jede Sekunde mehrmals gemessen und dann auf min^-1 hochgerechnet wird. Die Anzeige wäre zunächst aber sehr unruhig, da sämtliche Schwankungen, die es immer gibt, voll auf die Anzeige durchschlagen würden. Um die Anzeige zu beruhigen und kurze Ausreißer rauszudämpfen, wird dann immer nur der Durchschnitt z.B. der letzten 5 Messungen angezeigt. Wieviele Messungen zum Mitteln man nimmt, ist Geschmacksache. Alles hat ein Für und ein Wider.
Du misst die Zeit t für eine Anzahl n von Durchgängen. Angenommen, du brauchst t=10 sec für n=30 Durchgänge. Und der Radumfang sei 2000 mm (vgl. Tabelle)
Dann ist deine Geschwindigkeit:
Kannst natürlich auch nur einen oder drei Durchgänge messen, da käme dann bei gleicher Geschwindigkeit 1/3 bzw. 1 Sekunde heraus. Entsprechend hättest du 1/0,33 * 2000 mm/sec bzw. 3/1 * 2000 mm/sec
Die Umsetzung in Python sollte jetzt kein Problem mehr sein ...
Du erfasst bei jedem Sensordurchgang die Zeit.Die Zeitdiffrenez zwischen 2 Durchgängen ist eine Radumdrehung, aus dem Umfang ergibt sich die Strecke.
Um auch bei beschränkter Zeitgranularität und hoher Frequenz gute Ergebnisse zu erhalten, kannst du dann einfach 2 oder 3 Umdrehungen betrachten. Dadurch wird die Genauigkeit besser und der Wert ändert sich nicht so sprunghaft.
Du nimmst ne Liste (nen Array) von z.B. der Länge 10. Und einen Positionszähler (mod Länge), wenn ein Signal reinkommt, dann schreibst Du an der Postion die Zeit rein und bildest dann die Differenz zum Wert 1(2,3,..) Positionen davor.
Du kannst dann also wählen, wieviele Umdrehungen Du betrachten willst und dadurch den Wert glätten, aber eben auchbei hoher Frequenz Probleme mit der Zeitgranularität vermeiden.
----
Anstatt aktiv zu warten und zu pollen wäre es definitiv besser das ganze asynchron zu machen respektive auf den Sensorpuls zu reagiren.
Das ganze könnte grob so aussehen:
import time
import GPIO
curr=time.time_ns() # monotonic Time in ns
vals=[curr,curr,curr,curr,curr,curr,curr,curr,curr,curr] #init
pos=0
while True:
GPIO.wait_for_edge(....) #wait for sensor
vals[pos]=time.time_ns()
pos=(pos+1)%10 # go to next pos
diff=(vals[pos]-vals[pos-1])/1000000000
speed=umfang/diff
Anmerkungen: Wenn Differenz 0, führt das zu einem Problem, Anstatt nur 1 Wert zurückzuschauen, kannst Du auch eine Differenz von 2 oder 3 nutzen, Du kannst die Distanz des Rückblicks auch dynamisch ändern.
Anstatt einer Liste kannst Du auch ein Array nutzen, das wäre hier durchaus sinnvoll.
Ein weiteres mögliches Problem ist, daß Du einen Sensorpuls verpassen könntest, vor allem wenn Du umfangreichere Aktionen durchführen wolltest. Da wäre es sinnvoll die Schleife zu minimieren und den Rest in einen Thread auszulagern, der periodisch (z.B alle 0.5 Sekunden) die Berechnung macht und das Display aktualisiert.
So, das sollte Dir grob die Richtung vorgeben.
Einfach die Zeit je Umdrehung messen
Uns dann aus der Zeit für 1 Umdrehung die Geschwindigkeit berechnen
Bei x/sek oder x/min gib es immer unvollständige Umdrehungen die du bei 1 Sensor nicht genau ermittelst
Aber wie soll man das dann sinnvoll in Python integrieren und auf Kilometer pro Stunde hochrechnen
Berechnung?
Das ist doch Kreisberechnung
Der Sensor - ich nehme an du nutzt Reedkontakt oder Lichtschranke - legt einen Kreis zurück bei einer Umdehung
Das Rad dann auch
Die Strecke ist dann entsprechend der Reifengröße der Umfang des Rades.
D.h. du hast ein Strecke in einer bestimmten Zeit
Den Wert musst du dann in km/h umrechnen
Also einfache Mathematik
Und das mache ich dann am besten mit einer Schleife, die mit time.time bei Eingang des Signales die Zeit misst und dann pack’ ich zwischen rein eine Schleife, welche bei einem Signal die Schleife stoppt, um dann nochmal die Zeit zu stoppen und die Endzeit mit der Startzeit zu subtrahieren?