La Wemos LOLIN C3 Pico è una piccola scheda compatibile con gli standard WiFi 802.11 e Bluetooth LE, utilizza un chip RISC-V ESP32-C3. Può essere programmata direttamente con l’IDE di Arduino o tramite MicroPython.
Indice
Descrizione
La scheda Wemos LOLIN C3 Pico con ESP-32 appartiene alla serie delle schede C3 prodotte da Wemos LOLIN ed è un’evoluzione della C3 mini.
E’ poi un’evoluzione delle schede Wemos D1 mini il cui primo modello risale a 2015. A tal proposito vedere i precedenti articoli:
La scheda Wemos LOLIN C3 Pico è una piccola scheda, misura solo 25,4 × 25,4 mm, pari ad un 1″ quadrato. Basata sull’ESP32-C3 RISC-V, dispone di connettività WiFi a 2,4 GHz e Bluetooth Low Energy, alcuni I/O.
E’ dotata on-boar del supporto per batteria Li-Po, inclusi i circuiti di ricarica.
Sul PCB sono inoltre presenti un LED RGB e un connettore I2C per collegare display o sensori.
La LOLIN C3 Pico con ESP-32-C3 offre 4MByte di memoria Flash, 11 pin digitali di I/O che supportano PWM, I2C e One-Wire (tranne D0) tutti funzionanti con una tensione massima di 3,3Vcc e 1 ingresso analogico (max 3,2Vcc).
Pagina originale del produttore C3 Pico — WEMOS documentation
Specifiche tecniche
- SoC – Espressif Systems Microcontrollore RISC-V (RV32IMC) single-core a 32 bit di Espressif Systems ESP32-C3FH4 fino a 160 MHz (datasheet);
- 400 KB di SRAM e 4 MB di Flash;
- Connettività – WiFi 4 a 2,4 GHz e Bluetooth 5.0 LE (nel SoC);
- Header di espansione: 2 connettori a 8 pin con un massimo di 12 GPIO;
- ADC, I2C, SPI, UART (tensione I/O 3,3 V);
- Porta LOLIN I2C;
- USB – 1x USB di tipo C per alimentazione e programmazione a 5 V;
- Connettore JST a 2 pin per batteria Li-Po e supporto per la ricarica da 500 mA;
- Alimentazione elettrica: 5 V tramite porta USB-C o pin VIN, batteria tramite Connettore JST
- Varie – Pulsante di ripristino e pulsante utente, LED RGB, led batteria in carica;
- Dimensioni – 25,4 x 25,4 mm
- Peso: 2,6 grammi
Schema elettrico
Scarica schema elettrico in PDF
Lo schema elettrico della scheda Wemos LOLIN C3 Pico è basato sul chip ESP32-C3 ed è suddiviso in vari blocchi, tra i principali troviamo : ESP32-C3 Core, Power, Battery.
ESP8266 Core
- Processore singolo-core RISC-V a 32 bit, fino a 160 MHz ESP32-C3 (Datasheet).
- Punteggio CoreMark®:
1 core a 160 MHz: 407.22 CoreMark; 2.55 CoreMark/MHz - 384 KB ROM
- 400 KB SRAM (16 KB per la cache)
- 8 KB SRAM in RTC
- Flash integrata (vedere dettagli nel Capitolo 1 Confronto Serie ESP32-C3)
- Interfacce SPI, Dual SPI, Quad SPI, e QPI che permettono il collegamento a molteplici flash esterne
- Accesso alla flash accelerato dalla cache
- Supporta la Programmazione in-Circuit della flash (ICP)
Power
Per ridurre la tensione in ingresso da USB o batteria alla tensione di funzionamento della scheda di 3.3V. Viene utilizzato il chip ME6211c33 High Speed LDO Regulators, High PSRR, Low noise (Datasheet).
Circuito di carica batteria
Sulla scheda è anche presente il circuito che permette di caricare la batteria collegata, basata sul chip TP4054 (datasheet). Connettore della batteria: porta batteria PH-2.0 con ricarica da 500mA.
Nel circuito sono visibili due Jumper JP1 e JP2.
- JP1 VBAT: Il ponticello, se cortocircuitato permette di monitorare la tensione della batteria collegata al modulo. Sul circuito è presente un partitore in modo da non superare la tensione di 3.2V massima per il pin IO3.
- JP2 LED: Il ponticello, se cortocircuitato permette di abilitare un led che mostra quando la batteria è in carica.
Connettore batteria
Interfaccia I2C
L’ESP32-C3 non ha pin I2C dedicati. Tuttavia, è possibile implementare I2C basato su software (bit-banging) utilizzando qualsiasi pin GPIO disponibile. La scheda dispone di uno speciale connettore I2C JST SH, con passo di 1mm, per collegare display sensori.
- SDA => IO8
- SCL => IO10
Interfaccia SPI
Per il collegamento SPI , Master e Slave sono collegati da tre fili di dati, solitamente chiamati MISO (Master In, Slave Out), MOSI (Master Out, Slave In) e M-CLK.
- M-CLK => IO1
- MISO => IO0
- MOSI => IO4
- (SPI Bus SS (CS) è IO5
LED RGB
Sulla scheda è presente un piccolo led RGB tipo WS2812B pilotato dal IO7
Pinout Completo
| N° | PIN | Funzione | ESP-32 C3 |
|---|---|---|---|
| 1 | EN | EN /reset | CHIP_EN |
| 2 | 3 | IO-MISO, (battery) | GPIO3 |
| 3 | 2 | IO-SCK | GPIO2 |
| 4 | 1 | ADC-1 | GPIO1 |
| 5 | 0 | ADC-0 | GPIO0 |
| 6 | 4 | IO-MOSI | GPIO4 |
| 7 | 5 | IO-SS | GPIO5 |
| 8 | 3V | 3.3V | 3.3V |
| 1 | TX | TXD | GPIO20 |
| 2 | RX | RXD | GPIO21 |
| 3 | 10 | IO-SCL | GPIO10 |
| 4 | 8 | IO-SDA | GPIO8 |
| 5 | 7 | RGB-LED | GPIO7 |
| 6 | 6 | IO-SS | GPIO6 |
| 7 | GND | Ground | GND |
| 8 | V | VIN (BAT o VBUS) |
Dove trovare il modulo
Il modulo Wemos LOLIN C3 Pico, con ESP-32-C3 può essere acquistato direttamente dal produttore LOLIN Official Store presso AliExpress.
La scheda Wemos LOLIN C3 Pico viene fornita con due connettori maschi da saldare a vostra cura. Vi permetterà di utilizzare diversi piccoli shield che si innestano sull’unità principale e permettono di ampliare notevolmente le capacità di connessione con il mondo esterno.
Tra l’altro la piedinatura è simile ai moduli Wemos D1 mini, per cui molti si potranno utilizzare con qualche aggiustamento del codice anche con questa scheda.
Gestione del modulo da parte dell’IDE
Installazione del pacchetto EPS32
Per prima cosa abbiamo bisogno del pacchetto ESP32 nell’IDE di Arduino. Quindi si dovrà aprire l’IDE di Arduino e andare su File -> Preferenze.
Immettere il seguente indirizzo nelle impostazioni predefinite: https://dl/package_esp32_dev_index.json
Confermare poi con OK .
Ora si vai su Strumenti -> Gestore schede e cercare “ESP32”
Una volta installato il pacchetto, i modelli ESP32 saranno disponibili nell’IDE di Arduino.
Come caricare uno Sketch con l’IDE Arduino
Impostazione corretta della scheda
Per caricare il proprio sketch occorre selezionare la scheda giusta per Wemos LOLIN C3 Pico selezioneremo nel gruppo esp32 la LOLIN C3 Mini
NOTE
Nelle impostazioni della scheda presenti nella cartella relativa alla scheda “lolin_c3_mini” (file pins_arduino.h) sono visibili le impostazioni dei pin della scheda. Sotto le impostazioni presenti
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
#ifndef Pins_Arduino_h #define Pins_Arduino_h #include <stdint.h> static const uint8_t LED_BUILTIN = 7; #define BUILTIN_LED LED_BUILTIN // backward compatibility #define LED_BUILTIN LED_BUILTIN // allow testing #ifdef LED_BUILTIN static const uint8_t TX = 21; static const uint8_t RX = 20; static const uint8_t SDA = 8; static const uint8_t SCL = 10; static const uint8_t SS = 5; static const uint8_t MOSI = 4; static const uint8_t MISO = 3; static const uint8_t SCK = 2; static const uint8_t A0 = 0; static const uint8_t A1 = 1; static const uint8_t A2 = 2; static const uint8_t A3 = 3; static const uint8_t A4 = 4; static const uint8_t A5 = 5; #endif /* Pins_Arduino_h */ |
Come è riportato è presente anche l’impostazione del BUILTIN_LED, collegato al pin 7. Il led in questione è di tipo RGB, per cui il normale sketch “blink” non funzionerà.
Sotto la versione modificata che permette il lampeggio del led RGB di colore Rosso.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
/* Blink modificato */ #include <Adafruit_NeoPixel.h> void setup() { // inizializza il pin digitale LED_BUILTIN come uscita. pinMode(LED_BUILTIN, OUTPUT); } Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, LED_BUILTIN, NEO_GRB + NEO_KHZ800); void loop() { pixels.setPixelColor(0, pixels.Color(0, 255, 0)); //Accende il led di rossp pixels.show(); delay(1000); // aspetta un secondo. pixels.setPixelColor(0, pixels.Color(0, 0, 0)); //Spegne il led pixels.show(); delay(1000); // aspetta un secondo. } |
Mettere la scheda in modalità Device Firmware Upgrade (DFU)
Prima di poter caricare il proprio sketch occorre mettere il Wemos LOLIN C3 Pico mini in modalità Aggiornamento Firmware (DFU). Questo deve essere fatto prima di ogni caricamento di sketch
- Tenere premuto il pulsante 9
- Premere il pulsante RST
- Rilasciare il pulsante 9 quando si sente il segnale di connessione USB
Nel caso la procedura non andasse a buon fine occorrerà ripetere la procedura. Se l’operazione è andata a buon fine potrebbe essere necessario premere il pulsante di reset (RST) per far partire il programma.
Test di prova per riconoscimento Reti Wi-Fi
Per verificare che scheda Wemos LOLIN C3 Pico riconosca le reti Wi-Fi presenti si potrà ricorrere al programma disponibile nell’IDE e che si trova File -> Esempi -> ESP32 -> WiFiScan, sotto un’esempio di output.
Test del modulo
Gestione display RGB
Verificheremo la gestione del display RGB tipo WS2812B pilotato dal GPIO7 presente sulla scheda Wemos LOLIN C3 Pico.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
/* Wemos LOLIN C3 Pico Gestione LED RGB */ #include <Adafruit_NeoPixel.h> #define PIN 7 // pin per gestione led RGB // Quando configuriamo la libreria NeoPixel, gli diciamo quanti pixel // e quale pin usare per inviare segnali. Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, PIN, NEO_GRB + NEO_KHZ800); void setup() { pixels.begin(); // Si inizializza la libreria NeoPixel. } void loop() { pixels.setPixelColor(0, pixels.Color(255, 0, 0)); //Colore rosso pixels.show(); delay(1000); pixels.setPixelColor(0, pixels.Color(0, 255, 0)); //Colore verde pixels.show(); delay(1000); pixels.setPixelColor(0, pixels.Color(0, 0, 255)); //Colore blu pixels.show(); delay(1000); } |
Visualizzazione sui display OLED
Per il test si è utilizzata la scheda Wemos LOLIN C3 Pico collegato al Display OLED Shield V2.1.0
Materiale utilizzato
Per il collegamento tra la scheda Wemos LOLIN C3 Pico e il modulo Display OLED Shield V2.1.0 si è utilizzata una dual base già utilizzata per gli altri moduli Shield, questa risulta compatibile anche con la nuova scheda.
Scheda Wemos LOLIN C3 Pico |
 |
 |
Schema dei collegamenti
Foto del display OLED gestito Wemos LOLIN C3 Pico
Programma utilizzato
Sotto è riportato il codice utilizzato, per quanto riguarda le librerie di gestione del display, vedere l’articolo OLED Shield V2.1.0 – Wemos D1 mini.
Il programma si limita a scrivere un messaggio sul display
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
/* Test PICO C3 con OLED */ #include <Wire.h> #include <Adafruit_SSD1306.h> // Libreria OLED #define OLED_RESET -1 Adafruit_SSD1306 display(OLED_RESET); void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //I2C Address 0x3C display.clearDisplay(); display.setTextSize(1); display.setTextColor(WHITE); display.setCursor(10, 0); display.println("C3 PICO"); display.setCursor(20, 12); display.println("TEST"); display.setCursor(10, 24); display.println("DISPLAY"); display.setCursor(5, 36); display.print("ADRIROBOT"); display.display(); } void loop() { } |
Utilizzi del Wemos LOLIN C3 Pico con ESP32-C3
Gestione di un display 135×240 con interfaccia SPI a 4 fili.
Wemos D1 mini – Raccolta Shield disponibili
Per la scheda Wemos D1 mini e C3 Pico sono disponibili vari shield che appartengono a varie categorie: Display & Interactive Shield, Environment, Power, Control, Others.
Per l’elenco vedere articolo Wemos D1 mini – Raccolta Shield disponibili
