WiFi-Switch für Haushaltsgeräte mit ESP8266

Erfahren Sie, wie Sie mit dem ESP-Modul Ihren eigenen WLAN-Switch bauen und jedes Gerät an Ihrem Lieblingsort steuern.

Was sind WLAN-Switches?

Heutzutage leben wir im Zeitalter des Internets der Dinge und WiFi-Switches sind im Grunde die Grundlage dafür. Dabei handelt es sich um Geräte, die Haushaltsgeräte wie Lichter, Ventilatoren usw. aus der Ferne oder autonom ein-, ausschalten oder dimmen können, gesteuert durch unsere Mobiltelefone, unsere Stimme, die Raumtemperatur oder sogar Wettervorhersagen.

Wie funktionieren sie?

Sie basieren auf drahtloser Kommunikation (allgemein bekannt als WiFi), 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/2W

1x Dual-In-Line-Buchse (U3)

1x MOC3010 (Opto-Triac)

1x Triac BTA24

1x 100nf 400V Kondensator

1x Hi-Link 3,3V-Netzteil

1x Klemmenblock 2p

1x Klemmenblock 3p

PCB: Link zum Download der Gerber-Datei!

PCB hergestellt mit PCBGOGO (PCB-Herstellungsindustrie)

2. Ubidots -Geräte- und Variablenerstellung.

Gehen Sie zum Abschnitt „Geräte“ Ihres Ubidots -Kontos und erstellen Sie ein neues Gerät mit dem Namen „ wifiswitch “.

in Ihrem „ wifiswitch “-Gerät eine Variable namens „ light “.

3. Ubidots Dashboard und Widget-Erstellung.

Sobald unser Gerät und unsere Variable erstellt sind, können wir ein dashboard und ein Widget erstellen, um das Licht über ein Web- oder mobiles dashboard . Um ein neues dashboard , klicken Sie auf „ Daten > Dashboard “. Drücken Sie dann auf das Plus-Symbol und schließen Sie die dashboard Konfiguration wie gewünscht ab.

Erstellen Sie nun ein Steuerungs-Widget, um den Status der Glühbirne festzulegen, die der Variablen „Licht“ zugeordnet ist. Um das Steuerungs-Widget zu erstellen, wählen Sie das Plus-Symbol rechts oben auf der Seite aus. Anschließend drücken Sie als Widget-Typ „Wechseln“, wählen die zu steuernde Variable aus und schließen die Widget-Konfiguration wie gewünscht ab.

Anschließend können Sie Ihr Projekt programmieren und testen.

4. Programmieren 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 Dateien -> Einstellungen

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

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

2. Öffnen und installieren Sie das ESP8266-Board im Boards Manager: Extras -> Board -> Boards Manager

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

3. Wählen Sie nun die generische ESP8266-Karte aus dem Menü „Extras -> Karte“

4. Definieren oder überprüfen Sie den Port Ihres PCs, mit dem das Gerät kommuniziert. Gehen Sie zu Extras -> Port: -> Wählen Sie den Port aus

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

5. Laden Sie die Ubidots ESPMQTT-Bibliothek , falls Sie dies noch nicht getan haben. Klicken Sie nun auf Sketch –> Include Library –> Add .ZIP Library und wählen Sie die Ubidots ESP8266 MQTT-Bibliothek

Bei ordnungsgemäßem Hochladen erhalten Sie die Antwort: „Bibliothek zu Ihren Bibliotheken hinzugefügt.“

8. Schließen Sie die Arduino IDE und öffnen Sie sie erneut.

Programmierung des ESP8266:

Sobald Ihr ESP8266 eingerichtet ist, können wir mit der Veröffentlichung und dem Abonnement von Daten von/bei Ubidots , um den WLAN-Switch zu steuern.
1. Kopieren Sie den folgenden Code und fügen Sie ihn in die Arduino IDE ein. Vergessen Sie nicht, die WLAN-SSID und das Passwort sowie Ihr Ubidots Token anzupassen.

/**************************************** * Bibliotheken ******* *******************************/ #include „ Ubidots ESPMQTT.h“ /******* ******************************* * Konstanten definieren ************** **************************/ #define TOKEN "................. .........." // Ihr Ubidots TOKEN #define WIFINAME "........." //Ihre SSID #define WIFIPASS "........." // Ihr WLAN-Pass #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; // Variablen hinzufügen, damit das Programm 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 Messwert vom Eingangspin int lastButtonState = HIGH; // der vorherige Messwert vom Eingangspin int reading; unsigned long lastDebounceTime = 0; // wann der Ausgangspin das letzte Mal umgeschaltet wurde unsigned long debounceDelay = 50; float estadoluz; // Im Code zu verwendende Variable float value; // Variable zum Speichern von Eingabedaten uint8_t variable; // Zur Verwendung mit dem Switch-Case Ubidots ubiClient(TOKEN); WiFiClient-Client; /**************************************** * Zusatzfunktionen ****** **********************************/ 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(Nutzlast, Länge); set_state(variable_label); execute_cases(); free(variable_label); /////////////////Licht//////////////////// digitalWrite(luz, estadoluz); /////////////////Licht/////////////////// } // Thema analysieren, um die Variablenbezeichnung zu extrahieren, die sich geändert hat value 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); brechen; } } } // Von einem Array von Zeichen in einen Gleitkommawert umwandeln. 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); kostenlos (Demo); Rückgabewert; } // Zustandsmaschine zur Verwendung des Schalterfalls 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; // Nicht gültig } // Funktion mit Switch-Case, um zu ermitteln, welche Variable sich geändert hat, und den Wert entsprechend der Codevariablen zuzuweisen voidexecute_cases() { switch (variable) { case 0: estadoluz = value; Serial.print("Luz: "); Serial.println(estadoluz); Serial.println(); brechen; case ERROR_VALUE: Serial.println("error"); Serial.println(); brechen; Standard: Serial.println("default"); Serial.println(); } } /**************************************** * Funktionsprinzipal **** ************************************/ void setup() { // Geben Sie hier Ihren Setup-Code ein, einmal ausführen: pinMode(luz, OUTPUT); pinMode(Boton, INPUT); ubiClient. ubidots SetBroker("industrial.api. ubidots .com"); // Setzt den Broker richtig für das Geschäftskonto ubiClient.setDebug(true); // Übergeben Sie einen boolschen 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 = get Ubidots Device(DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); //Fügen Sie Ihre Variablenbeschriftungen und den zu sendenden Wert an ubiClient ein. ubidots Publish(DEVICE_LABEL); ubiClient.loop(); } ubiClient. ubidots Subscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Geräte- und Variablenbeschriftungen einfügen Serial.println(variable_labels[1]); } void loop() { // Geben Sie Ihren Hauptcode hier ein, um ihn wiederholt auszuführen: if(!ubiClient.connected()){ ubiClient.reconnect(); ubiClient. ubidots Subscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Geräte- und Variablenbeschriftungen einfügen } ubiClient.loop(); readit(); entprellen(); // Den Messwert speichern. Beim nächsten Durchlauf der Schleife wird es lastButtonState sein: lastButtonState = reading; } void readit(){ // den Zustand des Schalters in eine lokale Variable einlesen: reading = digitalRead(boton); if (reading != lastButtonState) { // Entprellungs-Timer zurücksetzen lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // was auch immer der Messwert ist, er liegt schon länger als die Entprellungsverzögerung // dort, also nehmen Sie ihn als den tatsächlichen aktuellen Zustand: readit2 (); } } void readit2(){ // wenn sich der Button-Status geändert hat: if (reading != buttonState) { buttonState = reading; toggle(); } } void toggle(){ // Schaltet die LED nur um, wenn der neue Tastenzustand LOW ist if (buttonState == LOW) { ledState = !ledState; // LED einstellen: digitalWrite(luz, ledState); ubiClient.add("light", ledState); //Fügen Sie Ihre Variablenbeschriftungen und den zu sendenden Wert an ubiClient ein. ubidots Publish(DEVICE_LABEL); } } char* get Ubidots Device(char* deviceLabel) { char* data = (char *) malloc(sizeof(char) * 700); char* Antwort = (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: industrial.api. ubidots .com\r\nUser-Agent:wifiswitch/1.0\r\n", data); sprintf(data, "%sX-Auth-Token: %s\r\nConnection: close\r\n\r\n", data, TOKEN); kostenlos(Daten); if (client.connect("industrial.api. ubidots .com", 80)) { client.println(data); } else { free(data); frei(Antwort); gib „e“ zurück; } int timeout = 0; while(!client.available() && timeout < 5000) { timeout++; if (timeout >= 4999){ free(data); frei(Antwort); gib „e“ zurück; } Verzögerung(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 (Antwort, " "); while (pch != NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok (NULL, " "); j++; } free(response); RückgabestatusCode; }

2. Hochladen des Codes auf den ESP8266:

Um den Code auf den ESP8266 hochzuladen, benötigen wir eine serielle Schnittstelle (Programmierer), um das Modul mit dem PC zu kommunizieren. Wir können USB-zu-TTL-Konverter verwenden, aber in diesem Fall werden wir die serielle Schnittstelle des Arduino verwenden, die eine sehr gute Leistung erbringt gute Arbeit.

Um den Code in den ESP8266 hochzuladen, müssen Sie den folgenden Verbindungen folgen.

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

Überprüfen Sie nun, ob Ihr Code korrekt ist, indem Sie in der Arduino IDE über dem Editor auf die Schaltfläche „Häkchen“ klicken.

Sobald der Code überprüft wurde, erhalten Sie eine Antwort ähnlich der folgenden, die anzeigt, dass er ordnungsgemäß eingerichtet ist.

Als nächstes müssen Sie den Code in Ihre NodeMCU hochladen. Wählen Sie dazu das Symbol mit dem Pfeil nach rechts neben dem Häkchensymbol.

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

5. Konfigurieren Sie Sprachbefehle mit Google Assistant:

WiFi Switch zu steuern , müssen wir zunächst eine Zwischenplattform namens IFTTT , die es uns ermöglicht, unseren Switch mit dem Google Assistant zu koppeln. Befolgen Sie zur korrekten Konfiguration die unten aufgeführten Schritte.

Wenn Sie noch kein Konto haben, registrieren Sie sich.

Klicken Sie auf „Meine Applets“.

Klicken Sie dann auf „Neues Applet“.

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

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

Klicken Sie auf „Einen einfachen Satz sagen“.

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 dann auf „ +das “, um die Aktion zu konfigurieren.

Suchen Sie nach dem Aktionsdienst Webhooks

Klicken Sie auf „ Webanfrage stellen “.

Komplette Aktionsfelder:

Klicken Sie abschließend auf Fertig stellen.

HINWEIS: Wiederholen Sie alles, um das Applet Licht ausschalten Body- Anweisung festzulegen.

6. Testsitzung:

Schließen Sie das Modul anhand des im Bild gezeigten Diagramms korrekt an Ihr AC-Gerät an.

Fügen Sie einen Taster Ihrer Wahl in den Klemmenblock mit der Bezeichnung SW ein.

Identifizieren Sie die Leitungs-, Neutral- und Lichtkabel:

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

Wenn Sie ein visueller Lerntyp sind, schauen Sie sich das folgende Video-Tutorial an. Hier finden Sie alle Schritte, die ich zum Aufbau dieses Projekts unternommen habe, sorgfältig erklärt:

Zusammenfassung:

In dieser Anleitung haben wir gerade gelernt, wie man einen WLAN-Schalter baut, der über das Internet mit Ihrer Stimme, Ihrer Handy-App oder Ihrem PC gesteuert werden kann und mit dem Sie eine Glühbirne in einem Schlafzimmer oder an einem anderen Ort steuern können. Dieses Gerät basiert auf dem WiFi-Modul ESP8266, einem winzigen Modul, mit dem das Projekt problemlos online gehen kann. Und dieses Gerät kann zur Steuerung vieler verschiedener Geräte wie Ventilatoren, Motoren, Vorhänge, Lichter, LED-Streifen und vielem mehr eingesetzt werden.

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