Arduino met esp8266

De ESP8266-01 is een geweldige module geweest om al onze dorst naar IOT-projecten te lessen. Sinds de release heeft het een sterke community ontwikkeld en is het uitgegroeid tot een gebruiksvriendelijke, goedkope en krachtige Wi-Fi-module. Een ander open-sourceplatform dat veel populairder is, is de Arduino, er zijn al talloze projecten omheen gebouwd. Het combineren van deze twee platforms opent deuren voor veel innovatieve projecten, dus in deze tutorial zullen we leren hoe we de ESP8266-01-module met Arduino kunnen verbinden. Op deze manier kunnen we gegevens verzenden of ontvangen tussen de Arduino en internet.

Voor deze tutorial zullen we de tijd, datum, temperatuur en vochtigheid van internet lezen met behulp van een API met de ESP8266-01. Stuur deze waarden vervolgens naar een Arduino-bord en geef ze weer op het 16 * 2 LCD-scherm. Klinkt goed toch !! Dus laten we beginnen.

Vereiste materialen:

1. Arduino Board (elke versie)
2. ESP8266-01
3. FTDI-programmeerbord met 3.3V-optie
4. 16x2 LCD
5. Potentiometer
6. Druk op de knop
7. Draden aansluiten
8. Breadboard

Hoe dingen werken?

Voordat we erin duiken, is het belangrijk om te weten hoe dit ding eigenlijk gaat werken. In principe moeten we beginnen met de ESP8266-01-module. We zullen de Arduino IDE gebruiken om de ESP8266 te programmeren en de code zal worden geschreven om een ​​API te gebruiken om een ​​JSON-bestand te lezen via http-verzoek. Vervolgens zullen we dit JSON-bestand formuleren om alleen de vereiste informatie uit het volledige JSON-bestand te extraheren.

Zodra de informatie is geformuleerd, zullen we deze afdrukken met behulp van de seriële communicatie. Deze seriële lijnen worden vervolgens verbonden met de Arduino, zodat de Arduino de informatie kan lezen die is verzonden vanaf ESP8266. Zodra de informatie is gelezen en verwerkt, geven we deze weer op het LCD-scherm.

Het is oké, als je dit nog niet helemaal hebt begrepen, want we zullen hetzelfde leren in de rest van deze tutorial.

Programmering van de ESP8266-01:

In deze tutorial wordt ervan uitgegaan dat u enige ervaring heeft met de ESP8266-module. Zo niet, dan is het aan te raden om de volgende drie tutorials door te lezen om er volledig inzicht in te krijgen.

1. Aan de slag met ESP8266-01
2. ESP8266-01 programmeren met AT-opdrachten
3. Programmeren van de ESP8266-01 met Arduino IDE en het flashen van het geheugen

Je kunt hier ook al onze ESP8266-projecten bekijken.

Hier gaan we de ESP8266-01-module programmeren met behulp van de Arduino IDE. Voor hardware gebruiken we het FTDI-bord met 3.3V om ESP8266 te programmeren, omdat het de hardware veel eenvoudiger maakt. Het schakelschema voor het verbinden van uw ESP8266 met FTDI-kaart wordt hieronder weergegeven.

Zorg ervoor dat aan de volgende voorwaarden is voldaan

1. De ESP8266-01 is slechts 3.3V tolerant, gebruik geen 5V. Zet FTDI dus alleen in de 3.3V-modus.

2. GPIO_0 moet worden geaard voor de programmeermodus

3. De reset-pin moet via een knop op de aardingspin worden aangesloten. Deze knop moet worden ingedrukt net voordat de code wordt geüpload. Elke keer dat de knop wordt ingedrukt, gaat de blauwe LED op de ESP8266-01-module hoog om aan te geven dat de module is gereset.

Zodra de verbindingen zijn gemaakt, opent u de Arduino IDE en controleert u of u een voorbeeldprogramma met succes kunt uploaden. Als je niet zeker weet hoe je de Arduino IDE moet gebruiken om een ​​programma naar ESP8266 te uploaden, volg dan de Programming ESP8266 met Arduino om het te leren. Op dit punt neem ik aan dat je het blink-programma met succes hebt geüpload.

. Het volledige programma wordt aan het einde van deze pagina gegeven, verderop leg ik ze uit als kleine fragmenten. Het programma vereist ook de Arduino JSON-bibliotheek om te compileren, dus als je de bibliotheek nog niet aan je Arduino IDE hebt toegevoegd, voeg deze dan toe door te downloaden uit de Arduino JSON-bibliotheek van Github.

De ESP8266 moet verbinding maken met internet om de gegevens over datum, tijd, temperatuur en vochtigheid te krijgen. U moet het dus toestaan ​​om verbinding te maken met uw wifi door de SSID en het wachtwoord in de onderstaande regels te bewijzen

const char * ssid = "JIO-Fi"; // Voer uw Wi-Fi SSID const char * password = "Pas123" in; // Voer uw Wi-Fi-wachtwoord in

In de setup () -functie controleren we of de ESP verbinding kan maken met de Wi-Fi, zo niet, dan zal hij daar voor altijd wachten door gewoon "Connecting.." op de seriële monitor af te drukken.

while (WiFi.status ()! = WL_CONNECTED) {// Wacht tot wifi is verbonden vertraging (1000); Serial.print ("Verbinden.."); // Afdrukken Verbinding maken… tot verbinding is gemaakt }

De volgende stap is de zeer belangrijke stap. Als de Wi-Fi-verbinding succesvol is, moeten we een http get-verzoek aanroepen om het JSON-bestand van internet te lezen. In deze tutorial gebruik ik de API van wunderground.com. Dus als u van plan bent om hetzelfde te gebruiken, kunt u naar de link gaan en u aanmelden voor de gratis API-sleutel of een API naar keuze gebruiken. Zodra u klaar bent met uw API, krijgt u een link zoals deze hieronder

Opmerking: ik heb de API-sleutel van deze link gewijzigd, dus dit zal niet werken. Houd uw API-sleutel beveiligd en deel deze niet.

Mijn API hier wordt gebruikt om de weergegevens van Chennai te krijgen. U kunt elke API gebruiken. Maar wanneer u de API in een browser laadt, zou deze een JSON-bestand moeten retourneren. Mijn API retourneert bijvoorbeeld het volgende JSON-bestand

De jouwe kan een bestand met andere gegevens retourneren. We kunnen controleren of dit JSON-bestand ook door onze ESP8266 wordt ontvangen door het te lezen en JSON af te drukken op onze seriële monitor met behulp van de volgende regels

int httpCode = http.GET (); // geef een get-verzoek door als (httpCode> 0) {// Controleer de terugkerende code // payload = http.getString (); // Bewaar de waarde op varibale Payload voor foutopsporing // Serial.println (payload); // Druk de payload af voor foutopsporing, anders becommentarieer beide regels

Ik heb deze regels becommentarieerd, omdat ze alleen nodig zijn om te testen. Als u er eenmaal voor heeft gezorgd dat ESP8266 de JSON-gegevens kan verkrijgen, is het tijd om de gegevens te formuleren. Zoals u kunt zien, zijn deze gegevens enorm en zijn de meeste waarden nutteloos, behalve degene die voor ons vereist zijn, zoals datum, tijd, temperatuur en vochtigheid.

Dus gebruiken we de JSON Arduino-bibliotheek om de voor ons vereiste waarden te scheiden en op te slaan in een variabele. Dit is mogelijk omdat de waarden in het JSON-bestand worden toegewezen als naamwaardeparen. Deze naam is dus een string die de voor ons vereiste waarde bevat.

Om dit te doen, moeten we naar een website gaan die het JSON-bestand analyseert en ons de Arduino-code geeft. Ja, zo eenvoudig is het. Ga verder naar https://arduinojson.org/assistant/ en plak het JSON-bestand dat we in onze browser hebben geladen en druk op enter. Toen ik klaar was, zag de mijne er hieronder ongeveer zo uit

Scroll een beetje naar beneden om het fraseringsprogramma te zien dat automatisch wordt aangemaakt

Het enige dat u hoeft te doen, is de gewenste variabele selecteren, deze kopiëren en in uw Arduino IDE plakken, zoals ik hier heb gedaan

/ * Fraseringsgegevens met behulp van de JSON-bibliotheek * / // Gebruik https://arduinojson.org/assistant/ om de fraseringswaarden voor uw JSON-string const size_t bufferSize = JSON_OBJECT_SIZE (0) + JSON_OBJECT_SIZE (1) + JSON_OBJECT_SIZE (2) + 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 ()); / * Einde van formuleringsgegevens * / // Adresseer de waarde sin naar de gewenste variabelen JsonObject & current_observation = root; // onder current_observation JsonObject & current_observation_observation_location = current_observation; // under observation_location const char * current_observation_station_id = current_observation; // "ICHENNAI1" // haal de locatiedetails op const char * current_observation_local_time_rfc822 = current_observation; // Lokale tijd // verkrijg de lokale tijd const char * current_observation_temperature_string = current_observation; // "90,7 F (32,6 C)" // verkrijg de temperatuurwaarde const char * current_observation_relative_humidity = current_observation; // "73%" // verkrijg de vochtigheidswaarde

Ik heb zojuist de variabelen current_observation_station_id, current_observation_local_time_rfc822, current_observation_temperature_string en current_observation_relative_humidity gekopieerd. Omdat we van plan zijn om alleen die vier gegevens op ons LCD-scherm weer te geven.

Ten slotte hebben we de gegevens die we nodig hebben van internet gehaald en opgeslagen als een variabele die we comfortabel kunnen gebruiken. Om deze gegevens naar Arduino te sturen, hoeven we ze alleen maar serieel via de seriële monitor te schrijven. De volgende regels zullen precies hetzelfde doen

// Druk de variabelen af ​​via seriële monitor Serial.print (current_observation_station_id); // stuur de locatiegegevens naar Arduino delay (100); // stabiliteitsvertraging Serial.print (current_observation_local_time_rfc822); // stuur de lokale tijddetails naar Arduino delay (100); // stabiliteitsvertraging Serial.print (current_observation_temperature_string); // stuur de temperatuurdetails naar Arduino delay (100); // stabiliteitsvertraging Serial.print (current_observation_relative_humidity); // stuur de vochtigheidsgegevens naar Arduino delay (100); // stabiliteitsvertraging

Merk op dat ik Serial.print () heb gebruikt en niet Serial.println () aangezien het commando Serial.println () een / n en / r zal toevoegen samen met de gegevens die niet nodig zijn voor ons. We hebben ook een vertraging van 10 seconden toegevoegd, zodat de ESP deze waarden alleen met een interval van 10 seconden naar Arduino stuurt.

ESP8266-01 verbinden met Arduino:

Tot nu toe hebben we onze ESP8266-01 geprogrammeerd om de vereiste gegevens van internet te lezen met een interval van 10 seconden en deze serieel te verzenden. Nu moeten we de ESP met Arduino verbinden, zodat we deze seriële gegevens kunnen lezen. We moeten ook een 16 * 2 LCD-scherm aan Arduino toevoegen, zodat we de gegevens kunnen weergeven die zijn ontvangen van de ESP8266-module. Het schakelschema om de ESP8266-module met Arduino te verbinden, wordt hieronder weergegeven

Zorg ervoor dat de GPIO_0-pin vrij blijft, voed de module alleen met de 3,3V-pin van Arduino en druk op de drukknop om de ESP-module in de bedieningsmodule te plaatsen. Nu zou het programma dat we naar ESP hebben geüpload moeten werken en zou de module de gegevens via een seriële pin naar Arduino moeten sturen. Deze seriële pinnen zijn verbonden met pin nummer 6 en 7 op de Arduino. We kunnen dus de software seriële optie op Arduino gebruiken om deze seriële gegevens van de pinnen te lezen.

Arduino-programma en werken:

Het volledige Arduino-programma staat ook samen met de ESP-code aan het einde van deze pagina. U kunt naar beneden scrollen om het programma te bekijken of verder lezen als u het programma wilt begrijpen.

Het interfacing-programma is vrij eenvoudig, we hoeven alleen de seriële softwarebibliotheek te gebruiken om de gegevens van pin 6 en 7 te lezen en op het LCD-scherm weer te geven. Omdat de gegevens die worden ontvangen in string-indeling zijn, moeten we de substring-optie gebruiken om de payload te splitsen naar onze vereiste of zelfs indien nodig om te zetten in integer. Dus we beginnen met het definiëren van de pinnen waarop het LCD-scherm is aangesloten.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pinnen waarop LCD is aangesloten LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Omdat we de Rx- en Tx-pinnen van ESP8266 hebben verbonden met de 6 en 7 ^de pin van Arduino, moeten we de Software-serie voor die pinnen initialiseren, zodat we de seriële gegevens van hen kunnen ontvangen. Ik heb namen dit als ESP_Serial, je kunt noem ze alles wat je maar wilt

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

Binnen de setup () functie initialiseren we de seriële communicatie voor seriële monitor en ook voor de software serieel. Als je je kunt herinneren dat we het ESP-programma hebben gemaakt om te communiceren met 9600 baudrate, dus we moeten dezelfde baudrate gebruiken voor de seriële poort van de software. We tonen ook gedurende 2 seconden een klein introbericht op het LCD-scherm.

leegte setup () {lcd.begin (16, 2); // We gebruiken een 16 * 2 LCD-scherm lcd.print ("Arduino & ESP"); // Toon een introbericht Serial.begin (115200); ESP_Serial.begin (9600); vertraging (2000); lcd.clear (); }

Binnen de functie main loop () moeten we controleren of de ESP8266 iets verzendt. Als dat het geval is, lezen we de string uit ESP8266 en slaan we deze op in een variabele genaamd payload. De variabele payload is van het type String en bevat de volledige informatie die is verzonden vanuit de ESP8266-module.

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

Nu moeten we deze string in kleine stukjes splitsen zodat we ze voor ons eigen doel kunnen gebruiken, in dit geval moeten we ze splitsen om ze op het LCD-scherm weer te geven. Dit kan eenvoudig worden gedaan door de substring- functie in Arduino te gebruiken. U moet de positie van elk teken kennen om deze subtekenreeksfunctie te gebruiken. U kunt de payload op een seriële monitor afdrukken om de positie van tekens te kennen en deze gebruiken om de subtekenreeksen te categoriseren, zoals hieronder wordt weergegeven

local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); temperatuur = payload.substring (48, 54); Vochtigheid = payload.substring (55, 60);

Nu kan ik doorgaan en deze variabelen gebruiken om ze af te drukken op een seriële monitor of ze gewoon op het LCD-scherm af te drukken. Door ze echter af te drukken op de seriële monitor, kunnen we o controleren of de substrings correct zijn gesplitst. Vervolgens drukken we ze gewoon af op het LCD-scherm met behulp van de volgende regels

lcd.clear (); lcd.setCursor (1, 0); lcd.print (lokale_datum); lcd.setCursor (8, 0); lcd.print (lokale_tijd); lcd.setCursor (1, 1); lcd.print (temperatuur); lcd.setCursor (10, 1); lcd.print (vochtigheid);

Upload het programma naar Arduino en zorg ervoor dat de aansluitingen zijn zoals weergegeven in het bovenstaande schakelschema. Pas het contrast van het LCD-scherm aan totdat u de dingen duidelijk ziet. U zou het intro-bericht op het LCD-scherm moeten zien en na enkele seconden zouden de details zoals datum, tijd, temperatuur en vochtigheid op het LCD-scherm moeten worden weergegeven, zoals hieronder weergegeven.

U kunt ook zien dat de blauwe led op de ESP8266 knippert elke keer dat de gegevens binnenkomen. Als u dit niet kunt zien, betekent dit dat de ESP niet in de programmeermodus is, probeer dan op de Reset-knop te drukken en controleer ook de verbindingen.

Op dezelfde manier kunt u elke API gebruiken om alle vereiste gegevens van internet te krijgen en deze naar de Arduino te sturen en uw werk met Arduino te verwerken. Er is heel veel API beschikbaar op internet en met al deze kun je een onbeperkt aantal projecten maken. Ik hoop dat je het project hebt begrepen en met plezier hebt gebouwd. Als je een probleem hebt gehad, plaats ze dan in de commentaarsectie hieronder of op onze forums.

U kunt hier al onze ESP8266-gerelateerde projecten vinden.