[UPDATE 05/02/2020] ESP01(ESP8266) e IOT da 4 Lire : Guida completa in Italiano!

Condividi questo articolo :

Premessa

Questo contenuto è una documentazione sempre in aggiornamento, per cui tutto quello che stai leggendo oggi potrebbe risultare diverso tra qualche mese o addirittura tra qualche giorno. Inoltre, il manuale d’uso che stai per leggere è stato creato in base alle nostre esperienze, non sono documentazioni prese da altri siti e tutto ciò, comprese le foto, sono di proprietà della redazione di Filo Connesso. Puoi suggerire correzioni e puoi condividere questa documentazione purché venga condivisa in versione integrale e sopratutto citandone la fonte. Sperando che venga apprezzato il nostro impegno e confidando nella tua collaborazione, ti auguriamo buona lettura! Creato con ❤️ da Filo Connesso!

CAPITOLO 1 | La Scheda

Le schede programmabili che si prestano molto bene alle applicazioni di IOT stanno diventando sempre più piccole e questa caratteristica aiuta moltissimo a realizzare oggetti connessi a internet di piccole dimensioni, i quali possono essere inseriti all’interno di piccoli spazi o addirittura indossati!

Te lo immagini uno smart watch fai da te ? Be, lavoraci su 😀!

Parliamo ora di ESP01, una piccola scheda dalle grandi potenzialità e iniziamo a sfatare subitissimo due miti che assediano la rete :

  1. ESP01 NON è un modulo/shield wifi per permettere la connessione di Arduino o schede simili ad Internet, ma è un micro controllore a tutti gli effetti, quindi va programmato a parte!
  2. ESP01 funziona con la seriale a 5V, NON servono fantomatici convertitori logici e potete collegarlo direttamente ai pin RX e TX di Arduino (Esperienza fatta in 2 anni). Tuttavia, servono 3.3V per alimentare la scheda [tollera dai 3.0V ai 3.6V], non alimentatelo a 5V poiché aggiungerete la funzione fumogeno alla scheda 🤣🤣🤣!

Ok, dopo questa piccola premessa che farà incazzare molte persone, iniziamo nell’approfondire in modo chiaro le caratteristiche della scheda e andiamo a vedere quali sono i pro e i contro di questo piccoletto.

Iniziamo dai contro, tanto per non farci mancare nulla…

Non ha una porta USB a bordo e la programmazione andrebbe fatta tramite convertitori seriali appositi, dei quali parleremo molto male in un capitolo a parte o in alternativa collegandolo ad Arduino tramite connessione seriale, la quale secondo noi, risulta la soluzione più rapida e indolore.

Per collegarlo ad Arduino possiamo avvalerci dei cavetti dupont o in alternativa dei cavetti dupont (Si, di nuovo), di una breadboard e affiancando tutto ad un adattatore da breadboard per ESP01.

Attenzione agli adattatori, poichè noi abbiamo avuto dei problemi con questi cosetti, i quali avevano il GND non collegato di fabbrica e che noi abbiamo opportunamente “riparato”.

Questo coso non funziona… ti credo, non ha il GND collegato 😨

A destra il modello riparato.

Altro punto dolente, è la presenza di soli due pin I/O, i quali sono indicati come GPIO0 e GPIO2. Questa caratteristica non ci permette di collegare moltissimi utilizzatori all’ESP01, come led e pulsanti, ma che risulta comunque comodo per piccolissime applicazioni.

E qui ci fu la svolta… tramite la libreria Wire.h è possibile usare i pin in funzione di I2C 😍!

Apriamo una piccola parentesi PRO. Sebbene il numero di pin sia limitato, l’uso dell’I2C su questo piccolo micro controllore apre moltissime porte poiché tantissimi dispositivi in commercio funzionano in I2C, per esempio i display, sensori ambientali, giroscopi e accelerometri ecc ecc e di conseguenza potremmo collegare a questo piccoletto un sacco di componenti CONTEMPORANEAMENTE.

Ebbene si, le connessioni I2C, per chi non lo sapesse, permettono di collegare in parallelo a soli due pin, più di un dispositivo compatibile con questo protocollo. E’ possibile collegare in totale 127 dispositivi e possono lavorare insieme poichè vengono gestiti con un sistema di BUS e ogni dispositivo ha un proprio indirizzo!

In commercio si trovano delle espansioni per ESP01 con varie funzioni, come relè, led rgb, sensori di vario genere e tutte queste soluzioni hanno in comune la possibilità di alloggiare l’ESP01 direttamente sulla scheda tramite un apposito alloggio studiato ad hoc.

Parliamo un pochino delle caratteristiche tecniche della scheda e vediamo di capirla in modo approfondito. Solitamente trovate in commercio i modelli ESP01 e ESP01-S che in linea di massima non hanno differenze tra di loro, se non fosse per la dimensione della memoria flash (memoria per i programmi) e che nello specifico abbiamo 500Kb per ESP01 e 1Mb per ESP01-S. Esiste una versione particolare dell’ESP01 che viene indicata come ESP01-M, non l’abbiamo provata e non sappiamo dirvi molto, se non che ha dimensioni ancora più ridotte dei fratelli maggiori, ma per paradosso presenta più pin!

Quanto può essere strana e misteriosa la vita 🤣?

A gestire il tutto e a processare i nostri programmi ci pensa un processore ESP8266, che permette anche la connettività al Wi-FI.

Tornando un attimino ai Pin di ESP01, che in certi casi sono indicati con una comoda serigrafia sulla scheda e in altri casi, come per il modello da 500Kb, non sono indicati, troviamo i pin di comunicazione seriale RX e TX, il pin di reset RST, i pin di alimentazione 3V3 e GND, il pin GPIO2 e infine i pin GPIO0 e CHPD, quest’ultimo in alcuni modelli è chiamato EN.

Il modello da 500kb non presenta la serigrafia sotto la pcb, la pedinatura rimane comunque la stessa!

Su questi ultimi due ci soffermeremo un attimino. Il pin GPIO0 oltre ad essere un pin utilizzabile per azionare cose, è anche il pin che abilita alla programmazione e in fase di caricamento del programma deve stare collegato a GND. Il pin CHPD è il pin ENABLE (abilitazione), su quest’ultimo c’è un po di mistero :

Oltre ad essere un pin necessario per entrare in modalità di programmazione collegandolo ai 3.3V, è un pin che in alcuni modelli deve rimanere collegato in ogni caso, anche dopo la programmazione, poiché permette di non mandare in “stand-by” il piccolo ESP01.

Potremmo dire infine che la dimensione della scheda è di circa 1.43cm di larghezza per 2.48cm di lunghezza, ma lo sapete che c’è ? Vediamo come si collega ad Arduino, giusto per fare la prima configurazione!

CAPITOLO 2 | Collegare ESP01 ad Arduino

Collegare ESP01 è semplice, iniziamo con il collegamento per programmarlo che chiameremo A1 (Si come l’autostrada).

Collegamento A1 :

Nello specifico il collegamento permette solo la comunicazione con Arduino per accedere alla modalità AT, che vedremo tra poco e per caricare il nostro codice su ESP01. Avremo quindi :

TX ESP01TX ARDUINO
GND ESP01GND ARDUINO
CHPD(EN) ESP013.3V ARDUINO
GPIO2 ESP01
GPIO0 ESP01(no per ATMODE, si per FLASH MODE)GND ARDUINO(no per ATMODE, si per FLASH MODE)
RST ESP01
3V3 ESP013.3V ARDUINO
RX ESP01RX ARDUINO

IMPORTANTE : Il pin del RESET di Arduino, come mostrato nell’immagine è collegato al GND. Se sul nostro Arduino non abbiamo nessun programma caricato che usufruisce della seriale (per esempio il classico Blink), il caricamento su ESP01 andrà a buon fine anche senza collegare il RESET a GND, in caso contrario ci restituirà un errore, per evitare seccature collegate il RESET di Arduino a GND, tanto ci vuole poco 😁!

Per poi passare al secondo tipo di collegamento, che chiameremo A2, che ci servirà per comandare Arduino tramite ESP01, il quale sfrutta due pin di Arduino che funzioneranno da Seriale Virtuale, quindi cosi :

Collegamento A2 :

E avremo questi collegamenti :

TX ESP0111 ARDUINO
GND ESP01GND ARDUINO
CHPD(EN) ESP013.3V ARDUINO
GPIO2 ESP01
GPIO0 ESP01
RST ESP01
3V3 ESP013.3V ARDUINO
RX ESP0110 ARDUINO

Questo collegamento potremmo utilizzarlo includendo nel nostro progetto la libreria SoftwareSerial, approfondite qui.

Finalmente un po di pratica…. Anzi no 😜!

CAPITOLO 3 | Installare il supporto schede ESP8266 su Arduino

Una cosa molto importante, la quale ci tenevamo particolarmente a precisare è che l’ide di Arduino permette l’aggiunta di varie schede anche diverse da Arduino, ma ciò non significa che sia lo strumento definitivo per la programmazione dell’ESP8266, poichè anche la stessa Espressif (Produttore dell’ESP8266) rilascia dei software e dei tool dedicati alla programmazione e all’interfacciamento con questo processore. L’uso dell’ide di Arduino permette di non discostarsi dal linguaggio di programmazione che molti di voi già conoscono e di rimanere in un ambiente di sviluppo familiare, se usate ovviamente Arduino!

Senza proporvi un capitolo lunghissimo, se avete bisogno dell’ide di Arduino lo trovate qui.

Dopo aver aperto l’ide rechiamoci nel menu File e successivamente clicchiamo su Impostazioni…


Aggiungere nel campo URL aggiuntive per il Gestore schede il link seguente (Non è uguale a quello mostrato in foto poichè è stato aggiornato) [UPDATE 17/06/2019] (qui la guida su come aggiungere la scheda in formato video):

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

Questo link permetterà di aggiungere tutte le schede con base ESP8266 con il supporto aggiornato. Possiamo cliccare su OK per chiudere le impostazioni dell’ide di Arduino.

Adesso dobbiamo andare nel menu Strumenti, poi su Scheda e infine cliccare su Gestore schede…

Nel Gestore schede cercate ESP8266 e installate l’unico gruppo di schede che vi compare, cioè esp8266 by ESP8266 Community. Una volta che l’installazione è terminata, potete cliccare su Chiudi per chiudere il Gestore schede.

Avete installato il supporto per ESP8266 sul vostro ide!

CAPITOLO 4 | AT Mode o Command Mode

Quando acquistate l’ESP01 e lo collegate usando il collegamento A1, al suo interno trovate una modalità di fabbrica, che vi permette di interrogare la scheda e settare alcuni parametri, questa modalità si chiama AT o Command Mode, tale modalità è presente anche su altri dispositivi, nello specifico sui moduli Bluetooth, altre schede wifi e alcuni moduli radio.

Possiamo sfruttare il Monitor Seriale dell’IDE di Arduino per usare la Command Mode e inviare comandi e ricevere risposte dall’ESP01.

Prima di provare a dialogare con ESP01, ricordatevi di scegliere la scheda Generic ESP8266 Module dal menu Strumenti -> Scheda e sempre dallo stesso menu selezionate la porta COM collegata al vostro Arduino.

Sul Monitor Seriale impostate il baudrate su 115200 e il fine righa su Entrambi (NL & CR).

Aprite Monitor Seriale dal menu Strumenti, scrivete AT nel campo di invio dati seriali e premete Invio, se ESP01 risponderà OK, la connessione è stata eseguita correttamente.

La modalità AT comprende vari comandi che possiamo inviare per interrogare il dispositivo e ricevere informazioni importanti, tra cui il nome del dispositivo, il suo MAC ADDRESS e cosi via.

Di seguito trovate tutti i comandi AT che vi potranno essere utili :

ATComando base di controllo.
AT+RSTComando di reset.
AT+GMRMostra la versione firmware.
AT+GSLP=temp(mills) Manda in sospensione dopo
il tempo impostato.
ATE0 e ATE1Disattiva e attiva l’echo dei
comandi inviati.
AT+CWMODE?Mostra la modalità
corrente
(Client(1) o AP(2)).
E’ possibile
cambiare la
modalità usando
AT+CWMODE=1,2,3(ibrida)
AT+CWJAP? Mostra la rete a cui è collegato attualmente ESP01.Per connettersi a una rete utilizzare
AT+CWJAP=nome,pswd
(necessita modalità 1 o 3).
AT+CWLAPMostra le connessioni presenti nel raggio di azione di ESP01.La prima cifra indica la cifratura della password :
0 = SENZA PASSWORD
1 = WEP
2 = WPA_PSK
3 = WPA2_PSK
4 = WPA_WPA2_PSK
AT+CWQAPDisconnettersi dalla rete a cui si è connessi.
AT+CWSAPConfigura un SoftAP.Usare
AT+CWSAP=nome,pswd,canale,cifratura(0,2,3,4)
per la cifratura guardareAT+CWLAP.
AT+CWDHCP=mode,switchImposta protocollo DHCP.I parametri per mode :
0 : set ESP8266 come softAP
1 : set ESP8266 come Client
2 : set both ESP8266 come ibrido
I parametri per switch :
0 : disattiva il DHCP
1 : attiva il DHCP
AT+CIPSTAMAC? Mostra il MAC ADDRESS.
AT+CIPSTA? Mostra e modifica IP in modalità Client.Per modificare (esempio) :
AT+CIPSTA=”192.168.1.108”
AT+CIPAP?Mostra e modifica IP in modalità AP.Per modificar (esempio) :
AT+CIPAP=”192.168.7.1”

Esistono infine altri comandi che permettono di effettuare operazioni particolari e articolate, ma tralasceremo questi comanti poiché quelli di nostro interesse per eseguire i nostri primi test su ESP01 vengono mostrati tutti in questa pagina.

Per ultimo, ma non in ordine di importanza, dovete sapere che una volta effettuato il caricamento del primo sketch all’interno di ESP01 la modalità AT verrà eliminata e non si potrà più accedere ad essa! Niente paura, è possibile effettuare i vari settaggi anche utilizzando la libreria apposita ESP8266WiFi.h.

CAPITOLO 4.1 | Ripristinare l’AT Mode per versione da 1Mb (serigrafato) [UPDATE 30/05/2019]

Sebbene l’AT Mode viene persa al momento del caricamento di uno sketch, è possibile utilizzare un tool e il firmware base forniti da Espressif per ripristinare la modalità comandi sulla nostra schedina.

Per semplificarvi il lavoro abbiamo realizzato un file .bin singolo completo di firwmare combinato per l’iniziazzazione dell’ESP01 che vi permetterà di riportare la scheda allo stato di fabbrica. Non dite che non vi vogliamo bene, ci aspettiamo un supporto enorme da parte vostra con un’iscrizione al canale Youtube e un mi piace a tutti i ventordici video che abbiamo! 😍😍

Nonostante il file .bin sia stato realizzato da noi, il suo contenuto non è di nostra proprietà, quindi fate riferimento a Espressif per diritti e supporto.

  1. Scaricare il Firmware combinato da qui con ATMODE V1.6.2, lo trovate in formato non combinato dal sito del produttore.
  2. Scaricare il tool di caricamento dal sito ufficiale del produttore o più velocemente cliccando qui.
  3. Collegate L’ESP01 con il collegamento A1 mostrato nel Capitolo 2.
  4. Sistemate tutto quanto in una cartella solamente per comodità e iniziamo!

Come detto abbiamo inserito tutto dentro una cartella e abbiamo estratto i due file .zip al suo interno :

Entriamo dentro la cartella flash_download_tools_v3.6.5_0 e navighiamo al suo interno affinché non troveremo il software flash_download_tools_v3.6.5.exe.

Apriamo il programma e dovrebbe comparire una finestra del genere :

Facciamo click sul primo pulsante ESP8266 DownloadTool e si aprirà questa finestra :

Settiamo i vari valori in questo modo :

Nella parte superiore settiamo l’allocazione di memoria su 0x000000 e successivamente premendo il pulsante “…” andiamo a selezionare il file .bin contenente il firmware base (AT_MODE_ESP8266.bin) per la scheda e infine spuntiamo la casella sulla sinistra per abilitare il caricamento del file in questione.

In basso, nella sezione FLASH SIZE selezionate l’opzione 8Mbit.

Accertiamoci che la com selezionata sia quella abbinata alla scheda Arduino e che il baudrate sia impostato su 115200.

A questo punto possiamo cliccare sul pulsante START e attendere che il processo sia terminato prima di testare se tutto è andato a buon fine :

Durante il processo il led su ESP01 l’ampeggerà in modo cadenzato e successivamente verrà mostrato il messaggio FINISH quando il processo di caricamento verrà terminato :

A questo punto possiamo chiudere tutte le finestre del tool di caricamento, staccare il pin GPIO0 dal GND e infine scollegare e ricollegare l’USB da Arduino per far tornare ESP01 in modalità “normale”.

Aprite il programma di Arduino e successivamente il Monitor Seriale e provate a lanciare il comando AT :

Et voilà, la modalità AT è tornata a funzionare! 😍

Possiamo verificare la versione del firmware installato con AT+GMR :

Avrete cosi ripristinato lo stato di fabbrica del vostro ESP01!

CAPITOLO 4.2 | ESP8266 Flasher [UPDATE 05/02/2020]

Abbiamo conosciuto ESP8266 Flasher grazie alla nostra community, un tool utilissimo e facile da usare che permette di caricare file .bin su Esp8266 in pochi e semplici passi!

Potete scaricare ESP8266 Flasher da qui.

Nel caso in cui volessimo ripristinare il firmware AT del nostro ESP01, potremmo usare il firmware citato nel capitolo precedente e che potete scaricare da qui https://www.filoconnesso.it/wp-content/uploads/2019/05/AT_MODE_ESP8266.zip.

Una volta scaricato il flasher e estratto il file zip ci sono due cartelle, ognuna contiene il software in base all’architettura del processore che usiamo sul computer : 32bit o 64bit.

Nel nostro caso abbiamo avvitato la versione a 64bit.

La cartella Config viene creata al primo avvio del programma e contiene i file di supporto del software.

Avviato il flasher, rechiamoci nella scheda Config e usando l’icona ingranaggio, andiamo a selezionare il file .bin da caricare sul processore :

Successivamente nella sezione Advanced impostiamo tutto in questo modo :

Infine, torniamo nella scheda Operation, impostiamo la porta giusta e successivamente facciamo click su Flash :

Avremo così caricato il firmware in modo molto veloce!

IMPORTANTE :

Per far funzionare il tutto abbiamo utilizzando il classico collegamento A1 che trovate raffigurato nel CAPITOLO 2 di questo manuale.

Come sempre, il GPIO0 collegato con il GND è necessario solo in fase di programmazione e va tolto una volta che il firmware è stato caricato, inoltre è necessario staccare e riattaccare ogni volta l’alimentazione della scheda prima di caricare un nuovo programma!

Firmware di test (Blink) :

https://filoconnesso.it/wp-content/uploads/BLINK0.bin (Per i modelli con il led sul pin 0)
https://filoconnesso.it/wp-content/uploads/BLINK1.bin (Per i modelli con il led sul pin 1)
https://filoconnesso.it/wp-content/uploads/BLINK2.bin (Per i modelli con il led sul pin 2)
https://filoconnesso.it/wp-content/uploads/BLINK4.bin (Per i modelli con il led sul pin 4)

CAPITOLO 5 | Il primo programma e risoluzione dei problemi di caricamento [UPDATE 26/12/2019]

Una volta installato il supporto per ESP8266 sull’ide di Arduino sicuramente siete li a grattarvi le mani perché volete fare qualcosa in più. Ebbene, tempo al tempo, state calmini!

Come per Arduino possiamo caricare per ora un semplice Blink, si dai, avete capito, il codice che fa lampeggiare il led, poiché anche il nostro piccolo ESP01 ha un led che possiamo accendere da codice.

Quindi dal menu File, andate su Esempi e successivamente su 01.Basics e infine cliccate su Blink.

Come sempre controllate che nel menu Strumenti sia selezionata la scheda Generic ESP8266 Module e la porta COM collegata ad Arduino.

Adesso potete cliccare sul pulsante Carica e in questo caso ci sono due risultati, il primo è il medesimo :

Il codice si sta caricando correttamente e questo processo è confermato anche dai led RX e TX di Arduino che lampeggiano freneticamente e infine il led, che di solito è di colore Blu presente su ESP01, inizierà a lampeggiare.

Se invece sei una persona di quelle che è sfortunata nella vita, proprio questa mattina ti è morto il gatto e per concludere andando a caricare il codice ti fa anche errore, niente paura almeno in questo caso è qualcosa di risolvibile! 🤣🤣🤣

Di solito gli errori che può dare l’ide di Arduino in fase di caricamento sono legati alla connessione seriale tra l’USB e ESP01 e possono essere simili a questo :

warning: espcomm_sync failed
error: espcomm_open failed
error: espcomm_upload_mem failed
error: espcomm_upload_mem failed

Per risolvere questo problema, qui sotto trovi alcuni consigli :

Consiglio 0 [UPDATE 24/04/2019] : Anche se sembra una stupidaggine, controlla sempre che la scheda selezionata e la porta COM siano corrette, oppure sostituisci il cavo usb!

Consiglio 1 : Prova a staccare e riattaccare il cavo USB dal pc, poichè il chip di conversione seriale su Arduino potrebbe essere occupato.

Ma come ? Prima è andato, adesso perché non va ? 😡

Consiglio 2 : Se hai appena caricato un codice ed è andato a buon fine, successivamente hai apportato delle modifiche e stai tentando di caricare di nuovo il codice ma non si carica, sappi che devi anche in questo caso staccare l’USB per spegnere tutto e riattaccarla perchè ESP01, una volta completato il caricamento, entra in modalità “normale” di funzionamento, uscendo dalla modalità di programmazione nonostante sia collegato ancora in flash mode. Non chiederci come fa, non lo sappiamo!

Consiglio 3 : Chiudi tutti i programmi che potrebbero influire sulla connessione seriale della scheda, anche Ultimaker Cura, che in via teorica non dovrebbe entrarci nulla, al contrario gli rompe le scatole! Essendo un software di slicing per le stampanti 3D permette di stampare tramite USB e vede Arduino come una stampante 3D, importunandole la seriale. 🤣

Consiglio 4 : Riavvia il computer e/o l’ide di Arduino, per i motivi descritti nel consiglio precedente.

Consiglio 5 [UPDATE 24/04/2019] : Utilizzate cavetti dupont e breadboard in buono stato per evitare falsi contatti e errori improvvisi durante un caricamento, sopratutto le breadboard dopo anni di utilizzo vanno sostituite poichè i contatti a molla al loro interno tendono ad allargarsi e a non fare più contatto!

Consiglio 6 [UPDATE 24/04/2019] : Caricate il programma senza componenti collegati sull’ESP01, potrebbero interfarire con il caricamento. Basta un componente che abbia un assorbimento anomalo o malfunzionamenti impercettibili per darvi molti problemi!

Consiglio 7 [UPDATE 03/09/2019] : Verificare la versione della scheda “esp8266” installata perché le ultime non vanno, consigliata la versione 2.5.0! (Grazie a Edoardo Sassi)

Consiglio 8 [UPDATE 03/09/2019] : Nel caso il codice per far lampeggiare il led blu della scheda non funzioni, mettere 1 al posto di 2! (Grazie a Edoardo Sassi)

Consiglio 8.1 [UPDATE 05/02/2019] : Il led builtin, che di default è sul pin 2, in alcuni modelli di ESP01 è su un pin diverso : provare i pin 0,1,2 e 4.

Consiglio 9 : BUTTA IL TUO ESP01 DALLA FINESTRA! Non scherziamo, ci sono capitate anche a noi delle schedine difettose, non puoi farci nulla e non conviene nemmeno mandarle indietro! 😁

Consiglio 10 [UPDATE 26/12/2019]: Date un’occhiata al flash mode, impostate quest’ultimo su DOUT (suggerito da Giovanni) :

[UPDATE 24/04/2019] Sto caricando sulla scheda di I/O… 😱😱😱😱😱 …… Ti fa questo errore ? E’ un errore prettamente legato all’Ide di Arduino e sostanzialmente ti scrive questo poiché ancora non ha terminato correttamente la connessione con la scheda, magari hai appena staccato e riattaccato il cavo usb e non hai aspettato il tempo necessario. Fai click di nuovo su carica e andrà tutto per il verso giusto! 😀

Allora, il led lampeggia ? Possiamo andare avanti, facciamo strada.

CAPITOLO 6 | Colleghiamo ESP01 alla nostra rete Wi-Fi!

La libreria ESP8266WiFi.h è una libreria che si installerà al momento dell’aggiunta del supporto per le schede ESP8266 e che quindi non dovrete cercare da nessuna parte su internet, è già li installata sul vostro computer, se siete stati bravi a seguire tutti i capitolo precedenti di questa guida.

Per aggiungere la libreria in questione basta inserire a inizio codice :

#include <ESP8266WiFi.h>

subito dopo possiamo creare due costanti che potremmo chiamare wifi_id e wifi_pswd, queste due costanti conterranno il nome e la password della connessione Wi-Fi, al quale vogliamo connetterci :

const char* wifi_id   = "TP-LINK_BDE0";
const char* wifi_pswd = "65402078";

Nel Setup() andiamo a impostare il nostro ESP01 in modalità Station o più semplicemente Client :

WiFi.mode(WIFI_STA);

e poi avviamo il collegamento con

WiFi.begin(wifi_id, wifi_pswd);

Questa ultima riga prenderà le due costanti create precedentemente che conterranno sia il nome che la password della nostra rete Wi-Fi e le utilizzerà per connettersi a Internet.

Fatto questo avremo una cosa del genere :

Ovviamente noi abbiamo inserito i dati della nostra connessione Wi-Fi, voi inserite i vostri, altrimenti non si connetterà! 😜

Tuttavia, noi inseriremo qualche altra righetta di codice, anche se già cosi dovrebbe funzionare, a noi piacerebbe conoscere l’ip del nostro ESP01 e capire se effettivamente è connesso realmente!

Quindi continuiamo a inserire nel Setup() questo ciclo :

while (WiFi.status() != WL_CONNECTED) {
delay(500);
}

Permetterà di mettere in pausa il programma affinchè la scheda non sarà realmente connesso alla rete Wi-Fi scelta.

e poi andiamo a scrivere sulla seriale, sempre restando sul Setup(), sia un messaggio che ci dice che il nostro ESP01 è connesso e cosa molto interessante, con quale IP è connesso :

Serial.begin(115200);
Serial.println("ESP01 Connesso!");
Serial.println(WiFi.localIP());

E questo è tutto :

Possiamo caricare il codice sul nostro ESP01, seguendo i precedenti capitolo e vediamo se tutto funziona.

Aprite il Monitor Seriale dal menu Strumenti e dovrebbe comparire il messaggio di questo tipo :

Il nostro piccoletto è connesso alla nostra rete a quanto pare! 😍

CAPITOLO 7 | Creare un Access Point!

La libreria ESP8266WiFi.h permette anche di creare un Access Point e cioè un dispositivo al quale è possibile collegarsi tramite Wi-Fi con un cellulare o un computer.

Questa soluzione aiuta a creare delle applicazioni dove magari non esiste un router o in generale non esiste una rete Wi-Fi al quale connettersi e rende possibile comunque, gestire a distanza il proprio progetto usando la rete Wi-Fi che lo stesso ESP01 eroga.

Iniziamo a scrivere il codice includendo la nostra libreria :

#include <ESP8266WiFi.h>

Creiamo le due costanti che conterranno il nome e la password del nostro Access Point :

const char* ap_id   = "esp_ap";
const char* ap_pswd = "esp123456";

Nel Setup() scriviamo questo per avviare l’Access Point :

WiFi.softAP(ap_id, ap_pswd);

Successivamente abbiamo bisogno di sapere l’IP del nostro ESP01 e quindi creiamo una variabile che conterrà il nostro IP :

IPAddress ap_ip = WiFi.softAPIP();

e successivamente lo scriviamo nel seriale :

delay(3000); //(opzionale)ci da 3 secondi di tempo per aprire il Monitor Seriale alla fine del caricamento.
Serial.begin(115200);
Serial.println(ap_ip);

Avremo a questo punto un qualcosa del genere :

Possiamo quindi provare a collegare il nostro cellulare per testare il corretto funzionamento del nostro nuovo Access Point!

Di norma l’ESP01 ha come indirizzo IP 192.168.4.1 che permette di accedere ad una pagina web tramite il browser (es. Google Chrome). Ovviamente la pagina risulterà bianca poiché nel nostro sketch non abbiamo ancora scritto codice per personalizzarla!

CAPITOLO 8 | Creare un Web Server!

Come accennato precedentemente è possibile creare una pagina Web che può essere personalizzata, come fosse un sito internet salvato all’interno del nostro ESP01. Questa caratteristica ci permette di creare un’interfaccia accessibile dal browser web e comandare vari accessori a distanza!

La pagina in questione può essere ottenuta sia in modalità Client che in modalità AP, permettendoci di creare un vero e proprio server web!

Includiamo le librerie che ci serviranno per creare il nostro server 😍 :

#include <WiFiClient.h>
#include <ESP8266WebServer.h>

Iniziamo a capire come sfruttare la libreria ESP8266WebServer.h per creare due pulsanti capaci di comandare un relè. Restando in modalità AP e avendo creato il programma seguendo il CAPITOLO 7 di questa guida, subito dopo le costanti, andiamo ad aprire un server HTTP su porta 80, in modo tale che ESP01 sia accessibile da un altro dispositivo tramite IP. Quindi :

ESP8266WebServer server(80);

Nel Setup() andiamo a creare 3 pagine virtuali, una accessibile da “129.168.4.1/” per la home (pagina con i pulsanti) e le ultime due “192.168.4.1/on” e “192.168.4.1/off” per accendere e spegnere il pin GPIO0 :

pinMode(0,OUTPUT); //imposto il pin GPIO0 come uscita
server.on("/", home);
server.on("/on", onpin);
server.on("/off", offpin);
server.begin(); //avvia il server

La prima riga crea la pagina home, che fa riferimento a una funzione che andremo a creare tra poco e che appunto richiamerà la pagina iniziale. Le due righe successive servono per creare due pagine secondarie che ci tengono informati sullo stato del pin e se fate caso oltre a dichiarare le pagine virtuali “/on” e “/off”, abbiamo anche inserito onpin e offpin, quest’ultime sono funzioni che andremo a creare subito dopo il Setup(). Scriviamole :

void onpin() {
digitalWrite(0,HIGH);
server.send(200, "text/html", "<a href="/">Indietro</a> Hai acceso il pin!");
}
void offpin() {
digitalWrite(0,LOW);
server.send(200, "text/html", "<a href="/">Indietro</a> Hai spento il pin!");
}

Le funzioni digitalWrite sono semplici da comprendere e servono sostanzialmente per abilitare e disabilitare il pin, mentre la funzione server.send permette di creare una pagina internet in formato “text/html” che ci mostra, in questo caso, la frase Hai acceso il pin! o Hai spento il pin!

IMPORTANTE : La reattività di risposta delle pagine e delle operazioni da intraprendere sono legate alla potenza di calcolo del processore, noi consigliamo sempre di lasciare un po di tempo da un invio di un comando e l’altro, poiché evita di sovraccaricare ESP01 e che questo vada ad accendere il relè dopo 1 minuto dalla ricezione del comando 🤣🤣🤣

Creiamo la funzione home() che conterrà la nostra pagina iniziale con i pulsanti on e off :

void home() {
server.send(200, "text/html", "<a href='/on'>Accendi</a> <a href='/off'>Spegni</a>");
}

Nel loop() inseriamo questa riga di codice che servirà per gestire le richieste provenienti dai dispositivi collegati :

server.handleClient();

Se avete seguito bene la guida dovreste avere il codice scritto in questo modo :

Se accediamo al nostro ESP01 dal browser scrivendo l’indirizzo 192.168.4.1, ovviamente una volta che ci siamo collegati alla sua rete Wi-Fi, che da progetto è esp_ap, ci verrà mostrata una pagina del genere :

E premendo Accendi o Spegni, il nostro relè dovrebbe armarsi o disarmarsi.

Noi per questo capitolo abbiamo usato questo relè adatto sia per ESP01 che per ESP01s, altre schede potrebbero usare il pin GPIO2 e quindi il programma dovrà essere modificato di conseguenza.

CAPITOLO 9 | Convertitori logici

Abbiamo visto che grazie al collegamento A1 fatto con Arduino è possibile programmare il nostro ESP01 e di conseguenza abbiamo la possibilità di creare i nostri programmi che sfruttano la connessione Wi-Fi!

Oltre alla possibilità di collegare ESP01 ad Arduino, esistono in commercio dei convertitori logici che trasformano ESP01 in una specie di pennetta USB abbinato ad un convertire seriale che permette di programmare ESP01 collegandolo direttamente ad una porta USB del nostro computer, senza usare cavetti dupont.

Ma non è tutto oro quello che luccica, giusto ? 🤣🤣🤣

Tutto bello e sembra essere facilissimo da collegare, ma necessita di una modifica per collegare (manualmente) il pin GPIO0 al GND per la flash mode, ma a noi non ha mai funzionato! Ebbene, provato su vari computer, installato i vari driver sia FDI che CH340x, ma niente… dovremmo provarne altri tipi per offrirvi una documentazione completa e non mancheremo nel farlo, anche se noi preferiamo il collegamento con Arduino o magari con un adattatore TTL. Aspettatevi aggiornamenti.

Update adattatori [UPDATE 04/11/2019]

Dopo diversi mesi di prova ci troviamo di nuovo qui a parlarvi di adattatori logici e di conseguenza fare un bel aggiornamento a questa guida, la quale, con nostro grandissimo piacere, ci ha riempito di feedback positivi! Dopo vari tentativi e acquisti fatti qua e la, abbiamo selezionato due adattatori perfetti per il nostro ESP-01 che non ci hanno deluso per niente!

A sinistra abbiamo un adattatore seriale con un chip FT232RL e a destra un adattatore seriale con chip CH340G, entrambi sono ottimi adattatori ma che vanno approfonditi prima di essere usati!

a. Adattatore con Chip FT232RL

L’adattatore in questione permette di essere inserito su una breadboard in posizione orizzontale a patto che a quest’ultimo vengano saldati i piedini nei fori preposti. Può essere usato con quasi tutte le schede programmabili per via della possibilità di passare da un’alimentazione 3.3V a 5V con un comodo ponticello incluso con la scheda (per il nostro ESP-01 ricordatevi di portare il ponticello su 3.3v)! Un difetto, se cosi vogliamo chiamarlo, è la presenza di una porta Mini USB, tipologia di attacco non più diffusa come un tempo. In sostanza un buon adattatore che dialoga bene con il nostro ESP-01 e non ha mai perso un colpo da quando lo stiamo utilizzando.

Funziona con i driver FTDI inclusi con l’ide di Arduino.

Qui sotto trovate lo schema di collegamento 😀 :

Ricordatevi sempre che il pin GPIO0 va collegato al GND solo in fase di programmazione e di lasciare il pin CH-PD (EN) collegato sempre ai 3.3V, se dovete caricare un programma su ESP-01 la prassi è questa :

  1. Collegare tutti i pin come mostrato nello schema.
  2. Caricare il programma sulla scheda.
  3. Scollegare il pin GPIO0 da GND.
  4. Staccare VCC per resettare ESP-01 e riattaccare VCC.

Potete acquistare l’adattatore qui : https://amzn.to/2NEbIiF (pacco da 3).

b. Adattatore con Chip CH340G

in allestimento…

CAPITOLO 10 | Alimentare la scheda

Una volta creato il nostro programma, volendo inserire il nostro ESP01 nel progetto finale, la prima domanda che ci poniamo è come facciamo ad alimentare la schedina, visto che richiede 3.3V ? Ebbene in commercio esistono varie soluzioni e noi ne abbiamo testate due delle quali ci siamo letteralmente innamorati! 😍

Se non abbiamo necessità di collegare nulla al nostro ESP01 possiamo avvalerci di un adattatore di tensione alimentabile a 5V, i quali sono più semplici da reperire, magari usando un caricabatterie per i cellulari. La seconda soluzione è un adattatore di tensione che può supportare fino ai 24V in ingresso con un comodo connettore DC e divide, usando dei comodi pin, la tensione in 3 tensioni differenti.

La prima tensione è equivalente alla tensione di ingresso nuda e cruda cosi come proviene dalla sorgente di alimentazione, mentre le altre due tensioni sono a 5V e a 3.3V, quest’ultima sarà utile per ESP01 e per vari altri componenti!

CAPITOLO 11 | Espandiamo le possibilità con I2C!

Quando abbiamo conosciuto per la prima volta l’ESP01, la prima cosa che ci è venuta in mente è stata….

Non ha la porta usb, ha solo due pin… ma a che cosa serve? 😟

Tuttavia, conoscendo il piccoletto, oltre ad essere utile per piccole applicazioni, magari creando una serie di lampadine che si accendono tutte insieme con un pulsante sul cellulare o sfruttando la shield per NeoPixel possiamo creare addirittura una lampada RGB, abbiamo scoperto che è possibile creare grazie alla libreria Wire.h una connessione di tipo I2C!

L’I2C, come detto in precedenza, è un protocollo di comunicazione via BUS che permette la connessione in parallelo di diversi dispositivi che sfruttano solo 2 cavi per funzionare!

Per usare la libreria, contenuta di dafault sull’ide di Arduino, possiamo includerla in questo modo :

#include <Wire.h>

e nel setup() possiamo inizializzare la nostra connessione I2C con :

Wire.begin(2,0);

GPIO2 sarà SDA e GPIO0 diventerà il pin SCL.

A questo punto sarà necessario includere le varie librerie e scrivere il codice attinente ai dispositivi che vogliamo collegare all’ESP01.

Noi abbiamo collegato un Display(SSD1306), un MPU-5060(accelerometro, giroscopio e termometro) e un BME280(barometro) e con nostra grande soddisfazione, come notate nella foto, tutto funziona contemporaneamente su una schedina cosi piccola!!! 😍

CAPITOLO 12 | Controllare i pin di Arduino con ESP01!

Abbiamo detto in precedenza che ESP01 non è un modulo Wi-Fi per Arduino e tanto meno non può essere considerato una shield per aggiungere la connettività senza fili a quest’ultimo! ESP01 come specificato già nei capitoli precendenti, è un microcontrollore e che quindi va programmato come Arduino ma non avendo un connettore USB, necessita un convertitore Seriale per programmarlo.

In questo capitolo ci servirà il collegamento A2 che trovate nel Capitolo 2 di questo manuale e che consente all’ESP01 di scrivere via seriale su due PIN differenti da RX e TX di Arduino sfruttando la libreria SoftwareSerial.

Iniziamo nel programmare il nostro ESP01 in modo tale da dedicarci successivamente alla programmazione da fare su Arduino e andiamo a collegare le nostre schede seguendo il collegamento A1.

Se volessimo creare dei pulsanti in grado di comandare i PIN da 2 a 13, la prima cosa da fare è seguire il Capitolo 8 di questo manuale per capire le meccaniche del codice che andremo a scrivere ora e che ci permettono di creare un WebServer, con una pulsantiera virtuale, avente ogni tasto legato a un pin di Arduino :

 #include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

ESP8266WebServer server(80);

String msg = " Comando inviato al pin ";
String javascript_redirect = "<script type="text/javascript">setTimeout(\"location.href = '/';\", 1500);</script>";

Le librerie incluse le conosciamo già e servono sostanzialmente per utilizzare tutte le funzioni del WiFi del nostro ESP01 e ci permettono anche di creare un WebServer. Per quanto riguarda le variabili stringa msg e javascript_redirect sono rispettivamente un messaggio che può essere modificato e che verrà riproposto ad ogni invio di comando, mentre la seconda variabile contiene un javascript che permette di ritornare alla pulsantiera virtuale dopo un determinato lasso di tempo, in questo caso 1500 millisecondi (1 secondo e mezzo dalla visualizzazione del messaggio di conferma).

String javascript_redirect = “<script type=”text/javascript”>setTimeout(\”location.href = ‘/’;\”, 1500);</script>”;

E’ inutile specificare che il valore può essere modificato e variato in base alle nostre esigenze 😍

Successivamente, nel void setup() apriamo la seriale e creiamo le varie pagine virtuali, una per ogni pin che andremo a comandare su Arduino :

Serial.begin(9600);

server.on("/", keyboard);

server.on("/2", pin2);
server.on("/3", pin3);
server.on("/4", pin4);
server.on("/5", pin5);
server.on("/6", pin6);
server.on("/7", pin7);
server.on("/8", pin8);
server.on("/9", pin9);
server.on("/12", pin12);
server.on("/13", pin13);

server.begin();

Se avete seguito per benino la guida… 😁 lo avete fatto vero ? … saprete che ogni riga creerà una pagina virtuale raggiungibile dall’IP che acquisirà ESP01 al momento della connessione e che richiamerà una funzione ben specifica, ogni pagina richiama una funzione e tutte le funzioni le andremo a creare subito dopo il Setup() :

 void pin2() {
Serial.println("2");
server.send(200, "text/html", javascript_redirect + msg + " 2");
}
void pin3() {
Serial.println("3");
server.send(200, "text/html", javascript_redirect + msg + " 3");
}
void pin4() {
Serial.println("4");
server.send(200, "text/html", javascript_redirect + msg + " 4");
}
void pin5() {
Serial.println("5");
server.send(200, "text/html", javascript_redirect + msg + " 5");
}
void pin6() {
Serial.println("6");
server.send(200, "text/html", javascript_redirect + msg + " 6");
}
void pin7() {
Serial.println("7");
server.send(200, "text/html", javascript_redirect + msg + " 7");
}
void pin8() {
Serial.println("8");
server.send(200, "text/html", javascript_redirect + msg + " 8");
}
void pin9() {
Serial.println("9");
server.send(200, "text/html", javascript_redirect + msg + " 9");
}
void pin12() {
Serial.println("12");
server.send(200, "text/html", javascript_redirect + msg + " 12");
}
void pin13() {
Serial.println("13");
server.send(200, "text/html", javascript_redirect + msg + " 13");
}
void keyboard() {
server.send(200, "text/html", "<a href='/2'>Pin2</a> <a href='/3'>Pin 3</a> <a href='/4'>Pin 4</a> <a href='/5'>Pin 5</a> <a href='/6'>Pin 6</a> <a href='/7'>Pin 7</a> <a href='/8'>Pin 8</a> <a href='/9'>Pin 9</a> <a href='/12'>Pin 12</a> <a href='/13'>Pin 13</a>");
}

I pin 10 e 11 sono stati esclusi nel codice poiché verranno usati successivamente per la connessione seriale tra le due schede!

A questo punto nel loop(), come abbiamo visto nei capitoli precedenti non ci resta che scrivere il codice che ci permetterà di smistare le richieste dai vari client (dispositivi) collegati alla pagina della nostra pulsantiera virtuale :

server.handleClient();

Nel nostro Ide dovremmo avere qualcosa del genere :

Adesso dobbiamo dare la possibilità al nostro ESP01 di collegarsi alla nostra rete WiFi e per fare ciò servirà approfondire l’argomento con il Capitolo 6.

Prima del setup() creiamo due costanti che conterranno il nome e la password della nostra rete WiFi :

const char* wifi_id   = "TP-Link_EFF8_2EX";
const char* wifi_pswd = "52197390";

Ovviamente i dati inseriti sono solo di esempio!

Nel setup(), alla fine di tutto il codice prepariamo la connessione al nostro WiFi :

WiFi.mode(WIFI_STA); 
WiFi.begin(wifi_id, wifi_pswd);

Successivamente, scriviamo dopo 3 secondi, giusto per darci il tempo di aprire il Monitor Seriale dopo il caricamento, l’indirizzo ip che il nostro ESP01 acquisisce subito dopo essersi collegato :

while (WiFi.status() != WL_CONNECTED) {
delay(500);
}

delay(3000);
Serial.println(WiFi.localIP());

Se avete scritto tutto per benino, dovreste avere il setup() cosi :

Perfetto, colleghiamo il nostro Arduino al computer tramite il cavo USB e accertiamoci che il collegamento sia corretto, ricordandovi che dovrete collegare il tutto seguendo lo schema A1 mostrato nel Capitolo 2. Caricate il codice sul vostro ESP01 e una volta che viene mostrata la conferma di caricamento completato, aprite il monitor seriale e aspettate qualche secondo :

Bene, nel nostro caso il router ha dato a ESP01 l’indirizzo IP 192.168.1.117.

Adesso manteniamo aperto il Monitor Seriale e apriamo dal nostro browser web, che sia da pc o cellulare, la pagina che abbiamo creato con la pulsantiera virtuale sul nostro ESP01 scrivendo http://indirizzo_ip_assegnato :

Bene, se tutto è regolare vedremo questa pagina bruttissima con i vari link ai vari pin, si è bruttissima ma non è una soddisfazione vederla? L’abbiamo creata noi! 😍

Clicchiamo i vari link e testiamo il corretto funzionamento, la pagina dovrebbe cambiare dandoci la conferma che il comando è stato inviato al pin scelto e successivamente, dopo qualche istante, dovrebbe tornare alla pagina dei pulsanti.

Funziona ? Bene, controlliamo se sul Monitor Seriale viene scritto ad ogni pressione del link il numero relativo al pin comandato :

Ebbene, se ci scrive quello che vogliamo noi, vuol dire che tutto funziona correttamente e possiamo passare a programmare il nostro Arduino! ❤️

Adesso collegate ESP01 e Arduino seguendo lo schema A2 che trovate sempre nel Capitolo 2 e creiamo il nostro programma che dovrà recepire i comandi inviati via seriale da ESP01 e dovrà controllare le uscite in base allo stato attuale di ogni singolo pin. Iniziamo a includere la libreria SoftwareSerial.h (è già installata sul vostro computer) :

#include <SoftwareSerial.h>

E poi configuriamo una nuova linea di connessione seriale utilizzando i pin 10 e 11 :

SoftwareSerial serial_from_esp01(11, 10);

Il pin 11 diventerà RX e il pin 10 sarà il pin TX.

Nel setup() apriamo una nuova connessione seriale Fisica con un baudrate differente dal classico 9600 :

Serial.begin(57600);

while (!Serial) {
; //attendi finché la seriale non sia inizializzata in modo corretto
}

Successivamente apriamo la seriale via software che riceverà i comandi da ESP01 :

serial_from_esp01.begin(9600);

In fine con un metodo che consideriamo molto elegante andiamo a impostare tutti i pin di Arduino UNO come uscita e spegnendoli all’accensione escludiamo automaticamente i pin 0, 1, 10 e 11 con un ciclo for :

for(int pin = 0;pin < 14; pin ++) { //per escludere altri aggiungere "or pin == pin_desiderato"
if(pin == 0 or pin == 1 or pin == 10 or pin == 11) {
//pin esclusi
} else {
pinMode(pin,OUTPUT);
digitalWrite(pin,LOW);
}
}

Andiamo nel loop() e scriviamo una serie di if (costrutti decisionali) che controlleranno quale pin andare a comandare in base ai link che premeremo sulla pulsantiera :

if (serial_from_esp01.available()) {

int cmd_from_esp01 = serial_from_esp01.read();

if(cmd_from_esp01 == 500) { //500 è un valore non considerato valido e quindi escluso
//non fare nulla
} else {
if(digitalRead(cmd_from_esp01) == HIGH) {
digitalWrite(cmd_from_esp01,LOW); //se acceso, spegne
} else if(digitalRead(cmd_from_esp01) == LOW) {
digitalWrite(cmd_from_esp01,HIGH); //se spento, accende
}
cmd_from_esp01 == 500; //valore non valido impostato per evitare che venga rifatta la lettura
}
}

A questo punto controlliamo se tutto il codice è scritto per benino, proprio come potete osservare nelle immagini seguenti :

Hai fatto tutto bene ? Ricordati che questa volta devi caricare il codice su Arduino e che quindi devi selezionare dal menu Strumenti la scheda Arduino/Genuino Uno e una volta fatto tutto questo puoi caricare il codice!

Ora non ci resta altro che provare se Arduino recepisce i comandi dalla nostra pagina web, per comodità per adesso testiamo solo il led 13 visto che è possibile osservarne il comportamento direttamente dalla scheda Arduino tramite il led L. Facciamo click sul link Pin 13 e possiamo notare con nostra grandissima soddisfazione che il led su Arduino si accenderà! Successivamente se facciamo click di nuovo sul link Pin 13 il led si spegnerà poichè il nostro programma controllerà lo stato del pin, lo troverà in HIGH e di conseguenza lo imposterà sul LOW.

Questo metodo resta la soluzione più rapida e economica per controllare Arduino a distanza ma come detto in precedenza non consigliamo l’accoppiata Arduino+ESP01 poichè è molto articolata, richiede una doppia programmazione e purtroppo un po limitata per un controllo completo dei pin di Arduino, ricordando magari che per i pin PWM non sarà possibile effettuare una scrittura analogica sul pin, se non lavorando molto sulla programmazione.

Per soluzioni più semplici vi consigliamo, come già fatto in precedenza di usare magari questa scheda che ha a disposizione più pin e con applicazioni semplicissime, come potrebbe essere anche Blynk, ci da la possibilità di fare molte più cose in minor tempo e senza scrivere una riga di codice!

CAPITOLO 13 | Sfruttare tutta la memoria flash di ESP01 per i modelli da 1Mb

Abbiamo detto in precedenza che ESP01 è venduto in due versioni, una da 500Kb di memoria e una da 1Mb. Installando il supporto per le schede con processore ESP8266 su Arduino, impostato di default per la scheda Generic ESP8266 Module, troviamo il Flash Size a 512K e potremmo incorrere in errori dove l’Ide ci indica che il programma scritto è troppo grande e che quindi non può essere caricato su ESP01.

Possiamo scegliere in modo semplice dal menu Strumenti un Flash Size maggiore, ovviamente pari alla memoria massima reale e disponibile su ESP01, cioè 1M (no SPIFFS) ove la scheda sia realmente la versione a 1Mb :

Guardate la differenza dello spazio occupato prima di aver impostato la memoria massima a disposizione, prendendo in considerazione il codice scritto nel capitolo precedente (55% di memoria occupata) :

E una volta applicata la correzione (27% di memoria occupata) :

Buono, vero ? 😍 Questo ci permetterà di creare programmi più articolati, senza preoccuparci troppo di minimizzare il codice e di conseguenza sacrificarne le funzionalità!

Ovviamente questa modifica non amplia la RAM che resterà sempre la stessa, per migliorare le prestazioni della RAM starà a noi utilizzare le variabili in modo corretto per evitare che queste vadano a incidere sensibilmente sulle prestazioni della schedina 😁😁😁

CAPITOLO 14 | Controllare ESP01 da fuori casa : Informazioni utili, delucidazioni e consigli!

Ti avvertiamo, questo sarà un argomento discorsivo e basta!

Abbiamo fatto una lunga strada insieme, per ora questo sarà l’ultimo capitolo di questo manuale ma non per sempre! Siamo arrivati al dunque e qui risponderemo a una domanda che molti di voi si chiedono e speriamo di darti alcune informazioni in merito per chiarire il tutto.

La domanda che attanaglia tanti di quelli che armeggiano con l’IOT fai da te è sempre la stessa…

Come faccio a controllare Arduino da fuori casa, magari mentre sono in vacanza ? 😍

Purtroppo non possiamo darti la soluzione definitiva poichè ci sono varie soluzioni, dalle più difficili alle più facili e tutto questo cambia in base al provider internet con il quale abbiamo sottoscritto il contratto, ma cercheremo di chiarirti tutti i dubbi in merito.

Partiamo dal presupposto che per accedere a un dispositivo collegato nella tua rete domestica dall’esterno, hai bisogno di qualcosa che ti permetta di far uscire questo dispositivo al di fuori della tua rete e che quest’ultimo diventi “pubblico”.

La soluzione più ovvia e quella che fino a un po di anni fa era l’unica soluzione, è quella di usufruire di un ip pubblico e aprire le porte del modem. Tutte le connessioni internet domestiche hanno un ip pubblico, anche la tua ne ha uno e lo puoi identificare usando questo sito https://whatismyipaddress.com/ . Il tuo ip pubblico è univoco e ti identifica sulla rete globale, permettendoti l’accesso al mondo di internet. Questo ip viene conferito alla tua connessione internet o più semplicemente al tuo modem in modo dinamico ogni volta che quest’ultimo effettua la connessione al web dopo la sua accensione e qui nasce la prima problematica :

Se è vero che la tua connessione ha un ip pubblico che puoi usare per accedere al tuo ESP01 dal di fuori della stessa, è anche vero che questo, ogni volta che va via la corrente, cambia e sei costretto a conoscere il nuovo ip da un cellulare o un pc connesso alla tua rete domestica ma se non sei a casa questo non puoi farlo a meno che non usi software di tele-assistenza! Per bypassare questo problema possiamo avvalerci dei server DNS, alcuni di questi sono a pagamento e altri sono gratuiti ma i problemi arrivano quando magari abbiamo modem proprietari di Fastweb, Vodafone, Tim ecc ecc che per nostra esperienza non permettono di settare DNS personalizzati.

Puoi anche richiedere un ip pubblico statico al tuo provider ma sappi che questo servizio è quasi sempre a pagamento.

Mettiamo il caso che tu abbia un modem “Custom” o un modem proprietario del provider che però permetta tali configurazioni, potrai in questo caso aggiungere al tuo modem le credenziali registrate precedentemente in uno dei servizi disponibili in rete e questo provvederà a inviare il nuovo ip pubblico al server DNS al posto tuo ogni volta che quest’ultimo cambierà e tu potrai accedere all’ip privato del tuo ESP01 opportunamente configurato con l’apertura delle porte da un indirizzo simile :

http://impiantodomoticodipippo.serverdnscaio.net

Non possiamo fornirti l’indicazione di configurazione per il tuo modem, visto che ogni modem ha una procedura diversa ma possiamo indicarti in linea di massima che la configurazione per le porte è quasi sempre sotto una sezione del pannello di controllo del tuo modem chiamata “Port Forwarding” o qualcosa del genere 😀

Puoi accedere nel pannello di controllo del modem da un’indirizzo ip che di solito è 192.168.0.1, 192.168.1.1 o simili (di solito le indicazioni per amministrare il modem sono indicate sotto il modem stesso o nel libretto di istruzioni) e uno dei servizi gratuiti per DNS maggiormente consigliati è DynDNS https://dyndns.it/ .

IMPORTANTE : A meno che non lavoriamo bene per creare un pannello di accesso con una password e sopratutto se non siamo degli esperti in sicurezza, tutto questo è sconsigliato, poiché qualsiasi malintenzionato potrebbe accedere al nostro pannello di controllo e controllare la nostra abitazione!

Per ovviare al problema sicurezza esistono su internet delle applicazioni che ci aiutano a realizzare dei controlli in modo semplice, rapido e ovviamente con un occhio maggiore alla sicurezza! Una di queste applicazioni può essere Blynk o se usiamo le nuove schede Arduino, come per esempio la MKR WiFi 1010, esiste anche la piattaforma Arduino IOT Cloud!

Queste applicazioni funzionano in modo simile ad un server DNS ma ci danno la possibilità di creare controlli ad hoc nei nostri progetti e di inviare i comandi tramite dei server dedicati, che faranno anche il lavoro di interfacciamento con quello che potrebbe essere un ESP01, un Arduino o qualsiasi altra scheda programmabile. Grazie a un codice generato in automatico dal sistema, che dovrà essere caricato sulla scheda di destinazione, questi servizi permettono una connessione dedicata tra la scheda e i server e infine permettono di creare i controlli che ci servono senza nemmeno scrivere una riga di codice! Questo risulta molto più sicuro che utilizzare la nostra rete con un nostro “server” che in questo caso sarà sostituito dalla stessa scheda, poichè dietro questi servizi, che tra l’altro sono gratuiti, ci sono figure professionali che ne sapranno qualcosa in più di noi per quanto riguarda la sicurezza 😜

Senza contare che usare servizi come Blynk, Arduino IOT Cloud, IFTTT, Adafruit IO ecc ecc permettono di limitare il sovraccaricamento delle richieste sulla nostra scheda e sopratutto sulla nostra connessione a internet, poichè quest’ultima non sarà mai performante come quella dei serve dedicati a tale scopo!

Per approfondire l’argomento del controllo a distanza puoi vedere questa documentazione.

CAPITOLO 15 | Video correlati

APPROFONDIMENTI

Documentazione sull’uso degli assistenti vocali (Google HOME e Alexa) con ESP01 qui.

Documentazione sull’uso dei led NeoPixel con ESP01 qui.

CONCLUSIONI (MA NON DEFINITIVE)

ESP01 è una scheda piccola e performante, adatta per piccoli progetti e grazie alla connettività WiFi offre la possibilità di creare applicazioni connesse ove la disponibilità di spazio scarseggia. Tuttavia, le piccole dimensioni portano ESP01 a nn avere molti pin e sopratutto a necessitare di apparati esterni che fungono da convertitori seriali/usb poichè a bordo della board non è presente alcuna porta usb, quest’ultima caratteristica porta ESP01 a non essere una scheda adatta ai neofiti poichè molto articolata da interfacciare con un pc per essere successivamente programmata!

IN SINTESI

Valutazione della redazioneCPU e RAMConnettivitàAdatto ai neofitiModuli espansioneI2CNumero I/0
★★★★☆
Dispositivo molto interessante
ESP8266Si, Wi-FiNo, ci sono soluzioni più semplici in termine di utilizzoSiSi2

Condividi questo articolo :

Redazione Filo Connesso

Redazione Filo Connesso

Siamo un gruppo di ragazzi appassionati di Informatica, elettronica e robotica. Abbiamo creato Filo Connesso per offrire materiale educativo e informativo dedicato ai nostri settori di interesse.

Potrebbero interessarti anche...

59 risposte

  1. Francesco ha detto:

    Bravissimi!!! Manuale MOLTO ben fatto. Il migloore che ho fin quì trovato scandagliando siti utaliani e stranieri.

  2. Fabio ha detto:

    Ciao ottima guida, ma ho un problema: ho eseguito tutti gli step capito 2 collegamento A; poi capitolo 3 e, in sequenza, capitolo 5 e 6 sempre lasciando i collegamenti di 2.A…. non ho messaggi di errore…. ma sul monitor seriale non mi appare nulla 🙁 🙁 🙁 sapete aiutarmi e dirmi perchè? Grazie

  3. Andrea ha detto:

    Articolo molto interessante.
    Mancava una panoramica/tutorial su questo splendido ed economico “controllore”.
    Ne approfitto per chiedere una info: A casa generalmente uso l’ ESP8266-01(il quale funziona alla perfezione), ma ho anche un paio di ESP8266-01S i quali non riesco in alcun modo a far andare (li programmo con l’IDE di Arduino con lo stesso sketch degli ESP8266-01 ma non funzionano).
    Qualcuno sa darmi qualche info?

    • Ciao! abbiamo avuto anche noi qualche problema ogni tanto con questi moduli, alcuni hanno il pin del led builtin differente l’uno dall’altro, altri quando carichi il codice, si carica ma non fa nulla. Insomma, un consiglio che possiamo darti è provare a farteli cambiare o a prenderli da un altro venditore, ogni produttore li produce in modo diverso e alcuni sono difettosi di fabbrica purtroppo! Grazie e tienici aggiornati!

  4. Maurizio ha detto:

    Ciao,
    ottima guida grazie. Uno spunto futuro potrebbe essere una guida per far comunicare due o più ESP8266 tra di loro. Cioè usare un ESP come input di qualcosa, che trasmette ad un altro ESP collegato ad Arduino che fa azioni di output Tutti collegati alla medesima wifi). In pratica un sensore+ESP al posto dello smartphone per generare gli input. Io ci sto provando. Ciao, Maurizio

  5. GiovanniT ha detto:

    PS: per evitare problemi di caricamento il FLASH MODE DEVE ESSERE IMPOSTATO SEMPRE su “DOUT”.

    Solo con questo settaggio viene scritto correttamente il codice sul microprocessore utilizzando ARDUINO come interfaccia.

    Un caro saluto,
    Giovanni

  6. Stanislao ha detto:

    Molto completo…Lode e a presto

  7. Stanislao ha detto:

    Nel capitolo 2 i collegamenti Rx e TX tra i due componenti non vanno incrociati…?

    • Ciao!! No, se tu noti Arduino ha il reset su GND e questo vuol dire che il processore dello stesso è disabilitato, facendo diventare Arduino un adattatore seriale e di conseguenza tx e rx devono coincidere con il seriale della scheda 🙂 Saluti e buon feste!

  8. franco ha detto:

    Vorrei commentare il CAPITOLO 9 | Convertitori logici che per voi è stata un’esperienza negativa, forse perché non avete usato l’accorgimento giuso !
    Basta sostituire ai 2 fili visibili dalle foro un piccolo pulsante che mantenuto premuto durante l’inserimento nella porta USB e quindi rilasciato, permette la programmazione dell’ ESP . Semplice no ?

    • Ciao! Logico, accorgimento che possiamo anche inserire nella guida! 😀 sta di fatto che quel tipo di convertitore a noi nn veniva proprio riconosciuto dal PC, altri convertitori con ch340 andavano bene! Grazie per il suggerimento, se troviamo un convertitore di quel tipo che funzioni, portiamo la documentazione per la modifica con il pulsante! 🙂 Un saluto!!!

  9. franco ha detto:

    questo è l’oggetto:
    https://www.amazon.it/Esp8266-seriale-sviluppo-Adattatore-velocit%C3%A0/dp/B07WFF359N
    ne ho 2 che utilizzo da anni senza aver mai avuto problemi! Vorrei aggiungere che in relazione al capitolo 4.1 per caricare il firmware utilizzo il piu semplice programmino “esp8266_flasher.exe” in cui indico la porta e il file bin da caricare e il gioco è fatto molto più velocemente. Ciao

    • Grazie, per quanto riguarda i convertitori ne abbiamo provati 3 (sistemi operativi e computer differenti) e non ha mai funzionato, sará stato un caso moooolto sfortunato il nostro. Per quanto riguarda il tool, non lo conoscevamo. Aggiorneremo a breve la guida, come sempre ci fa piacere ricevere consigli e suggerimenti da chi segue il nostro progetto! 🙂 grazie ancora!

  10. Nicolò Carandini ha detto:

    Articolo pieno di utili informazioni, semplicemente eccezionale!!!
    Sono stato mezzo pomeriggio a cercare di capire perché non mi rispondeva ai comandi AT. Siete gli unici che mi hanno svelato il mistero, ovvero che dopo il caricamento di uno sketch non funziona più!
    Unica cosa che aggiungerei, anche se è implicita nella connessione per controllare i pin della scheda Arduino, è un esempio di uso dell’ESP1 a servizio di una scheda Arduino, per la connettività WiFi.
    Supponendo di avere una scheda Arduino che riceve i dati da alcuni sensori (non collegabili direttamente all’ESP1 per svariati motivi) i dati potrebbero essere inviati dall’Arduino all’ESP1 per essere inviati tramite WiFi, in modalità client collegato a un router, a un server in Cloud per il data logging e successive elaborazioni e attività. Al momento lo sto facendo per una classica Weather Station.

    • Ciao! intanto grazie per l’interesse e siamo felici di aver risolto il tuo problema. Tuttavia l’accoppiata Arduino + ESP01 non la troviamo proprio comoda per fare la tua applicazione, però in quel caso basta mandare in via sequenziale i dati tramite seriale e immagazzinarli in un array presente sul ESP01, questa operazione è un po lentina e sopratutto prevede di programmare due schede che dialogano tra loro quando alla fine con un wemos d1 mini hai tutto in una scheda poco più grande di un ESP01 con anche una porta micro usb! In ogni caso un piccolo esempio lo inseriremo appena possibile, un saluto e buona sperimentazione!

  11. Massimiliano ha detto:

    Ciao, ottimo servizio.
    Ciao a tutti, non so se questo sia il topic giusto dove chiedere, ma ci provo lo stesso…
    Ho una scheda ESP8266-01, che ho acquistato in abbinamento ad un relè.
    Ho seguito il tutorial e penso di essere riuscito a programmare la scheda con successo utilizzando il metodo A1.
    Unico inconveniente è che il monitor seriale non mi da alcun cenno di vita (ho controllato il baudrate ed è quello giusto).
    Ho quindi riflashato la scheda utizzando il soft Esp8266_Flasher.exe ed il firmware v0.9.9.2AT.bin e collegandomi subito dopo con il monitor seriale di Arduino IDE, riesco ad inviare iregolarmente i comandi AT.
    Se, però, scollego la scheda e/o l’arduino non riesco più ad avviare l’ESP…se mi ricollego alla scheda sempre utilizzando il monitor seriale dell’IDE ed invio i comandi AT, con le stesse impostazioni di prima, la scheda ESP è come se fosse spenta.
    Se, invece, rifaccio le procedure per flashare il firmware e dopo non scollego la scheda ma mi collego subito con l’IDE allora tutto torna a funzionare bene.
    E’ come se subito dopo il flash del firmware la scheda fosse accesa mentre quando la scollego s spegne enon c’è più modo di interagire con essa se non riflashando il firmware.
    C’è un modo per “accendere” la scheda, una volta scollegata dall’arduino?
    Ciao e grazie

    • Ciao e grazie per l’interesse! Il pin CHP(EN) è collegato a 3.3v ? E’ importante che questo pin rimanga collegato ai 3.3v altrimenti la scheda va in sleepmode 🙂 Tienici aggiornati e buona sperimentazione!!!

    • Massimiliano ha detto:

      Ciao grazie per la velocissima risposta…si è collegato (i collegamenti sono gli stessi del tuo schema A1). Unica differenza è che quando il monitor seriale si riesce a collegare alla scheda, il baudrate è a 9600 e non a 115200 come suggerito (ma ho letto che il baudrate varia a seconda della scheda).
      Ciao e grazie ancora

    • Ciao di nulla! Il baudrate varia anche in base al baudrate impostato nel Serial.begin(), se il tuo codice ha il begin su 9600 per forza di cose la scheda scrive sul 9600. In ogni caso se stai usando esattamente il collegamento su A1 una volta staccato e riattaccato la scheda va di nuovo in download mode, è importante che tu tenga scollegato il gpio0 a questo punto, come mostrato nel collegamento A2. Il Gpio0 manda la scheda in download mode ogni volta che l’accendi 🙂 un saluto.

  12. Massimiliano ha detto:

    SEI UN GENIO….grazie mille ora funziona tutto una meraviglia, grazie ancora. Sei mitico

  13. Massimiliano ha detto:

    Torno a torturarti, stavo seguendo il tutorial e giunto al CAPITOLO 8 | Creare un Web Server!ho seguito pedissequamente i passaggi ma l’IDE mi restituisce questo errore:
    C:\Users\Utente\sketch_nov15a\WEB\WEB.ino: In function ‘void onpin()’:

    WEB:33:42: error: invalid operands of types ‘const char [9]’ and ‘const char [33]’ to binary ‘operator/’

    server.send(200, “text/html”, “Indietro Hai acceso il pin!”);

    ^

    C:\Users\Utente\sketch_nov15a\WEB\WEB.ino: In function ‘void offpin()’:

    WEB:40:43: error: invalid operands of types ‘const char [9]’ and ‘const char [33]’ to binary ‘operator/’

    server.send (200, “text/html”, “Indietro Hai acceso il pin!”);

    ^

    Più di una libreria trovata per “ESP8266WiFi.h”
    Usata: C:\Users\Utente\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.6.3\libraries\ESP8266WiFi
    Più di una libreria trovata per “ESP8266WebServer.h”
    Usata: C:\Users\Utente\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.6.3\libraries\ESP8266WebServer
    exit status 1
    invalid operands of types ‘const char [9]’ and ‘const char [33]’ to binary ‘operator/’

    evidenziandomi questa riga dello sketch:
    server.send (200, “text/html”, “Indietro Hai acceso il pin!”);

    Dov’è che sbaglio?
    Sempre grazie mille per la disponibilità

    • Ciao, scusa il ritardo ma hai apportato qualche modifica ? Ho testato il codice e pare che non mi da nessun problema! Scrivi a redazione@filoconnesso.it nel caso in cui tu abbia apportato delle modifiche, inviando il codice che usi in tal modo vediamo se riusciamo a combinare qualcosa! Grazie intanto e buon proseguimento!!

  14. Antonio ha detto:

    BILTIN 1,2,3 O 4 DOVE LO METTO?

    • Ciao e scusa per il ritardo, quelli sono i pin che puoi inserire nel codice per comandare il led sulla scheda, ne puoi usare uno alla volta per capire con un blink dove è collegato il led della tua scheda. Un saluto e buona sperimentazione!

  15. Totobilly ha detto:

    Siete come il cacio sui maccheroni. Ci voleva un blog in italiano. Per prima cosa volevo indicare al blog che a me su 2 PC WIN7/8 programmava l’ESP-01 ma poi non mi partiva lo scketh. Ho solo impostato (perché l’ho notato sul PC WIN10, dove funzionava tutto) sull’IDE di Arduino su Strumenti>Reset Method>”no dtr (aka ck)”, e funziona tutto alla perfezione. Ho inoltre notato che qualcuno ha problemi sull’interfaccia Arduino. Se acquistate questo “CH340 Usb a Seriale ESP8266 ESP-01 ESP-01S ESP01 ESP01S Senza Fili Wifi Developent Bordo Del Modulo per Arduino Programmer Adapter” ha anche l’interruttore per switchare tra Prog. e UART. Ottimo.

  16. Totobilly ha detto:

    Ho acquistato diversi moduli Relays a 2 e 4 ch. Purtroppo i moduli relays a 2 canali mi sono arrivati senza ESP-01. Siccome ne ho diversi di chippini ESP-01, come posso fare per scaricare lo sketch da ESP-01 montato sul relays a 4 ch. (Che funziona, mediante l’app “WIFI controller” per Android), per poi modificarlo per adattarlo ai moduli a 2 relays, e ricaricarlo sul modulo ESP-01 da inserire sui relays a 2 ch?. In poche parole … Come scaricare lo scketch da un modulo ESP-01? Grazie.

  17. Totobilly ha detto:

    Ed avere lo sketch per il comando dei 2 relays?

    • Buongiorno, non abbiamo esempi dedicati e specifici e non li produciamo per le altre persone perché ci toglie tempo e lo consideriamo lavoro non produttivo, in ogni caso questa guida ha tutte le informazioni necessarie per dare modo a chi inizia di produrre qualsiasi sketch di cui si ha bisogno, per lo meno c’è modo di capire e far funzionare due relè collegati al proprio esp01, visto che bastano due digitalwrite da azionare con due pulsanti (addirittura nella guida c’è un esempio per una tastiera virtuale completa di 13 tasti), restiamo a disposizione per delucidazioni rapide e se hai bisogno di una buona guida sulla programmazione,visto e considerato che mi pare di capire che usi da poco queste piattaforme, c’è una guida sulla programmazione base di Arduino, che poi alla fine è lo stesso linguaggio con cui si programmano gli esp01 :D. Restiamo a disposizione e fai buona sperimentazione!

  18. Paolo ha detto:

    Buongiorno,
    bella guida grazie. Sto combattendo con il capitolo 8 ovvero il web server. Una volta scaricato il codice provo a collegarmi ma funziona 1 volta su 10….la maggior parte delle volte lo smartphone/pc non si collega. Quando miracolosamente si collega la pagina web funziona un paio di volte e poi risulta sempre non raggiungibile. Provato diversi browser. Con l’esempio dell’access point invece mi collego sempre. I problemi iniziano quando nel loop metto la riga di codice “server.handleClient();”.
    Qualche idea?

    • Ciao scusa il ritardo, ma il tuo commento era andato nello spam e non lo avevamo visto! In realtà server.handleClient() è indispensabile, non puoi pensare di fare qualsiasi web server senza quella riga perchè permette di gestire le connessioni al web server. E’ strano che non ti funzioni, il codice è esattamente quello che usiamo o lo hai già modificato ?

  19. Roberto ha detto:

    Ciao,tutto molto interessante,però in fase di compilazione su questa riga:

    String javascript_redirect = “setTimeout(\”location.href = ‘/’;\”, 1500);”;

    mi da questo errore:
    expected ‘,’ or ‘;’ before ‘text’

    se mi puoi aiutare…grazie

  20. Roberto ha detto:

    Scusa era questa

    String javascript_redirect = “setTimeout(\”location.href = ‘/’;\”, 1500);”;

  21. Roberto ha detto:

    Risolto grazie
    Guardando le foto con le schermate che sono diverse dal testo nell’articolo

    • Ciao Scusa il ritardo, ma avevamo perso il tuo commento nello spam, maledetto sistema automatizzato per i commenti!! 😀 Comunque siamo felicissimi che tu abbia risolto!!!!

    • Leonardo Barea ha detto:

      Si in effetti c’è un errore nel “block-preformatted” (nel blocco dove si può copiare il codice per intenderci), la quale mancano 2 slash

  22. Fabio T. ha detto:

    Congratulazioni per il tuo ottimo articolo, mi ha permesso di dare una risposta a moltissimi dubbi che avevo in merito all’utilizzo del ESP-01.
    Attualmente sto utilizzando l’adattare seriale FT232 come indicato nell’articolo, la programmazione a il ripristino del firmare hanno funzionato al primo tentativo, invece non mi partivano le esecuzioni degli schetch, dopo aver scollegato il PIN GP0 dal GND, ho provato a scollegare anche il PIN CHP0 dai 3.3 V e in questo modo funziona correttamente.

  23. mauro ha detto:

    Salve ragazzi, bravi!! una domanda devo inviare da arduino all esp8266 D1 mini, 8 byte dove ci sono 8 valori la luminosità ; l illuminazione; il voltaggio,,,,ecc… valori da 0 a 255, poi questi dati li voglio inviare a blynk x visualizzarli. Secondo Voi cosa conviene l I2C o la seriale, se mi date una dritta, premetto sono alle prime armi con l ESP, sono riuscito tramite blynk comunque ad accendere e spegnere il led….. comunque l’arduino UNO è il mio preferito. ciao , grzieeee!!!!

    • Buongiorno! Allora, parti del presupposto se vuoi fare tutto senza impazzire su trasferimento di dati, evita proprio di usare esp+arduino, ma vai su una scheda all in one come Arduino MKR Wi-Fi 1010 o Nodemcu (quest’ultimo molto economico). Se proprio vuoi continuare sulla tua strada, scegli la via dell’i2c poiché con il seriale è un casino far riconoscere alla scheda che recepisce i dati quando deve leggere e quando deve starsene buona. Una domanda che mi sorge spontanea perché usare una d1 mini che ha a bordo già tutto quello che serve con Arduino UNO ?

  24. Federico ha detto:

    Cerco aiuto con questo piccolo ma dannato esp8266-01. Ho scelto questo modulino sia per le sue dimensioni ridotte che per il basso consumo che dovrebbe avere in deep-sleep. Difatti il mio progettino prevede l’uso di batteria. Il sensore che ho scelto è il BME280 per la ricchezza delle grandezze fisiche che è in grado di misurare. Nelle mie intenzioni il modulino deve trasmettere i valori misurati ad un ricevitore dotato di un ricco display. Il tipo di trasmissione che ho scelto è ESP-NOW. Fatto i programmi iniziali su ESP32 sia per il sender che per il receiver riscontro che la funzionalità è perfetta, tranne il consumo in deep-sleep. Allora passo ad ESP-01, inizialmente usando un devkit. Tutto funziona bene, tranne anche qui il consumo dormiente che si assesta sui 10 mA. Allora acquisto tre modulini esp-01 ed il relativo adattatore USB per il caricamento programma. Ebbene, è qui che è cascato l’asino: il caricamento riesco a farlo, ma attivando il monitor mi compare la scritta che non viene trovato un valido BME280. Ho anche fatto girare un programma di scan dell’ID di I2C ed anche questo mi dice che non rileva
    nulla. I pin che uso per il bus I2C sono DIO-0 per il SDA e DIO-2 per SCL.
    Ho sbattuto la testa a destra e a sinistra, ma sono del tutto bloccato. Chi mi può dare qualche suggerimento per riuscire a capire cosa c’è che non va? O almeno suggerire qualche test per indagare. Purtroppo non ho un oscilloscopio, ma forse se ne può fare a meno. Sarebbe un peccato dover abbandonare il modulino, perchè le sue caratteristiche nominali vanno a nozze con il mio progetto. Please, help me!

    • Ciao! scusa il ritardo nel risponderti ma il tuo messaggio era finito nello SPAM! Allora, la prima domanda che mi viene spontanea è hai incluso la libreria Wire.h? La seconda cosa che vorrei chiederti ha inizializzato la libreria Wire.h con Wire.begin(0,2); nel setup ? Grazie per l’interesse e tienici aggiornati!! 🙂

  25. Michele ha detto:

    Ciao, é possibile ricevere sempre le notifiche su Blynk anche con app chiusa ?

  26. Federico ha detto:

    Aggiungo che ovviamente ho provato a cambiare sia il modulino che il BME280 che l’adattatore USB senza risultato. Ho anche inserito nel programma il comando di un LED tramite il pin 03 che ha funzionato, confermando che il programma gira dopo il caricamento. Il problema quindi è che non viene rilevato il sensore. Anche l’ID del sensore che ho inserito nel programma, 0x76, dovrebbe essere a posto, perchè nella prova con l’esp dev kit funziona.

  27. Antonio Durighello ha detto:

    Buongiorno e complimenti per il lavoro molto ben fatto ed il tempo che ci dedicate e la condivisione a cui tengo particolarmente in quanto faccio parte di un gruppo di makers qui a Genova.
    Ammetto la mia profonda ignoranza sulla gestione delle reti, io ho preso in rete una schedina ed ho caricato un file di arduino con un loop vuoto per testare i comandi AT, sono arrivato a collegarmi alla mia rete di casa e con il comando AT+CIFSR mi conferma il collegamento con la mia rete fastweb (non vorrei fosse lei la causa del malfunionamento) quando provo ad interagire spedendo messaggi il server mi dà errore, spiego i passi: AT+CIPMUX=1 poi AT+CIPSERVER =1,80 e mi da subito errore.

    grazie per l’aiuto
    Antonio

  28. Leonardo Barea ha detto:

    Ciao,
    complimenti per l’ottima guida!! Sto trovando dei problemi nella parte di codice relativa alla programmazione dell’esp01 nel capitolo 12. In particolare con tutti i programmi prima non ho trovato nessun errore, sempre andato tutto bene, ma andando a programmare la schedina con il codice del capitolo 12, quando arriva al 100%, mi da questo errore (sinteticamente):

    Writing at 0x00000000… (7 %)

    ……………………………………………….

    Writing at 0x00034000… (100 %)

    esptool.FatalError: Timed out waiting for packet header
    esptool.FatalError: Timed out waiting for packet header

    Questo mi capita sia con la programmazione tramite arduino (schema A1) che con un programmatore a chiavetta, ho provato a caricare altri programmi e gli altri non mi danno problemi, quindi probabilmente è qualcosa sul codice ma non capisco cosa….
    Inoltre un altro dubbio che ho è il Serial.begin(9600) serve per comunicare con arduino giusto? L’upload speed va lasciato a 115200 giusto?
    Grazie

    • Buongiorno, scusa la latenza nel risponderti ma alcuni commenti come al solito ci finiscono nello spam e non li vediamo. Comunque quell’errore li è un errore che ti indica che il codice non è stato caricato perchè esp non è stato trovato dal convertitore seriale, mi sembra strano che ti faccia questo problema solo su quel codice, ti chiediamo di accedere al gruppo telegram “Bar Filo Connesso” e li chiedere di questa problematica, qualcuno ti saprà aiutare 😀 (avendo la possibilità anche di postare foto e video)

  29. Samuele ha detto:

    Ciao! È possibile avere anche qualche tips per eseguire il reset dell esp01 utilizzando MacOSX? Grazie

  30. Marco Antinori ha detto:

    Buongiorno a tutti, sto programmando due diverse schedine (esp-01 e esp03) attraverso un programmatore di futuraelettronica (ft1191m e un convertitore seriale. Utilizzo la libreria 2.3.0 ma dal momento che l’esp03in modalità softap manifestando sistematici problemi di disconnessione (mentre funziona correttamente con lo esp-01). Per l’invio dei comandi utilizzo roboremo . ho provato utilizzare una versioni più recente della libreria (a partire dalla 2.5.0 in poi, come da voi suggerito). I dispositivi apparentemente sembrano programmarsi ma all’avvio anche il semplice blink proposto negli esempi non funziona. ho provato a giocare con le impostazioni ma senza alcun risultato. qualcosa mi sfugge. suggerimenti? grazie Marco

    • Ciao se hai telegram entra nel gruppo “Bar Filo Connesso” cosi puoi madarci qualche informazione in più a riguardo (foto e video) giusto per capire anche quale modello è il tuo esp01.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *