Gesichtserkennungs-Sicherheitssystem für einen Kühlschrank mit Raspberry Pi - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Beim Durchstöbern des Internets habe ich festgestellt, dass die Preise für Sicherheitssysteme zwischen 150 $ und 600 $ und höher liegen, aber nicht alle Lösungen (auch die sehr teuren) können mit anderen intelligenten Tools bei Ihnen zu Hause integriert werden! Sie können beispielsweise keine Überwachungskamera an Ihrer Haustür aufstellen, damit diese automatisch die Tür für Sie oder Ihre Freunde öffnet!

Ich habe mich für eine einfache, kostengünstige und leistungsstarke Lösung entschieden, die Sie überall verwenden können! Es gibt viele Handbücher, wie man billige und selbstgemachte Sicherheitssysteme erstellt, aber ich möchte eine wirklich nicht triviale Anwendung davon demonstrieren – Sicherheitssystem für einen Kühlschrank mit Gesichtserkennung!

Wie funktioniert es? Die IP-Kamera auf der Oberseite eines Kühlschranks, Sensoren (zwei Tasten) erkennen, wenn eine Person die Kühlschranktür öffnet, danach macht Raspberry Pi ein Bild von dieser Person (mit IP-Kamera) und sendet es dann an die Microsoft Face API um das Bild zu analysieren und den Namen der Person zu erhalten. Mit diesen Informationen scannt Raspberry Pi die „Zugriffsliste“: Wenn die Person keine Berechtigung zum Zugriff auf den Kühlschrank hat, benachrichtigt Raspberry den Besitzer per E-Mail, SMS und Twitter! (Siehe Bilder oben)

Wieso den? Das System ermöglicht es Ihnen, Ihre Familienmitglieder zu kontrollieren, insbesondere wenn sie eine Diät machen oder damit kämpfen, nach Mitternacht nichts mehr zu essen! Oder verwenden Sie es einfach zum Spaß!

Darüber hinaus können Sie die Kamera an Ihrer Haustür aufstellen und das System so konfigurieren, dass es die Tür öffnet, wenn Sie, Ihre Familienmitglieder oder Freunde sich nähern. Und das ist nicht das Ende! Die Anwendungsmöglichkeiten sind endlos!

Lass uns anfangen!

Schritt 1: Vorbereitung

Du wirst brauchen:

• Raspberry Pi 3 (Sie können ältere Versionen verwenden, aber die dritte Generation verfügt über Wi-Fi, daher ist es sehr praktisch)
• Tasten
• Drähte
• Alte Smartphone- oder Raspberry Pi-Kamera

Als erstes müssen Sie Ihren Raspberry Pi konfigurieren. Detaillierte Anweisungen dazu finden Sie hier und hier, aber die wichtigsten Schritte werden wir in diesem Handbuch behandeln.

1. Laden Sie hier Win32 DiskImager herunter (wenn Sie Windows verwenden)
2. Laden Sie den SD-Formatierer hier herunter
3. Legen Sie die SD-Karte in Ihren Computer ein und formatieren Sie sie mit dem SD-Formatierer
4. Laden Sie Raspbian Image von hier herunter (Wählen Sie "Raspbian Jessie mit Pixel")
5. Führen Sie Win32 DiskImager aus, wählen Sie Ihre SD-Karte aus, geben Sie den Pfad zum Raspbian-Image an, klicken Sie auf "Schreiben"
6. Legen Sie die SD-Karte in Ihren Raspberry Pi ein und schalten Sie das Gerät ein!

Außerdem müssen Sie Ihren Raspberry Pi so konfigurieren, dass er über SSH auf das System zugreifen kann. Anleitungen gibt es viele im Internet, man kann diese zum Beispiel nutzen oder man kann Monitor und Tastatur anschließen.

Jetzt ist Ihr Pi konfiguriert und Sie können fortfahren!

Schritt 2: Einen Sensor herstellen

Schrittbeschreibung: In diesem Schritt werden wir einen Sensor erstellen, der erkennt, wenn eine Person die Tür eines Kühlschranks öffnet und Raspberry Pi aktiviert.

Um es einzurichten, benötigen Sie die 2 Schaltflächen, die Sie ursprünglich vorbereitet haben. Die erste Taste erkennt, wenn die Tür geöffnet wird, die zweite Taste erkennt, wenn die Tür geöffnet wird, bis wir ein Foto von einer Person machen.

1. Lötdrähte an Knöpfe.
2. Befestigen Sie den ersten Knopf an der Kühlschranktür so, dass er beim Schließen der Tür gedrückt wird (siehe Bild oben)
3. Bringen Sie den zweiten Knopf an der Kühlschranktür an, wie auf dem Foto oben gezeigt. Diese Taste muss immer losgelassen werden, außer wenn die Tür den Punkt erreicht, an dem das System ein Bild aufnimmt. Zum Aufstellen müssen Sie etwas an Ihrem Kühlschrank befestigen, damit diese Taste beim Öffnen der Tür im gewünschten Maße gedrückt wird (siehe Fotos oben).
4. Schließen Sie die Drähte von den Tasten an den Raspberry Pi an: erste Taste an GPIO 23 und Masse, zweite Taste an GPIO 24 und Masse (siehe Fritzing-Diagramm).

Hinweis: Ich verwende BCM-Pinout (nicht Board), mehr zum Unterschied lesen Sie hier.

Sobald Sie über SSH mit Ihrem Raspberry Pi verbunden sind, geben Sie zum Ausführen der Python-Shell das Terminal ein:

python3

Wenn Sie Monitor und Tastatur an Raspberry Pi anschließen, führen Sie einfach „Python 3 IDLE“aus dem Menü aus.

Der nächste Schritt besteht darin, dass Raspberry Pi mit den Tasten funktioniert. Wir werden spezielle Listener an die GPIO 23 und 24 Pins anhängen, die auf das Ereignis „Ansteigende Flanke“und „Fallende Flanke“an diesen Pins lauschen. Im Fall des Ereignisses rufen die Listener die von uns definierten Funktionen auf. „Steigende Flanke“bedeutet, dass der Taster gedrückt wurde und nun losgelassen wurde (erster Taster – Tür wird geöffnet), „fallende Flanke“bedeutet, dass der Taster losgelassen und jetzt gedrückt wurde (zweiter Taster – Tür hat einen bestimmten Punkt erreicht). Mehr zur Funktionalität der Tasten - hier.

Importieren Sie zuerst eine Bibliothek, die uns Zugriff auf die Pins gibt:

RPi. GPIO als GPIO importieren

Definieren Sie nun spezielle Funktionen, die aufgerufen werden, wenn ein Ereignis ausgelöst wird:

def Sensor1(Kanal): print(“Sensor 1 ausgelöst“)def Sensor2(Kanal): print(“Sensor 2 ausgelöst)

Pinbelegungstyp einstellen:

GPIO.setmode(GPIO. BCM)

Pins konfigurieren:

GPIO.setup(23, GPIO. IN, pull_up_down=GPIO. PUD_UP)GPIO.setup(24, GPIO. IN, pull_up_down=GPIO. PUD_UP)

Hörer anhängen:

GPIO.add_event_detect(23, GPIO. RISING, callback=sensor1, Bouncetime=300)GPIO.add_event_detect(24, GPIO. FALLING, callback=sensor2, Bouncetime=300)

Jetzt können Sie es testen! Wenn Sie die Taste 1 drücken, sehen Sie im Terminal eine Meldung „Sensor 1 ausgelöst“, die Taste 2 gibt Ihnen die Meldung „Sensor 2 ausgelöst“.

Hinweis: Wenn Sie mit dem Experimentieren fertig sind, vergessen Sie nicht, die folgende Funktion aufzurufen: GPIO.cleanup().

Lassen Sie uns eine weitere Funktion einrichten, die aufgerufen wird, wenn die Tür den Punkt erreicht, an dem wir ein Foto machen! Sie können es selbst tun oder meine Implementierung verwenden, die ich hier angehängt habe (sensor.py)

Hinweis: sensor.py wird nur zu Testzwecken verwendet, die Dateien mit voller Funktionalität habe ich im letzten Schritt angehängt.

Schritt 3: IP-Kamera konfigurieren

Schrittbeschreibung: Jetzt konfigurieren wir das alte Smartphone als IP-Kamera.

Die Nutzung des Smartphones als IP-Kamera erfolgt per App. Es gibt verschiedene Apps für Android, iOS, Windows Phone, die Sie verwenden können. Ich habe mich für die "IP-Webcam" für Android entschieden. Dies ist eine kostenlose App und sie ist einfach zu konfigurieren.

Führen Sie die App aus, gehen Sie zu "Videoeinstellungen", um die Auflösung der von der App bereitgestellten Fotos einzurichten. Tippen Sie dann auf "Server starten" (Erstes Bild oben). Am unteren Bildschirmrand müssen Sie die IP-Adresse der Kamera sehen (Siehe zweites Bild oben). Im Browser können Sie https://cam_ip_address/photo-j.webp

Zum Schluss befestigen Sie die Kamera am Kühlschrank (letztes Bild oben).

Schritt 4: Gesichts-API

Schrittbeschreibung: In diesem Schritt werden wir über die Gesichts-API von Microsoft sprechen, die Gesichtserkennung durchführt und Personen identifiziert.

Die Gesichts-API von Microsoft ist ein Dienst zur Gesichtserkennung, mit dem wir Fotos analysieren und Personen darauf identifizieren können.

Zunächst benötigen Sie ein Microsoft Azure-Konto. Wenn Sie noch keine haben, können Sie sie hier kostenlos erstellen.

Zweitens gehen Sie zu https://portal.azure.com, klicken Sie auf der linken Seite auf "Neu", geben Sie in das Formular "Cognitive Services APIs" ein, wählen Sie es aus und klicken Sie auf "Erstellen". Oder Sie können diesen Link öffnen. Jetzt müssen Sie den Namen Ihres Dienstes eingeben, die Art des Abonnements, die Art der benötigten API (in unserem Fall die Face API), den Standort, die Preisstufe, die Ressourcengruppe auswählen und den rechtlichen Bedingungen zustimmen (siehe Screenshot, der diesem Schritt hinzugefügt wurde).

Klicken Sie drittens auf "Alle Ressourcen", wählen Sie Ihren Face API-Dienst aus und sehen Sie sich die Nutzungsstatistiken, Anmeldeinformationen usw. an.

Details zur Face API finden Sie hier, Beispiele in verschiedenen Programmiersprachen werden bereitgestellt. Für dieses Projekt verwenden wir Python. Sie können die Dokumentation lesen und Ihren eigenen Funktionsumfang erstellen oder den hier bereitgestellten verwenden (dies ist nicht der vollständige Funktionsumfang von Microsoft, nur die Punkte, die für dieses Projekt benötigt werden). Meine Python-Dateien sind an diesen Schritt angehängt.

Kommen wir zur Struktur der Arbeit mit der Face API. Um die Funktion "Identifikation" zu verwenden, müssen wir eine Bibliothek von Personen erstellen, die den Face API-Dienst verwenden, um die von der App aufgenommenen Fotos zu erkennen. Um es einzurichten, befolgen Sie bitte die Schritte:

1. Erstellen Sie eine Gruppe
2. Personen zu dieser Gruppe hinzufügen
3. Gesichter zu diesen Personen hinzufügen
4. Zuggruppe
5. Senden Sie ein Foto mit der Person, die Sie identifizieren möchten (Sie müssen ein Foto und eine Gruppen-ID angeben, in der der Dienst nach Kandidaten sucht)
6. Ergebnis: Als Antwort erhalten Sie eine Liste der Kandidaten, die auf dem von Ihnen eingereichten Foto zu sehen sein können.

Ich habe drei Dateien mit spezifischen Funktionen erstellt, die es ermöglichen, mit Gruppen, einzelnen Personen und einzelnen Fotos zu arbeiten:

• PersonGroup.py - enthält Funktionen, die es ermöglichen: Gruppe erstellen, Informationen über die Gruppe abrufen, Liste aller Ihrer Gruppen abrufen, Gruppe trainieren und den Schulungsstatus abrufen
• Person.py - enthält Funktionen, die es ermöglichen: Person erstellen, Personeninformationen abrufen, alle Personen in einer bestimmten Gruppe auflisten, Gesichter zu einer bestimmten Person hinzufügen
• Face.py - enthält Funktionen, die es ermöglichen: Gesicht auf dem Bild erkennen, Person identifizieren, Namen der identifizierten Person abrufen

In der Datei "recognition.py" stelle ich Funktionen bereit, mit denen Sie überprüfen können, ob das Bild ein Gesicht enthält, und Gesichter zu einer bestimmten Person hinzufügen (Fügt automatisch Gesicht aus vielen Bildern aus dem angegebenen Ordner hinzu).

Laden Sie die an diesen Schritt angehängte Datei herunter, entpacken Sie sie, ändern Sie die globale Variable 'KEY' in diesen drei Dateien: PersonGroup.py, Person.py und Face.py in Ihren eigenen Schlüssel, den Sie finden können: portal.azure.com > alle Ressourcen > Gesichts-API-Dienst (oder wie Sie ihn genannt haben) > Registerkarte Schlüssel. Sie können einen der beiden Schlüssel verwenden.

Hinweis: Hier trainieren wir den Face API-Dienst, um Personen zu erkennen, sodass die folgenden Aktionen von jedem Computer aus ausgeführt werden können (Raspberry Pi wird dafür nicht benötigt) - Änderungen werden auf dem Server von Microsoft gespeichert.

Führen Sie nach dem Ändern von KEY die Dateierkennung.py aus und geben Sie den folgenden Befehl in die Python-Shell ein:

PersonGroup.create("family", 'fff-fff')) // Sie können Ihren eigenen Namen und Ihre ID verwenden für

Gruppe printResJson(PersonGroup.getPersonGroup('fff-fff'))

Sie müssen Daten über die gerade erstellte Gruppe sehen. Geben Sie nun ein:

printResJson(Person.createPerson('fff-fff', 'Name der Person'))

Jetzt erhalten Sie eine Personen-ID. Erstellen Sie einen Ordner mit Bildern dieser Person, sodass alle Bilder das Gesicht dieser Person enthalten. Sie können die Funktion DetectFaceOnImages inerkennung.py verwenden, die Ihnen anzeigt, auf welchen Fotos ein Gesicht erkannt wurde. Führen Sie nun den Befehl aus:

addFacesToPerson('Ordner mit Bildern', 'Personen-ID, die Sie nach dem vorherigen Befehl erhalten haben', 'fff-fff')

Dann müssen wir unseren Service schulen, indem wir Folgendes eingeben:

PersonGroup.trainPersonGroup('fff-fff')printResJson(PersonGroup.getPersonGroupTrainingStatus('fff-fff'))

Jetzt ist unsere Gruppe geschult und bereit, eine Person zu identifizieren.

Um die Person auf dem Bild zu überprüfen, können Sie:

Face.checkPerson(image, 'fff-fff')

Als Antwort erhalten Sie eine Liste der Kandidaten und der Wahrscheinlichkeit, die auf dem Foto zu sehen sind.

Hinweis: Jedes Mal, wenn Sie Gesichter zu einer Person oder einer Person zu einer Gruppe hinzufügen, müssen Sie die Gruppe trainieren!

Schritt 5: Knotenrote Konfiguration

Schrittbeschreibung: In diesem Schritt erstellen wir einen Node-Red-Flow, der Sie über die Zugriffsverletzung auf Ihren Kühlschrank informiert =)

Wenn Ihr Raspberry Pi auf Raspbian Jessie November 2015 oder neueren Versionen läuft, müssen Sie Node-Red nicht installieren, da es bereits vorinstalliert ist. Sie müssen es nur aktualisieren. Bitte verwenden Sie hier das Handbuch.

Jetzt müssen wir den Twilio-Knoten auf dem Node-Red installieren, damit wir eine Textnachricht auslösen können. Terminal öffnen und eingeben:

cd ~/.node-rednpm install node-red-node-twilio

Mehr zum Twilio-Knoten hier. Führen Sie danach Node-Red aus, indem Sie in das Terminal eingeben:

Knoten-rot

Gehen Sie dann zu: https://127.0.0.1:1880/ - wenn Sie den Browser auf Ihrem Raspberry Pi öffnenhttps://{raspberry_pi_ip}:1880/ - wenn Sie den Node-Red-Editor von einem anderen Computer aus öffnen möchten

Um die IP-Adresse von Himbeer-Pi zu erfahren, verwenden Sie diese Anweisung.

Jetzt müssen Sie den Twilio-Knoten in der Liste der Knoten in Ihrem Node-Red-Editor finden (normalerweise erscheint er nach der Gruppe 'social').

Es ist Zeit, den Flow zu schaffen!

Hinweis: Sie können meinen an diesen Schritt angehängten Flow verwenden, vergessen Sie jedoch nicht, die Knoten zu konfigurieren: E-Mail, Twitter und Twilio. Lesen Sie später darüber.

Unser Ablauf beginnt mit dem "notify"-Knoten, der die POST-Anforderung von unserem Hauptprogramm mit einigen Daten über Zugriffsverletzungen akzeptiert (ein Beispiel für die Daten finden Sie im Kommentarknoten "über das Empfangen von Objekten"). Dieser Knoten antwortet sofort mit einer "Ok"-Nachricht, damit das Hauptprogramm weiß, dass die Daten empfangen wurden (Flow: /notify > response with Ok > response). Der grüne Knoten unten mit dem Namen msg.payload ist für Debugging-Zwecke da: Wenn etwas nicht funktioniert, können Sie ihn verwenden.

Vom ersten Knoten (/notify) werden Daten an "Datenthema" und "Bildthema" weitergegeben, wo die Themen "Daten" bzw. "Bild" hinzugefügt wurden.

Im Knoten "compile" erhalten wir Daten (die wir im ersten Schritt erhalten) mit dem Thema "Daten" und ein Bild mit dem Thema "Bild" (das Bild stammt aus /home/pi/image.jpg). Diese beiden Nachrichten sollten zu einem Objekt zusammengefasst werden, aber die beiden Objekte werden zu unterschiedlichen Zeiten empfangen! Um dies zu handhaben, verwenden wir die "Kontext"-Funktion, die es uns ermöglicht, Daten zwischen Funktionsaufrufen zu speichern.

Im nächsten Schritt prüfen Sie, ob es sich um eine Person aus unserer Zugangsliste oder um einen Fremden handelt (checkConditions-Knoten). In den Daten, die wir erhalten, gibt es ein Feld „trustedPerson“: „true“bedeutet, dass wir diese Person kennen, diese aber die Zugangsberechtigung verletzt hat, „false“bedeutet, dass die Person ein Fremder ist.

Wenn das Ergebnis „wahr“ist, senden wir eine Benachrichtigung an Twitter, Twilio und E-Mail; wenn das Ergebnis „falsch“ist - nur E-Mail und twilio. Wir erstellen ein Objekt für E-Mail mit einer Nachricht, angehängtem Bild und E-Mail-Betreff, ein Objekt für twilio mit einer Nachricht. Bei Twitter fügen wir einem Objekt Daten hinzu, wenn "trustedPerson" wahr ist. Senden Sie diese drei Objekte dann an drei verschiedene Knoten.

Hinweis: Wenn der folgende Knoten keine Nachricht erhalten sollte, senden wir einfach "null" an ihn.

Es ist Zeit, Knoten für die Benachrichtigung zu konfigurieren!

Twitter Fügen Sie dem Flow den Knoten "twitter" hinzu. Öffnen Sie es per Doppelklick. Klicken Sie auf den Bleistift neben "Twitter ID". Klicken Sie dann auf „Klicken Sie hier, um sich bei Twitter zu authentifizieren“. Rufen Sie Ihr Twitter-Konto auf und geben Sie dem Node-Red die erforderlichen Berechtigungen.

EmailFügen Sie dem Flow den Knoten "E-Mail" hinzu. Wenn Sie Gmail nicht verwenden, müssen Sie die Daten in den folgenden Feldern ändern - "Server" und "Port" (Sie finden den Server und den Port, den Sie auf den Hilfeseiten Ihres E-Mail-Agenten verwenden sollten), andernfalls ändern Sie diese nicht Felder.

• An > E-Mail-Adresse, an die Nachrichten gesendet werden
• Benutzer-ID > Login von Ihrer E-Mail (möglicherweise das gleiche wie das Feld "An")
• Passwort > Passwort von Ihrem E-Mail-Konto
• Name > Name für diesen Knoten

Twilio Gehen Sie zu https://www.twilio.com/try-twilio und registrieren Sie ein Konto. Überprüfen Sie es. Gehen Sie zu https://www.twilio.com/console. Klicken Sie auf "Telefonnummern" (großes #-Symbol) und erstellen Sie eine kostenlose Nummer. Wenn Sie sich außerhalb der USA befinden, müssen Sie GEO-Berechtigungen hinzufügen, gehen Sie zu https://www.twilio.com/console/sms/settings/geo-pe… und fügen Sie Ihr Land hinzu.

Gehen Sie nun zum Node-Red-Editor, fügen Sie den Twilio-Knoten hinzu, doppelklicken Sie darauf, um ihn zu konfigurieren und füllen Sie alle Felder aus:

• Anmeldeinformationen > Lokale Anmeldeinformationen verwenden

• Twilio > bearbeiten

  • Konto-SID > von hier nehmen
  • Von > geben Sie die virtuelle Nummer ein, die Sie erstellt haben
  • Token > von hier nehmen
  • Name > Twilio
• Ausgabe > SMS
• An > Ihre Telefonnummer
• Name > Name für diesen Knoten.

Klicken Sie auf Bereitstellen

Jetzt ist Ihr Flow fertig! Sie können es testen, indem Sie eine POST-Anfrage mit dem angegebenen Objekt senden!

Schritt 6: Kompilieren des gesamten Projekts

Schrittbeschreibung: In diesem Schritt werden wir alle Teile zusammenfügen und sie als separates System arbeiten lassen.

In diesem Schritt müssen Sie:

1. Altes Smartphone als IP-Kamera konfigurieren
2. Haben funktionierende Sensoren
3. Geschulte Gesichts-API von Microsoft
4. Konfigurierter Node-Red-Flow

Jetzt müssen wir den Code verbessern, den wir in Schritt 2 geschrieben haben. Genauer gesagt die Funktion process(), die aufgerufen wird, wenn eine Person die Tür öffnet. In dieser Funktion werden wir Folgendes tun:

1. Holen Sie sich das Bild von der IP-Kamera und speichern Sie es in „/home/pi/“mit dem Namen „image.jpg“(Funktion „fromIpCam“in der Datei „getImage“)
2. Rufen Sie den Namen der Person auf diesem Bild ab (Funktion „checkPerson“in Datei „Erkennung“)
3. Zugriffsberechtigung für diese Person prüfen (Funktion „check“in Datei „access“)
4. Basierend auf dem Ergebnis der Funktion „Check“Nachricht verfassen
5. Erstellte Nachricht an Node-Red senden (Funktion „toNodeRed“in Datei „sendData“)

Hinweis: Um den vollständigen Code der genannten Funktionen zu sehen, laden Sie bitte die Zip-Datei herunter, die diesem Schritt beigefügt ist.

Über die Funktion „fromIpCam“. Diese Funktion stellt die GET-Anfrage an Ihre IP-Kamera, ruft das fokussierte Bild als Antwort ab und speichert es in dem von Ihnen angegebenen Pfad. Sie müssen dieser Funktion die IP-Adresse der Kamera zur Verfügung stellen.

Über die Funktion „checkPerson“. Die Funktion erhält als Parameter Pfad zu Bild und Gruppe, in der Sie eine Person aus dem Foto suchen möchten. Zunächst erkennt es ein Gesicht auf dem bereitgestellten Bild (Datei Face.py, Funktion „Erkennen“). Als Antwort erhält es eine ID, wenn ein Gesicht erkannt wurde. Dann ruft es die Funktion "Identifizieren" (Face.py-Datei) auf, die ähnliche Personen in der angegebenen Gruppe findet. Als Antwort erhält es eine Personen-ID, wenn eine Person gefunden wird. Dann rufen Sie die Funktion „person“(Datei Person.py) mit der Personen-ID als Parameter auf, die Funktion „Person“gibt eine Person mit der angegebenen ID zurück, wir erhalten den Namen der Person und geben ihn zurück.

Über die Funktion „Prüfen“. Diese Funktion befindet sich in der Datei „access“, in der auch „Access List“als globale Variable platziert wird (Sie können sie nach Belieben ändern). Rufen Sie den Namen einer Person aus der vorherigen Funktion ab, vergleichen Sie diese Person mit der Zugangsliste und geben Sie das Ergebnis zurück.

Hinweis: Das vollständige Projekt ist dem nächsten Schritt beigefügt.

Schritt 7: Fazit

In diesem Schritt habe ich das vollständige Projekt angehängt, das Sie entpacken und auf Ihrem Raspberry Pi platzieren sollten.

Damit dieses Projekt funktioniert, führen Sie die Datei "main.py" aus.

Wenn Sie Raspberry Pi über SSH steuern, müssen Sie zwei Programme von einer Shell ausführen: Python-Programm und Node-Red. Geben Sie im Terminal Folgendes ein:

Knoten-rot

Drücken Sie "Strg + Z" und geben Sie ein:

Arbeitsplätze

Sie sehen den Node-Red-Prozess. Sehen Sie sich die ID des Prozesses an und geben Sie Folgendes ein:

bg

Jetzt muss Node-Red im Hintergrund arbeiten. Gehen Sie dann in das Verzeichnis mit Ihrem Projekt und führen Sie das Hauptprogramm aus:

python3 main.py

Hinweis: Vergessen Sie nicht, KEY in Python-Dateien (Schritt 4) und Anmeldeinformationen im Node-Red-Flow (Schritt 5) zu ändern.

Fertig! Ihr Kühlschrank ist sicher!

Ich hoffe, Sie genossen dieses hartnäckige! Fühlen Sie sich frei, Ihre Gedanken in Kommentaren zu hinterlassen.

Ich würde mich freuen, wenn Sie für mein Projekt stimmen =)

Dankeschön!