WiFi-Switch für Haushaltsgeräte mit ESP8266

Lerne, wie du mit dem ESP-Modul deinen eigenen WLAN-Schalter baust und wie du damit jedes beliebige Gerät in deinem Lieblingszimmer steuern kannst.

Was sind WLAN-Schalter?

Wir leben heutzutage im Zeitalter des Internets der Dinge, und WLAN-Schalter bilden dessen Grundlage. Diese Geräte ermöglichen es, Haushaltsgeräte wie Lampen, Ventilatoren usw. ferngesteuert oder autonom ein- und auszuschalten oder zu dimmen – per Smartphone, Sprachsteuerung, Raumtemperatur oder sogar Wetterberichten.

Wie funktionieren sie?

Sie basieren auf drahtloser Kommunikation (allgemein bekannt als WLAN), die es ihnen ermöglicht, sich mit dem Internet zu verbinden und Daten zu verarbeiten, sodass sie aufgrund bestimmter, vom Benutzer festgelegter Bedingungen Maßnahmen ergreifen können.

Bewerbungsvoraussetzungen:

• ESP8266-Modul (ESP-01)
• Leiterplatte
• Steckbrett
• Verdrahtungskabel
• Ubidots -Konto
• Arduino Nano

1. Schema:

Materialien:

3x 1k Ohm Widerstände 1/4W

2x 470 Ohm Widerstände 1/2 W

1x Doppel-Inline-Buchse (U3)

1x MOC3010 (Opto-Triac)

1x Triac BTA24

1x 100nF 400V Kondensator

1x Hi-Link 3,3V Netzteil

1x Klemmenblock 2-polig

1x Klemmenblock 3-polig

Leiterplatte: Link zum Herunterladen der Gerber-Datei!

Leiterplatte hergestellt mit PCBGOGO (Leiterplattenherstellungsindustrie)

2. Ubidots -Geräte- und Variablenerstellung.

Ubidots zum Bereich „Geräte“ und erstellen Sie ein neues Gerät mit dem Namen „ wifiswitch “.

innerhalb Ihres " wifiswitch "-Geräts eine Variable namens " light ".

3. Erstellung Ubidots Dashboard und von Widgets.

Sobald Gerät und Variable erstellt sind, können wir ein dashboard und ein Widget erstellen, um die Beleuchtung über ein Web- oder mobiles dashboard . Um ein neues dashboard , tippen Sie auf „ Daten > Dashboard “. Tippen Sie anschließend auf das Plus-Symbol und konfigurieren Sie das dashboard nach Ihren Wünschen.

Erstellen Sie nun ein Steuerelement, um den Status der Glühbirne, die der Variablen „Licht“ zugeordnet ist, festzulegen. Klicken Sie dazu auf das Plus-Symbol oben rechts auf der Seite. Wählen Sie anschließend „Schalter“ als Steuerelementtyp aus, wählen Sie die zu steuernde Variable und konfigurieren Sie das Steuerelement nach Ihren Wünschen.

Dann können Sie Ihr Projekt programmieren und testen.

4. Programmierung mit der Arduino IDE.

1. Falls noch nicht geschehen, laden Sie die Arduino IDE herunter.

1a. Öffnen Sie die Arduino IDE und wählen Sie Datei -> Einstellungen.

1b. Fügen Sie die unten stehende URL in das „Zusätzliche Board-Manager-URLs“ . Sie können mehrere URLs hinzufügen, indem Sie diese durch Kommas trennen.

http://arduino.esp8266.com/stable/package_esp8266com_index.json​

2. Öffnen und installieren Sie das ESP8266-Board im Boardverwalter: Werkzeuge -> Board -> Boardverwalter

2a. Sie können die Platine ganz einfach finden, indem Sie „ESP8266“ in die Suchleiste eingeben.

3. Wählen Sie nun im Menü „Werkzeuge“ → „Platine“

4. Ermitteln oder überprüfen Sie den Port Ihres PCs, mit dem das Gerät kommuniziert. Gehen Sie zu „Tools“ → „Port“ → und wählen Sie den Port aus.

4b. Stellen Sie sicher, dass Ihre IDE-Upload-Geschwindigkeit 115200 beträgt, indem Sie zu Tools -> Upload-Geschwindigkeit -> 115200

5. Laden Sie die Ubidots ESPMQTT-Bibliothek , falls Sie dies noch nicht getan haben. Klicken Sie nun auf Sketch → Bibliothek einbinden → .ZIP -Bibliothek hinzufügen und wählen Sie die Ubidots ESP8266 MQTT-Bibliothek

Bei erfolgreichem Upload erhalten Sie die Antwort: „Bibliothek zu Ihren Bibliotheken hinzugefügt.“

8. Schließen Sie die Arduino IDE und öffnen Sie sie anschließend wieder.

Programmierung des ESP8266:

Sobald Ihr ESP8266 eingerichtet ist, können wir Daten von/zu Ubidots , um den WLAN-Schalter zu steuern. Ubidots
anzupassen .

/**************************************** * Bibliotheken ****************************************/ #include "UbidotsESPMQTT.h" /**************************************** * Konstanten definieren ****************************************/ #define TOKEN "............................." // Ihr Ubidots -Token #define WIFINAME "........." // Ihre SSID #define WIFIPASS "........." // Ihr WLAN-Passwort #define DEVICE_LABEL "wifiswitch" // Name des Geräts #define VARIABLE_LABEL1 "light" // Name der Ubidots -Variablen const int ERROR_VALUE = 65535; // Fehlerwert const uint8_t NUMBER_OF_VARIABLES = 2; // Anzahl der Variablen, die das Programm abonnieren soll char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Variablennamen #define luz 0 #define boton 2 int seguro=0; int ledState = LOW; // der aktuelle Zustand des Ausgangspins int buttonState; // der aktuelle Wert vom Eingangspin int lastButtonState = HIGH; // der vorherige Wert vom Eingangspin int reading; unsigned long lastDebounceTime = 0; // die letzte Zeit, zu der der Ausgangspin umgeschaltet wurde unsigned long debounceDelay = 50; float estadoluz; // Variable, die im Code verwendet werden soll float value; // Variable zum Speichern von Eingabedaten uint8_t variable; // Zur Verwendung mit dem switch case Ubidots ubiClient(TOKEN); WiFiClient client; /**************************************** * Hilfsfunktionen ****************************************/ void callback(char* topic, byte* payload, unsigned int length) { char* variable_label = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(topic, variable_label); value = btof(payload, length); set_state(variable_label); execute_cases(); free(variable_label); /////////////////Light///////////////////// digitalWrite(luz, estadoluz); /////////////////Light///////////////////// } // Thema parsen, um die Variablenbezeichnung zu extrahieren, deren Wert sich geändert hat void get_variable_label_topic(char * topic, char * variable_label) { Serial.print("topic:"); Serial.println(topic); sprintf(variable_label, ""); for (int i = 0; i < NUMBER_OF_VARIABLES; i++) { char * result_lv = strstr(topic, variable_labels[i]); if (result_lv != NULL) { uint8_t len ​​= strlen(result_lv); char result[100]; uint8_t i = 0; for (i = 0; i < len - 3; i++) { result[i] = result_lv[i]; } result[i] = '\0'; Serial.print("Label ist: "); Serial.println(result); sprintf(variable_label, "%s", result); break; } } } // Umwandlung eines Arrays von Zeichen in einen Float-Wert. float btof(byte * payload, unsigned int length) { char * demo = (char *) malloc(sizeof(char) * 10); for (int i = 0; i < length; i++) { demo[i] = payload[i]; } float value = atof(demo); free(demo); return value; } // Zustandsautomat für switch case void set_state(char* variable_label) { variable = 0; for (uint8_t i = 0; i < NUMBER_OF_VARIABLES; i++) { if (strcmp(variable_label, variable_labels[i]) == 0) { break; } variable++; } if (variable >= NUMBER_OF_VARIABLES) variable = ERROR_VALUE; // Ungültig } // Funktion mit switch case, um zu bestimmen, welche Variable geändert wurde, und weist der Code-Variablen den entsprechenden Wert zu. void execute_cases() { switch (variable) { case 0: estadoluz = value; Serial.print("Luz: "); Serial.println(estadoluz); Serial.println(); break; case ERROR_VALUE: Serial.println("error"); Serial.println(); break; default: Serial.println("default"); Serial.println(); } } /**************************************** * Hauptfunktion ****************************************/ void setup() { // Hier Ihren Setup-Code einfügen, der einmalig ausgeführt wird: pinMode(luz, OUTPUT); pinMode(boton, INPUT); ubiClient.ubidotsSetBroker("ubidots"); // Setzt den Broker für das Geschäftskonto korrekt ein. ubiClient.setDebug(true); // Übergibt einen booleschen Wert (true oder false), um Debug-Meldungen zu aktivieren. Serial.begin(115200); ubiClient.wifiConnection(WIFINAME, WIFIPASS); ubiClient.begin(callback); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* deviceStatus = getUbidotsDevice(DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); // Fügt die Variablenbezeichnungen und den zu sendenden Wert ein.ubidotsPublish(DEVICE_LABEL); ubiClient.loop(); }ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); // Geräte- und Variablenbezeichnungen einfügen Serial.println(variable_labels[1]); } void loop() { // Hier den Hauptcode einfügen, der wiederholt ausgeführt wird: if(!ubiClient.connected()){ ubiClient.reconnect();ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); // Geräte- und Variablenbezeichnungen einfügen } ubiClient.loop(); readit(); debounce(); // Messwert speichern. Beim nächsten Schleifendurchlauf ist es der letzteTastenzustand: lastButtonState = reading; } void readit(){ // Zustand des Schalters in eine lokale Variable einlesen: reading = digitalRead(boton); if (reading != lastButtonState) { // Entprelltimer zurücksetzen lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // Der Messwert ist länger als die Entprellzeit aktiv, // daher wird er als aktueller Zustand betrachtet: readit2(); } } void readit2(){ // Wenn sich der Tastenzustand geändert hat: if (reading != buttonState) { buttonState = reading; toggle(); } } void toggle(){ // Die LED wird nur umgeschaltet, wenn der neue Tastenzustand LOW ist if (buttonState == LOW) { ledState = !ledState; // LED setzen: digitalWrite(luz, ledState); ubiClient.add("light", ledState); // Variablenbezeichnungen und zu sendende Werte einfügenubidotsPublish(DEVICE_LABEL); } } char* getUbidotsDevice(char* deviceLabel) { char* data = (char *) malloc(sizeof(char) * 700); char* response = (char *) malloc(sizeof(char) * 400); sprintf(data, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(data, "%s HTTP/1.1\r\n", data); sprintf(data, "%sHost:ubidots\r\nUser-Agent:wifiswitch/1.0\r\n", data); sprintf(data, "%sX-Auth-Token: %s\r\nConnection: close\r\n\r\n", data, TOKEN); free(data); if (client.connect("ubidots", 80)) { client.println(data); } else { free(data); free(response); return "e"; } int timeout = 0; while(!client.available() && timeout < 5000) { timeout++; if (timeout >= 4999){ free(data); free(response); return "e"; } delay(1); } int i = 0; while (client.available()) { response[i++] = (char)client.read(); if (i >= 399){ break; } } char * pch; char * statusCode; int j = 0; pch = strtok (response, " "); while (pch != NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok (NULL, " "); j++; } free(response); return statusCode; }

2. Hochladen des Codes auf den ESP8266:

Um den Code auf den ESP8266 hochzuladen, benötigen wir eine serielle Schnittstelle zur Kommunikation (Programmiergerät) zwischen dem Modul und dem PC. Wir könnten USB-zu-TTL-Konverter verwenden, aber in diesem Fall werden wir die serielle Schnittstelle des Arduino nutzen, die dafür sehr gute Dienste leistet.

Um den Code auf den ESP8266 hochzuladen, müssen Sie die folgenden Verbindungen herstellen.

HINWEIS: Bitte seien Sie vorsichtig mit der VCC-Versorgung des ESP8266, er funktioniert nur mit einer 3,3V-Spannung.

Überprüfen Sie nun, ob Ihr Code korrekt ist, indem Sie in der Arduino IDE oberhalb des Editors auf die Schaltfläche „Prüfen“ klicken.

Sobald der Code verifiziert wurde, erhalten Sie eine Antwort ähnlich der unten stehenden, die anzeigt, dass er ordnungsgemäß eingerichtet ist.

Als Nächstes müssen Sie den Code auf Ihren NodeMCU hochladen. Wählen Sie dazu das Pfeilsymbol nach rechts neben dem Häkchensymbol aus.

Sobald der Code hochgeladen ist, erhalten Sie die folgende Meldung in der Arduino IDE:

5. Sprachbefehle mit Google Assistant konfigurieren:

Um Ihren WLAN-Schalter mit Google Home zu steuern, müssen Sie zunächst die Plattform IFTTT . Dadurch können Sie Ihren Schalter mit dem Google Assistant verbinden. Befolgen Sie die unten stehenden Schritte, um die Konfiguration korrekt durchzuführen.

Falls Sie noch kein Konto haben, registrieren Sie sich.

Klicken Sie auf „Meine Applets“.

Klicken Sie anschließend auf „Neues Applet“.

Klicken Sie auf „ + dies “, um den Auslöser Ihrer Bedingung zu konfigurieren.

Suchen Sie nach dem Dienst „Google Assistant“ und klicken Sie darauf.

Klicken Sie auf „Sagen Sie einen einfachen Satz“.

Füllen Sie die Triggerfelder mit den Phrasen aus, mit denen Sie das Licht, die Reaktion und die Sprache steuern möchten, und klicken Sie dann auf „ Trigger erstellen “.

Klicken Sie anschließend auf „ +das “, um die Aktion zu konfigurieren.

Suchen Sie nach dem Aktionsdienst Webhooks

Klicken Sie auf „ Webanfrage stellen “.

Aktionsfelder ausfüllen:

Klicken Sie abschließend auf „Fertigstellen“.

HINWEIS: Wiederholen Sie alle Schritte, um das Applet „ Licht ausschalten “ mit der korrekten Body- Anweisung einzurichten.

6. Testsitzung:

Schließen Sie das Modul gemäß dem im Bild gezeigten Diagramm korrekt an Ihr Wechselstromgerät an.

Fügen Sie im Klemmenblock mit der Bezeichnung SW einen Taster Ihrer Wahl hinzu.

Identifizieren Sie die Phase-, Neutralleiter- und Lichtleiter:

Stellen Sie die Verbindungen her, platzieren Sie den Knopf, ziehen Sie die Schrauben fest und testen Sie den Vorgang.

Falls Sie eher visuell lernen, schauen Sie sich das folgende Video-Tutorial an. Dort werden alle Schritte, die ich zum Bau dieses Projekts durchgeführt habe, detailliert erklärt:

Zusammenfassung:

In dieser Anleitung haben wir gelernt, wie man einen WLAN-Schalter baut, der sich per Sprachsteuerung, Smartphone-App oder PC über das Internet bedienen lässt und mit dem man beispielsweise eine Glühbirne im Schlafzimmer oder an einem anderen Ort steuern kann. Das Gerät basiert auf dem ESP8266-WLAN-Modul, einem winzigen Modul, das eine einfache Internetverbindung ermöglicht. Es kann zur Steuerung vieler verschiedener Geräte wie Ventilatoren, Motoren, Vorhänge, Lampen, LED-Streifen und vielem mehr eingesetzt werden.

Beginnen Sie noch heute mit der Entwicklung Ihrer IoT Lösungen mit Ubidots.