Scheda di sviluppo ESP32, CH340C, 30P, USB-C, WiFi e Bluetooth

La scheda di sviluppo ESP32-WROOM-32D con CH340C e USB-C è una piattaforma completa, con processore, WiFi e Bluetooth integrati, quindi questo tutorial usa la scheda stessa, senza nessun'altra scheda di sviluppo in aggiunta. Lo scopo è metterla in funzione per la prima volta e verificare che il radio WiFi funzioni correttamente, avviando un punto di accesso a cui si può collegare un telefono o un laptop.

Come funziona:

Il modulo ESP32-WROOM-32D può funzionare come punto di accesso WiFi (Access Point), creando una propria rete senza router, a cui altri dispositivi possono collegarsi direttamente. In questa modalità la scheda assegna automaticamente l'indirizzo IP 192.168.4.1 al proprio server web, e qualsiasi telefono o laptop collegato alla rete creata può aprire questo indirizzo in un browser per vedere una pagina generata dalla scheda. La funzione esp_wifi_ap_get_sta_list legge dal driver WiFi la lista dei client collegati e la potenza del segnale ricevuto da ciascuno, espressa in dBm, un valore tipico essendo tra -40 dBm (segnale forte, vicino alla scheda) e -80 dBm (segnale debole, a distanza maggiore). Il test legge anche il motivo dell'ultimo riavvio della scheda, utile per osservare se l'alimentatore è troppo debole, caso in cui appare il messaggio di brownout.

Cosa ti serve:

• 1 x Scheda di Sviluppo ESP32, CH340C, 30P, USB-C, WiFi e Bluetooth
• 1 x Cavo dati Smart Charge, USB a USB-C, Fast Charging
• 1 x Alimentatore 5V 1A USB

Collegamento:

Per questo test non si collega nessun sensore o modulo esterno, la scheda usa solo il radio WiFi integrato. L'unico collegamento necessario è l'alimentazione e il collegamento dati tramite la porta USB-C, verso il computer per la programmazione oppure verso un alimentatore da 5V per il funzionamento indipendente.

Scheda e librerie:

Nell'Arduino IDE selezionate da Tools - Board la scheda ESP32 Dev Module, fornita dal pacchetto esp32 di Espressif Systems, installato da Boards Manager. Se il pacchetto non appare nella lista, aggiungete in File - Preferences, alla voce Additional Boards Manager URLs, l'indirizzo https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json e cercate poi esp32 in Boards Manager. Il codice qui sotto non ha bisogno di nessuna libreria installata manualmente, usa solo WiFi.h e WebServer.h, incluse automaticamente dal pacchetto esp32 per Arduino.

Il codice:

Il programma avvia la scheda in modalità Access Point, esegue un piccolo server web all'indirizzo 192.168.4.1 e mostra sul monitor seriale lo stato delle connessioni e il motivo dell'ultimo riavvio.

/*
  ESP32-WROOM-32D 30-pin DevKit (CH340C, USB-C) - WiFi Access Point test
  Board: "ESP32 Dev Module" (installed from Boards Manager, package "esp32" by Espressif Systems)
  Additional Boards Manager URL (File > Preferences):
  https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  Libraries: none to install, WiFi.h and WebServer.h are included with the esp32 Arduino core
  Wiring: none, this test only uses the onboard WiFi radio of the ESP32-WROOM-32D module
  Power and programming through the onboard USB Type-C connector (use a good cable, or a 5V/1A supply)
  Usage: connect a phone or laptop to the "ESP32-TEST" WiFi network (password 12345678)
  then open a browser at http://192.168.4.1
*/
#include <WiFi.h>
#include <WebServer.h>
#include "esp_wifi.h"
const char* apSsid = "ESP32-TEST";
const char* apPassword = "12345678";   // Minimum 8 characters
const int apChannel = 6;               // Fixed 2.4 GHz channel
WebServer server(80);
unsigned long lastReport = 0;
// Text for the reason of the last reset (shows if the board restarted because of a weak power supply)
const char* resetReasonText(esp_reset_reason_t reason) {
  switch (reason) {
    case ESP_RST_POWERON:  return "Power on / EN button";
    case ESP_RST_SW:       return "Software reset";
    case ESP_RST_PANIC:    return "Crash (panic)";
    case ESP_RST_BROWNOUT: return "BROWNOUT - power supply too weak";
    case ESP_RST_INT_WDT:
    case ESP_RST_TASK_WDT:
    case ESP_RST_WDT:      return "Watchdog";
    default:               return "Other";
  }
}
// List of connected clients with the signal strength received by the ESP32 from each one
String stationReport() {
  wifi_sta_list_t list;
  if (esp_wifi_ap_get_sta_list(&list) != ESP_OK || list.num == 0) {
    return "No clients connected\n";
  }
  String out;
  for (int i = 0; i < list.num; i++) {
    char line[80];
    snprintf(line, sizeof(line), "Client %d: %02X:%02X:%02X:%02X:%02X:%02X  RSSI: %d dBm\n",
             i + 1,
             list.sta[i].mac[0], list.sta[i].mac[1], list.sta[i].mac[2],
             list.sta[i].mac[3], list.sta[i].mac[4], list.sta[i].mac[5],
             list.sta[i].rssi);
    out += line;
  }
  return out;
}
// Web page served at http://192.168.4.1, refreshes every 2 seconds
void handleRoot() {
  String page = "<!DOCTYPE html><html><head><meta http-equiv='refresh' content='2'>";
  page += "<title>ESP32 AP test</title></head><body>";
  page += "<h2>ESP32 AP test - OK</h2>";
  page += "<p>Signal received by the ESP32 from each client:</p><pre>";
  page += stationReport();
  page += "</pre><p>Uptime: ";
  page += String(millis() / 1000);
  page += " s</p></body></html>";
  server.send(200, "text/html", page);
}
void setup() {
  Serial.begin(115200);     // Start serial communication at 115200 baud
  delay(1000);
  Serial.println();
  Serial.println("ESP32-WROOM-32D WiFi Access Point test starting...");
  Serial.print("Last reset reason: ");
  Serial.println(resetReasonText(esp_reset_reason()));
  WiFi.mode(WIFI_AP);
  bool ok = WiFi.softAP(apSsid, apPassword, apChannel);
  if (!ok) {
    Serial.println("ERROR: softAP() failed to start, check power supply");
  }
  IPAddress ip = WiFi.softAPIP();
  Serial.print("Access Point \"");
  Serial.print(apSsid);
  Serial.print("\" started, IP address: ");
  Serial.println(ip);
  server.on("/", handleRoot);
  server.begin();
  Serial.println("Web server started, connect a phone and open http://192.168.4.1");
}
void loop() {
  server.handleClient();
  // Print a short status line every 5 seconds, useful to spot brownouts
  if (millis() - lastReport > 5000) {
    lastReport = millis();
    Serial.print("Uptime: ");
    Serial.print(millis() / 1000);
    Serial.print(" s  Free heap: ");
    Serial.print(ESP.getFreeHeap());
    Serial.println(" bytes");
  }
}

Come funziona il codice:

Nella sezione delle definizioni, apSsid e apPassword stabiliscono il nome e la password della rete creata dalla scheda, mentre apChannel fissa il canale WiFi a 2.4 GHz usato dal punto di accesso. L'oggetto server, di tipo WebServer, gestisce le richieste ricevute sulla porta 80. La funzione resetReasonText traduce il codice interno dell'ultimo riavvio in un testo facile da leggere, incluso l'avviso di brownout quando l'alimentatore è troppo debole. La funzione stationReport interroga la lista dei client collegati tramite esp_wifi_ap_get_sta_list e costruisce un testo con l'indirizzo MAC e la potenza del segnale (RSSI) per ogni client. La funzione handleRoot costruisce la pagina HTML inviata al browser, includendo il report dei client e il tempo di funzionamento. Nel setup, la scheda avvia la comunicazione seriale, mostra il motivo dell'ultimo riavvio, attiva la modalità WIFI_AP, avvia il punto di accesso con WiFi.softAP e poi il server web con server.begin. Nel loop, server.handleClient elabora le richieste ricevute, e ogni 5 secondi la scheda mostra sul monitor seriale il tempo di funzionamento e la memoria RAM libera, utile per osservare eventuali problemi di alimentazione.

Risultato:

Aprite il monitor seriale a 115200 baud, vedrete il messaggio di avvio, l'indirizzo IP del punto di accesso e poi un report ogni 5 secondi. Collegate un telefono alla rete ESP32-TEST con la password 12345678 e aprite nel browser l'indirizzo 192.168.4.1, la pagina deve mostrare il messaggio di conferma e la potenza del segnale ricevuto dalla scheda dal telefono.

ESP32-WROOM-32D WiFi Access Point test starting...
Last reset reason: Power on / EN button
Access Point "ESP32-TEST" started, IP address: 192.168.4.1
Web server started, connect a phone and open http://192.168.4.1
Uptime: 5 s  Free heap: 212340 bytes
Uptime: 10 s  Free heap: 211980 bytes
Client 1: A4:C1:38:5E:2F:9B  RSSI: -52 dBm
Uptime: 15 s  Free heap: 211980 bytes
Uptime: 20 s  Free heap: 211976 bytes

Problemi frequenti:

Non appare niente sul monitor seriale: verificate di aver selezionato la porta COM corretta e la velocità di 115200 baud, e se la porta non appare per niente, installate il driver CH340C per il sistema operativo usato.

Il caricamento del programma fallisce o si blocca all'inizio: tenete premuto il pulsante BOOT esattamente nel momento in cui l'Arduino IDE inizia l'upload, poi rilasciatelo dopo qualche secondo, oppure usate un cavo USB-C con fili dati, non solo di ricarica.

La scheda si resetta da sola o mostra il messaggio di brownout esattamente quando si avvia il WiFi: la causa quasi certa è un alimentatore o un cavo USB che non riesce a fornire il picco di corrente fino a 500 mA, provate un'altra porta USB sul retro del computer o un alimentatore separato da 5V 1A.

Il punto di accesso ESP32-TEST non appare nella lista delle reti WiFi del telefono: aspettate qualche secondo dopo l'avvio, verificate che il telefono cerchi reti sulla banda a 2.4 GHz e che la scheda non si sia resettata a causa dell'alimentazione debole.

La pagina all'indirizzo 192.168.4.1 non si carica anche se il telefono è collegato alla rete: disattivate temporaneamente i dati mobili del telefono, perché alcuni telefoni cercano di usare internet invece della rete locale creata dalla scheda.

Limiti e consigli:

La scheda funziona solo a tensioni di 3.3V su tutti i pin dati, e applicare 5V direttamente su un pin GPIO può distruggere il modulo ESP32, usate convertitori di livello logico per sensori o moduli a 5V. La memoria flash da 4 MB e i 520 KB di SRAM sono sufficienti per la maggior parte dei progetti IoT, ma le applicazioni che combinano WiFi, Bluetooth e elaborazione grafica intensa possono arrivare al limite della memoria RAM disponibile. Partendo da questo test, la scheda può essere estesa con sensori su I2C o SPI, moduli relè per automazioni, oppure può inviare dati verso un server cloud tramite WiFi, usando la stessa rete locale invece della modalità Access Point.