Home / Italian Posts / DataLogging con Modulo ESP32

DataLogging con Modulo ESP32

Abstract : in questo Post mostriamo un esempio di utilizzo del modulo ESP32 (con la scheda di sviluppo ESP-WROOM-32) per l’acquisizione da remoto di un segnale analogico. Il modulo ESP32 offre nativamente il supporto per il WiFi ed una serie di GPIO, sia digitali che analogici, inoltre vanta un consumo molto basso e dimensioni molto contenute. Queste caratteristiche rendono il modulo ESP32 particolarmente adatto per le cosiddette applicazioni IoT (Internet of Things) dove consumi ridotti, connettività e piccole dimensioni sono particolarmente importanti.

DataLogging & IoT

La tecnologia IoT (“Internet of Thinghs” o “Internet delle cose”) sta diventando sempre più utilizzata nel mondo odierno. Naturalmente, per chi si occupa ed utilizza la tecnologia,  è evidente che non si tratta di una cosa realmente nuova : è semplicemente l’integrazione, in un unico “oggetto” piccolo e smart avente capacità computazionale, di diverse tecnologie pre-esistenti, quali il WiFi, il Bluetooth e la sensoristica. Nel frattempo sono nate numerose piattaforme hardware e software che consentono la progettazione e l’utilizzo di oggetti e servizi basati sul paradigma IoT.

Per compiti di datalogging da remoto abbiamo deciso di utilizzare un approccio IoT. Abbiamo utilizzato un modulo ESP32 che acquisisce il dato analogico tramite ADC e lo mette a disposizione su rete WiFi tramite un server web. Il server web, ad una interrogazione http, risponde restituendo il valore del dato.
Il modulo ESP32 viene acceduto da un microcomputer Raspberry Pi che ha la funzione di memorizzazione e gestione dei dati.

Lo schema sotto mostra l’architettura del sistema.

Modulo ESP32

(da https://circuits4you.com/)

ESP32-WROOM-32 è un modulo versatile e potente con interfacce Wi-Fi+BT+BLE MCU, può essere utilizzato in una vasta gamma di applicazioni, che vanno dalle reti di sensori a basso consumo fino ai compiti che richiedono maggiore potenza di calcolo come la gestione del segnale audio e la decodifica MP3.

Il “core” di questo modulo è il chip ESP32. Il chip incorporato è progettato per essere scalabile e versatile. Esistono due core della CPU che possono essere controllati individualmente e la frequenza di clock della CPU è regolabile da 80 MHz a 240 MHz. L’utente può anche spegnere la CPU e utilizzare il coprocessore a bassa potenza per monitorare costantemente le periferiche per rilevare variazioni o superamento delle soglie. ESP32 integra un ricco set di periferiche, che vanno dai sensori tattili capacitivi, sensori Hall, interfaccia per schede SD, Ethernet, SPI ad alta velocità, UART, I2S e I2C.

The chip embedded is designed to be scalable and adaptive. There are two CPU cores that can be individually controlled, and the CPU clock frequency is adjustable from 80 MHz to 240 MHz. The user may also power off the CPU and make use of the low-power co-processor to constantly monitor the peripherals for changes or crossing of thresholds. ESP32 integrates a rich set of peripherals, ranging from capacitive touch sensors, Hall sensors, SD card interface, Ethernet, high-speed SPI, UART, I2S and I2C.

L’integrazione di Bluetooth, Bluetooth LE e Wi-Fi assicura che il modulo possa essere utilizzato in una vasta gamma di applicazioni e che il modulo sia pronto per utilizzi futuri : l’uso del Wi-Fi consente la connessione diretta a Internet attraverso un router Wi-Fi, mentre l’utilizzo della interfaccia Bluetooth consente all’utente di connettere il modulo al telefono.

Le immagini seguenti mostrano il modulo con il LED di alimentazione e il LED presente a bordo già collegati al GPIO2.

ESP32 Wroom 32 DevKit ha in totale 25 GPIOs dei quali alcuni sono solo input. Il modulo è caratterizzato da un insieme di periferiche :

  • 18 canali di conversione Analog-to-Digital (ADC)
  • 10 GPIOs usabili come tasti capacitivi
  • 3 interfacce UART
  • 3 interfacce SPI
  • 2 interfacce I2C
  • 16 output PWM
  • 2 convertitori Digital-to-Analog (DAC)
  • 2 interfacce I2S

Lo schema sotto mostra il pin-out del modulo.

Hardware

Il modulo ESP32 è stato inserito in una semplice scatolina in plastica (il metallo non va bene perché schermerebbe il segnale WiFi). La scheda viene alimentata attraverso un regolatore 3,3 V quindi la tensione di alimentazione esterna può variare senza problemi da 6 a 12 V. Il pin della scheda configurato con analog input viene portato su connettore esterno BNC. L’immagine sotto mostra il modulo all’interno della scatola.

Software

Per la programmazione del modulo ESP32 si può tranquillamente utilizzare la IDE per Arduino : è sufficiente configurare la IDE caricando la tipologia di scheda ESP32 che si sta utilizzano, per i dettagli si può fare riferimento ai numerosi tutorials che si trovano in rete. Anche la programmazione è molto semplice dato che si trovano in rete numerosi esempi. In questa sede diamo soltanto alcuni dettagli sui punti più significativi del firmware che abbiamo caricato sul nostro modulo ESP32.

Nel programma definiamo una serie di variabili e costanti tra le quali nome e password della nostra rete WiFi (che possono essere poi lette da un file di configurazione), l’indirizzo IP prescelto per il nostro modulo che avrà così un IP statico, il pin del LED di stato pre-cablato sulla scheda ed il pin dell’ingresso analogico che vogliamo acquisire.

char ssid[] = WiFi_SSID;          // network name
char pass[] = WiFi_PASS;          // network password
const int LED = 2;                // built-in LED
const int analogPin = 36;         // analog pin
IPAddress local_ip(192,168,1,61); // IP Address of the shield
IPAddress gateway(192,168,1,1);   // IP Address of the gateway
IPAddress subnet(255,255,0,0);    // IP Address of the subnet

Nel setup si fa la configurazione dell’ingresso analogico in modo da sfruttare tutto il range, l’ingresso analogico viene convertito da un ADC a 12 bit quindi il risultato della conversione va da 0 a 4095, con attenuazione di 6dB il fondo scala corrisponde a 2,2V. Viene poi configurata la parte WiFi della scheda e si procede alla connessione alla rete WiFi. Sulla scheda viene poi istanziato il web server che risponderà alle nostre interrogazioni http.

void setup() {
...
analogSetPinAttenuation(analogPin,ADC_6db); // Attenuation 2, full scale 2,2V
...
// WIFI_AP : solo Access Point
// WIFI_STA : solo Client
// WIFI_AP_STA : duale, sia AP che Client, default
// WIFI_OFF : WiFi OFF
WiFi.mode(WIFI_AP_STA);
WiFi.config(local_ip, gateway, subnet);
WiFi.disconnect();
...
// Connecting to WiFi
while(status != WL_CONNECTED){
  Serial.print("Attempting to connect to SSID: ");
  Serial.println(ssid);
  // connect to WPA network
  status = WiFi.begin(ssid,pass);
  delay(5000); // delay 5 seconds
}
...
// Starting server
server.begin();
...
}

Il codice per leggere le richieste di un client che si connette al nostro server è presentato sotto. Si istanzia un oggetto client che si pone in attesa delle connessioni. Quando viene rilevata una connessione si legge la request http (nel nostro caso assolutamente banale) e si prepara la response. Nel nostro caso la response è la lettura del segnale analogico acquisito.

void loop() {
  // Listen for incoming clients
  WiFiClient client = server.available();
  if(client) {
    // get a client
    Serial.println("New client");
    // an http request ends with a blank line
    bool currentLineIsBlank = true;
    // string to hold incoming data from client
    String currentLine = "";
    while(client.connected()) {
      if(client.available()){
        // reading from the client
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          client.println("HTTP/1.1 200 OK");
          client.println("Content-type:text/html");
          client.println();

          analogSetPinAttenuation(analogPin,ADC_6db);
          int sensorReading = analogRead(analogPin);
          Serial.print("sensorReading: ");
          Serial.println(sensorReading);
          client.print("sensorReading: ");
          client.print(sensorReading);
          client.println();
          break;
        } 
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
          currentLine = "";
        } else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
          currentLine += c;
        }
      } 
    }
    // close the connection
    client.stop();
    Serial.println("Client disconnected");
  }
}

Dopo aver caricato il firmware sulla scheda è possibile interrogare il servizio http esposto dal nostro web server : è sufficiente utilizzare un comune browser ed inserire l’indirizzo IP del modulo ESP. Se tutto è andato bene il server risponderà con il valore dell’ingresso analogico acquisito, come mostrato nella immagine seguente.

Naturalmente la lettura del segnale analogico potrà avvenire anche in maniera automatizzata utilizzando ad esempio un programma python che gira su di un Raspberry connesso sulla medesima rete WiFi. In questo ultimo caso la connessione al server web e la lettura del segnale analogico viene ottenuta con un codice python simile al seguente :

#Lettura dati da server web ESP32 IP= 192.168.1.61
response = urllib.urlopen('http://192.168.1.61/')
ESP32Response = response.read()
#Lettura dati ADC da ESP32
ADC_Value0 = int(int(ESP32Response[15:])/2)

Se ti è piaciuto questo articolo puoi condividerlo sui “social” Facebook, Twitter o LinkedIn con i pulsanti presenti sotto. In questo modo ci puoi aiutare ! Grazie !

Donazioni

Se vuoi contribuire allo sviluppo di questo sito ed allo sviluppo di nuove attività sperimentali puoi fare una donazione, Grazie !

Check Also

Misurazione della Rotazione della Via Lattea

PDF Abstract : In questo post vogliamo continuare l’attività di studio della struttura della nostra …