Hallo
Dank meiner vorherigen Projekte habe ich mich größtenteils mit µPython beschäftigt, und habe eine Funktion den Timer lieben gelernt. Gibt es auch für das normale Python auf einem Zero auf welchem das Raspbian System Buster 32 bit läuft eine solche Funktion mit der man periodische Abläufe zumindest im Bereich 1/10 Selunden genau starten kann ?
Danke im Voraus
Günter
Schau mal ob du hier fündig wirst!
Man könnte threading.Timer erweitern:
import time
from threading import Timer
class MyTimer(Timer):
SINGLE = object()
PERIODIC = object()
def __init__(self, mode, intervall, function, *args, **kwargs):
super().__init__(intervall, function, *args, **kwargs)
self.mode = mode
self._running = False
def stop(self):
self._running = False
def run(self):
self._running = True
if self.mode is self.PERIODIC:
while self._running:
super().run()
self.finished.clear()
else:
super().run()
def cb(msg):
print(f"{time.perf_counter():.1f}: {msg}")
t = MyTimer(MyTimer.PERIODIC, 0.1, cb, ("Hello",))
t.start()
time.sleep(20)
t.stop()Vom Timing her ist es aber nicht so genau, wie bei den Mikrocontrollern.
Guenter.H. Da laufen ja normale Betriebssysteme drauf und da ist ein übliches Mittel für Nebenläufigkeit Threads zu verwenden. Was die zeitliche Genauigkeit angeht: Da laufen ja normale Betriebssysteme drauf, also deutlich mehr als nur Dein Programm alleine, und der Kernel entscheidet wann welcher Prozess welchen Prozessor(kern) benutzen darf. Einerseits klingt so ungefähr alle 1/10 Sekunde machbar, andererseits so wirklich *garantiert* wird das natürlich nicht.
Falls man eine GUI programmiert, kommt dann noch dazu, dass GUI-Rahmenwerke in der Regel zum Grossteil nicht thread-sicher sind, man also die GUI selbst nur aus dem Thread in dem die GUI-Hauptschleife läuft verändern darf. Deshalb haben GUI-Rahmenwerke Wege um zeitverzögerte Ausführung von Funktionen über deren Hauptschleife anzufordern. Auch wieder mit Einschränkungen was die Genauigkeit des Zeitpunkts angeht.
Guenter.H. Nein, das fällt da nicht drunter. Ich erwähnte das bloss, weil man öfter mal den Fall hat das jemand Nebenläufigkeit mit Threads macht und das dann mit einem GUI-Rahmenwerk (Tk, Gtk, Qt, wxWidgets, …) kombinieren will, wo es oft sinnvoller ist erst einmal zu schauen welche Mittel das verwendete Rahmenwerk zur Verfügung stellt.
Wenn ich deinen Code richtig verstanden habe übergibst du mit "MyTimer(MyTimer.PERIODIC, 0.1, cb, ("Hello",))" schon den Inhalt der Ausgabe. Wenn diese sich aber nun während der Laufzeit periodisch vom Programmablauf ändert ?
Wie kann ich dann in der Funktion "cb" einen oder den aktuellen Inhalt einer Variable einschleusen ?
Günter
Guenter.H. Über das Argument. Man muss da ja keinen unveränderlichen Wert übergeben, sondern kann auch eine `queue.Queue` in die ein anderer Thread Werte steckt, oder ein beliebiges Objekt von dem man Werte abfragen kann. Da muss man dann darauf achten, dass das ganze thread-sicher passiert. Die `queue.Queue` sichert den Zugriff bereits ab, bei eigenen Objekten muss man da gegebenenfalls selbst für sorgen, dass da keine Probleme entstehen können weil mehrere Abläufe gleichzeitig darauf zugreifen können.
So?
import time
from functools import partial
from queue import Empty, Queue
from random import randint
from threading import Thread
from tkinter import Button, IntVar, Label, Tk
def add_stuff(queue):
queue.put(randint(0, 6000))
def worker(queue, variable):
while True:
time.sleep(0.5)
try:
variable.set(queue.get(timeout=5))
queue.task_done()
# Queue.task_done sollte man verwenden,
# wenn man später Queue.join nutzen möchte
except Empty:
print("Warteschalnge ist leer")
def main():
q = Queue()
for value in range(10):
q.put(value)
root = Tk()
value = IntVar(root, 666)
Label(root, textvariable=value).pack()
Button(
root, text="Add random number to queue", command=partial(add_stuff, q)
).pack()
Button(root, text="Quit", command=root.destroy).pack()
thread = Thread(target=worker, args=(q, value), daemon=True)
root.after(1000, thread.start)
root.mainloop()
if __name__ == "__main__":
main()Hallo @DeaD_EyE
ich habe eine Meßroutine, welche über einen MCP3202 zeitlich begrenzt jedoch permanet eine Spannung überwacht. Jedesmal wenn ein gewisser Grenzwert überschritten wird, wird ein Counter um 1 erhöht. Wenn dieser Counter den Nennwert von 1800 überschreitet, erfolgte eine Unterbrechung des Meßvorgangs. Eine gewisse Folge an GPIO Schaltvorgängen wird ausgeführt bis am ADC Eingang wieder eine Minimalspannung erfasst, der Counter auf Null gesetzt - dann geht das ganze Spiel von vorne los.
Nun möchte ich noch das dieser Counter auf den letzten 4 Stellen dieser doppelten 4-fach Siebensegmentanzeige regelmäßig aktualisiert wird.
Wozu braucht man da Nebenläufigkeit? Kann man die Anzeige nicht einfach jedes mal ändern wenn sich der Wert ändert?
Nein das funktioniert leider nicht. Wenn ich jedesmal mit der Werterhöhung des Counters auch eine Displayaktualisierung durchführe gehen mir Werte verloren. Teilweise erhöht sich der Counter selber mehrere Male pro Sekunde. Ich muss selber auch nicht den wirklich so "aktuellen" Wert haben, es ist eher nur eine Anzeige oder Orientierunsghilfe.
Ich habe das auch schon versucht mittels Ausgabe print(counter) nur dazu ist selbst das ZERO zu langsam bei angeschlossen HDMI Monitor. Die Darstellung erfolgt dabei stark zeitverzögert, und es kommt zu Überschreitungen. Was bedeutet der Counter erfasst nicht mehr alle Überschreitungen.
Rein vom eigentlcihen Programmablauf ist alles bestens, nur möchte ich für mich eine kleine Orientierungshilfe / -anzeige haben, damit ich ungefähr abschätzen kann wie lange dieser einzelne Vorgang noch dauern könnte.
Oder welche Art Display / Anzeige wäre hierfür ggf. besser geeignet ? Ich hatte nun gerade noch diese Dual 4-fach Anzeige herumliegen und auch gleich angeschlossen. Deswegen hatte ich schon eingangs geschrieben ungefähr 1/10 Sekunde sollte ausreichend sein.