Wie man mit Arduino ein Bewegungserkennungssystem erstellt: 7 Schritte

Erstellen Sie mit einem mit Arduino programmierten und von Ubidots betriebenen Feather HUZZAH einen Zähler für Bewegungs- und Präsenzproduktionen.

Effektive physische Bewegungs- und Anwesenheitserkennung in Smart Homes und Smart Manufacturing kann bei Anwendungen von AAL-Lösungen (Ambient Assisted Living) für ältere Menschen oder einem Produktionszählsystem, das ein größeres MES versorgt, sehr nützlich sein. Andere Anwendungen für die Bewegungs- und Anwesenheitserkennung sind unter anderem:

1. Tür- und Torautomatisierung
2. Parksensoren zur Kennzeichnung von freien Stellen
3. Fernüberwachung des Tankfüllstands
4. Smart Homes und Einrichtungen für Beleuchtung und Sicherheit
5. Erkennung und Zählung von Einheiten in Förderlinien
6. Markierungserkennung auf gedruckten Materialien
7. Flüssigkeitserkennung in Kippern aus Pappe, Kunststoff und Papier
8. Entfernungserkennung
9. Personenzähler

Während es viele Anwendungen für Anwesenheit und Bewegung gibt, gibt es ebenso viele Sensoren zum Erfassen von Daten, wie kapazitive, induktive, photoelektrische und Ultraschallsensoren. Abhängig von den Kosten, Umgebungsbedingungen und Genauigkeitsanforderungen sollte die am besten geeignete Hardware für die Umgebungs- und Anwendungsanforderungen ausgewählt werden.

In diesem Tutorial konzentrieren wir uns auf den Aufbau eines Echtzeit-Produktionszählers. Die Anwendung zählt jede Einheit, die auf einem Förderband vorbeifährt. Wir werden die Arduino IDE verwenden, um einen Feather HUZZAH ESP8266, einen Ultraschallsensor und Ubidots zu programmieren, um unsere Anwendung zu entwickeln und unser IoT-Dashboard anzuzeigen.

Zubehör:

Schritt 1: Anforderungen

1. Feder HUZZAH mit ESP8266MB7389-100
2. Ultraschallsensor
3. Arduino IDE 1.8.2 oder höher
4. Ubidots-Konto -oder- Bildungslizenz

Schritt 2: Setup

• I Hardware-Setup
• II. Firmware-Setup
• III. Ubidots-Anwendungsentwicklung (Ereignisse, Variablen und Dashboards)

Schritt 3: Hardware-Setup

Der Ultraschallsensor MB7389-100 ist dank seiner IPv67-Schutzart eine kostengünstige Option für Industrieanwendungen mit hohen Anforderungen an Reichweite und geringen Stromverbrauch bei schwierigen Wetterbedingungen.

Um zu beginnen, spiegeln Sie das folgende Diagramm, um den Ultraschallsensor an der zu befestigen Feder HUZZAH ESP8266.

HINWEIS: Die Sensorablesung kann analog oder als PWM erfolgen. Im Folgenden wird das Setup für das PWM-Lesen erläutert. Weitere Informationen finden Sie in den oben gezeigten Beispielen.

Optional Platzieren Sie den Mikrocontroller und die Sensoren im IP67-Gehäuse, um sie vor Staub, Wasser und anderen bedrohlichen Umwelteinflüssen zu schützen. Der Standardfall sieht ähnlich aus wie auf den Fotos oben.

Schritt 4: Firmware-Setup

Zuerst sollten Sie die Feather Huzzah in der Arduino IDE installieren und den Code kompilieren. Denken Sie daran, diese Einstellung durch einen einfachen Blinktest zu überprüfen. Weitere Informationen zum Anschließen Ihres Feather-Geräts finden Sie in dieser hilfreichen Anleitung zur Hardware-Einrichtung.

Um Sensordaten an die Ubidots IoT Development Platform zu senden, kopieren Sie den folgenden Code und fügen Sie ihn in die Arduino IDE ein. Denken Sie daran, den Namen des Wi-Fi-Netzwerks, das Kennwort und das Ubidots-Konto-Token zuzuweisen, die im Code angegeben sind.

/ ************************************************ ****************/#umfassen / ******************************** Konstanten und Objekte *************** ***************** // * Ubidots * / const char * SSID_NAME = "xxxxxxxx"; // Tragen Sie hier Ihren SSID-Namen ein char * SSID_PASS = "xxxxxxxx"; // Geben Sie hier Ihr Passwort einconst char * TOKEN = "Assig_your_ubidots_token"; // Gib hier dein TOKENconst-Zeichen ein * DEVICE_LABEL = "motion-control"; // Ihr Geräteetikettconst char * VARIABLE_LABEL = "distance"; // Ihre Variable labelconst char * USER_AGENT = "ESP8266"; const char * VERSION = "1.0"; const char * HTTPSERVER = "industrial.api.ubidots.com"; // Ubidots Business-Benutzer // const char * HTTPSERVER = " things.ubidots.com "; // Ubidots Educational-Benutzerint HTTPPORT = 80; / * Ultraschallsensor * / const int pwPin1 = 5; // Der PWM-Pin, an dem der Sensor angeschlossen istWiFiClient clientUbi; / ************************************ **************************** // ** Ermittelt die Länge des Körpers @arg Variable den Körper vom Typ char @return dataLen the Länge der Variablen * / int dataLen (char * variable) {uint8_t dataLen = 0; für (int i = 0; i <= 250; i ++) {if (variable i! = ' 0') {dataLen ++; } else {break; }} return dataLen;} / ******************************* Hauptfunktionen ********* ********************** / void setup () {Serial.begin (115200); / * Verbindet mit AP * / WiFi.begin (SSID_NAME, SSID_PASS); while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } pinMode (pwPin1, INPUT); WiFi.setAutoReconnect (true); Serial.println (F ("WiFi connected")); Serial.println (F ("IP address:")); Serial.println (WiFi.localIP ());} void loop () {/ * Der Sensorwert wird in Millimetern zurückgegeben, wenn Sie möchten, dass * er in Zoll umgerechnet wird. Erstellen Sie einfach eine Variable, die auf -> distance / 25.4 * / float distance zeigt = pulseIn (pwPin1, HIGH); sendToUbidots (DEVICE_LABEL, VARIABLE_LABEL, distance); delay (1000);} void sendToUbidots (const char * device_label, const char * variable_label, float sensor_value) {char * body = (char *) malloc (sizeof (char) * 150); char * data = (char *) malloc (sizeof (char) * 300); / * Speicherplatz zum Speichern der zu sendenden Werte * / char str_val 10; / * ---- Wandelt die Werte der Sensoren in Zeichen um. ----- * / / * 4 ist die minimale Breite, 2 ist die Präzision. float value wird auf str_val * / dtostrf kopiert (sensor_value, 4, 2, str_val); / * Erstellt den zu sendenden Body in der Anfrage * / sprintf (body, "{"% s ":% s}", variable_label, str_val); / * Erstellt die HTTP-Anforderung als POST * / sprintf (data, "POST /api/v1.6/devices/%s", device_label); sprintf (Daten, "% s HTTP / 1.1 r n", Daten); sprintf (data, "% sHost: things.ubidots.com r n", data); sprintf (Daten, "% sUser-Agent:% s /% s r n", Daten, USER_AGENT, VERSION); sprintf (Daten, "% sX-Auth-Token:% s r n", Daten, TOKEN); sprintf (data, "% sConnection: close r n", data); sprintf (data, "% sContent-Type: application / json r n", data); sprintf (data, "% sContent-Length:% d r n r n", data, dataLen (body)); sprintf (data, "% s% s r n r n", data, body); / * Erstverbindung * / clientUbi.connect (HTTPSERVER, HTTPPORT); / * Überprüfen Sie die Clientverbindung * / if (clientUbi.connect (HTTPSERVER, HTTPPORT)) {Serial.println (F ("Posting your variables:")); Serial.println (Daten); / * HTTP-Anfrage senden * / clientUbi.print (data); } / * Solange der Client verfügbar ist, lesen Sie die Antwort des Servers * / while (clientUbi.available ()) {char c = clientUbi.read (); Serial.write (c); } / * Freier Speicher * / free (data); frei (Körper); / * Stoppen Sie den Client * / clientUbi.stop ();}

ProTip: Sie können überprüfen, ob Ihr Gerät richtig angeschlossen ist, indem Sie den seriellen Monitor in der Arduino IDE öffnen.

Sie können überprüfen, ob ein Gerät in Ihrem Ubidots-Backend erstellt wurde, indem Sie es in Ihrem Konto Geräteverwaltung -> Geräte anzeigen.

Wenn Sie auf Ihr Gerät klicken, finden Sie eine Variable namens "Entfernung", in der die Messwerte des Sensors gespeichert werden. Dieser Name wurde in dem Code zugewiesen, den Sie gerade in die Arduino IDE eingefügt haben. Wenn Sie Ihre automatischen Variablen anpassen möchten, bearbeiten Sie die Gerätekarte, oder aktualisieren Sie den Code mit der für Ihre Anwendung richtigen Variablennomenklatur.

Da der Feather HUZZAH ESP8266 mit Ubidots verbunden ist und Daten an Ubidots meldet, ist es jetzt an der Zeit, die Anwendung mit der von Ubidots sorgfältig entwickelten Konfiguration der codefreien Anwendung zu erstellen.

Schritt 5: Ubidots-Anwendungsentwicklung

Ubidots-Ereigniskonfiguration

Die aktuellen Messwerte, die wir an Ubidots senden, sind Entfernungseingaben. Um diese Messwerte in die gewünschte Ausgabe zu übersetzen, die wir möchten - gezählte Einheiten -, sollten wir ein Ereignis wie folgt erstellen:

1. Erstellen Sie im aktuellen Gerät "motion-control" eine neue Standardvariable namens "boxes", die bei jeder Zählung einer neuen Einheit eine 1 erhält.
2. Gehe zu Geräteverwaltung -> EreignisseKlicken Sie auf das blaue Plus-Symbol in der rechten oberen Ecke der Seite, um ein neues Ereignis hinzuzufügen.
3. Konfigurieren Sie Ihr Ereignis beginnend mit "Wenn Trigger":

• Wählen Sie eine Variable aus: "Entfernung"
• Wert: Wert (Standard)
• Ist kleiner oder gleich dem maximal zu erwartenden Abstand zwischen dem Sensor und den vorbeikommenden Kästen. * Unsere Anwendung fordert 500 mm
• Zum 0 Minuten
• sparen

4. Nachdem die Trigger gemäß den Spezifikationen Ihrer Anwendung konfiguriert wurden, klicken Sie oben rechts auf das orangefarbene Pluszeichen, um eine bedingte Aktion hinzuzufügen.

5. Wählen Sie als Aktion „Set Variable“.

6. Wählen Sie als nächstes die zuvor erstellte Standardvariable "boxes" und den Wert "1".

7. Speichern Sie die Änderungen. Wenn das Ereignis richtig eingerichtet ist, sendet es jedes Mal eine "1", wenn der Abstand zwischen Sensor und Gerät länger als ein angegebener Schwellenwert ist. Dies deutet darauf hin, dass sich kein Objekt in der Nähe befindet - und sollte ein neues Gerät zählen, das gerade vorbeigegangen ist .

Auf der feder-spezifischen Gerätekarte finden Sie die Variablen "Felder", in denen jedes Mal eine "1" gesendet wird, wenn die Anwesenheit einer Einheit festgestellt wird.

Dieser Prototyp eignet sich besonders für industrielle Förderbänder und zum Zählen von Einheiten und kann an unterschiedliche Umgebungen oder Hardware angepasst werden, einfach in Ihre Codierung oder Ihre Anwendungsentwicklung.

8. Visualisieren Sie die Anzahl der erfassten Einheiten (oder wie oft ein Objekt erkannt wurde)
Mit der Variablen "boxes" erstellen wir nun eine neue Variable für das fortlaufende Fenster, um die Gesamtzahl der von der Variablen "boxes" empfangenen Messwerte in einem definierten Spam (Minuten, Stunden, Tage, Wochen usw.) zu summieren. Führen Sie die folgenden einfachen Schritte aus, um diese Entwicklung auszuführen:

Weisen Sie Ihrer neuen Rolling Window-Variablen die folgenden Anmeldeinformationen zu

Wähle ein Gerät: Bewegungssteuerung (oder der Name des Geräts, an das Sie Ihre Daten senden)

Wählen Sie eine Variable aus: Kisten

Berechnen Sie die: Summe

Jeden: "1" Stunde (oder entsprechend Ihren Bewerbungsanfragen)

Weisen Sie nun der neuen Variablen einen Namen zu, der die Anzahl der Kästchen (oder Bewegungen) angibt, die in einer Stunde gezählt wurden, genau wie "Kästchen / Stunde" oder "Einheiten / Stunden".

Schritt 6: Dashboard-Konfigurationen

Erstellen Sie schließlich ein Dashboard, um die Anzahl der erfassten Einheiten anzuzeigen.

Gehen Sie zu Geräteverwaltung -> Dashboards und fügen Sie ein neues Widget hinzu. Dieses Widget zeigt die Anzahl der heute gezählten Felder nach Stunden an.

Weisen Sie Ihrem neuen Widget die folgenden Anmeldeinformationen zu, um Ihre Anzahl zu visualisieren.

Wie möchten Sie Ihre Daten sehen ?: Diagramm

Wählen Sie einen Widget-Typ aus: Liniendiagramm

Gerät hinzufügen: Bewegungskontrolle

Fügen Sie eine Variable hinzu: Boxen / Stunde

Fertig. Mit dieser abschließenden Dashboard-Entwicklung ist Ihre Anwendung vollständig und Sie verfügen nun über ein effizientes und effektives Bewegungs- und Anwesenheitserkennungssystem. Hier ist ein letzter Blick auf unsere Ergebnisse.

Schritt 7: