Scheda ESP32-C3 SuperMini

L’ESP32-C3 SuperMini è una scheda di sviluppo piccola, economica e interessante, ma la documentazione è un po’ scarsa e difficile da trovare. In questo tutorial imparerai come iniziare con questa scheda.

In particolare, imparerai come installare il core ESP32, così da poter programmare la scheda tramite l’Arduino IDE. Daremo anche un’occhiata più da vicino al pinout e ti fornirò alcuni circuiti di esempio e codice con cui sperimentare.

Componenti necessari

Puoi acquistare la scheda ESP32-C3 SuperMini su AliExpress o una scheda molto simile su Amazon, dove è chiamata “ESP32-C3 Mini”. Tuttavia, la scheda Amazon ha un LED RGB, mentre quella di AliExpress ha solo un LED rosso e uno blu. Ho inserito i link di entrambe qui sotto. Ti serviranno anche un cavo USB-C e una breadboard con alcuni fili Dupont per fare delle prove.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Caratteristiche dell’ESP32-C3 SuperMini

L’ESP32-C3 SuperMini è una piccola scheda di sviluppo (22,52x18mm) per IoT, basata sull’Espressif ESP32-C3. Contiene un processore RISC-V single-core a 32 bit fino a 160 MHz e dispone di 400KB di SRAM, 384KB di ROM e una flash integrata da 4M. Il consumo energetico è piuttosto basso, con 43µA in modalità deep sleep.

ESP32C3 Datasheet

La scheda supporta i protocolli WiFi 802.11b/g/n a 2,4GHz con modalità Station, SoftAP, SoftAP+Station e modalità mista, oltre a Bluetooth 5.0.

Per quanto riguarda gli IO, la scheda offre 1 x I2C, 1 x SPI, 2 x UART, 11 x GPIO (PWM) e 4 x ADC. L’immagine qui sotto mostra il fronte e il retro della scheda:

Front and Back of ESP32-C3 SuperMini board — Fronte e retro della scheda ESP32-C3 SuperMini

Noterai che la scheda ha un pulsante BOOT e uno RST. Accanto al pulsante di reset c’è un LED di alimentazione rosso e accanto al pulsante per il bootloader c’è un LED blu programmabile collegato al GPIO 8.

Pinout

L’immagine seguente mostra il pinout della scheda, con le interfacce POWER, GPIO, I2C e SPI evidenziate:

L’alimentazione può avvenire tramite USB-C oppure fornendo 3,3-6V sul pin 5V e massa sul pin GND. BMa non collegare USB-C e 5V contemporaneamente! Nota inoltre che la scheda utilizza logica a 3,3V.

Installazione del Core ESP32

Se è il tuo primo progetto con una scheda della serie ESP32, dovrai prima installare il core ESP32. Se le schede ESP32 sono già installate nel tuo Arduino IDE, puoi saltare questa sezione.

Inizia aprendo la finestra Preferenze selezionando “Preferences…” dal menu “File”. Si aprirà la finestra Preferenze mostrata qui sotto.

Nella scheda Settings troverai una casella di testo in fondo alla finestra etichettata “Additional boards manager URLs“:

In questo campo incolla il seguente URL:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Questo permetterà all’Arduino IDE di sapere dove trovare le librerie core ESP32. Successivamente installeremo le librerie core ESP32 usando il Boards Manager.

Apri il Boards Manager tramite “Tools -> Boards -> Board Manager”. Vedrai il Boards Manager apparire nella barra laterale sinistra. Digita “ESP32” nel campo di ricerca in alto e dovresti vedere due tipi di schede ESP32; le “Arduino ESP32 Boards” e le schede “esp32 by Espressif”. Noi vogliamo le librerie esp32 by Espressif. Clicca sul INSTALL e attendi che il download e l’installazione siano completati.

Install ESP32 Core libraries — Installa le librerie Core ESP32

Selezione della scheda ESP32C3 Dev Module

Infine dobbiamo selezionare una scheda ESP32. Nel caso dell’ESP32-C3 SuperMini, scegliamo la generica “ESP32C3 Dev Module”. Per farlo, clicca sul menu a tendina e poi su “Select other board and port…”:

Drop-down Menu for Board Selection — Menu a tendina per la selezione della scheda

Si aprirà una finestra dove potrai digitare “esp32c3” nella barra di ricerca. Vedrai la scheda “ESP32C3 Dev Module” sotto Boards. Cliccaci sopra, seleziona la porta COM per attivarla e poi clicca OK:

Board Selection Dialog with ESP32C3 Dev Module — Finestra di selezione scheda con ESP32C3 Dev Module

In alternativa, potresti anche selezionare la più recente “Nologo ESP32C3 Super Mini“, se disponibile. Puoi vederla nello screenshot sopra (2 righe sotto ESP32C3 Dev Module).

Nota che devi collegare la scheda al computer tramite cavo USB prima di poter selezionare una porta COM.

Abilitare la comunicazione seriale

Per permettere la comunicazione seriale con l’ESP32-C3 SuperMini assicurati che “USB CDC On Boot” sia abilitato. Trovi questa impostazione sotto “Tools -> USB CDC On Boot”:

Enabling USB CDC On Boot — Abilitare USB CDC On Boot

Se questa impostazione è disabilitata, il Serial Monitor non funzionerà, ad esempio!

Se hai problemi a flashare la SuperMini, tieni premuto il pulsante BOOT, poi
premi il pulsante RESET, rilascia RESET e infine rilascia BOOT. Questo mette la SuperMini in modalità download. Di solito però non è necessario.

Allo stesso modo, se il programma caricato non parte dopo il download, premi e rilascia il pulsante RESET. Anche questo di solito non serve.

Esempi

In questa sezione troverai alcuni esempi di codice per testare la tua SuperMini:

Esempio di codice: Blink

Il seguente esempio è il classico programma Blink che farà lampeggiare il LED blu a bordo della SuperMini collegato al GPIO 8:

#define LED 8 // Blue LED

void setup() {
  pinMode(LED, OUTPUT);
}

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

Esempio di codice: Scansione Wi-Fi

Questo esempio dal Manual mostra come scansionare la rete Wi-Fi locale:

#include "WiFi.h"

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
}

void loop() {
  Serial.println("scan start");
  int n = WiFi.scanNetworks();
  Serial.println("scan done");
  if (n == 0) {
    Serial.println("no networks found");
  } else {
    Serial.print(n);
    Serial.println(" networks found");
    for (int i = 0; i < n; ++i) {
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
    }
    delay(10);
  }
  Serial.println("");
  delay(5000);
}

Esempio di codice: OLED su I2C

L’interfaccia I2C della SuperMini è sui pin 8 (SDA) e 9 (SCL). L’immagine qui sotto mostra come collegare un display OLED, per esempio:

e qui c’è il codice per testare il cablaggio e l’OLED. Scrive semplicemente il testo “make” sul display. Nota che dovrai installare la Adafruit_SSD1306 library.

#include "Adafruit_SSD1306.h"

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void setup() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextSize(4);
  oled.setTextColor(WHITE);
}

void loop() {
  oled.clearDisplay();
  oled.setCursor(20, 16);
  oled.print("make");
  oled.display();
  delay(1000);
}

Se vuoi collegare un LCD invece, dai un’occhiata al How to synchronize ESP32 clock with SNTP server tutorial, che sfrutta anche la capacità Wi-Fi della SuperMini.

Esempio di codice: Display E-Paper su SPI

Come esempio finale, controlleremo un display E-Paper tramite l’interfaccia SPI della SuperMini. Lo schema di collegamento qui sotto mostra come collegare un 4.2″ e-Paper Display ai pin SPI:

Connecting e-Paper to SuperMini via SPI — Collegamento e-Paper a SuperMini via SPI

Di seguito una tabella con tutte le connessioni per comodità. Nota che puoi alimentare il display con 3,3V o 5V ma le linee dati SPI devono essere a 3,3V! Per sicurezza, usa 3,3V per l’alimentazione.

Display e-Paper	ESP32-C3 SuperMini
CS/SS	7
SCL/SCK	4
SDA/DIN/MOSI	6
BUSY	1
RES/RST	2
DC	0
VCC	3.3V
GND	G

I pin hardware SPI per la SuperMini sono 5 (MISO), 6 (MOSI), 7 (CS/SS) e 4 (SCK/SCL). Gli altri pin sono liberi di essere scelti.

Prima di poter disegnare sul display e-Paper dovrai installare due librerie. La Adafruit_GFX libreria grafica, che fornisce un set comune di primitive grafiche (testo, punti, linee, cerchi, ecc.). E la GxEPD2 libreria, che fornisce il driver grafico per il display E-Paper.

Il seguente esempio di codice usa queste librerie per stampare il testo “Makerguides” sul display:

#include "GxEPD2_BW.h"

// hardware SPI
// #define MISO 5
// #define MOSI 6
// #define SCK 4

#define CS 7
#define DC 0
#define RST 2
#define BUSY 1
GxEPD2_BW<GxEPD2_420_GDEY042T81, GxEPD2_420_GDEY042T81::HEIGHT>
  epd(GxEPD2_420_GDEY042T81(CS, DC, RST, BUSY));

void setup() {
  epd.init(115200, true, 50, false);
  epd.setRotation(1);
  epd.setTextColor(GxEPD_BLACK);
  epd.setTextSize(2);
  epd.setFullWindow();

  epd.fillScreen(GxEPD_WHITE);
  epd.setCursor(90, 190);
  epd.print("Makerguides");
  epd.display();
  epd.hibernate();
}

void loop() {}

Se vuoi realizzare qualcosa di più interessante dai un’occhiata ai tutorial Monthly Calendar on E-Paper Display e Analog Clock on e-Paper Display.

Conclusioni

In questo post hai imparato come usare l’ESP32-C3 SuperMini. La SuperMini è ottima per progetti IoT che richiedono un ingombro ridotto ma anche Wi-Fi o Bluetooth. Grazie al basso consumo in deep sleep è anche una buona scheda per progetti alimentati a batteria. Il suo principale svantaggio è il numero relativamente piccolo di pin GPIO.

Buon divertimento con il tinkering ; )

Schemi

Le sezioni seguenti mostrano gli schemi per l’alimentazione, i pulsanti e i LED, e il microcontrollore della scheda ESP32-C3 SuperMini.

Alimentazione

Schematics for Power Supply — Schema dell’alimentazione

Microcontrollore

Schematics for Microcontroller — Schema del microcontrollore

Pulsanti e LED

Schematics for Buttons and LEDs — Schema di pulsanti e LED

Pin Header

Stefan Maetschke