Parallele Verarbeitung
-
maksimilian -
22. Dezember 2018 um 12:29 -
Unerledigt
-
-
Parallele Verarbeitung? Schau mal ob du hier fündig wirst!
-
- Offizieller Beitrag
-
Hallo Maksimilian,
ja, gibt es.
Nennt sich State Machine.
Die meisten werden Dir allerdings zu Threads raten. Geht auch - ist aber meist weniger elegant.
Je nach Programmiersprache werden auch Co-Prozesse bzw. Co-Expressions eine Lösung darstellen. Auch dazu gibt es Tutorials zu Hauf...
Beste Grüße
Andreas
-
Hallo,
Zitatgibt es die Möglichkeit, in raspbian parallele Abläufe zu implementiern ?
Kommt drauf an. Auf einem 1-Kern Raspi wie dem Pi Zero: nein, weil nur 1 Kern. Auf den Mehrkern Pis: grundsätzlich ja.
Die Frage ist dann eher, ob du _wirklich_ echte Parallelität brauchst oder "nur" Nebenläufigkeit. Nebenläufigkeit reicht i.d.R. für das von dir beschriebene aus.
Die konkrete Umsetzung hängt von der Programmiersprache deiner Wahl ab.
Gruß, noisefloor
-
das muss ja nicht parallel laufen
während die LED an oder aus ist hast du jede Menge Zeit Sensoren auszulesen, wenn das Auslesen in die Zeit passt
wie machst du das am Backofen, schaust du der Pizza beim backen zu die ganze Zeit?
oder weisst du sie ist in 25 Minuten fertig und machst derzeit was anderes und schaust in 25 Minuten wieder beim Backofen vorbei?
Man kann ja geschickter programmieren!
-
Hallo maksimilian,
genug der Rückfragen, hier mal ein Beispiel wie man das in Python lösen kann.
Code
Alles anzeigen####################################################################### # zuerst mal die intergrierten Programme import threading import RPi.GPIO as IO # GPIO für Python laden import time # ####################################################################### # Ab hier stehen alle Board-Setups die nötig sind IO.setwarnings(False) # Fehlermeldungen für GPIO unterdrücken IO.setmode(IO.BOARD) # Pinbelegung auf Board setzen ( 1 - 40 Pinnummer gilt) IO.setup(32, IO.OUT) # Pin 32 (GPI21) wird zum dig. Ausgang - Audioverstärker ein ################################################################## # 500ms Zyklus # def alle_500ms(): global timeloop if timeloop == 1: IO.output(32, 1) timeloop = 0 else: IO.output(32, 0) timeloop = 1 timer = threading.Timer(0.5, alle_500ms) timer.start() # # ertser Start der 500ms timeloop = 1 timer = threading.Timer(0.5, alle_500ms) timer.start() ####################################################### # Ab hier steht der Rest des Pythonprogramms #
Einfach mal kopieren und ausprobieren.
Viele Grüße
Thotaa
-
Hallo,
Thotaa: Threads sind unter Python nicht parallel (Stichwort: GIL), "nur" nebenläufig. Wenn man unter Python echte Parallelität braucht, brauchst du eine Multicore CPU und das `multiprocessing` Modul (oder `concurrent.futures` mit Multiprocessing).
Zum Code: statt dem komischen Konstrukt mit dem selbst-rekursiven Aufruf kannst du die Arbeit im Thread auch in eine Endlosschleife packen und statt der in 99,9% der Fälle schlechten Verwendung von `global` nutzt du `threading.Event`, um die Endlosschleife bei Bedarf zu stoppen bzw. eine `True` oder `False` Bedingung zu übergeben / signalisieren.
Gruß, noisefloor
-
Oder mit gpiozero, das in vieler Hinsicht besser ist als RPi.GPIO:
Pythonfrom gpiozero import LED from signal import pause led = LED(21) led.blink() # Restlicher Code pause()
Doku zu gpiozero.LED.blink: https://gpiozero.readthedocs.io/en/stable/api_…ozero.LED.blink
-
Hallo,
noch eine Ergänzung maksimilian , weil ich es die Tage vergessen hatte: es gibt im allgemeinen zwei Probleme im Programmierumfeld, denen mal mit Nebenläufigkeit begegnen kann: "I/O bound" und "CPU bound". Letzteres heißt, dass die Rechenleistung eines CPU-Kerns der limitierende Faktor ist, ersteres, dass I/O der limitierende Faktor ist. CPU bound Probleme kann man mit echter Parallelität (=mehr CPU Kerne, die gleichzeitig rechnen) begegnen. Ein CPU-bound Problem ist z.B. ein Test auf Primzahlen. Wenn du 8 Kernen hast, kannst du auf jedem Kern einen Test durchführen.
I/O bound heißt, dass die CPU hauptsächlich auf I/O wartet (Netzwerk, GPIO, was-auch-immer). Dazu gehört auch das im Ausgangspost beschriebene Problem, also Blinken einer CPU (das Schalten der LED ist vergleichsweise schnell, da Hauptzeit wartet die CPU darauf, erneut einen Schaltvorgang durchführen zu können, warten auf einen Tastendruck etc. Dem kann man am einfachsten mit einem Modul wie gpiozero begegnen, dass das mit Bordmitteln direkt kann. Threads sind in Python aufgrund der Implementierung und des GIL nicht so der Hit (wenn natürlich trotzdem möglich). 1. Wahl ist seit Python 3.5 asyncio, bzw. Module wie trio, die async/await in Python umsetzen.
Gruß, noisefloor
-
Hallo Ihr,
entschuldigt meine späte Reaktion. Obwohl ich das Thema abonniert habe, erhalte ich keine Mails. Danke für alle Antworten. Jetzt habe ich erst einmal Stoff zum Testen.
Ich benutze übrigens den aktuellsten PI und programmiere mit Python3.
maksimilian
-
Du musst auch in den Einstellungen Emails für Benachrichtigung aktivieren, wenn Du sowas haben willst
Jetzt mitmachen!
Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!