Ein RPi w/ Sensoren-->2ten RPi ansteuern

Heute ist Stammtischzeit:
Jeden Donnerstag 20:30 Uhr hier im Chat.
Wer Lust hat, kann sich gerne beteiligen. ;)
  • Hallo zusammen,

    ich suche nach einer grundsätzlichen Vorgehensweise, nach dem Motto: "Wie macht man das überhaupt?"

    ich habe:
    Zwei Raspberry Pis mit jeweils einer Raspicam. An einem der Raspberry Pi habe ich die GPIOs mit verschiedenen Sensoren bestückt. Die Raspberry Pis stehen an verschiedenen Positionen.

    ich möchte:
    Wenn die Sensoren in einer bestimmten Schrittfolge angesprochen werden, sollen von beiden Kamera jeweils ein Foto gemacht werden. (Und ggf auf einem Webserver(?)) ausgegeben werden.)

    ich habe bereits:
    in Python ein Programm geschrieben mit dem die Schrittkette sicher erkannt wird und der Raspberry Pi mit den Sensoren ein Bild macht.

    also meine Fragen konkreter:
    Wenn die Schrittkette auf dem GPIO-RPi erkannt, sollen mit beiden RPi möglichst gleichzeitig Fotos gemacht werden. Der GPIO-RPi müsste dem anderen also mitteilen, dass die Schrittkette durchlaufen ist und er ein Foto machen soll.
    Wie geht man so etwas überhaupt an?
    Zur Zeit lese ich: https://www.forum-raspberrypi.de/Thread-andere-…n-bisschen-Ajax

    Wenn dann die Fotos gemacht wurden, sollen die Fotos von einem anderen Rechner angezeigt werden. Also ein Interface, das beide Bilder liefert. Das will ich über einen Apache2-Webserver machen lassen, dazu müsste ich aber die Bilder von einem zum anderen RPi bekommen, oder? Wie mache ich das geschickt? Ich hätte jetzt das gefunden: http://picamera.readthedocs.io/en/release-1.1…-network-stream

    Für jeden Vorschlag dankbar!

    Mit freundlichen Grüßen
    Danpi

  • Kannst du auch einfacher haben mit PIGPiO. Das laeuft als Daemon (also eigener Prozess) auf dem PI mit den beschalteten GPIOs. Und weil es ein Server-Prozess ist, kann der andere PI darauf auch zugreifen, mit dem exakt gleichen Programm! Nur musst du die Netzwerkadresse des anderen PI uebergeben. Und schon laeuft zweimal das gleiche Programm, befuettert aus den gleichen GPIOs.


  • Kannst du auch einfacher haben mit PIGPiO. Das laeuft als Daemon (also eigener Prozess) auf dem PI mit den beschalteten GPIOs. Und weil es ein Server-Prozess ist, kann der andere PI darauf auch zugreifen, mit dem exakt gleichen Programm! Nur musst du die Netzwerkadresse des anderen PI uebergeben. Und schon laeuft zweimal das gleiche Programm, befuettert aus den gleichen GPIOs.

    wow, top :D

    Werde ich dann ausprobieren und berichten :danke_ATDE:

  • Das was deets erwähnte => GPIO-Server

    Ansonsten würde ich das mithilfe von Socket realisieren - also einem eigenen. pigpio nutzt zur Kommunikation übers Netzwerk auch Socket. Das kannst du relativ einfach mit Python umsetzen und wäre unabhängig von GPIO, denn die RaspiCam steuert man ja eigentlich nicht über GPIO :s
    Siehe dazu FAQ => Nützliche Links / Linksammlung => Daten zwischen PI's über Netzwerk verschicken

    Was du auch machen könntest wäre den Stream beider/aller RaspiCams auf einem vereinen sodass du also Live zugucken kannst was die gerade aufnehmen, siehe dazu ebenfalls in der Linksammlung Verzögerungs freies Streamen (lowest streaming latency)

    Und zu guter letzt würde ich das Webinterface dann ebenfalls direkt in Python umsetzen, so könntest du dann auch Problemlos die Socket Sache und pigpio direkt implementieren... Siehe dazu ebenfalls in der Linksammlung [Python] Webserver, Websocket und ein bisschen AJAX
    Dort könntest du dann auch zentral alle relevanten GPIO Zustände visualisieren, oder die Sensorwerte anzeigen, oder die Bilddateien; oder was auch immer ;)
    Es muss aber keine Webseite sein, du könntest auch pygame oder tkinter verwenden - auch dafür findest du Lösungen im lowest latency Thread :fies:

    Ansonsten: Dateien automatisiert übertragen , siehe Linksammlung Automatisierte Dateiübertragung (ftp / sftp / scp ..usw..)

  • Vielen Dank für Deine Antwort :danke_ATDE: Ich habe jetzt auf jeden Fall schon einmal was, wo ich mich entlang hangeln kann, jetzt heißt es ausprobieren :lol:



    Das kannst du relativ einfach mit Python umsetzen und wäre unabhängig von GPIO, denn die RaspiCam steuert man ja eigentlich nicht über GPIO :s

    Wie genau meinst Du das? :huh: Also generell benutze ich im Python-Programm zur konkreten Kamera-Steuerung PiCamera. Dazu frage ich die GPIOs und ihre Schritt-Folge ab.
    Mein ganzer Vorgang dauert in der Regel zwischen 8-15 Sekunden. Bei Schritt 0/1 lasse ich schon die Preview laufen, damit sich Beleuchtung etc anpasst.
    Bei Schritt N mache ich dann das Capture. Bisher bekomme ich dabei gute Bilder

  • Die GPIO's kannst du über pigpio und somit Netzwerk ansprechen/steuern, aber die RaspiCam selbst wird ja nicht über GPIO gesteuert.

    Du könntest halt ein eigenes Script auf Basis von Socket schreiben - also zum Beispiel:

    Pi-A hat nur eine RaspiCam.
    Pi-B hat die ganzen Sensoren und auch eine RaspiCam.

    Welcher davon als Client oder Server fungiert ist relativ egal - der eine verbindet sich über Socket und Netzwerk zum anderen - ich leg jetzt einfach mal fest das sich Pi-A zum Pi-B verbindet und somit Pi-B der Server wäre ;)

    Erkennt Pi-B jetzt eine Bewegung (oder was auch immer bei dir der Auslöser ist), schickt er über den Socket einen selbst definierten Befehl an Pi-A von wegen "Aufnehmen!". Pi-A nimmt ein Bild oder Video auf und schickt die Datei dann via sftp/scp an Pi-B...

    Da kommt in dem Fall kein pigpio-Socket zum Einsatz da Pi-A keine GPIO's verwendet.

    Später könntest du natürlich auch an Pi-A Sensoren anschließen und dann auch pigpio verwenden bzw über Netzwerk ansprechen...

  • Dass die Kamera selbst nicht über die GPIOs läuft weiß ich.

    Grundsätzlich finde ich die von Dir vorgeschlagene Vorgehensweise gut, dann könnt ich ja wie Du sagtest den PIGPIO-Teil weglassen.

    Ich habe nur Bedenken, dass wenn ich ein Befehl "Aufnehmen" sende, das Capture vom Pi-A schlechtere Qualität hat, da dann keine Preview laufen würde?

    Der Vorgang ist halt Prozess- und nicht zeitgesteuert.

    Wobei nichts gegen zwei Befehle "starte Preview" und "mache Aufnahme" sprechen würde, oder?


  • Wobei nichts gegen zwei Befehle "starte Preview" und "mache Aufnahme" sprechen würde, oder?

    ;)
    Was du Wie umsetzt ist ja dir überlassen. Ob du erst ein Preview und erst 5 Minuten später eine Aufnahme startest, legst du selbst fest ;) Es gibt keine Grenzen, alles ist möglich :)

  • Hallo nochmal,

    Ich wollte heute schon einmal ein wenig starten, habe aber nur einen Raspberry Pi mit einer Platine mit Schaltern, zur Simulation der Sensoren, und einen Windows-PC
    (Morgen habe ich wieder volles Equipment, habe heute aber Zeit)

    Ist es möglich, dass ich den Raspberry Pi als Server laufen lasse und dann statt den Aufnahmen -und damit verbunden preview und Capture- einfach beispielsweise Textdsteien schreibe oder Bildschirmausgaben mache und auf dem Windows-PC, der als Client dienen soll, auch statt den Aufnahmen(preview, Capture) Textdsteien schreibe und dem Pi schick?

    Also in kurz:
    Dummy-Augbau mit Windows-PC als Raspberry Pi ohne Sensoren und der Rsspberry-Pi mit den Schaltern als Sensor-Pi.


    Sodass ich später quasi nur noch den Windows-PC durch den Pi ersetzen muss und statt den Textdateien eben Aufnahmen mache und verschicke.

    Oder wäre dazu viel zusätzlicher Aufwand nötig? Ich möchte erst einmal das Vrrständnis für die Client/Server Struktur bekommen und ein wenig ausprobieren.
    Aber es sollt halt nicht von vornherein ins Nichts führen, daher die Frage :helpnew: . Dass ich keine Erfahrung habe, brauche ich ja nicht zu erwähnen :lol:

    Vielen Dank im Voraus :danke_ATDE:

    Einmal editiert, zuletzt von Danpi (18. September 2016 um 08:56)

  • Hallo zusammen,

    ich habe jetzt ein Server und einen Client geschrieben. Das habe ich aber noch nicht wirklich verstanden.

    Zum Testen habe ich für die einzelnen Schritte print-Ausgaben gemacht, einfach nach dem Aufbau der Verbindung mit c.send("Ausgabe") auf dem Server und print s.recv(1024) auf dem Client. Um das zu überprüfen, habe ich also an beiden PIs Monitore. Die Ausgaben kommen schön synchron.

    Nun weiß ich aber nicht, wie ich sozusagen echte Befehle, die ich in Python bearbeiten kann, an den Client schicke. Ich habe bisher versucht die Strings zu vergleichen und dann auf der Client-Seite eben zum Beispiel cam.start_preview() aufzurufen. Abgesehen davon, dass das ja wahrscheinlich ohnehin nicht die richtige Methode ist, hat es auch nicht funktioniert :lol:
    Ich wollte halt sozusagen einen billigen Interrupt machen, der bei Übereinstimmung reagiert.

    Also, die Frage ist:
    Wie rufe ich von der Server-Seite Befehle im Python-Skript der Client-Seite auf?
    Bei send() brauche ich ja eh Strings (oder Puffer), da werde ich ja keine Befehle reinpacken können.

    Danke im Voraus :danke_ATDE:

  • Was du sendest legst du ja selber fest. Das wiederum kannst du beim Empfänger dann auch exakt prüfen und eine entsprechende Aktion durchführen.

    Orientier dich dabei einfach an dem: Netzwerkzugriff auf 1Wire Sensor (Das ist Beispiel#2 aus oben erwähnter Linksammlung)
    Auf dem einen Pi, der die Daten empfangen und verarbeiten soll, startest du Server.py
    Auf dem anderen Pi übergibst du direkt beim ausführen den zu sendeten Text.... Zum Beispiel:

    Code
    python Client.py get.cputemp:1


    Als Antwort müsste beim Client dann die CPU Temperatur des Servers erscheinen :)

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!