Demoboard ESP32: altre applicazioni per chiudere la panoramica (parte 3)

Chiudiamo la panoramica sulla scheda di prototipazione basata sul popolare modulo WiFi, con ulteriori applicazioni. Terza puntata.

Nelle due puntate precedenti abbiamo introdotto la demoboard per il famoso e diffusissimo SoC ESP32 della Espressif, che nello specifico è montato a bordo di una scheda con ESP32 commercializzata da www.futurashop.it con il codice YB555. Oltre ad avervi proposto alcuni sketch scritti da noi per introdurvi nel mondo dello sviluppo con questo hardware, in ottica IoT; abbiamo descritto nel dettaglio firmware e creato degli esempi che abbiamo iniziato a presentarvi nella prima e nella seconda puntata. Adesso proseguiamo su questa strada proponendo gli ultimi esempi applicativi che utilizzano l’hardware di bordo e i moduli collegabili esternamente tramite gli appositi connettori. Nello specifico andiamo a utilizzare questi componenti di bordo e moduli esterni:

• pulsanti UP, DOWN, LEFT, RIGHT, OK;
• Servomotore;
• Display OLED 0,96”;
• Relé 5V (RL1);
• LED rosso (LD1);
• Led verde (LD2).

Ricordiamo che il cuore della demoboard è la scheda di sviluppo e prototipazione YB555 basata sull’ESP32 (ESP-WROOM-32) che integra un Wi-Fi 802.11 b/g/n, un Bluetooth dual-mode (classico e BLE) e 25 GPIO. Supporta una velocità di trasmissione dati fino a 150 Mbps, ha una potenza di uscita in’antenna di 20,5 dBm e unconsumo in modalità sleep di soli 5 µA.

Interazione LED e PULSANTI

Iniziamo con il vedere un’applicazione nella quale utilizziamo i pulsanti a bordo della scheda e ne visualizziamo la condizione sul display OLED on-board (cod. OLED096C oppure cod. OLEDGVSCSD reperibili on-line su www.futurashop.it); questo esempio applicativo fornisce un’idea di come si possono utilizzare e integrare i pulsanti in un’applicazione vera e propria, ottenendo un feedback sul display oppure determinate azioni.

Lo sketch da caricare in questo caso si chiama OLED_Pulsanti.ino e una volta mandato in esecuzione sulla scheda ATmega2560 che governa la demoboard, sul display viene indicato di volta in volta quale pulsante è stato premuto fra quelli disposti a joystick, ossia UP, DOWN, LEFT, RIGHT e OK (P1, P2, P3, P4, P5). Inoltre il codice di esempio permette di associare la pressione di uno dei predetti pulsanti all’accensione dei LED a bordo della scheda; per l’esattezza, se viene premuto LEFT o RIGHT si accenderà il LED verde (LD2), mentre se si preme UP o DOWN verrà comandata l’accensione del LED rosso (LD1). Nel caso venga premuto il pulsante OK si accenderanno entrambi i LED.

Questa applicazione e il codice che segue, proposto nel Listato 1, possono essere integrate in altre per ottenere un modulo di gestione dei pulsanti e per collegare i relativi input a determinate azioni, che possono essere non solo quelle descritte, ma anche l’attivazione di altre uscite, non ultima quella a relé.

Per l’utilizzo dello sketch dovete copiare la cartella “libraries” che si trova negli esempi scaricabili dal nostro sito www.elettronicain.it fra i file di questo numero della rivista, sotto “/Documenti”/Arduino”, quindi aprire l’IDE di Arduino e caricare il codice di esempio disponibile nella cartella “OLED_Pulsanti.

Listato 1

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>



#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED display height, in pixels



// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library. 

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), ...

#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)

#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);



#define NUMFLAKES 10 // Number of snowflakes in the animation example



#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16



const int P_UP = 23;

const int P_DOWN = 4;

const int P_LEFT = 16;

const int P_RIGHT = 17;

const int P_OK = 5;

const int LEDV = 26;

const int LEDR = 25;



void setup() {

Serial.begin(9600);



// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally

if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {

Serial.println(F(“SSD1306 allocation failed”));

for(;;); // Don’t proceed, loop forever

}



// Show initial display buffer contents on the screen --

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds



// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(20, 30);

display.print(“ PUSH “);



// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want...rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches...





/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/



pinMode(P_UP, INPUT_PULLUP);

pinMode(P_DOWN, INPUT_PULLUP);

pinMode(P_LEFT, INPUT_PULLUP);

pinMode(P_RIGHT, INPUT_PULLUP);

pinMode(P_OK, INPUT_PULLUP);

pinMode(LEDV, OUTPUT);

pinMode(LEDR, OUTPUT);

}



void loop() 

{

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

switch (Ctrl_Push()) 

{

case 1:

Serial.println(“Push UP”);

display.setCursor(50, 30);

display.print(“UP”);

digitalWrite(LEDR,HIGH);

break;

case 2:

Serial.println(“Push DOWN”);

display.setCursor(40, 30);

display.print(“DOWN”);

digitalWrite(LEDR,HIGH);

break;

case 3:

Serial.println(“Push LEFT”);

display.setCursor(40, 30);

display.print(“LEFT”);

digitalWrite(LEDV,HIGH);

break;

case 4:

Serial.println(“Push RIGHT”);

display.setCursor(40, 30);

display.print(“RIGHT”);

digitalWrite(LEDV,HIGH);

break;

case 5:

Serial.println(“Push OK”);

display.setCursor(50, 30);

display.print(“OK”);

digitalWrite(LEDR,HIGH);

digitalWrite(LEDV,HIGH);

break;

default:

display.setCursor(40, 30);

display.print(“----”);

digitalWrite(LEDV,LOW);

digitalWrite(LEDR,LOW);

break;



}



display.display();

delay(500);

}



int Ctrl_Push()

{

int push = 0;

if (digitalRead(P_UP)==LOW) push = 1;

if (digitalRead(P_DOWN)==LOW) push = 2;

if (digitalRead(P_LEFT)==LOW) push = 3;

if (digitalRead(P_RIGHT)==LOW) push = 4;

if (digitalRead(P_OK)==LOW) push = 5;

return push;

}

Controllo Servocomandi

Passiamo adesso a un secondo esempio applicativo che è molto interessante perché riguarda la gestione dei servo analogici (da modellismo, robotica ecc.) attraverso la nostra demoboard; per implementarla utilizziamo l’uscita dedicata ai servocomandi, che sul circuito stampato è quella siglata CNU11, a tre poli: S (1) 5V (2) e GND (3). Si tratta della connessione standard per i connettori a passo 2,54 mm utilizzati nei servo, come ad esempio quello reperibile presso la Futura Elettronica (www.futurashop.it) con il codice prodotto SERVO206, con coppia di 1,5kg, rotazione: 160°, velocità a 4,8V: 0,12 s,/60°.

Per la gestione dei servo abbiamo scritto lo sketch d’esempio OLED_Servo.ino, il quale, quando viene eseguito, imposta la demoboard in modo che il servocomando collegato al connettore CNU11 ruoterà prima in senso orario di 180° e poi di altrettanti gradi in senso antitorario; questo codice esegue quindi un test di funzionamento dei servocomandi, facendo compiere al loro alberino una rotazione completa, divisa in due passaggi che corrispondono alle semirotazioni opposte rispetto alla posizione di riposo (0 gradi). Per l’utilizzo dello sketch dovete copiare la cartella “libraries” che si trova negli esempi scaricabili dal nostro sito www.elettronicain.it fra i file di questo numero della rivista, sotto “/Documenti”/Arduino”, quindi aprire l’IDE di Arduino e caricare uno dei codici di esempio disponibili nelle cartelle “OLED_Servo” oppure “Servo”. Il codice completo per la gestione dei servocomandi è riportato nel Listato 2.

Listato 2

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>



//for Servo

#include <Servo.h>



#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED displdfsfdfsfdsfdsfdsfdsay height, in pixels



// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library. 

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), ...

#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)

#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);



#define NUMFLAKES 10 // Number of snowflakes in the animation example



#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16



//for Servo

static const int servoPin = 18;

Servo servo1;



void setup() 

{

Serial.begin(9600);



// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally

if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {

Serial.println(F(“SSD1306 allocation failed”));

for(;;); // Don’t proceed, loop forever

}



// Show initial display buffer contents on the screen --

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds



// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(10, 30);

display.print(“ Servo “);



// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want...rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches...





/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/

servo1.attach(servoPin);

}



void loop() 

{

for(int posDegrees = 0; posDegrees <= 180; posDegrees++) 

{

servo1.write(posDegrees);

Serial.println(posDegrees);

delay(20);

}



for(int posDegrees = 180; posDegrees >= 0; posDegrees--) 

{

servo1.write(posDegrees);

Serial.println(posDegrees);

delay(20);

}

}

Utilizzo della connessione WiFi

Il modulo ESP32 che governa l’intera demoboard si distingue per una caratteristica: l’avere a bordo la connessione WiFi ed è questa la ragione per cui l’abbiamo scelta: avere a bordo una connettività per l’accesso a Internet e per affacciare alla Rete le nostre applicazioni, in perfetta ottica IoT.

Per quello che riguarda la sezione ricetrasmittente WiFi, opera in un range di frequenza compreso fra 2,4 GHz e 2,5 GHz e le sue caratteristiche tecniche principali sono le seguenti:

• conformità IEEE 802.11 b/g/n HT40;
• stack in banda base e LwIP;
• modalità Sniffer / Station / SoftAP e Wi-Fi direct mode;
• massimo data-rate di 150 Mbps@11n HT40, 72 Mbps@11n HT20, 54 Mbps@11g e 11 Mbps@11b;
• massima potenza di trasmissione 19,5 dBm@11b, 16,5 dBm@11g, 15,5 dBm@11n;
• sensibilità in ricezione: -97 dBm.

Il transceiver è anche predisposto per supportare le modalità di protezione della connessione WEP, WPA/WPA2 PSK/Enterprise e la crittografia con accelerazione hardware AES / SHA2 / ECC / RSA-4096. Andiamo dunque a vedere l’esempio applicativo che utilizza questo hardware, il quale prevede che il dispositivo si connetterà alla propria rete WiFi per eseguire un test di connettività.

A connessione avvenuta, verrà mostrato l’indirizzo IP assegnato al modulo ESP sul display. Al termine il modulo rimarrà in attesa di una connessione da parte di un client interno alla rete, sulla porta TCP 8088. A connessione avvenuta un messaggio fornirà tale informazione e ogni carattere scritto sul terminale del client verrà mostrato sul display, nei limiti di capienza del display. Se a connessione avvenuta si preme uno dei cinque pulsanti a bordo della scheda, il client riceverà sul terminale l’indicazione del pulsante premuto.

Lo sketch di test si chiama OLED_WiFi.ino e si trova sotto la cartella degli esempi, ovvero sotto “/Documenti”/Arduino”; aprite l’IDE di Arduino e caricate lo sketch, quindi andate a modificare le variabili “apn” e “ssid” con i parametri della propria rete, perché queste ultime avranno parametri generici in quanto non possiamo sapere a quale rete il codice sarà applicato.

In particolare, nel codice di esempio, che vedete riportato nel Listato 3, dovete modificare le righe seguenti:

const char* ssid = “NOME APN”;

const char* password = “PASSWORD APN”;

inserendo al posto del testo virgolettato NOME APN il nome del vostro access point e al posto di PASSWORD APN la password (o passkey) che utilizzate per l’accesso alla rete WiFi.

Listato 3

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>



//for WiFi

#include <WiFi.h>





#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED displdfsfdfsfdsfdsfdsfdsay height, in pixels



// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library. 

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), ...

#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)

#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);



#define NUMFLAKES 10 // Number of snowflakes in the animation example



#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16



//for WiFi

const char* ssid = “NOME APN”;

const char* password = “PASSWORD APN”;

/* create a server and listen on port 8088 */

WiFiServer server(8088);



const int P_UP = 23;

const int P_DOWN = 4;

const int P_LEFT = 16;

const int P_RIGHT = 17;

const int P_OK = 5;

const int LEDV = 26;

const int LEDR = 25;





void setup() {

Serial.begin(9600);



// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally

if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {

Serial.println(F(“SSD1306 allocation failed”));

for(;;); // Don’t proceed, loop forever

}



// Show initial display buffer contents on the screen --

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds



// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(5, 30);

display.print(“ WiFi “);



// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want...rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches...





/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/

pinMode(P_UP,INPUT_PULLUP);

pinMode(P_DOWN,INPUT_PULLUP);

pinMode(P_RIGHT,INPUT_PULLUP);

pinMode(P_LEFT,INPUT_PULLUP);

pinMode(P_OK,INPUT_PULLUP);





Serial.begin(9600);

OLED_Message(“Connecting to “,ssid);

Serial.print(“Connecting to “);

Serial.println(ssid);

/* connecting to WiFi */

WiFi.begin(ssid, password);

/*wait until ESP32 connect to WiFi*/

while (WiFi.status() != WL_CONNECTED) 

{

delay(500);

Serial.print(“.”);

}

Serial.println(“”);

Serial.println(“WiFi connected with IP address: “);

String testo = WiFi.localIP().toString();

OLED_Message(“WiFi connected”,testo); 

Serial.println(WiFi.localIP());

delay(2000);

/* start Server */

server.begin();

}



void loop() 

{

/* listen for client */

WiFiClient client = server.available(); 

uint8_t data[30]; 

if (client) 

{ 

OLED_Message(“Client Connected”,””);

Serial.println(“new client”); 

display.setCursor(0, 20); 

/* check client is connected */ 

while (client.connected()) 

{ 

switch (Ctrl_Push()) 

{

case 1:

Serial.print(“Push UP”); 

client.write(“\nUP”); 

break;

case 2:

Serial.println(“Push DOWN”);

client.write(“\nDOWN”); 

break;

case 3:

Serial.println(“Push LEFT”);

client.write(“\nLEFT”); 

break;

case 4:

Serial.println(“Push RIGHT”);

client.write(“\nRIGHT”); 

break;

case 5:

Serial.println(“Push OK”);

client.write(“\nOK”); 

break;

default:

break;



}

Attendi_Push();

if (client.available()) 

{

int len = client.read(data, 30);

if(len < 30)

{

data[len] = ‘\0’; 

}else 

{

data[30] = ‘\0’;

} 

Serial.print(“client sent: “); 

Serial.println((char *)data); 

display.print((char *)data);

display.display(); 

}

} 

}

OLED_Message(“Client Disconnected”,””);

}



void OLED_Message(String text_display1, 

String text_display2)

{

int lunghezza = 0;

display.clearDisplay();

display.setTextSize(1); 

// Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(0, 0);

lunghezza = text_display1.length();

lunghezza=21-lunghezza;

lunghezza=lunghezza/2;

for (int i=0;i<lunghezza;i=i+1)

{

display.print(“ “); 

}

display.print(text_display1);

display.setCursor(0, 20);

lunghezza = text_display2.length();

lunghezza=21-lunghezza;

lunghezza=lunghezza/2;

for (int i=0;i<lunghezza;i=i+1)

{

display.print(“ “); 

}

display.print(text_display2);

display.display(); 

delay(1500);

}



int Ctrl_Push()

{

int push = 0;

if (digitalRead(P_UP)==LOW) push = 1;

if (digitalRead(P_DOWN)==LOW) push = 2;

if (digitalRead(P_LEFT)==LOW) push = 3;

if (digitalRead(P_RIGHT)==LOW) push = 4;

if (digitalRead(P_OK)==LOW) push = 5; 

return push;

}



void Attendi_Push()

{ 

while (( digitalRead(P_UP)==LOW) || 

(digitalRead(P_DOWN)==LOW) || 

(digitalRead(P_LEFT)==LOW) || 

(digitalRead(P_RIGHT)==LOW) || 

(digitalRead(P_OK)==LOW)) delay(10);

}

Scansione del bus I²C

L’ultimo esempio applicativo che proponiamo è in realtà un’utility, giacché il relativo codice permette di interrogare il bus I²C per rilevare cosa è affacciato ad esso e fornire sul display o tramite Serial Monitor l’indirizzo di tutti i dispositivi collegati ad esso.

Come vedete nel Listato 4, il codice fa uso della libreria wire.h, che permette di comunicare con i dispositivi I²C/TWI attraverso le due linee SDA (linea dati) e SCL (Serial Clock) che si trovano sia a bordo scheda, sia riportate sul connettore di espansione siglato I2C, che vale per i dispositivi connessi al bus esternamente alla scheda.

A partire da Arduino 1.0, la libreria si è allineata alle altre librerie di lettura/scrittura; per questo motivo, le funzioni send() e receive() originarie sono state sostituite con read() e write(). Le versioni recenti della libreria Wire possono utilizzare i timeout per prevenire un blocco a fronte di determinati problemi sul bus, ma questi non sono abilitati per impostazione predefinita nelle versioni correnti (si consiglia di abilitare sempre questi timeout quando si utilizza la libreria Wire). Caricate dunque l’ultima versione della libreria.

Listato 4

#include <Wire.h>





void setup()

{

Wire.begin();



Serial.begin(9600);

while (!Serial); 

Serial.println(“\nI2C Scanner”);

}





void loop()

{

byte error, address;

int nDevices;

address=0x76;



Serial.println(“Scanning...”);



nDevices = 0;

for(address = 1; address < 127; address++ )

{

// The i2c_scanner uses the return value of

// the Write.endTransmisstion to see if

// a device did acknowledge to the address.

Wire.beginTransmission(address);

error = Wire.endTransmission();



if (error == 0)

{

Serial.print(“I2C device found at address 0x”);

if (address<16)

Serial.print(“0”);

Serial.print(address,HEX);

Serial.println(“ !”);



nDevices++;

}

else if (error==4)

{

Serial.print(“Unknown error at address 0x”);

if (address<16)

Serial.print(“0”);

Serial.println(address,HEX);

} 

}

if (nDevices == 0)

Serial.println(“No I2C devices found\n”);

else

Serial.println(“done\n”);



delay(5000); // wait 5 seconds for next scan

}

Conclusioni

Bene, con questo esempio di utilizzo terminiamo la panoramica sulla demoboard ESP32, che in tre articoli vi ha presentato le possibilità di utilizzo dell’hardware, seppure non tutte quelle possibili, sia a bordo che connesso tramite i connettori dedicati. Ogni esempio è stato corredato di sketch per implementarlo e testarlo. Ora lasciamo a voi e alla vostra inventiva l’implementazioni di ulteriori applicazioni, che testerete e debuggerete sulla demoboard, per poi uscire dalla fase prototipale e realizzarle in maniera definitiva. Buon lavoro!