Arduino mit esp8266

Der ESP8266-01 war ein großartiges Modul, um all unseren Durst nach IOT-Projekten zu stillen. Seit seiner Veröffentlichung hat es eine starke Community aufgebaut und sich zu einem benutzerfreundlichen, billigen und leistungsstarken Wi-Fi-Modul entwickelt. Eine andere Open-Source-Plattform, die viel beliebter ist, ist das Arduino, um das bereits unzählige Projekte gebaut wurden. Die Kombination dieser beiden Plattformen öffnet Türen für viele innovative Projekte. In diesem Tutorial erfahren Sie, wie Sie das ESP8266-01-Modul mit Arduino verbinden. Auf diese Weise können wir Daten zwischen dem Arduino und dem Internet senden oder empfangen.

In diesem Tutorial werden Uhrzeit, Datum, Temperatur und Luftfeuchtigkeit mithilfe einer API mit dem ESP8266-01 aus dem Internet gelesen. Senden Sie diese Werte dann an eine Arduino-Karte und zeigen Sie sie auf dem 16 * 2-LCD-Bildschirm an. Klingt cool, richtig !! Also lasst uns anfangen.

Erforderliche Materialien:

1. Arduino Board (Beliebige Version)
2. ESP8266-01
3. FTDI-Programmierplatine mit 3,3-V-Option
4. 16x2 LCD
5. Potentiometer
6. Druckknopf
7. Kabel anschließen
8. Steckbrett

Wie Dinge funktionieren?

Bevor wir eintauchen, ist es wichtig zu wissen, wie dieses Ding tatsächlich funktionieren wird. Grundsätzlich müssen wir mit dem Modul ESP8266-01 beginnen. Wir werden die Arduino IDE verwenden, um den ESP8266 zu programmieren, und der Code wird so geschrieben, dass eine API zum Lesen einer JSON-Datei über eine http-Anforderung verwendet wird. Dann werden wir diese JSON-Datei formulieren, um nur die erforderlichen Informationen aus der vollständigen JSON-Datei zu extrahieren.

Sobald die Informationen formuliert sind, drucken wir sie über die serielle Kommunikation aus. Diese seriellen Leitungen werden dann mit dem Arduino verbunden, damit der Arduino die vom ESP8266 gesendeten Informationen lesen kann. Sobald die Informationen gelesen und verarbeitet wurden, werden sie auf dem LCD-Bildschirm angezeigt.

Es ist in Ordnung, wenn Sie dies nicht vollständig verstanden haben, denn wir werden dasselbe im Rest dieses Tutorials lernen.

Programmieren des ESP8266-01:

In diesem Tutorial wird davon ausgegangen, dass Sie Erfahrung mit dem ESP8266-Modul haben. Wenn nicht, wird empfohlen, die folgenden drei Tutorials durchzulesen, um alles vollständig zu verstehen.

1. Erste Schritte mit ESP8266-01
2. Programmieren von ESP8266-01 mit AT-Befehlen
3. Programmieren des ESP8266-01 mit der Arduino IDE und Flashen des Speichers

Sie können hier auch alle ESP8266-Projekte überprüfen.

Hier programmieren wir das ESP8266-01-Modul mit der Arduino IDE. Für Hardware verwenden wir die FTDI-Karte mit 3,3 V zum Programmieren von ESP8266, da dies die Hardware sehr einfach macht. Das Schaltbild für den Anschluss Ihres ESP8266 an eine FTDI-Karte ist unten dargestellt.

Stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind

1. Der ESP8266-01 ist nur 3,3 V tolerant, verwenden Sie keine 5 V. Stellen Sie FTDI also nur im 3,3-V-Modus ein.

2. GPIO_0 muss für den Programmiermodus geerdet sein

3. Der Reset-Pin sollte über einen Knopf mit dem Erdungsstift verbunden sein. Diese Schaltfläche sollte unmittelbar vor dem Hochladen des Codes gedrückt werden. Bei jedem Drücken der Taste leuchtet die blaue LED am ESP8266-01-Modul hoch, um anzuzeigen, dass das Modul zurückgesetzt wurde.

Sobald die Verbindungen hergestellt sind, öffnen Sie die Arduino IDE und prüfen Sie, ob Sie ein Beispielprogramm erfolgreich hochladen können. Wenn Sie nicht sicher sind, wie Sie die Arduino IDE zum Hochladen eines Programms auf ESP8266 verwenden sollen, befolgen Sie die Anweisungen zum Programmieren von ESP8266 mit Arduino. An dieser Stelle gehe ich davon aus, dass Sie das Blinkprogramm erfolgreich hochgeladen haben.

. Das vollständige Programm finden Sie am Ende dieser Seite weiter unten. Ich erkläre sie als kleine Schnipsel. Für das Programm muss auch die Arduino JSON-Bibliothek kompiliert werden. Wenn Sie die Bibliothek also noch nicht zu Ihrer Arduino IDE hinzugefügt haben, fügen Sie sie durch Herunterladen aus der Arduino JSON-Bibliothek von Github hinzu.

Der ESP8266 muss eine Verbindung zum Internet herstellen, um Daten zu Datum, Uhrzeit, Temperatur und Luftfeuchtigkeit abzurufen. Sie müssen also zulassen, dass eine Verbindung zu Ihrem WLAN hergestellt wird, indem Sie die SSID und das Kennwort in den folgenden Zeilen nachweisen

const char * ssid = "JIO-Fi"; // Geben Sie Ihre Wi-Fi-SSID ein const char * password = "Pas123"; // Geben Sie Ihr WLAN-Passwort ein

Innerhalb der Funktion setup () prüfen wir , ob das ESP eine Verbindung mit dem WLAN herstellen kann. Wenn nicht, wartet es dort für immer, indem es auf dem seriellen Monitor „Connecting..“ druckt.

while (WiFi.status ()! = WL_CONNECTED) {// Warte bis die Verbindung zum Wi-Fi hergestellt ist Verzögerung (1000); Serial.print ("Connecting.."); // Verbindung drucken.. bis die Verbindung hergestellt ist }

Der nächste Schritt ist der sehr wichtige Schritt. Wenn die Wi-Fi-Verbindung erfolgreich ist, müssen wir eine http get-Anforderung aufrufen, um die JSON-Datei aus dem Internet zu lesen. In diesem Tutorial verwende ich die von wunderground.com bereitgestellte API. Wenn Sie also vorhaben, dasselbe zu verwenden, können Sie sich für den kostenlosen API-Schlüssel anmelden und eine beliebige API Ihrer Wahl verwenden. Sobald Sie mit Ihrer API fertig sind, erhalten Sie unten einen Link wie diesen

Hinweis: Ich habe den API-Schlüssel dieses Links geändert, damit dies nicht funktioniert. Bewahren Sie Ihren API-Schlüssel sicher auf und geben Sie ihn nicht weiter.

Meine API hier wird verwendet, um die Wetterdaten von Chennai abzurufen. Sie können eine beliebige API verwenden. Wenn Sie die API jedoch in einen beliebigen Browser laden, sollte eine JSON-Datei zurückgegeben werden. Zum Beispiel gibt meine API die folgende JSON-Datei zurück

Ihre könnte eine Datei mit anderen Daten zurückgeben. Wir können überprüfen, ob diese JSON-Datei auch von unserem ESP8266 empfangen wird, indem wir sie lesen und JSON auf unserem seriellen Monitor mit den folgenden Zeilen drucken

int httpCode = http.GET (); // eine Get-Anfrage übergeben if (httpCode> 0) {// Überprüfen Sie den Rückkehrcode // payload = http.getString (); // Speichern Sie den Wert auf varibale Payload zum Debuggen // Serial.println (payload); // Drucke die Nutzdaten zum Debuggen aus, andernfalls kommentiere beide Zeilen

Ich habe diese Zeilen kommentiert, da sie nur zum Testen benötigt werden. Sobald Sie sichergestellt haben, dass ESP8266 die JSON-Daten abrufen kann, ist es Zeit, die Daten zu formulieren. Wie Sie sehen können, sind diese Daten riesig und die meisten Werte sind unbrauchbar, mit Ausnahme derjenigen, die für uns erforderlich sind, wie Datum, Uhrzeit, Temperatur und Luftfeuchtigkeit.

Daher verwenden wir die JSON Arduino-Bibliothek, um die für uns erforderlichen Werte zu trennen und in einer Variablen zu speichern. Dies ist möglich, weil die Werte in der JSON-Datei als Name-Wert-Paare zugewiesen werden. Dieser Name ist also eine Zeichenfolge, die den für uns erforderlichen Wert enthält.

Dazu müssen wir auf eine Website wechseln, die die JSON-Datei analysiert und uns den Arduino-Code gibt. Ja, so einfach ist das. Fahren Sie mit https://arduinojson.org/assistant/ fort, fügen Sie die JSON-Datei ein, die wir in unseren Browser geladen haben, und drücken Sie die Eingabetaste. Als ich fertig war, sah meine unten so aus

Scrollen Sie ein wenig nach unten, um das automatisch erstellte Phrasierungsprogramm anzuzeigen

Alles was Sie tun müssen, ist die gewünschte Variable auszuwählen, sie zu kopieren und in Ihre Arduino IDE einzufügen, wie ich es hier getan habe

/ * Phrasierungsdaten mithilfe der JSON-Bibliothek * / // Verwenden Sie https://arduinojson.org/assistant/, um die Phrasierungswerte für Ihre JSON-Zeichenfolge const size_t bufferSize = JSON_OBJECT_SIZE (0) + JSON_OBJECT_SIZE (1) + JSON_OBJECT_SIZE (2) abzurufen + 2 * JSON_OBJECT_SIZE (3) + JSON_OBJECT_SIZE (8) + JSON_OBJECT_SIZE (12) + JSON_OBJECT_SIZE (56) + 2160; DynamicJsonBuffer jsonBuffer (bufferSize); JsonObject & root = jsonBuffer.parseObject (http.getString ()); / * Ende der Phrasierungsdaten * / // Adressiere den Wert sin an die gewünschten Variablen JsonObject & current_observation = root; // unter current_observation JsonObject & current_observation_observation_location = current_observation; // unter Beobachtungsort const char * current_observation_station_id = current_observation; // "ICHENNAI1" // erhalte die Standortdetials const char * current_observation_local_time_rfc822 = current_observation; // Ortszeit // Ortszeit abrufen const char * current_observation_temperature_string = current_observation; // "90,7 F (32,6 C)" // erhalte den Temperaturwert const char * current_observation_relative_humidity = current_observation; // "73%" // erhalte den Feuchtigkeitswert

Ich habe gerade die Variablen current_observation_station_id, current_observation_local_time_rfc822, current_observation_temperature_string und current_observation_relative_humidity kopiert. Da wir planen, nur diese vier Daten auf unserem LCD-Bildschirm anzuzeigen.

Schließlich haben wir die benötigten Daten aus dem Internet erhalten und als Variable gespeichert, die wir bequem verwenden können. Um diese Daten an Arduino zu senden, müssen wir sie nur seriell über den seriellen Monitor schreiben. Die folgenden Zeilen machen genau das Gleiche

// Drucke die Variablen über den seriellen Monitor Serial.print (current_observation_station_id); // sende die Standortdetails an Arduino delay (100); // Stabilitätsverzögerung Serial.print (current_observation_local_time_rfc822); // sende die lokalen Zeitdetails an Arduino delay (100); // Stabilitätsverzögerung Serial.print (current_observation_temperature_string); // Sende die Temperaturdetails an Arduino delay (100); // Stabilitätsverzögerung Serial.print (current_observation_relative_humidity); // Sende die Feuchtigkeitsdetails an Arduino delay (100); // Stabilitätsverzögerung

Beachten Sie, dass ich Serial.print () und nicht Serial.println () verwendet habe, da der Befehl Serial.println () ein / n und / r zusammen mit den Daten anfügt, die für uns nicht benötigt werden. Wir haben außerdem eine Verzögerung von 10 Sekunden hinzugefügt, damit der ESP diese Werte nur im Abstand von 10 Sekunden an Arduino sendet.

ESP8266-01 mit Arduino verbinden:

Bisher haben wir unseren ESP8266-01 so programmiert, dass er die erforderlichen Daten im Abstand von 10 Sekunden aus dem Internet liest und seriell versendet. Jetzt müssen wir das ESP mit Arduino verbinden, damit wir diese seriellen Daten lesen können. Wir müssen Arduino auch ein 16 * 2-LCD-Display hinzufügen, damit wir die vom ESP8266-Modul empfangenen Daten anzeigen können. Das Schaltbild zur Schnittstelle des ESP8266-Moduls mit Arduino ist unten dargestellt

Stellen Sie sicher, dass der GPIO_0-Pin frei bleibt, versorgen Sie das Modul nur mit dem 3,3-V-Pin von Arduino und drücken Sie den Druckknopf, um das ESP-Modul in das Betriebsmodul zu setzen. Jetzt sollte das Programm, das wir auf ESP hochgeladen haben, funktionieren und das Modul sollte die Daten über die serielle PIN an Arduino senden. Diese seriellen Pins sind mit Pin 6 und 7 des Arduino verbunden. Wir können also die serielle Software-Option auf Arduino verwenden, um diese seriellen Daten von den Pins zu lesen.

Arduino Programm und Arbeiten:

Das vollständige Arduino-Programm finden Sie zusammen mit dem ESP-Code am Ende dieser Seite. Sie können nach unten scrollen, um das Programm anzuzeigen, oder weiterlesen, wenn Sie das Programm verstehen möchten.

Das Schnittstellenprogramm ist ziemlich einfach. Wir müssen nur die serielle Softwarebibliothek verwenden, um die Daten von Pin 6 und 7 zu lesen und auf dem LCD-Bildschirm anzuzeigen. Da die empfangenen Daten im Zeichenfolgenformat vorliegen, müssen wir die Teilzeichenfolgenoption verwenden, um die Nutzdaten gemäß unserer Anforderung aufzuteilen oder sie bei Bedarf sogar in eine Ganzzahl umzuwandeln. Zunächst definieren wir die Pins, an die das LCD angeschlossen ist.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pins, an die das LCD angeschlossen ist LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Da wir die angeschlossenen Rx und Tx - Pins von ESP8266 mit der 6 und 7 ^th Stift von Arduino müssen wir die Initialisierung Software serielle für die Stifte, so dass wir die seriellen Daten von ihnen empfangen können.Ich Namen dieses als ESP_Serial haben, können Sie Nennen Sie ihnen alles, was Sie wollen

SoftwareSerial ESP_Serial (6,7); // Tx, Rx

Innerhalb der Funktion setup () initialisieren wir die serielle Kommunikation für den seriellen Monitor und auch für die serielle Software. Wenn Sie sich erinnern können, haben wir das ESP-Programm so eingestellt, dass es mit einer Baudrate von 9600 kommuniziert, sodass wir für die serielle Software-Schnittstelle dieselbe Baudrate verwenden müssen. Wir zeigen auch eine kleine Intro-Meldung für 2 Sekunden auf dem LCD an.

void setup () {lcd.begin (16, 2); // Wir verwenden ein 16 * 2 LCD-Display lcd.print ("Arduino & ESP"); // Eine Intro-Nachricht anzeigen Serial.begin (115200); ESP_Serial.begin (9600); Verzögerung (2000); lcd.clear (); }}

Innerhalb der Funktion main loop () müssen wir prüfen, ob der ESP8266 etwas sendet. Wenn dies der Fall ist, lesen wir die Zeichenfolge aus ESP8266 und speichern sie in einer Variablen namens payload. Die variable Nutzlast ist vom Typ String und enthält die vollständigen Informationen, die vom ESP8266-Modul gesendet wurden.

while (ESP_Serial.available ()> 0) {payload = ESP_Serial.readString ();

Jetzt müssen wir diese Zeichenfolge in kleine Teile aufteilen, damit wir sie für unseren eigenen Zweck verwenden können. In diesem Fall müssen wir sie aufteilen, um sie auf dem LCD-Bildschirm anzuzeigen. Dies kann durch leicht getan werden mit der Teilzeichenfunktion in Arduino. Sie müssen die Position jedes Zeichens kennen, um diese Teilzeichenfolgenfunktion verwenden zu können. Sie können die Nutzdaten auf dem seriellen Monitor drucken, um die Position der Zeichen zu ermitteln und die Teilzeichenfolgen wie unten gezeigt zu kategorisieren

local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); Temperatur = Nutzlast (48, 54); Luftfeuchtigkeit = Nutzlast (55, 60);

Jetzt kann ich diese Variablen verwenden, um sie entweder auf dem seriellen Monitor oder einfach auf dem LCD zu drucken. Wenn Sie sie jedoch auf dem seriellen Monitor drucken, können Sie überprüfen, ob die Teilzeichenfolgen korrekt aufgeteilt sind. Als nächstes drucken wir sie einfach mit den folgenden Zeilen auf das LCD-Display

lcd.clear (); lcd.setCursor (1, 0); lcd.print (local_date); lcd.setCursor (8, 0); lcd.print (local_time); lcd.setCursor (1, 1); lcd.print (Temperatur); lcd.setCursor (10, 1); lcd.print (Luftfeuchtigkeit);

Laden Sie das Programm auf Arduino hoch und stellen Sie sicher, dass die Verbindungen den Angaben im obigen Schaltplan entsprechen. Passen Sie den Kontrast des LCD-Displays an, bis Sie die Dinge klar sehen. Sie sollten die Intro-Meldung auf dem LCD sehen und nach einigen Sekunden sollten die Details wie Datum, Uhrzeit, Temperatur und Luftfeuchtigkeit wie unten gezeigt auf dem LCD-Bildschirm angezeigt werden.

Sie können auch feststellen, dass die blaue LED am ESP8266 jedes Mal blinkt, wenn die Daten eingehen. Wenn Sie dies nicht sehen können, befindet sich das ESP nicht im Programmiermodus. Drücken Sie die Reset-Taste und überprüfen Sie auch die Verbindungen.

Ähnlich können Sie jede API verwenden, um alle erforderlichen Daten aus dem Internet abzurufen und an das Arduino weiterzuleiten und Ihre Arbeit mit Arduino zu verarbeiten. Im Internet stehen unzählige APIs zur Verfügung, mit denen Sie eine unbegrenzte Anzahl von Projekten erstellen können. Ich hoffe, Sie haben das Projekt verstanden und es genossen, es zu bauen. Wenn Sie auf ein Problem gestoßen sind, veröffentlichen Sie es im Kommentarbereich unten oder in unseren Foren.

Alle Projekte zu ESP8266 finden Sie hier.