Le Seeed Studio XIAO ESP32-S3 est une petite carte microcontrôleur conçue pour les applications embarquées et IoT. Elle fait partie de la série XIAO, qui se concentre sur des cartes très compactes avec une forte capacité de traitement. La carte mesure seulement environ 21 × 17,8 mm, ce qui la rend adaptée aux designs avec contraintes d’espace.
Elle est basée sur la puce ESP32-S3 avec un processeur dual-core Xtensa LX7 fonctionnant jusqu’à 240 MHz. La carte intègre le Wi-Fi et le Bluetooth Low Energy, permettant une communication sans fil sans matériel supplémentaire. Elle offre également une mémoire flash et PSRAM intégrées, supportant des applications avancées comme l’IA en périphérie et le traitement de données.
La gestion de l’alimentation est une caractéristique importante de cette carte. Elle supporte la charge de batterie et propose des modes basse consommation pour des designs économes en énergie. Cela la rend adaptée aux projets portables et alimentés par batterie.
Dans ce tutoriel, vous apprendrez comment programmer le XIAO ESP32-S3 avec l’IDE Arduino.
Où acheter
Vous pouvez vous procurer le XIAO ESP32-S3 chez Seeed Studio ou Amazon. Vous aurez également besoin d’un câble USB-C, si vous n’en possédez pas déjà un. Un petit dissipateur thermique peut aussi être nécessaire si vous exécutez des calculs intensifs sur la carte.
XIAO ESP32-S3
Câble USB C
Petit dissipateur 9×9 mm
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.
Caractéristiques de la carte XIAO ESP32-S3
Le XIAO ESP32-S3 est construit autour du système sur puce ESP32-S3R8. Il utilise un processeur dual-core Xtensa LX7 avec une architecture 32 bits. Le CPU peut fonctionner à une fréquence allant jusqu’à 240 MHz. La photo ci-dessous montre le recto et le verso de la carte :
La puce offre 8 Mo de mémoire flash et 8 Mo de PSRAM. Cette mémoire étendue permet l’exécution de firmwares plus complexes et supporte la mise en tampon pour des applications gourmandes en données comme le traitement audio ou d’image.
L’ESP32-S3 inclut aussi un support matériel pour les instructions vectorielles. Cela améliore les performances pour le traitement du signal et l’inférence de réseaux neuronaux.
Connectivité sans fil
La carte intègre un sous-système Wi-Fi complet à 2,4 GHz. Elle supporte les standards IEEE 802.11 b/g/n pour la communication réseau. Le module Wi-Fi est intégré à la puce et ne nécessite pas de composants externes à part une antenne pour une meilleure réception. La photo ci-dessous montre le XIAO ESP32-S3 avec l’antenne externe attachée.
Le Bluetooth Low Energy 5.0 est également supporté. Cela permet une communication basse consommation avec des capteurs, smartphones et autres appareils BLE. La puce peut aussi fonctionner en mode Bluetooth Mesh pour des réseaux IoT distribués.
GPIO et interfaces périphériques
Le XIAO ESP32-S3 expose plusieurs interfaces numériques et analogiques. Il offre jusqu’à 11 broches GPIO avec capacité PWM. Il inclut aussi jusqu’à 9 canaux ADC pour l’entrée analogique. L’image suivante montre le brochage du XIAO ESP32-S3 :
La carte supporte les protocoles de communication courants. Ceux-ci incluent UART, I2C et SPI. L’ESP32-S3 utilise une matrice GPIO flexible, permettant de mapper la plupart des fonctions périphériques sur différentes broches.
Des broches dédiées sont disponibles pour la communication I2C avec les signaux SDA et SCL. Les signaux SPI incluent clock, MOSI et MISO. L’UART est disponible pour la communication série et le débogage.
Parmi les fonctionnalités supplémentaires, on trouve une LED utilisateur et une LED d’état de charge. Il y a aussi des boutons reset et boot pour le contrôle du firmware et le flashage.
USB et intégration système
L’ESP32-S3 inclut un support USB natif. La carte XIAO utilise un connecteur USB-C pour l’alimentation, la programmation et le transfert de données. L’interface USB est directement connectée au microcontrôleur. Elle ne nécessite pas de convertisseur USB-série externe.
La puce supporte la fonctionnalité USB OTG. Cela lui permet de fonctionner à la fois comme périphérique USB et comme hôte USB. Cette fonctionnalité permet des applications telles que les périphériques USB HID ou la journalisation de données sur un stockage externe.
Gestion de l’alimentation
La carte supporte l’alimentation par USB et par batterie. Un circuit de charge intégré permet de charger une batterie lithium 3,7 V. Cela permet un fonctionnement autonome sans matériel de gestion d’alimentation externe.
La tension de fonctionnement est typiquement de 3,3 V. Le régulateur embarqué fournit une alimentation stable pour le microcontrôleur et les périphériques.
L’ESP32-S3 supporte plusieurs modes d’économie d’énergie. Ceux-ci incluent modem sleep, light sleep et deep sleep. Le tableau ci-dessous montre la consommation de courant de l’ESP32-S3 selon les différents modes :
| Mode | Courant typique (puce) | Unité | Description |
|---|---|---|---|
| Modem Sleep | ~10,5 – 90 | mA | CPU actif, Wi-Fi désactivé |
| Light Sleep | ~240 – 750 | µA | CPU en pause, mémoire conservée |
| Deep Sleep | ~7 – 25 | µA | RTC actif, majorité du système hors tension |
Ces valeurs représentent la consommation de la puce ESP32-S3 elle-même. La carte XIAO ESP32-S3 consommera généralement un peu plus à cause du matériel embarqué.
Spécifications techniques
Le tableau suivant résume les caractéristiques techniques du XIAO ESP32-S3 :
| Paramètre | Spécification |
|---|---|
| Microcontrôleur | ESP32-S3R8 (Xtensa LX7 dual-core) |
| Fréquence CPU | Jusqu’à 240 MHz |
| Architecture | 32 bits |
| Mémoire Flash | 8 Mo |
| PSRAM | 8 Mo |
| Sans fil | Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0 |
| USB | USB-C, USB OTG natif |
| Broches GPIO | Jusqu’à 11 |
| Canaux ADC | Jusqu’à 9 |
| Interfaces de communication | UART, I2C, SPI |
| Tension de fonctionnement | 3,3 V |
| Alimentation | USB-C ou batterie LiPo 3,7 V |
| Fonctionnalités d’alimentation | Charge de batterie, support du deep sleep |
| Dimensions | ~21 × 17,8 mm |
| Fonctionnalités supplémentaires | LED utilisateur, LED de charge, boutons reset et boot |
Comparaison du XIAO ESP32-S3 avec d’autres cartes ESP32 populaires
L’écosystème ESP32 a beaucoup évolué, et choisir la bonne carte peut être déroutant. Le tableau ci-dessous compare les options les plus populaires, incluant la série compacte XIAO et les cartes ESP32 classiques.
| Caractéristique | XIAO ESP32-S3 | XIAO ESP32-S3 Plus | XIAO ESP32-S3 Sense | ESP32-C5 | ESP32 DevKit | ESP32-CAM |
|---|---|---|---|---|---|---|
| MCU | ESP32-S3 | ESP32-S3 | ESP32-S3 | ESP32-C5 | ESP32 | ESP32 |
| CPU | Dual-core LX7 | Dual-core LX7 | Dual-core LX7 | RISC-V | Dual-core LX6 | Dual-core LX6 |
| Fréquence d’horloge | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz |
| Accélération IA | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| PSRAM | 8 Mo | Jusqu’à 8 Mo+ | 8 Mo | ❌ | Optionnel | 4 Mo |
| Flash | 8–16 Mo | Jusqu’à 16 Mo+ | 8–16 Mo | Externe | 4–16 Mo | 4 Mo |
| Wi-Fi | 2,4 GHz | 2,4 GHz | 2,4 GHz | Wi-Fi 6 (2,4 + 5 GHz) | 2,4 GHz | 2,4 GHz |
| Bluetooth | BLE 5 | BLE 5 | BLE 5 | BLE 5.3 | Classique + BLE | Classique + BLE |
| USB | USB natif | USB natif | USB natif | Dépend de la carte | Puces UART | Non |
| Caméra | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ |
| Microphone | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| Format | Ultra compact | Compact | Compact + extension | Variable | Grand | Module |
| GPIO | Limité | Modéré | Limité | Modéré | Élevé | Très limité |
| Cas d’usage idéal | IoT compact | Projets d’extension | IA / Vision | IoT Wi-Fi 6 | Prototypage général | Streaming caméra |
Quelle carte choisir ?
- XIAO ESP32-S3: Meilleur équilibre entre taille, performance et fonctionnalités pour la plupart des projets IoT.
- XIAO ESP32-S3 Plus: Bon choix si vous avez besoin de plus d’options d’extension et de flexibilité.
- XIAO ESP32-S3 Sense: Idéal pour les projets IA, caméra et audio (reconnaissance faciale, détection d’objets).
- ESP32-C5: Meilleur pour les applications sans fil modernes avec Wi-Fi 6 et support 5 GHz.
- ESP32 DevKit : Parfait pour les débutants et le prototypage sur breadboard avec un accès maximal aux GPIO.
- ESP32-CAM: Option économique pour des projets simples de streaming caméra, mais plus limité.
Un des avantages les plus sous-estimés de l’ESP32-S3 est sa capacité USB native. Contrairement aux cartes ESP32 classiques qui utilisent une puce UART externe pour la communication, le S3 peut s’interfacer directement via USB. Cela permet des fonctionnalités puissantes comme l’USB HID (permettant à la carte de se comporter comme un clavier ou une souris) et la communication série CDC native sans matériel supplémentaire.
Notez aussi l’importance de la PSRAM pour les applications qui manipulent des flux de données volumineux ou continus, comme le traitement audio, la capture vidéo et les charges de travail IA. Ces cas d’usage dépassent rapidement la SRAM interne limitée des microcontrôleurs classiques. En pratique, la PSRAM fait souvent la différence entre un projet qui fonctionne à peine et un projet fiable.
Si vous démarrez un nouveau projet en 2026, la famille ESP32-S3 est généralement le meilleur choix grâce au support USB natif et à l’accélération IA. Les cartes ESP32 classiques restent utiles, mais surtout pour des projets sensibles au coût ou hérités qui ne nécessitent pas les nouvelles fonctionnalités de l’ESP32-S3.
Installer le Core ESP32
Si vous souhaitez utiliser l’IDE Arduino pour programmer la carte, vous devez d’abord installer le Core ESP32 pour activer le support des cartes ESP32 dans l’IDE Arduino. Ouvrez votre Arduino IDE et suivez les étapes décrites ci-dessous. En cas de problème, vous pouvez trouver des instructions plus détaillées dans notre tutoriel Install ESP32 core in Arduino IDE.
URLs supplémentaires pour le gestionnaire de cartes
Commencez par ouvrir la boîte de dialogue Préférences en sélectionnant « Preferences… » dans le menu « File » :
Cela ouvrira la boîte de dialogue Préférences affichée ci-dessous. Sous l’onglet Settings, vous trouverez un champ d’édition en bas de la fenêtre intitulé « Additional boards manager URLs » :
Dans ce champ, copiez l’URL suivante : « https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json«
Cela permettra à l’IDE Arduino de savoir où trouver les bibliothèques du core ESP32. Ensuite, nous allons installer les bibliothèques du core ESP32 via le Boards Manager.
Gestionnaire de cartes
Ouvrez le BOARDS MANAGER en cliquant sur l’icône de la carte dans la barre latérale de l’IDE Arduino :
Le BOARDS MANAGER apparaîtra à droite de la barre latérale. Tapez « ESP32 » dans le champ de recherche en haut et vous verrez deux types de cartes ESP32 : les « Arduino ESP32 Boards » et les cartes « esp32 by Espressif ». Nous voulons les bibliothèques esp32 par Espressif. Cliquez sur le bouton INSTALL et attendez la fin du téléchargement et de l’installation.
Une fois installé, votre Boards Manager devrait ressembler à ceci, bien que la version (ici 3.3.7) puisse être différente.
À l’étape suivante, je vous montre comment sélectionner la carte ESP32 pour le XIAO ESP32-S3.
Sélectionner la carte XIAO_ESP32S3
Vous pouvez sélectionner une carte dans le menu déroulant sous la barre de menu : dans l’exemple ci-dessous, une Arduino Uno est sélectionnée :
Cliquer sur le nom de la carte actuellement sélectionnée (Arduino Uno) ouvrira la boîte de sélection de carte. Dans la zone de recherche, tapez « xiao s3 » et sélectionnez « XIAO_ESP32S3 » comme montré ci-dessous :
Si la carte est connectée à votre PC via USB, vous devriez aussi pouvoir sélectionner le port COM. Dans la capture d’écran ci-dessus, c’est COM13, mais dans votre cas, ce sera peut-être un autre port COM.
Exemples de code
Dans cette section, je vous propose quelques exemples de code pour tester les principales fonctionnalités du XIAO ESP32-S3.
Trouver les broches I2C et SPI
Ce premier exemple affiche les interfaces I2C et SPI, nécessaires pour connecter de nombreux capteurs et écrans :
void print(const char* name, int pin) {
Serial.print(name);
Serial.println(pin);
}
void setup() {
Serial.begin(115200);
delay(2000);
print("LED: ", LED_BUILTIN);
print("SDA: ", SDA);
print("SCL: ", SCL);
print("SS: ", SS);
print("MOSI: ", MOSI);
print("MISO: ", MISO);
print("SCK: ", SCK);
}
void loop() { }
Vous pouvez utiliser ce code pour d’autres cartes supportées dans l’IDE Arduino. Pour plus d’informations, voir le Find I2C and SPI default pins tutoriel. Pour le XIAO ESP32-S3, ce code affiche :
LED: 21 SDA: 5 SCL: 6 SS: 44 MOSI: 9 MISO: 8 SCK: 7
Faire clignoter la LED embarquée
C’est l’exemple classique Blink. Il allume et éteint la LED embarquée pendant une seconde. La LED embarquée du XIAO ESP32-S3 est connectée à GPIO21 mais est inversée. LOW signifie que la LED est allumée et HIGH qu’elle est éteinte. Vous pouvez voir cela dans l’exemple de code ci-dessous :
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
Serial.println("Off");
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
Serial.println("On");
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Lire & écrire sur GPIO
Dans les exemples très courts suivants, nous lisons et écrivons sur les GPIO. Pour spécifier les broches dans le code, vous pouvez utiliser le numéro GPIO x ou le numéro Dx. Par exemple, selon le brochage, D3 ou GPIO4 identifient la même broche et dans votre code vous pouvez utiliser l’un ou l’autre. Les deux exemples de code suivants sont identiques en fonction et définissent GPIO4 à HIGH:
digitalWrite(D3, HIGH); // D3 == GPIO4
digitalWrite(4, HIGH); // D3 == GPIO4
Si vous souhaitez lire des signaux analogiques, vous pouvez utiliser les constantes prédéfinies Ax. Par exemple, le code suivant lit une entrée analogique sur A3, qui est la même broche que GPIO4:
int val = analogRead(A3); // A3 == GPIO4
int val = analogRead(4); // A3 == GPIO4
Les valeurs analogiques vont de 0 à 4095, ce qui correspond à une tension d’entrée entre 0 et 3,3 V.
Entrée tactile
Cet exemple montre comment utiliser les broches tactiles capacitives du XIAO ESP32-S3 pour détecter des entrées tactiles. Si vous touchez la première broche (D0) de la carte, la LED intégrée s’allume. Vous devrez peut-être ajuster le seuil de détection.
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
int value = touchRead(T1);
Serial.println(value);
if (value > 30000) {
digitalWrite(LED_BUILTIN, LOW);
} else {
digitalWrite(LED_BUILTIN, HIGH);
}
delay(200);
}
HID pour contrôle du volume
L’ESP32-S3 supporte l’USB HID (Human Interface Device), ce qui signifie que vous pouvez contrôler des périphériques informatiques comme le clavier ou le volume avec l’ESP32 connecté. Dans les exemples suivants, nous utilisons les entrées tactiles T1 et T2 pour augmenter ou diminuer le volume de l’ordinateur :
#include "USB.h"
#include "USBHIDConsumerControl.h"
USBHIDConsumerControl UCC;
#define TOUCH_THRESHOLD 30000
bool upPressed() {
return touchRead(T1) > TOUCH_THRESHOLD;
}
bool downPressed() {
return touchRead(T2) > TOUCH_THRESHOLD;
}
void setup() {
USB.begin();
UCC.begin();
}
void loop() {
if (upPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
UCC.release();
}
if (downPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_DECREMENT);
UCC.release();
}
delay(100);
}
Au lieu des entrées tactiles, vous pouvez évidemment aussi connecter des boutons. Mais avec les entrées tactiles, il suffit d’insérer des câbles sur la première (D0) et la deuxième (D1) broche pour tester le code du contrôleur de volume.
Voir la bibliothèque arduino-esp32 pour plus d’exemples HID. Faites attention en utilisant l’ESP32 en mode HID, car vous pouvez facilement désactiver votre souris ou inonder votre ordinateur de frappes, le rendant inutilisable tant que l’ESP32 est connecté.
Notez aussi que la carte ne peut pas être flashée pendant que le HID est actif. Elle disparaît comme périphérique USB dans l’IDE Arduino. Pour remettre la carte en mode flash, vous devez :
- Appuyer et maintenir le bouton BOOT (B)
- Tout en maintenant BOOT (B), appuyez puis relâchez RESET (R)
- Relâchez le bouton BOOT (B)
Comme les boutons BOOT (B) et RESET (R) sur l’ESP32-S3 sont très petits, cela peut être assez délicat.
Wi-Fi
L’exemple suivant montre comment connecter le XIAO ESP32 à un réseau Wi-Fi. Cela fonctionnera sans antenne externe si vous êtes proche du routeur Wi-Fi. Mais pour une meilleure portée, il est conseillé d’installer l’antenne.
#include <WiFi.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nConnected");
Serial.println(WiFi.localIP());
}
void loop() {
}
Serveur Web
Vous pouvez étendre l’exemple Wi-Fi précédent et facilement créer un serveur Web simple. Le code suivant crée un serveur web, affiche l’adresse IP du serveur et affiche le texte « Hello from XIAO ESP32-S3! » sur la page racine :
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
WebServer server(80);
void handleRoot() {
server.send(200, "text/plain", "Hello from XIAO ESP32-S3!");
}
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(WiFi.localIP());
server.on("/", handleRoot);
server.begin();
}
void loop() {
server.handleClient();
}
Téléchargez le code sur votre ESP32-S3, ouvrez le Moniteur Série et copiez l’adresse IP affichée (ex. « 192.168.1.160 ») dans la barre d’adresse de votre navigateur. Vous devriez voir apparaître le message :
Scanner Web
Si vous souhaitez scanner votre réseau Wi-Fi local pour détecter les réseaux disponibles, voici un exemple de code :
#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);
}
Vous pouvez commencer sans antenne Wi-Fi attachée et vous ne trouverez que les réseaux Wi-Fi les plus forts. Si vous connectez l’antenne, vous découvrirez probablement plus de réseaux. Par exemple, sans antenne, je reçois un signal faible (-77 dB) et un seul réseau :
scan start scan done 1 networks found 1: maetasus (-77)*
Dès que j’attache l’antenne, plus de réseaux sont détectés et la force du signal de mon réseau local (maetasus) passe de -77 dB à -35 dB :
scan start scan done 5 networks found 1: maetasus (-35)* 2: FRITZ!Box 5590 DQ (-75)* 3: WLAN-762918 (-81)* 4: portthru (-83) 5: WLAN-579476 (-91)*
Bluetooth
Cet exemple montre comment créer un serveur Bluetooth Low Energy (BLE) simple.
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
void setup() {
Serial.begin(115200);
BLEDevice::init("XIAO-ESP32-S3");
BLEServer *pServer = BLEDevice::createServer();
BLEDevice::getAdvertising()->start();
Serial.println("BLE server started");
}
void loop() {
}
Vous pouvez vérifier si le serveur est actif en utilisant un scanner BLE sur votre téléphone. Les options courantes sont nRF Connect ou LightBlue. Si vous lancez un scan, vous verrez apparaître « XIAO-ESP32-S3 ».
Capteur de pression et température (BME280) via I2C
Cet exemple de code montre comment connecter un capteur via I2C au XIAO ESP32-S3. Nous utiliserons le BME280 dans cet exemple. Pour plus d’informations sur ce capteur, voir les tutoriels How To Use BME280 Pressure Sensor With Arduino et Weather Station on e-Paper Display.
L’interface I2C du XIAO ESP32-S3 se trouve sur les broches 5 (SDA) et 6 (SCL). Le schéma de câblage ci-dessous montre comment connecter le BME280 au XIAO ESP32-S3.
Le code suivant montre comment lire la pression, la température, l’humidité et l’altitude depuis le capteur BME280 et afficher les mesures dans le Moniteur Série :
#include "Adafruit_BME280.h"
#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76
Adafruit_BME280 bme;
void setup() {
Serial.begin(11520);
while(!Serial);
if (!bme.begin(BME280_ADDRESS)) {
Serial.println("Can't find BME280!");
while(1) delay(10);
}
}
void loop() {
Serial.print("Temperature in degC = ");
Serial.println(bme.readTemperature());
Serial.print("Pressure in hPa = ");
Serial.println(bme.readPressure() / 100.0F);
Serial.print("Altitude in m = ");
Serial.println(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.print("Humidity in %RH = ");
Serial.println(bme.readHumidity());
Serial.println();
delay(5000);
}
Si tout est correctement câblé, vous devriez voir des données similaires à la sortie ci-dessous :
Temperature in degC = 22.93 Pressure in hPa = 1000.40 Altitude in m = 107.53 Humidity in %RH = 34.61
OLED via I2C
Dans cet exemple de code, nous utilisons à nouveau l’interface I2C mais connectons un écran OLED au XIAO ESP32-S3. Comme précédemment, nous utilisons les broches 5 (SDA) et 6 (SCL) pour l’I2C. La photo ci-dessous montre la connexion à réaliser avec l’OLED :
Voici le code. Il écrit simplement le texte “make” sur l’écran. Notez que vous devrez installer la bibliothèque Adafruit_SSD1306 library en premier.
#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);
}
Écran E-Paper via SPI
Dans cet exemple suivant, nous allons contrôler un écran E-Paper via l’interface SPI du XIAO ESP32-S3. Les broches SPI matérielles pour le XIAO ESP32-S3 sont 8 (MISO), 9 (MOSI), 44 (CS/SS) et 7 (SCK). Les autres broches sont libres.
Le schéma de câblage ci-dessous montre comment connecter un 4.2″ e-Paper Display aux broches SPI :
Voici un tableau récapitulatif des connexions pour plus de commodité. Notez que vous pouvez alimenter l’écran en 3,3 V ou 5 V mais les lignes de données SPI doivent être en 3,3 V ! Pour plus de sécurité, utilisez 3,3 V pour l’alimentation.
| Écran e-Paper | XIAO ESP32-S3 |
|---|---|
| CS/SS | GPIO44 |
| CLK/SCL/SCK | GPIO7 |
| SDA/DIN/MOSI | GPIO9 |
| BUSY | GPIO1 |
| RES/RST | GPIO2 |
| DC | GPIO3 |
| VCC | 3,3 V |
| GND | G |
Avant de pouvoir dessiner sur l’écran e-Paper, vous devrez installer la bibliothèque GxEPD2 qui fournit le pilote graphique pour l’écran E-Paper. Le code ci-dessous utilise cette bibliothèque pour afficher le texte « Makerguides » sur l’écran :
#include "GxEPD2_BW.h"
// hardware SPI
// #define MISO 8
// #define MOSI 9
// #define SCK 7
#define CS 44
#define DC 3
#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() {}
Si vous souhaitez réaliser quelque chose de plus intéressant, consultez les tutoriels Monthly Calendar on E-Paper Display ou Analog Clock on e-Paper Display.
Deep Sleep
Le code suivant montre comment utiliser le mode deep-sleep avec l’ESP32-S3. Toutes les 10 secondes, il met l’ESP32-S3 en deep-sleep pendant 5 secondes puis le réveille :
#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP 5
void setup() {
Serial.begin(115200);
Serial.println("Awake...");
delay(10000);
Serial.println("Going to sleep...");
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
esp_deep_sleep_start();
}
void loop() {}
Attention lorsque vous augmentez la durée du deep-sleep. Pendant le deep-sleep, la carte se déconnecte de l’USB et vous ne pouvez pas flasher de nouveau logiciel. Pour remettre la carte en mode flash, vous devez :
- Appuyer et maintenir le bouton BOOT (B)
- Tout en maintenant BOOT, appuyez puis relâchez RESET (R)
- Relâchez le bouton BOOT
Mise à jour OTA (Over The Air)
Dans ce dernier exemple de code, je vous montre comment effectuer une mise à jour Over The Air (OTA) du code sur le XIAO ESP32-S3. Cela a l’avantage de ne pas avoir à brancher votre ESP32 pour flasher un nouveau code.
#include <WiFi.h>
#include <ArduinoOTA.h>
const char* wifi_ssid = "YOUR_SSID";
const char* wifi_pwd = "YOUR_PASSWORD";
const char* ota_pwd = "1234";
const char* ota_name = "my-xiao-esp32-s3";
void setup() {
WiFi.begin(wifi_ssid, wifi_pwd);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
ArduinoOTA.setHostname(ota_name);
ArduinoOTA.setPassword(ota_pwd);
ArduinoOTA.begin();
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
ArduinoOTA.handle();
// Main code
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
L’ESP32 apparaîtra sous Tools -> Ports -> Network Ports avec le nom d’hôte « my-xiao-esp32-s3 ». Si vous flashez sur cet hôte, l’IDE Arduino demandera un mot de passe (« 1234 ») puis transférera le nouveau code via Wi-Fi. Évidemment, vous devriez choisir un mot de passe plus sûr que « 1234 » ; )
Dans l’exemple de code, le programme principal est le simple Blink. Changez le délai, flashez le nouveau code et vérifiez si la fréquence de clignotement a changé pour tester la mise à jour OTA.
Conclusions
Cet article vous a montré comment démarrer avec le Seeed Studio XIAO ESP32-S3. Seeed Studio fournit des informations supplémentaires dans son Wiki.
Notez qu’il existe une version XIAO ESP32-S3-Plus avec plus de Flash (16 Mo) et de broches GPIO. Il y a aussi le XIAO-ESP32-S3-Sense, qui est équipé d’une caméra et d’un microphone. Si vous souhaitez enregistrer de l’audio ou diffuser de la vidéo, choisissez le XIAO-ESP32-S3-Sense. Si vous avez besoin de plus de mémoire ou d’entrées/sorties, optez pour le XIAO ESP32-S3-Plus.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage 😉
