Sto svolgendo in queste settimane un corso Arduino per i miei allievi di II’, ma gli impegni dei consigli di classe e le attività di vicepresidenza mi hanno portato a spostare un paio di lezioni e per farmi perdonare ho deciso di implementare velocemente una breve lezioni che generi l’effetto “waooo” 🙂 spero possa funzionare. L’idea è quella di comandare la marcia e l’arresto di motori asincroni trifase (380 Vac) remotamente attraverso comandi dati da cellulare utilizzando tecnologia a basso costo.

Aggiungere funzionalità di controllo remoto via WiFi ai propri progetti Arduino è ormai diventato relativamente semplice e molto economico. E’ da qualche tempo che sto utilizzando i noti ESP8266 nella versione più economica ESP01 per effettuare esperimenti di domotica a basso costo. ESP8266 è un microcontrollore programmabile in una modalità molto simile a quanto viene fatto per Arduino è costituito da un circuito SoC (System on Chip) dalle dimensioni ridottissime (5 x 5 mm) e la scheda che lo ospita integra un’antenna WiFi.

Esistono diversi modelli di ESP che includono l’ESP8266 ad essi è stato assegnato un nome che ha la seguente struttura ESP-XX dove XX è un numero che in questo momento va da 01 a 13 e che sicuramente nei prossimi mesi sarà destinato ad aumentare. In generale numeri più alti indicano funzionalità e performance più elevate, ma sicuramente ad oggi la versione più diffusa per semplicità di utilizzo e costi resta ancora l’ESP01.

I modelli ESP differiscono uno dall’altro per le seguenti caratteristiche:

• dimensioni del modulo;
• memoria flash, esterna al chip e varia da 512 KByte fino a 4MByte;
• numero di pin;
• antenna WiFi stampata su scheda o su apposito connettore a cui collegare un’antenna

Nell’immagine che segue un elenco dei più diffusi moduli ESP disponibili:

In questa breve trattazione utilizzerò l’ESP01.

Di seguito il pinout dell’ESP01

E’ estremamente importante ricordare che l’alimentazione della schedano NON può essere superiore ai 3,3V il rischio è la distruzione della scheda, quindi per poter operare con l’ESP non possiamo interfacciarla direttamente ad una scheda Arduino il cui livello di funzionamento è 5V (per maggiori informazioni sui livelli logici consultare il post: Livelli logici TTL e CMOS – cosa si nasconde dietro un HIGH o LOW di una digitalWrite di Arduino?) inoltre non potrete utilizzare direttamente l’alimentazione di Arduino a 3,3V per alimentare direttamente l’ESP, in quanto, in stato di utilizzo del WiFi, la corrente assorbita dall’ESP potrebbe rendere instabile il funzionamento di Arduino, pertanto è buona norma alimentare l’ESP mediante alimentazione separata. Un semplice circuito di alimentazione ben dimensionato costituito da un LM317 o un LM117 può risolvere. In questo esempio per ovviare rapidamente al problema ho utilizzato un pacco batteria indipendente che mi ha permesso di trasportare i miei progetti basati su ESP ovunque. Se possedete solamente alimentatori da 5V esistono delle schede molto economiche fatte proprio per breadboard che vi permettono di predisporre, sulle linee di alimentazione della breadboard, tensioni di 3,3V o 5V (anche in modo indipendente per le due linee di alimentazione della breadboard):

Oltre all’alimentazione di 3,3V anche i livelli logici di tutti gli altri pin dell’ESP funzionano a 3,3V quindi incompatibili con Arduino, pertanto per comunicare tra le due schede bisognerà costruire o acquistare dei traslatori di livello, nell’immagine che segue alcuni adattatori che potete acquistare per pochissimi euro:

Un traslatore di livello può essere facilmente costruito, può essere impiegato anche in questo caso un LM317 una ricerca su google ho un libro di elettronica delle scuole superiori (ad indirizzo elettronico) vi fornirà tutte le indicazioni (se riuscirò ne farò un post specifico).
In ogni caso se ancora non siete abili nella progettazione elettronica vi consiglio l’acquisto di un traslatore di livello uno come quelli indicati nell’immagine sopra, o se possedete ancora un vecchio alimentatore per cellulare (da 3,7 V) potete modificarne il connettore ed utilizzarlo per alimentare l’ESP.

L’ESP01 è dotato di un connettore ad 8 pin con passo 2,54 mm disposti su due file:

questa disposizione dei pin non permette un utilizzo diretto su breadboard in quanto metterebbe in cortocircuito le due file di pin, per ovviare a tale problema esistono opportune schede adattartici che ne permettono l’utilizzo su breadboard e che trasformano il tipo di connessione in un passo DIP (dual-inline package) ovvero in una configurazione a piedini disposte su due file parallele sui lati maggiori. In generale una configurazione DIP è seguita da un numero che indica il numero di piedini che il componente possiede, DIP16 indica un integrato a 16 pin, 8 per lato.

Nell’immagine un ATtiny26 un microcontrollore a 8-bit AVR RISC-based dell’ex ATMEL ora Microchip. Come si evince dall’immagine è costituito da un contenitore DIP20, cioè 20 pin totali, 10 per ogni fila. La scanalatura centrale consente di inserire il circuito integrato a cavallo della scanalatura, in questo caso rimangono a disposizione di ogni pin dell’integrato 4 fori per collegare ulteriori componenti.

Per il collegamento su breadboard dell’esp01 preferisco utilizzare la scheda adattatrice che ho segnalato sopra che è un DIP8, utile in quanto ha la doppia funzione di adattamento di connessione alla breadboard e di traslatore di livello  logico, quindi usando questo adattatore potrete usare un’alimentazione a 5V:

Modalità operative della scheda

Gli ESP8266 possono operare in due modalità:

1. modalità programmazione che viene effettuata mediante l’interfaccia UART e permette di caricare sulla scheda il firmware e gli sketch;
2. modalità di boot utilizzando la memoria flash esterna della scheda, ovvero per porre l’ESP in modalità esecuzione programmi.

Per utilizzarlo in una delle due modalità è necessario predisporre ad HIGH o LOW i pin della GPIO 0 e GPIO 2 secondo la tabella indicata di seguito (trovate maggiori informazioni seguendo il link). Ricordo che in questo caso HIGH corrisponde a 3,3V e LOW a 0V.

Dalla tabella si evince che lo stato di GPIO 0 determina la modalità di funzionamento, cioè se siamo in modalità programmazione  (UART) o in modalità esecuzione programma (Flash). Durante la realizzazione dei vostri progetti dovete tenere in conto che GPIO 0 e GPIO 2 non potete collegarli a dispositivi con livello logico alto.

Per una trattazione estesa sull’uso della GPIO 0 e della GPIO 2 come output ed input vi rimando ai seguenti post: ESP8266 Using GPIO0/GPIO2/GPIO15 Pins e How to Use the ESP8266-01 Pins

E’ buona norma:

• collegate tra tra Vcc e massa un condensatore da 100 nF
• ed una resistenza resistenze da 10KOhm tra:
  • EN e Vcc (se posto a massa resetta l’ESP)
  • GPIO0 e Vcc
  • RST e Vcc

Il trasferimento dei nostri programmi dal computer alla scheda ESP avverrà mediante una comunicazione seriale, attraverso i pin URXD e UTXD della scheda ESP, ma per far ciò abbiamo necessità di un elemento che farà da ponte tra il nostro computer e l’ESP, si tratta di un convertitore USB/Seriale, una scheda FTDI232.
Le schede FTDI232 sono estremamente economiche, ne esistono di diverse versioni e diversi produttori, quella che impiego per i miei progetti è una  FTDI232 3.3V 5.5V FTDI USB a TTL Serial Adapter:

La scheda è dotata di un’interfaccia USB Mini B ed un connettore dotato di 6 piedini così nominati:

Notate il jumper che stabilisce l’alimentazione della scheda. Nel caso voleste utilizzare questa scheda per alimentare l’ESP fate attenzione a come posizionate il jumper, nel caso si utilizzi per l’ESP una scheda adattatrice DIP8 come quelle che uso io, la posizione del jumper deve essere sui 5V. I pin DTR e CTS non saranno utilizzati.

Passiamo ora alla sperimentazione.

Dovrete far riconoscere all’IDE di Arduino la scheda ESP8266, per far ciò seguite i medesimi passi indicati nel post: “IoT con WeMos D1 Mini usando Arduino IDE e Blynk” alla voce: “Usare WeMos D1 Mini con IDE Arduino” al termine dell’installazione dal menù Tools > Board selezionate Generic ESP8266 Module

 

Come potete vedere dall’immagine, nella sezione Tools appariranno diverse impostazioni in più, la più importa è “Upload Speed” che stabilisce il baudrate (numero di caratteri al secondo).
Il baudrate di default per l’ESP8266 può variare a seconda del modello, ma la maggior parte dei moduli funziona a 9600 o 115200 baud. Nel mio caso l’impostazione corretta è 115200.

Realizziamo il circuito 

Collegamenti

• RX (FTDI232) – TX (adattatore ESP01)
• TX (FTDI232) – RX (adattatore ESP01)
• BT1 – RST (adattatore ESP01) [collegare secondo pin Bt1 a GND]
• BT2 – CTS (adattatore ESP01) [collegare secondo pin Bt2 a GND]
• GPIO 2 (adattatore ESP01) > R 220 Ohm > LED > GND
• EN (adattatore ESP01) > R 10 KOhm > Vcc
• RST (adattatore ESP01) > R 10 KOhm > Vcc
• GPIO 0 (adattatore ESP01) > R 10 KOhm > Vcc
• Condensatore da 100nF tra Vcc e GND
• Collegare Vcc e GND della scheda FTDI232 a Vcc e GND sulla breadboard

Quando alimentato, l’ESP8266 si avvierà in modalità “operation mode” se GPIO0 è HIGH o si avvierà in modalità “firmware load mode” se GPIO0 è posto a LOW cioè connesso a GND. I due pulsanti che vedete nell’immagine sopra vengono utilizzati per porre l’ESP8266 in una delle due modalità.

Per effettuare il caricamento di un nuovo sketch dall’Ide di Arduino sull’ESP8266 seguire il seguenti passi:

1. Alimentare l’ESP8266 e connettete la scheda FTDI232 al vostro computer mediante cavo USB
2. Selezionate la porta USB corretta dal menù Tool > Port
3. Premete contemporaneamente il pulsante 2 (GPIO 0 a GND) e il pulsante 1 (RST a GND)
4. Lasciare il pulsante 1, dopo averlo lasciato attendete per circa 1 secondo
5. Lasciare il pulsante 2 (ESP8266 si trova ora in modalità firmware mode)
6. Nell’IDE di Arduino effettuato l’upload del vostro sketch sull’ESP8266 facendo click sul pulsante “upload”, questa fase potrebbe richiedere qualche minuto. Mentre effettuate l’upload mantenete aperta anche la Serial Monitor.

Se tutto viene effettuato correttamente vi verrà restituito un messaggio simile a:

Uploading xxxxxxx bytes from /tmp/buildxxxxx.tmp/Blink.cpp.bin to flash at 0x00000000 ….

Nel caso l’upload non sia andato a buon fine potreste ottenere un messaggio del tipo:

warning: espcomm_sync failed error: espcomm_open failed

I problemi che possono causare il non caricamento dello sketch possono essere di diverso tipo i più comuni sono:

• scambio dei pin TX ed RX
• velocità di trasferimento dati non corretta
• sequenza nel mettere l’ESP8266 in modalità firmware non corretta (non premiamo nella giusta sequenza i pulsanti).

Per effettuare il primo test utilizziamo il solito programma Blink che permetterà di effettuare il lampeggio del LED collocato sull’ESP, lo trovate seguendo il percorso: File > Examples > ESP8266 > Blink

Effettuiamo ora il Blink ad intervalli di 1 secondo del LED esterno che abbiamo inserito nel nostro circuito collegato alla GPIO 2 (il pin digitale 2 corrisponde alla GPIO 2):

void setup() {
  // inizializzazione del pin digitale 2 che corrisponde a GPIO2 sull'ESP8266
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, HIGH);
  delay(1000);
  digitalWrite(2, LOW);
  delay(1000);
}

quanto realizzato nel post: IoT con WeMos D1 Mini usando Arduino IDE e Blynk quando ho mostrato come effettuare l’accensione e lo spegnimento di un LED da pagina web. Riprendiamo lo stesso sketch ed effettuiamo alcune piccole modifiche, utilizzo della sola libreria #include <ESP8266WiFi.h>,  ipostazione della variabile pinLed a 2 (che corrisponde alla GPIO 2), variazione del titolo della pagina web:

/*
 * Prof. Michele Maffucci
 * 12.05.2017
 * accensione/spegnimento LED da pagina web
 * con ESP8266
 * per maggiori informazioni:
 * https://www.arduino.cc/en/Reference/WiFi
 * https://github.com/esp8266
 */

#include <ESP8266WiFi.h>

// La connessione dell'ESP8266 al un network WiFi viene
// realizzata usando un personal encryption WEP e WPA2
// Per poter sapere a quale rete connettersi bisogna
// effettuare un broadcast dell'SSID (nome del network) 

// definizione di due array di caratteri
// in cui memorizzare nome della rete WiFi e password

const char ssid[] = "nome della rete";       // inserire l'ssid della rete
const char pass[] = "password della rete";   // password della rete

// Creazione di un server web in ascolto sulla porta 80
// attende contenuti (pagine html, immagini, css, ecc...)
WiFiServer server(80);

int pinLed = 2;                   // LED connesso tra pin 2 e ground

void setup() {
  Serial.begin(115200);           // inizializzazione Serial Monitor
  delay(10);

  pinMode(pinLed, OUTPUT);         
  digitalWrite(pinLed, LOW);      // LED inizialmente spento

  // Connessione alla rete WiFi
  
  Serial.println();
  Serial.println();
  Serial.println("------------- Avvio connessione ------------");
  Serial.print("Tentativo di connessione alla rete: ");
  Serial.println(ssid);

  /* 
   * Viene impostata l'impostazione station (differente da AP o AP_STA)
   * La modalità STA consente all'ESP8266 di connettersi a una rete Wi-Fi
   * (ad esempio quella creata dal router wireless), mentre la modalità AP 
   * consente di creare una propria rete e di collegarsi
   * ad altri dispositivi (ad esempio il telefono).
   */
  
  WiFi.mode(WIFI_STA);

  /* 
   *  Inizializza le impostazioni di rete della libreria WiFi e fornisce lo stato corrente della rete,
   *  nel caso in esempio ha come parametri ha il nome della rete e la password.
   *  Restituisce come valori:
   *  
   *  WL_CONNECTED quando connesso al network
   *  WL_IDLE_STATUS quando non connesso al network, ma il dispositivo è alimentato
  */
  WiFi.begin(ssid, pass);

  /* 
   *  fino a quando lo non si è connessi alla WiFi
   *  compariranno a distanza di 250 ms dei puntini che
   *  evidenziano lo stato di avanzamento della connessione
  */  
  while (WiFi.status() != WL_CONNECTED) {
    delay(250);
    Serial.print(".");
  }

  // se connesso alla WiFi stampa sulla serial monitor
  // nome della rete e stato di connessione
  Serial.println("");
  Serial.print("Sei connesso ora alla rete: ");
  Serial.println(ssid);
  Serial.println("WiFi connessa");

  // Avvia il server
  server.begin();
  Serial.println("Server avviato");

  // Stampa l'indirizzo IP
  Serial.print("Usa questo URL : ");
  Serial.print("http://");
  Serial.print(WiFi.localIP()); // Restituisce i'IP della scheda
  Serial.println("/");
}

void loop() {

  // Verifca se il client e' connesso
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Aspetta fino a quando il client invia dei dati
  Serial.println("Nuovo client");
  while (!client.available()) {
    delay(1);
  }

  // Legge la prima richiesta
  
  /* 
   * readStringUntil() legge i caratteri dal buffer seriale
   * all'interno di una stringa fino a quando non riceve il
   * carattere di terminazione in questo cas \r
   * oppure si verivica un time out
   */
   
  String request = client.readStringUntil('\r');
  Serial.println(request);
  client.flush();                               // flush() elimina il buffer una volta che
                                                // tutti i caratteri in uscita sono stati inviati.

  // Verifica quale richiesta e' stata fatta

  /*
   * Individua un carattere o una stringa all'interno di un'altra stringa (nell'esempio la strina è request).
   * Per impostazione predefinita, ricerche dall'inizio della stringa,
   * ma è possibile effettuare la ricerca partendo da un dato indice,
   * permettendo di individuare tutte le istanze del carattere o della stringa.
   * Se il valore restituito è -1 allora la stringa non è stata trovata.
   */

  int valore = LOW;
  if (request.indexOf("/LED=ON") != -1) {
    digitalWrite(pinLed, HIGH);
    valore = HIGH;
  }
  if (request.indexOf("/LED=OFF") != -1) {
    digitalWrite(pinLed, LOW);
    valore = LOW;
  }

  // Restituisce la risposta
  
  /*
   * La pagina web dovrà essere formattata con la sua intestazione html
   * e variando il messaggio che identifica lo stato del LED 
   */
   
  // intestazione pagina html
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println(""); //  non dimenticare questa linea
  client.println("<!DOCTYPE HTML>");
  client.println("<html>");

  // titolo della pagina
  client.println("<h2>Intefaccia di controllo LED mediante ESP8266</h2>");

  // includiamo tutto il testo in un div in cui il font è impostato a 20 px
  // N.B. ricorda che per poter considerare le " come stringa e' necessario farle precedere da uno \
  client.print("<div style=\"font-size: 20px;\">");
  client.print("Il LED e': ");

  if (valore == HIGH) {
    // stampa ON di colore verde
    client.print("<strong style=\"color:green;\">ON</strong>");
  } else {
    // stampa OFF di colore rosso
    client.print("<strong style=\"color:red;\">OFF</strong>");
  }
  // stampa una riga separatrice
  client.println("<hr>");
  // lista puntata
  client.println("<ul>");
  client.println("<li>Fai click <a href=\"/LED=ON\">QUI</a> per portare ad ON il LED sul pin 2</li>");
  client.println("<li>Fai click <a href=\"/LED=OFF\">QUI</a> per portare ad OFF il LED sul pin 2</li>");
  client.println("</ul>");
  client.print("</div>");
  client.println("</html>");

// chiusura connessione
  delay(1);
  Serial.println("Client disconnesso");
  Serial.println("");
}

Effettuate l’upload, durerà qualche minuto, ricordate di seguire la sequenza di pressione dei pulsanti come indicato sopra:

Matenete aperta la finestra della Serial Monitor, vi apparirà la finestra con la URL a cui collegarsi:

Il click sui link nella pagina faranno accendere e spegnere il LED:

Di seguito i messaggi che appaiono sulla Serial Monitor ogni volta che facciamo click sui link della pagina web:

Bene! Abbiamo realizzato il nostro primo esperimento con un ESP01.

Vi segnalo alcuni link di riferimento utili per approfondire lo studio:

• Kolban’s Book on the ESP32 & ESP8266
• ESP8266 Community Forum
• ESP8266 Community Forum – GitHub
• Schede comparative tra i diversi modelli ESP
• Espressif.com documents (produttore della scheda ESP8266)
• Mappa per orientarsi (Espressif)
• Get Started (Espressif)

Buona sperimentazione a tutti 🙂