Arduino con esp8266

ESP8266-01 è stato un ottimo modulo per placare tutte le nostre sete di progetti IOT. Dal suo rilascio, ha sviluppato una forte comunità e si è evoluto in un modulo Wi-Fi facile da usare, economico e potente. Un'altra piattaforma open source molto più popolare è Arduino, ha già un sacco di progetti costruiti attorno ad esso. La combinazione di queste due piattaforme aprirà le porte a molti progetti innovativi, quindi in questo tutorial impareremo come interfacciare il modulo ESP8266-01 con Arduino. In questo modo saremo in grado di inviare o ricevere dati tra Arduino e Internet.

Ai fini di questo tutorial leggeremo l'ora, la data, la temperatura e l'umidità da Internet utilizzando un'API con ESP8266-01. Quindi inviare questi valori a una scheda Arduino e visualizzarli sullo schermo LCD 16 * 2. Sembra fantastico, vero !! Quindi iniziamo.

Materiali richiesti:

1. Scheda Arduino (qualsiasi versione)
2. ESP8266-01
3. Scheda programmatore FTDI con opzione 3.3V
4. LCD 16x2
5. Potenziometro
6. Premi il bottone
7. Cavi di collegamento
8. Breadboard

Come funzionano le cose?

Prima di immergerci, è importante sapere come funzionerà effettivamente questa cosa. Fondamentalmente, dobbiamo iniziare con il modulo ESP8266-01. Useremo l' IDE Arduino per programmare ESP8266 e il codice verrà scritto per utilizzare un'API per leggere un file JSON tramite richiesta http. Quindi formuleremo questo file JSON per estrarre solo le informazioni richieste dal file JSON completo.

Una volta formulate le informazioni, le stamperemo utilizzando la comunicazione seriale. Queste linee seriali verranno quindi collegate ad Arduino, in modo che Arduino possa leggere le informazioni inviate da ESP8266. Una volta che le informazioni sono state lette ed elaborate, le visualizzeremo sullo schermo LCD.

Va bene, se non l'hai capito completamente, perché impareremo lo stesso nel resto di questo tutorial.

Programmazione di ESP8266-01:

Questo tutorial presuppone che tu abbia una certa esperienza con il modulo ESP8266. In caso contrario, si consiglia di leggere i seguenti tre tutorial per capirlo completamente.

1. Iniziare con ESP8266-01
2. Programmazione di ESP8266-01 utilizzando i comandi AT
3. Programmazione di ESP8266-01 utilizzando Arduino IDE e flashing della sua memoria

Puoi anche controllare tutti i nostri progetti ESP8266 qui.

Qui programmeremo il modulo ESP8266-01 utilizzando l'IDE di Arduino. Per l'hardware stiamo usando la scheda FTDI con 3.3V per programmare ESP8266, poiché renderà l'hardware molto semplice. Di seguito è mostrato lo schema del circuito per il collegamento dell'ESP8266 con la scheda FTDI.

Assicurati che le seguenti condizioni siano soddisfatte

1. ESP8266-01 tollera solo 3,3 V, non utilizzare 5 V. Quindi imposta FTDI solo in modalità 3.3V.

2. GPIO_0 deve essere collegato a terra per la modalità di programmazione

3. Il pin di ripristino deve essere collegato tramite un pulsante al pin di terra. Questo pulsante dovrebbe essere premuto appena prima di caricare il codice. Ogni volta che si preme il pulsante, il LED blu sul modulo ESP8266-01 si accenderà per indicare che il modulo è stato ripristinato.

Una volta terminate le connessioni, apri l'IDE di Arduino e controlla se sei in grado di caricare correttamente un programma di esempio. Se non sei sicuro di come utilizzare l'IDE di Arduino per caricare il programma su ESP8266, segui la programmazione ESP8266 con Arduino per impararlo. A questo punto presumo che tu abbia caricato con successo il programma blink.

. Il programma completo è fornito alla fine di questa pagina più sotto, li spiego come piccoli frammenti. Il programma richiede anche la compilazione della libreria JSON di Arduino, quindi se non hai già aggiunto la libreria al tuo IDE Arduino, aggiungila scaricandola dalla libreria JSON di Arduino da Github.

L'ESP8266 deve connettersi a Internet per ottenere i dati su data, ora, temperatura e umidità. Quindi devi consentirgli di connettersi al tuo Wi-Fi dimostrando l'SSID e la password nelle righe seguenti

const char * ssid = "JIO-Fi"; // Inserisci il tuo SSID Wi-Fi const char * password = "Pas123"; // Immettere la password Wi-Fi

All'interno del setup () funzione che controlla se l'ESP è in grado di connettersi con il Wi-Fi, se non si aspetterà lì per sempre semplicemente stampando “Collegamento..” sul monitor di serie.

while (WiFi.status ()! = WL_CONNECTED) {// Attendi fino a quando il Wi-Fi è connesso delay (1000); Serial.print ("Connessione in corso.."); // Stampa connessione.. fino a quando non viene stabilita la connessione }

Il passaggio successivo è il passaggio molto importante. Se la connessione Wi-Fi ha esito positivo, dobbiamo invocare una richiesta http get per leggere il file JSON da Internet. In questo tutorial utilizzo l'API fornita da wunderground.com. Quindi, se hai intenzione di utilizzare lo stesso, puoi accedere al collegamento e registrarti per la chiave API gratuita o utilizzare qualsiasi API di tua scelta. Una volta finalizzato con la tua API, ti ritroverai con un collegamento simile a questo di seguito

Nota: ho modificato la chiave API di questo collegamento, quindi non funzionerà. Mantieni la tua chiave API al sicuro e non condividerla.

La mia API qui viene utilizzata per ottenere i dati meteorologici di Chennai. Puoi usare qualsiasi API. Ma quando carichi l'API in qualsiasi browser, dovrebbe restituire un file JSON. Ad esempio, la mia API restituisce il seguente file JSON

Il tuo potrebbe restituire un file con dati diversi. Possiamo verificare se questo file JSON viene ricevuto anche dal nostro ESP8266 leggendolo e stampando JSON sul nostro monitor seriale utilizzando le seguenti righe

int httpCode = http.GET (); // passa una richiesta get if (httpCode> 0) {// Controlla il codice di ritorno // payload = http.getString (); // Memorizza il valore su varibale Payload per il debug // Serial.println (payload); // Stampa il payload per il debug altrimenti commenta entrambe le righe

Ho commentato queste righe, poiché sono necessarie solo per i test. Dopo esserti assicurato che ESP8266 sia in grado di ottenere i dati JSON, è il momento di formulare i dati. Come puoi vedere, questi dati sono enormi e la maggior parte dei valori sono inutili tranne quelli che ci sono necessari come data, ora, temperatura e umidità.

Quindi usiamo la libreria JSON Arduino per separare i valori richiesti per noi e memorizzarli in una variabile. Ciò è possibile perché i valori nel file JSON vengono assegnati come coppie di valori nome. Quindi questo nome è una stringa che conterrà il valore richiesto per noi.

Per fare questo dobbiamo spostarci su un sito web che analizzerà il file JSON e ci fornirà il codice Arduino. Sì, è così facile. Procedi su https://arduinojson.org/assistant/ e incolla il file JSON che abbiamo caricato nel nostro browser e premi invio. Una volta fatto il mio sembrava qualcosa di simile a questo sotto

Scorri un po 'verso il basso per vedere il programma di fraseggio creato automaticamente

Tutto quello che devi fare è selezionare la variabile che desideri, copiarla e incollarla sul tuo IDE Arduino, come ho fatto qui

/ * Dati di fraseggio utilizzando la libreria JSON * / // Usa https://arduinojson.org/assistant/ per ottenere i valori di fraseggio per la tua stringa JSON 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 ()); / * End of Phrasing Data * / // Indirizza il valore sin alle variabili desiderate JsonObject & current_observation = root; // sotto current_observation JsonObject & current_observation_observation_location = current_observation; // sotto posizione_osservazione const char * current_observation_station_id = current_observation; // "ICHENNAI1" // ottiene i dettagli sulla posizione const char * current_observation_local_time_rfc822 = current_observation; // Local time // recupera l'ora locale const char * current_observation_temperature_string = current_observation; // "90.7 F (32.6 C)" // ottiene il valore della temperatura const char * current_observation_relative_humidity = current_observation; // "73%" // ottiene il valore di umidità

Ho appena copiato le variabili current_observation_station_id, current_observation_local_time_rfc822, current_observation_temperature_string e current_observation_relative_humidity . Dal momento che stiamo progettando di visualizzare solo quei quattro dati sul nostro schermo LCD.

Infine, abbiamo ottenuto i dati di cui abbiamo bisogno da Internet e li abbiamo salvati come una variabile che possiamo usare comodamente. Per inviare questi dati ad Arduino dobbiamo solo scriverli in serie tramite il monitor seriale. Le seguenti righe faranno esattamente lo stesso

// Stampa le variabili tramite il monitor seriale Serial.print (current_observation_station_id); // invia i dettagli della posizione ad Arduino delay (100); // ritardo di stabilità Serial.print (current_observation_local_time_rfc822); // invia i dettagli dell'ora locale ad Arduino delay (100); // ritardo di stabilità Serial.print (current_observation_temperature_string); // invia i dettagli della temperatura ad Arduino delay (100); // ritardo di stabilità Serial.print (current_observation_relative_humidity); // invia i dettagli sull'umidità ad Arduino delay (100); // ritardo di stabilità

Nota che ho usato Serial.print () e non Serial.println () poiché il comando Serial.println () aggiungerà a / ne / r insieme ai dati che non sono necessari per noi. Abbiamo anche aggiunto un ritardo di 10 secondi in modo che l'ESP invii questi valori solo ad un intervallo di 10 secondi ad Arduino.

Collegamento di ESP8266-01 con Arduino:

Finora abbiamo programmato il nostro ESP8266-01 per leggere i dati richiesti da Internet a un intervallo di 10 secondi e inviarli in serie. Ora dobbiamo interfacciare l'ESP con Arduino in modo da poter leggere questi dati seriali. Dobbiamo anche aggiungere un display LCD 16 * 2 ad Arduino in modo da poter visualizzare i dati ricevuti dal modulo ESP8266. Di seguito è mostrato lo schema del circuito per interfacciare il modulo ESP8266 con Arduino

Assicurati che il pin GPIO_0 sia lasciato libero, alimenta il modulo solo con il pin 3.3V di Arduino e premi il pulsante per mettere il modulo ESP nel modulo operativo. Ora il programma che abbiamo caricato su ESP dovrebbe aver iniziato a funzionare e il modulo dovrebbe inviare i dati tramite pin seriale ad Arduino. Questi pin seriali sono collegati ai pin numero 6 e 7 su Arduino. Quindi possiamo usare l'opzione seriale del software su Arduino per leggere questi dati seriali dai pin.

Programma e funzionamento Arduino:

Il programma Arduino completo viene fornito anche insieme al codice ESP alla fine di questa pagina. È possibile scorrere verso il basso per visualizzare il programma o continuare a leggere se si desidera comprendere il programma.

Il programma di interfacciamento è piuttosto semplice, non ci resta che utilizzare la libreria seriale del software per leggere i dati dai pin 6 e 7 e visualizzarli sullo schermo LCD. Poiché i dati ricevuti sono in formato stringa, dobbiamo utilizzare l'opzione della sottostringa per suddividere il payload in base alle nostre esigenze o persino convertirlo in numero intero se necessario. Quindi iniziamo definendo i pin a cui è collegato il display LCD.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pin a cui è collegato LCD LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Dato che abbiamo collegato i pin Rx e Tx di ESP8266 con il 6 e il 7 ^° pin di Arduino, dobbiamo inizializzare il seriale del software per quei pin in modo che possiamo ricevere i dati seriali da loro. Ho chiamato ESP_Serial, puoi nominali come preferisci

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

All'interno della funzione setup () inizializziamo la comunicazione seriale per il monitor seriale e anche per la seriale del software. Se potessi ricordare che abbiamo creato il programma ESP per comunicare a 9600 baud rate, quindi dobbiamo usare lo stesso baud rate per la porta seriale del software. Visualizziamo anche un piccolo messaggio di introduzione sul display LCD per 2 secondi.

void setup () {lcd.begin (16, 2); // Stiamo usando un display LCD 16 * 2 lcd.print ("Arduino & ESP"); // Visualizza un messaggio introduttivo Serial.begin (115200); ESP_Serial.begin (9600); ritardo (2000); lcd.clear (); }

All'interno della funzione main loop () dobbiamo controllare se ESP8266 sta inviando qualcosa. Se lo è, leggiamo la stringa da ESP8266 e la salviamo in una variabile chiamata payload. Il payload variabile è di tipo String e conterrà le informazioni complete inviate dal modulo ESP8266.

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

Ora dobbiamo dividere questa stringa in piccoli pezzi in modo da poterli utilizzare per i nostri scopi, in questo caso dobbiamo dividerli per visualizzarli sullo schermo LCD. Questo può essere fatto facilmente usando la funzione sottostringa in Arduino. Devi conoscere la posizione di ogni carattere per usare questa funzione di sottostringa . È possibile stampare il payload sul monitor seriale per conoscere la posizione dei caratteri e utilizzarli per classificare le sottostringhe come mostrato di seguito

local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); temperatura = carico utile. sottostringa (48, 54); Umidità = carico utile. Sottostringa (55, 60);

Ora posso andare avanti e utilizzare queste variabili per stamparle sul monitor seriale o semplicemente stamparle sul display LCD. Tuttavia stamparli sul monitor seriale ci aiuterà a controllare se le sottostringhe sono divise correttamente. Successivamente li stampiamo sul display LCD utilizzando le seguenti righe

lcd.clear (); lcd.setCursor (1, 0); lcd.print (local_date); lcd.setCursor (8, 0); lcd.print (local_time); lcd.setCursor (1, 1); lcd.print (temperatura); lcd.setCursor (10, 1); lcd.print (umidità);

Carica il programma su Arduino e assicurati che le connessioni siano come mostrato nello schema del circuito sopra. Regola il contrasto del display LCD fino a visualizzare chiaramente le cose. Dovresti vedere il messaggio Intro sul display LCD e poi dopo pochi secondi i dettagli come data, ora, temperatura e umidità dovrebbero essere visualizzati sullo schermo LCD come mostrato di seguito.

Puoi anche notare che il led blu sull'ESP8266 lampeggia ogni volta che arrivano i dati. Se non riesci a vederlo significa che l'ESP non è in modalità di programmazione prova a premere il pulsante Reset verifica anche i collegamenti

In modo simile a questo, puoi utilizzare qualsiasi API per ottenere tutti i dati richiesti da Internet e inviarli ad Arduino ed elaborare il tuo lavoro con Arduino. Ci sono tonnellate di API disponibili su Internet e con tutte queste puoi realizzare un numero illimitato di progetti. Spero che tu abbia capito il progetto e ti sia piaciuto realizzarlo. Se hai riscontrato problemi, pubblicali nella sezione commenti qui sotto o sui nostri forum.

Puoi trovare tutti i nostri progetti relativi a ESP8266 qui.