In questo articolo vediamo come far comunicare questi due microcontrollori sfruttando il bus I2C.
La famiglia ESP lavora a 3,3V mentre la famiglia Arduino usa i 5V, questa differenza rende complicata la comunicazione tra i due microcontrollori se non andiamo a interporre un adattatore di livelli sulla UART. Il protocollo I2C puo’ lavorare sia a 3,3 che a 5V pertanto useremo questo BUS per la comunicazione tra i due microcontrollori.
– SCHEMA ELETTRICO –
Nel caso che vedremo andremmo a settare l‘esp32 come Master mentre l’arduino nano verrà impostato come slave. Il protocollo I2C prevede che il master “interroghi” ogni singolo slave e attenda la sua risposta.
L’img1 mostra il semplicissimo schema di collegamento tra le due schede. Per il progetto useremo i pin di default I2C per entrambi ( pin21,22 per ESP e pin A4,A5) che corrispondono rispettivamente SDA linea dati e SCL clock di sincronismo. Il protocollo prevede che il bus abbia la linea SDA a livello logico alto che viene abbassato al momento della comunicazione, il master generera’ il clock (SCL). I due dispositivi devono avere in comune la massa GND.
La comunicazione tra i due device puo avvenire in due modi, nel primo il master invia una richiesta di n byte allo slave senza specificare nulla e lo slave risponde con le istruzioni contenute nella funzione specificata in .onRequest(funzione). Mentre nel secondo caso, il master invia prima dei dati allo slave il quale li elabora tramite la funzione richiamata da .onReceive(funzione) poi il master richiede i dati allo slave.
Vediamo nel dettaglio i due casi con l’ausilio di schemi e codici di esempio.
1° caso
Il master invia una richiesta di nbyte dati allo slave tramite la funzione wire.requestFrom(indirizzo, nbyte) allo slave indirizzo e poi si mette in ascolto per la risposta. Lo slave attiva la funzione onRequest() e risponde al master
– Codice –
Vediamo il codice da inserire nel master:
//ESP32 - I2C master
#include "Wire.h" //libreria I2C
void setup(){
Serial.begin(9600);
Wire.begin(); //senza valori significa che e' master
}
void loop(){
Serial.println("Avvio trasmissione...");
//contatta lo slave con indirizzo 0x1
Wire.requestFrom(1,12); //invio richiesta e mi aspetto 12 byte di risposta
while(Wire.available()){
//stampo i dati provenienti dal bus
char c = Wire.read();
Serial.print(c);
}
Serial.println("\n Ricezione completata.");
delay(2000);
}e il codice dello slave:
//arduino nano I2C slave
#include "Wire.h" //libreria I2C
int LED = 13;
int roger = 0;
void setup() {
pinMode(LED,OUTPUT);
Wire.begin(1); //inizializzo il BUS e assegno indirizzo 1
Wire.onRequest(richiestaRicevuta); //imposto la funzione da eseguire su chiamata dal master
}
//funzione richiamata su ricezione dal master
void richiestaRicevuta(){
digitalWrite(LED, HIGH); // accendo il led on board
Wire.write("HELLO WORLD!"); //invio la risposta sul bus i2c
roger = 1; // setto il roger a 1
}
void loop() {
if(roger){
int ritardo = 1000*roger; //calcolo il tempo di accensione
delay(ritardo);
digitalWrite(LED, LOW); // spengo il led on board
roger = 0; // resetto il roger
}
}I commenti inseriti nel codice sono sufficienti a capire come lavora. In pratica il Master(esp32) invia sul bus I2C una richiesta allo Slave con indirizzo 1 (arduino nano), il quale arrivata la chiamata, risponde al Master con il messaggio “HELLO WORLD!”. Il master a questo punto rimane in ascolto e riceve i 12 byte che aveva richiesto allo slave stampando i caratteri in ordine di arrivo.
2° caso
In questo caso il master invia prima dei dati verso lo slave, lo slave attiva la funzione onReceive() ed elabora i dati inviati dal master e termina. Subito dopo il master invia una richiesta dati e lo slave attiva la funzione onRequest().
Il codice da inserire nel master
//ESP32 - I2C master
#include "Wire.h" //libreria I2C
String msg ="ita";
void setup(){
Serial.begin(9600);
Wire.begin(); //senza valori significa che e' master
}
void loop() {
Serial.print("richiesto messaggio in : ");
Serial.println(msg);
//inizia la trasmissione verso lo slave 1
Wire.beginTransmission(1);
if(msg == "ita"){
Wire.write("ita");
msg="eng";
} else {
Wire.write("eng");
msg = "ita";
}
//termina la trasmissione
Wire.endTransmission();
//richiede i dati allo slave
Wire.requestFrom(1, 3);
while(Wire.available()){
char rx = Wire.read();
Serial.print(rx);
}
Serial.println();
delay(1000);
}e questo e il codice dello slave
//arduino nano I2C slave
#include "Wire.h" //libreria I2C
int LED = 13;
int roger = 0;
String rx;
void setup() {
Serial.begin(9600);
pinMode(LED,OUTPUT);
Wire.begin(1); //inizializzo il BUS e assegno indirizzo 1
Wire.onRequest(datiRichiesti); //imposto la funzione da eseguire su richiesta dati dal master
Wire.onReceive(datiRicevuti); //imposto la funzione da eseguire su invio dati dal master
}
void loop() {
delay(100);
}
void datiRicevuti(int howMany){
digitalWrite(LED, HIGH); //accendo led onboard per segnalare la ricezione della richiesta
//ricevo i dati e li inserisco in un array di caratteri
char rxbuff[3];
int i = 0;
while(Wire.available()){
rxbuff[i]=Wire.read();
i++;
}
//converto l'arrey di caratteri in una stringa
rx = String(rxbuff);
delay(500);
digitalWrite(LED, LOW); //spengo il led onboard
}
void datiRichiesti(){
if(rx == "ita"){
Wire.write("ITA");
} else {
Wire.write("ENG");
}
}Anche in questo caso i commenti al codice sono abbastanza chiari ma vediamo lo scopo dell’esempio e il flusso delle informazioni.
Il master richiede allo slave il messaggio alternativamente in lingua italiana o ingelse. Per far cio il master invia allo slave il codice della lingua del messaggio tramite la la sequenza .beginTrasmission() -> .write() -> .endTrasmission() lo slave si accorge che il master gli ha inviato dei dati e quindi innesca la funzione specificata tramite .onReceive(), riceve i dati con .read() e li imagazzina in una variabile globale chiamata rx. A questo punto il master invia una richiesta di dati allo slave il quale prima di inviagliela verifica in che lingua deve rispondere.
Conclusioni
Il bus i2c e’ molto comodo per le comunicazioni tra microprocessori, sensori e altre periferiche che si trovano vicine, infatti il bus non può superare i 2mt altrimenti potrebbero esserci problemi di affidabilità, d’altronde e’ stato studiato per lo scambio di dati su dispositivi alloggiati sulla stessa scheda. Per comunicazioni ad alto raggio ci sono altri bus ( rs485, canbus etc etc)
