Baguette S3 : notice d'utilisation du modèle et guide utilisateur

Vous venez de recevoir votre Baguette S3 ? Ce petit module ESP32-S3 au format allongé est un concentré de fonctionnalités pour prototyper vos projets. Nous vous expliquons ici comment exploiter tout son potentiel, de l’alimentation et le brochage jusqu’à la programmation avec les environnements les plus populaires.

Prendre en main la carte

Une fois la configuration terminée et les exemples parcourus, vous pourrez approfondir vos connaissances avec notre article sur la création d’une interface serveur web. Un autre tutoriel dédié à CircuitPython propose également des exemples complémentaires.

Sommaire

Caractéristiques de la carte
Alimentation
Broches GPIO
Trous de fixation
Mode boot/programmation à faire en premier
Programmer la Baguette S3
- Arduino IDE
- ESPHome via Home Assistant
- MicroPython
- CircuitPython

Caractéristiques de la carte

Un rappel rapide des fonctionnalités que nous allons vous montrer à utiliser :

Alimentation

Le moyen le plus simple d’alimenter la carte est d’utiliser le port USB-C, qui permet aussi une connexion de données avec votre PC pour la programmation. Un régulateur intégré abaisse cette tension à 3,3V pour le module ESP32-S3.

Lorsqu’elle est alimentée, la LED bleue ‘PWR’ de la carte s’allume.

Alimentation via les broches

Si vous préférez alimenter la carte directement via les broches, deux options s’offrent à vous :

Broche 5V – vous pouvez connecter une source d’alimentation régulée 5V à la broche 5V (et GND à la broche G)
- Cette option utilise alors le régulateur intégré pour fournir 3,3V au module ESP32-S3
Broche 3V – vous pouvez connecter une source d’alimentation régulée 3,3V à la broche 3V (et GND à la broche G)
- Nous ne recommandons généralement pas cette option, car il est préférable de rester sur les pads 5V et de laisser passer cette tension par le régulateur LDO intégré ME6211.

Exemple de consommation

Nous avons effectué un test simple en conditions réelles, utilisant la carte avec un capteur mmWave et une carte SD, pour vous donner une idée de la consommation, à l’aide de notre outil de profilage d’alimentation.

Nous avons mesuré une consommation moyenne d’environ 130mA, avec un pic à 139mA. Vos résultats peuvent varier, car tout dépend de ce que fait votre Baguette S3 et du matériel supplémentaire qu’elle alimente.

Broches GPIO

La Baguette S3 dispose d’un connecteur à 30 broches, qui fournit les fonctions suivantes – beaucoup d’entre elles sont partagées (la même broche peut être utilisée à différentes fins, définies dans votre code) :

Il convient de faire attention lors de l’utilisation de certaines broches pour certaines fonctions, car cela pourrait empêcher la carte de démarrer.

La carte propose :

23 broches GPIO générales
UART (TX et RX)
SPI (MOSI, MISO, CLK et CS)
I2C (SDA et SCL)
ADC (ADC1 et ADC2)
Alimentation (5V, 3,3V et GND)
Certaines de ces broches sont également des ‘Strapping pins’, comme expliqué ci-dessous.

Important : La plupart des broches de l’ESP32-S3 peuvent être programmées pour d’autres fonctions ; cependant, nous avons documenté les positions par défaut ci-dessous.

Broches d’entrée/sortie générales

Ce sont vos broches GPIO classiques pour les entrées/sorties numériques, à configurer dans votre code en sortie haute ou basse, ou à définir comme entrées.

Broches UART

Les broches UART (RX/TX) ont été séparées des GPIO générales sur la carte ; cependant, vous pouvez les utiliser comme broches GPIO si vous le souhaitez. Si elles ne sont pas configurées, elles sont HAUTES par défaut.

Broches SPI

Les broches SPI (MISO/MOSI/CLK/CS) servent à connecter des périphériques SPI. Ce sont les broches SPI ‘matérielles’, mais les broches de l’ESP32-S3 étant entièrement configurables par logiciel, vous pouvez utiliser d’autres broches pour le SPI si nécessaire.

Autres broches

Plusieurs autres broches sont utilisées par le port MicroSD et la LED RGB. Bien qu’elles ne soient pas sorties, nous les ajoutons ici pour être exhaustifs :

SD SCK	GPIO9
SD MISO	GPIO11
SD MOSI	GPIO10
SD CS	GPIO7
RGB LED	GPIO8

Limites de courant des broches

Comme la plupart des cartes de développement, vous devez être conscient de la quantité de courant que chaque broche peut consommer. Tirer trop de courant d’une broche GPIO peut endommager définitivement votre carte !

Chaque broche peut tirer jusqu’à 40mA maximum absolu, mais essayez de vous maintenir aux alentours de 20mA
La broche 3V (3,3V) est alimentée par le régulateur intégré et fournit jusqu’à 500mA ; cependant, gardez à l’esprit qu’elle alimente aussi le module ESP
La broche 5V – la carte peut tirer jusqu’à 1A depuis le connecteur USB-C (y compris pour son propre fonctionnement)

Connecteur d’en-tête

Une bande de connecteurs est incluse dans le kit, que vous pouvez souder pour une utilisation sur plaque d’essai si c’est votre intention :

Vous pouvez également monter des borniers compacts 2,54mm si vous préférez, comme on peut le voir sur l’image ci-dessous (notez que deux blocs ne tiendront pas parfaitement côte à côte. Nous utilisons ici un bloc à 10 voies pour utiliser des broches spécifiques) :

Pads sur la face inférieure

Si vous prévoyez de souder des fils directement sur la carte, nous recommandons de les souder directement sur les pads plats et ovales de la face inférieure. Ils sont beaucoup plus faciles à travailler et à retravailler plus tard que de souder dans les trous des pads.

Trous de fixation

Un mot rapide sur le montage – la carte dispose de deux trous de fixation M2.5, vous offrant la possibilité de la fixer dans un boîtier ou sur un panneau.

Nous proposons des fixations M2.5 dans la boutique si vous en avez besoin, y compris des packs de entretoises nylon abordables et des vis/écrous.

Mode boot/programmation

Si vous utilisez la Baguette S3 pour la première fois ou changez de plateforme, vous devrez peut-être mettre la carte en mode programmation. Cela peut être réalisé en maintenant le bouton BOOT enfoncé pendant la mise sous tension (branchement du câble USB-C).

Cependant, la façon la plus simple d’y parvenir (et de minimiser l’usure du connecteur USB) est de maintenir le bouton BOOT enfoncé, puis d’appuyer sur le bouton RESET tout en gardant le bouton BOOT enfoncé.

Après avoir appuyé sur RESET, vous pouvez alors relâcher le bouton boot, et la carte devrait maintenant être en mode programmation. Ce processus devrait être identique quel que soit le système d’exploitation de votre ordinateur hôte.

Programmer la Baguette S3

Cette section couvre comment programmer votre Baguette S3 avec les options populaires pour les cartes ESP – cliquez sur un lien ci-dessous pour accéder directement à cette partie :

Arduino
ESPHome via Home Assistant
MicroPython
CircuitPython

Nous n’aborderons pas les bases génériques comme « comment installer l’IDE Arduino » ou d’autres sujets non spécifiques à la Baguette S3, car ils sont déjà bien documentés.

Tous les exemples et captures d’écran de ce guide proviennent d’un environnement Windows.

Autres plateformes – Si vous souhaitez voir des exemples pour d’autres plateformes, laissez un commentaire à la fin de cet article.

Arduino IDE

La Baguette S3 utilise un module ESP32-S3, qui est pris en charge à partir du package de cartes Arduino 2.0 et versions ultérieures. Ce guide se concentre donc sur la version 2.0 au minimum. Les captures d’écran ci-dessous peuvent paraître différentes avec les nouvelles versions, mais le processus devrait rester assez similaire.

Installer le logiciel

La première étape est de vous assurer que vous avez l’IDE Arduino installé et prêt – vous pouvez télécharger le logiciel depuis le site d’Arduino.

Définition dans le gestionnaire de cartes

Une fois installé, nous devons nous assurer que l’ESP32 est défini dans le gestionnaire de cartes.

Allez dans Outils -> Carte -> Gestionnaire de cartes – cela affichera une barre latérale à gauche. Si nous tapons « ESP32 » dans la recherche, nous pouvons alors sélectionner pour installer le “esp32 by Espressif Systems” :

Une fois ajouté, vous verrez maintenant un nouveau menu ‘esp32’ lorsque vous irez dans Outils -> Carte. Nous devons sélectionner ESP32 -> ESP32 S3 Dev Module, comme sur la capture d’écran ci-dessous :

Configuration série

Nous devons maintenant apporter une modification pour obtenir une sortie série sur la console pour le débogage.

Puisque nous avons sélectionné le “ESP32 S3 Dev Module”, nous aurons maintenant plus d’options sous Outils. Nous devons changer l’option “USB CDC On Boot :” pour l’activer, comme ceci :

Ce paramètre permet au port USB d’être également utilisé pour une console série. C’est nécessaire car il n’y a pas de puce USB-Série discrète, celle-ci étant intégrée aux puces de la gamme ESP-S3.

Sélection du port

Enfin, nous devons confirmer que le port correct est sélectionné sous Outils -> Port. Les ports listés, et leur numéro, dépendront de votre plateforme et du nombre d’autres appareils que vous avez connectés ; cependant, vous pourriez constater que votre Baguette apparaît comme un ‘ESP32 Family device’.

Parfois, d’autres appareils apparaissent comme des ports COM, ce qui peut prêter à confusion. La meilleure façon de déterminer lequel est votre Baguette S3 est de la débrancher et de voir quel port disparaît de la liste (puis de la rebrancher).

Important : Débranchez toute autre carte de développement pour éviter d’effacer une autre carte !

Nous sommes maintenant à un point où nous pouvons utiliser notre carte avec l’IDE Arduino !

LED RGB intégrée (WS2812C adressable)

Nous allons utiliser l’exemple Neopixel d’Adafruit, qui a créé une excellente bibliothèque qui fait une grande partie du travail à notre place.

Dans l’IDE Arduino, nous devons aller dans Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques, comme ceci :

Similairement au gestionnaire de cartes, cela ouvrira un panneau latéral où nous pouvons rechercher “Adafruit neopixel” :

Une fois la bibliothèque installée, nous pouvons ouvrir un des nouveaux exemples installés en allant dans Fichier -> Exemples -> Adafruit Neopixel -> Simple example.

Nous devons apporter deux modifications au fichier pour le faire fonctionner avec notre Baguette S3, pour indiquer que notre LED RGB est connectée sur la broche 8, et que nous avons un seul pixel :

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN        8 // On Trinket or Gemma, suggest changing this to 1
// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 1 // Popular NeoPixel ring size

Pour expliquer l’exemple, nous avons trois commandes principales pour contrôler la LED.

pixels.clear();

Cette commande éteint les couleurs du pixel.

pixels.setPixelColor(i, pixels.Color(0, 150, 0));

Ici, nous pouvons définir la couleur souhaitée de la LED. Les trois nombres fournis sont au format RGB (Rouge, Vert et Bleu) et peuvent aller de 0 (éteint) à 255 (pleine luminosité). La ligne ci-dessus définira donc la couleur sur un vert à un peu plus de la moitié de la luminosité.

pixels.show();

Avant de pouvoir voir la couleur, nous devons inclure pixels.show pour envoyer les données à la LED.

Carte MicroSD

Vous pouvez insérer une carte MicroSD dans le slot intégré, ce qui peut être utile pour du stockage à long terme, ou lorsque vous avez besoin de plus d’espace que celui disponible en interne pour des projets nécessitant de l’enregistrement de données.

Pour commencer, nous allons utiliser l’exemple intégré, qui se trouve dans Exemples pour ESP32S3 Dev Board -> SD -> SD_Test.

Nous devons trouver la section ci-dessous pour la modifier :

/*
Uncomment and set up if you want to use custom pins for the SPI communication
#define REASSIGN_PINS
int sck = -1;
int miso = -1;
int mosi = -1;
int cs = -1;
*/

Ces sont les broches qui indiquent au code quelles broches utiliser pour la carte SD. Nous devons modifier le code, comme montré ci-dessous, pour configurer correctement les broches pour la Baguette S3, et également décommenter le code pour activer le changement de broche :

#define REASSIGN_PINS
int sck = 9;
int miso = 11;
int mosi = 10;
int cs = 7;

Avec ces broches correctement configurées, la bibliothèque ‘SD.h’ peut être utilisée pour interagir avec le système de fichiers sur la carte SD.

Les exemples de code montrent comment effectuer des opérations standard telles que travailler avec des répertoires ou manipuler des fichiers. Il affichera la sortie sur le moniteur série de l’IDE. Celui-ci peut être activé avec l’option en haut à droite, en utilisant cette icône :

Le début de la sortie série sera similaire à ce qui suit (votre sortie différera en fonction du contenu de votre carte SD). Les plus observateurs remarqueront que nous avions inséré une carte SD Raspberry Pi pour le test :

SD Card Type: SDSC
SD Card Size: 1876MB
Listing directory: /
  FILE: COPYING.linux  SIZE: 18693
  FILE: bootcode.bin  SIZE: 52116
  FILE: LICENCE.broadcom  SIZE: 1494
  FILE: start.elf  SIZE: 2864164
  FILE: start_cd.elf  SIZE: 678372
  FILE: fixup.dat  SIZE: 6695
  FILE: fixup_cd.dat  SIZE: 2622
  FILE: cmdline.txt  SIZE: 133
  FILE: config.txt  SIZE: 30725
  FILE: kernel.img  SIZE: 5629040
  FILE: bcm2709-rpi-2-b.dtb  SIZE: 22493
  FILE: bcm2710-rpi-3-b.dtb  SIZE: 23588
  FILE: bcm2710-rpi-3-b-plus.dtb  SIZE: 23707
  FILE: bcm2710-rpi-cm3.dtb  SIZE: 22342
  DIR : overlays
  DIR : System Volume Information
  DIR : .fseventsd

Port Qwiic / I2C

Nous avons deux broches I2C dédiées sur le connecteur GPIO, étiquetées SDA et SCL, mais aussi un connecteur Qwiic (3,3V) qui partage les mêmes broches.

Pour utiliser ces broches, nous allons utiliser le simple exemple de scanner I2C disponible sur randomnerd tutorials. Nous allons utiliser leur exemple de code, mais nous devons d’abord l’adapter pour fonctionner avec notre carte.

Commencez par ajouter nos définitions de broches I2C comme nouvelles lignes (après la ligne #include est un bon endroit) :

#define I2C_SDA 47
#define I2C_SCL 48

Ensuite, nous devons spécifier les broches en modifiant la ligne existante Wire.begin() pour qu’elle devienne :

Wire.begin(I2C_SDA, I2C_SCL);

Avec ces modifications en place, si vous avez un périphérique branché sur le port Qwiic ou sur les broches dédiées, lorsque vous exécuterez votre code, le Moniteur Série devrait maintenant afficher quelque chose de similaire à ceci :

I2C Scanner
Scanning...
I2C device found at address 0x77
done

L’adresse affichée différera en fonction du périphérique que vous avez connecté (de nombreux périphériques Qwiic ont une adresse fixe, parfois imprimée sur le PCB).

Si vous ne voyez aucune adresse, vérifiez votre câblage et assurez-vous d’avoir ‘USB CDC on boot enabled’ dans l’IDE (que nous avons configuré plus tôt).

ESPHome via Home Assistant

Travailler avec ESPHome peut être un peu plus complexe, mais aussi beaucoup plus simple à certains égards.

Les exemples ci-dessous utilisent la version 2025.8.3. Avec les nouvelles versions, les choses peuvent changer, paraître différentes ou simplement ne plus fonctionner ! Faites-nous savoir dans les commentaires si vous rencontrez des problèmes.

Pour notre exemple, nous allons ajouter la carte depuis le module complémentaire ESPHome de Home Assistant. Nous supposons que vous avez déjà ESPHome en fonctionnement sur votre appareil hôte Home Assistant. Sinon, vous pouvez suivre les instructions ici.

Ajouter la Baguette S3 à ESPHome

Pour commencer, nous nous rendons sur la page du module complémentaire ESPHome et cliquons sur “New Device” (actuellement dans le coin inférieur droit) :

On vous demandera un nouveau nom pour votre appareil. Pour notre exemple, nous nommerons la carte “baguette-s3” :

À ce stade, on nous demandera de connecter la carte Baguette S3 à l’ordinateur depuis lequel nous effectuons la configuration, et de sélectionner “Connect” :

Nous devons ensuite sélectionner le port série, qui apparaîtra comme USB JTAG/Serial ou similaire, selon la plateforme que vous utilisez.

Après avoir cliqué sur connecter, il affichera ensuite “Preparing Installation”. Cela peut prendre un certain temps.

Si vous recevez un avertissement indiquant que l’opération a réussi mais que la carte n’a pas pu être reconnectée, appuyer sur le bouton RESET reprend généralement la communication.

Une fois le processus terminé, vous aurez maintenant une nouvelle entrée pour la carte dans votre tableau de bord ESPHome au sein de Home Assistant :

De là, vous pouvez cliquer sur éditer et voir la configuration YAML par défaut. Il est recommandé de l’ajouter de cette manière car les éléments, tels que la clé API et le mot de passe OTA, sont uniques à votre configuration.

Définition de la carte

La définition de carte dont nous avons besoin est installée par défaut ; cependant, nous devons spécifier la carte en configurant les éléments suivants dans notre exemple :

esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: esp-idf

Nous devons également activer le serveur web pour voir nos options et interagir avec la carte. Cela peut être réalisé en insérant ce qui suit dans notre config :

web_server:
  port: 80

LED RGB intégrée (WS2812C adressable)

Pour utiliser la LED RGB intégrée, nous devons définir quelle broche nous utilisons et le nombre de LEDs, comme ceci :

light:
  - platform: esp32_rmt_led_strip
    rmt_symbols: 96
    chipset: ws2812
    rgb_order: GRB
    is_rgbw: False
    pin: GPIO08
    num_leds: 1
    name: "Neopixel LED"
    id: leds
    color_correct: [80%, 80%, 80%]
    default_transition_length: 2s

Avec cette configuration, nous pouvons visiter la carte dans ESPHome, ce qui nous donnera la page web suivante, où nous pouvons voir l’état de la LED RGB et la basculer ainsi que régler le niveau de luminosité :

Carte MicroSD

Pour utiliser une carte MicroSD dans ESPHome, nous avons besoin d’un ‘composant externe’ qui est introduit en ajoutant le lien depuis la page GitHub du composant.

Nous devons également modifier la façon dont nous définissons la carte en ajoutant une petite section ‘external_components’ après le type de carte, comme montré ci-dessous :

esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: esp-idf
    sdkconfig_options:
      CONFIG_FATFS_LFN_STACK: "y"
external_components:
  source: github://n-serrette/esphome_sd_card

Pour la configuration, nous allons définir les broches utilisées par notre carte SD et quelques capteurs basiques pour afficher des informations sur celle-ci :

web_server:
  port: 80
sd_mmc_card:
  id: sd_mmc_card1
  mode_1bit: true
  clk_pin: GPIO9
  cmd_pin: GPIO10
  data0_pin: GPIO11
  data3_pin: GPIO7
sensor:
  - platform: sd_mmc_card
    type: used_space
    unit_of_measurement: Mb
    name: "SD card used space"
    filters:
      - lambda: return sd_mmc_card::convertBytes(x, sd_mmc_card::MemoryUnits::MegaByte);
  - platform: sd_mmc_card
    type: total_space
    name: "SD card total space"
    unit_of_measurement: Gb
    filters:
      - lambda: return sd_mmc_card::convertBytes(x, sd_mmc_card::MemoryUnits::GigaByte);
  - platform: sd_mmc_card
    type: free_space
    name: "SD card free space"
    unit_of_measurement: Gb
    filters:
      - lambda: return sd_mmc_card::convertBytes(x, sd_mmc_card::MemoryUnits::GigaByte);
text_sensor:
  - platform: sd_mmc_card
    sd_card_type:
      name: "SD card type"

Si vous visitez la carte dans ESPHome, cela affichera maintenant ce qui suit sur la page web (ce que vous verrez sera différent selon votre carte SD) :

Plus d’opérations et d’exemples concernant la carte SD peuvent être trouvés sur la page GitHub du composant.

Port Qwiic / I2C

Nous avons deux broches I2C dédiées sur le connecteur GPIO, étiquetées SDA et SCL, mais aussi un connecteur Qwiic (3,3V) qui partage les mêmes broches.

Pour le port I2C/Qwiic, nous allons configurer les broches requises, puis exécuter un scan des périphériques I2C connectés. Nous devons inclure la configuration suivante :

Web_server:
  port: 80
i2c:
    sda: 47
    scl: 48
    scan: True

C’est aussi simple que cela, et si vous visitez maintenant la carte dans ESPHome ou ouvrez les journaux, vous verrez une sortie similaire à celle ci-dessous (mais avec l’adresse de votre périphérique) :

[16:54:31][C][i2c.idf:081]: I2C Bus: 
[16:54:31][C][i2c.idf:082]: SDA Pin: GPIO47 
[16:54:31][C][i2c.idf:082]: SCL Pin: GPIO48 
[16:54:31][C][i2c.idf:102]: Results from bus scan: 
[16:54:31][C][i2c.idf:108]: Found device at address 0x77

MicroPython

Comme d’habitude, nous utiliserons Thonny comme notre IDE pour MicroPython. Pas le plus tendance, mais il est largement utilisé par les débutants comme par les expérimentés.

Installer le logiciel

La première étape est de vous assurer que Thonny est installé et prêt – vous pouvez télécharger Thonny ici. L’installation est simple et bien documentée.

Installez Thonny, ouvrez le programme, puis passez à l’étape suivante une fois prêt.

Installer MicroPython sur la Baguette S3

Connectez votre Baguette S3 à votre PC via USB-C, puis mettez votre carte en mode boot/programmation comme nous l’avons montré plus tôt.

Dans Thonny, cliquez sur cette section en bas à droite de l’interface, puis sélectionnez ‘Configure Interpreter’.

Vous devez maintenant sélectionner ‘MicroPython (ESP32)’ dans la première liste déroulante, detection automatique dans la seconde boîte (par défaut généralement) :

ATTENTION ! Ne cliquez pas encore sur ‘OK’ ! Vous devez maintenant sélectionner le lien ‘Install or update MicroPython (esptool)’ :

Cela ouvrira une autre fenêtre où vous devez sélectionner les options suivantes :

Port cible : Généralement, l’option ‘USB JTAG’
- Si vous voyez plusieurs options, sortez, débranchez d’autres appareils et réessayez.
Famille MicroPython : ESP32-S3
Variante : Espressif-ESP32-S3
Version : Sélectionnez la dernière version (1.26.1 au moment de la rédaction)

Sélectionnez maintenant ‘Install’ et Thonny installera la version appropriée de MicroPython pour fonctionner avec votre Baguette S3.

Vous verrez une barre de progression en bas à gauche de la fenêtre, qui affichera éventuellement ‘Done !’. Vous pouvez maintenant fermer cette fenêtre, puis sélectionner ‘OK’ pour fermer la fenêtre de l’interpréteur, retournant à l’interface principale de Thonny.

Votre carte devrait maintenant être automatiquement sélectionnée et affichée en bas à droite de Thonny comme ceci (si ce n’est pas le cas, cliquez sur ce texte et sélectionnez le port/option ESP32 correct) :

Votre Baguette S3 est maintenant prête avec MicroPython installé !

LED RGB intégrée (WS2812C adressable)

Une bibliothèque Neopixel est déjà intégrée à MicroPython pour notre utilisation. Vous trouverez ci-dessous un exemple de code pour l’essayer.

Collez le code ci-dessous dans Thonny, puis sélectionnez le petit triangle vert (bouton d’exécution) ou sélectionnez Exécuter > Exécuter le script courant dans le menu :

from machine import Pin
from time import sleep_ms
import machine, neopixel, time
np1 = neopixel.NeoPixel(machine.Pin(8), 1)
while True:
    np1.fill((255,0,0)) # set to red, full brightness
    np1.write()
    sleep_ms(500)
    np1.fill((0,0,255)) # set to red, full brightness
    np1.write()
    sleep_ms(500)

En guise de rapide découpage des éléments principaux ici, la ligne suivante définit que nous avons un neopixel sur la broche 8, que nous appelons np1 :

np1 = neopixel.NeoPixel(machine.Pin(8), 1)

La ligne suivante règle le neopixel sur la luminosité maximale avec du rouge :

np1.fill((0,0,255)) # set to red, full brightness

Et cette ligne ordonne ensuite au neopixel de prendre la couleur que nous avons sélectionnée :

np1.write()

Carte MicroSD

Insérez une carte MicroSD vide/nettoyée dans le slot, et nous vous montrerons quelques exemples utilisant la classe SD card intégrée à MicroPython. Récupérez des morceaux de ces exemples de code pour vos propres projets afin d’écrire des données sur une carte MicroSD :

Le code suivant monte la carte SD en utilisant les broches que la Baguette S3 utilise pour le slot SD, écrit une nouvelle ligne de texte dans un fichier test (test.txt), puis démonte la carte SD.

import os
from machine import Pin, SDCard
import time
# SD card pin definition
SD_SCK_PIN = 9
SD_MOSI_PIN = 10
SD_MISO_PIN = 11
SD_CS_PIN = 7
# Mount point definition
MOUNT_POINT = "/sd"
# Mount, write a test file to the SD, and unmount
def run_sd_test():
    sd = None
    try:
        # Initialise the SD card using a hardware SPI peripheral (slot=2)
        print("Initializing SD card...")
        sd = SDCard(
            slot=2,
            sck=Pin(SD_SCK_PIN),
            mosi=Pin(SD_MOSI_PIN),
            miso=Pin(SD_MISO_PIN),
            cs=Pin(SD_CS_PIN)
        )
        print(f"Mounting filesystem at '{MOUNT_POINT}'...")
        os.mount(sd, MOUNT_POINT)
        print("Mount successful.")
        # File Operations
        file_path = f"{MOUNT_POINT}/test.txt"
        # Add a newline character (\n) to the end of the string
        file_content = f"Test write successful at {time.time()}\n"
        print(f"Appending to '{file_path}'...")
        # Open the file in append mode ("a") to add content to the end
        with open(file_path, "a") as f:
            f.write(file_content)
    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        # Unmount to prevent corruption
        if sd:
            try:
                os.umount(MOUNT_POINT)
                print("SD card unmounted.")
            except OSError:
                # This can happen if the initial mount failed
                print("Filesystem was not mounted, skipping unmount.")
if __name__ == "__main__":
    run_sd_test()

Si vous souhaitez lire le contenu de ce fichier précis, utilisez le code ci-dessous.

Astuce : exécutez le premier exemple ci-dessus plusieurs fois pour voir plusieurs lignes de texte ici :

import os
from machine import Pin, SDCard
import time
# SD card pin definition
SD_SCK_PIN = 9
SD_MOSI_PIN = 10
SD_MISO_PIN = 11
SD_CS_PIN = 7
# Mount point definition
MOUNT_POINT = "/sd"
# Mounts the SD card and reads the content of a specific file.
def read_specific_file():
    sd = None
    try:
        # Initialise the SD card using a hardware SPI peripheral (slot=2)
        print("Initializing SD card...")
        sd = SDCard(
            slot=2,
            sck=Pin(SD_SCK_PIN),
            mosi=Pin(SD_MOSI_PIN),
            miso=Pin(SD_MISO_PIN),
            cs=Pin(SD_CS_PIN)
        )
        print(f"Mounting filesystem at '{MOUNT_POINT}'...")
        os.mount(sd, MOUNT_POINT)
        print("Mount successful.")
        # Read the contents of test.txt
        file_path = f"{MOUNT_POINT}/test.txt"
        print(f"Reading contents of '{file_path}'...")
        print("--- File Content ---")
        with open(file_path, "r") as f:
            # Iterate over the file object to read and print each line individually
            for line in f:
                # .strip() removes leading/trailing whitespace, including the newline character
                print(line.strip())
        print("--------------------")
    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        # Unmount to prevent corruption
        if sd:
            try:
                os.umount(MOUNT_POINT)
                print("SD card unmounted.")
            except OSError:
                # This can happen if the initial mount failed
                print("Filesystem was not mounted, skipping unmount.")
if __name__ == "__main__":
    read_specific_file()

Voici un autre exemple qui liste le contenu des fichiers de la carte Micro SD :

import os
from machine import Pin, SDCard
import time
# SD card pin definition
SD_SCK_PIN = 9
SD_MOSI_PIN = 10
SD_MISO_PIN = 11
SD_CS_PIN = 7
# Mount point definition
MOUNT_POINT = "/sd"
# Mounts the SD card and lists its contents.
def read_sd_contents():
    sd = None
    try:
        # Initialise the SD card using a hardware SPI peripheral (slot=2)
        print("Initializing SD card...")
        sd = SDCard(
            slot=2,
            sck=Pin(SD_SCK_PIN),
            mosi=Pin(SD_MOSI_PIN),
            miso=Pin(SD_MISO_PIN),
            cs=Pin(SD_CS_PIN)
        )
        print(f"Mounting filesystem at '{MOUNT_POINT}'...")
        os.mount(sd, MOUNT_POINT)
        print("Mount successful.")
        # List the contents of the SD card's root directory
        print(f"Listing contents of '{MOUNT_POINT}':")
        contents = os.listdir(MOUNT_POINT)
        print(contents)
    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        # Unmount to prevent corruption
        if sd:
            try:
                os.umount(MOUNT_POINT)
                print("SD card unmounted.")
            except OSError:
                # This can happen if the initial mount failed
                print("Filesystem was not mounted, skipping unmount.")
if __name__ == "__main__":
    read_sd_contents()

Port Qwiic / I2C

Nous avons deux broches I2C dédiées sur le connecteur GPIO, étiquetées SDA et SCL, mais aussi un connecteur Qwiic (3,3V) qui partage les mêmes broches.

Le code ci-dessous recherchera les périphériques I2C connectés. C’est un exemple simple et autonome. Nous configurons les broches I2C utilisées par la Baguette S3, puis utilisons la commande intégrée i2c.scan(), qui scannera tous les périphériques I2C et rapportera leurs adresses :

from machine import Pin, I2C
import time
# Setup I2C on I2C0, using GP4 (SDA) and GP5 (SCL)
i2c = I2C(0,
          scl=Pin(48),
          sda=Pin(47),
          freq=100000)
# Scan for devices
devices = i2c.scan()
if devices:
    print("I2C devices found:", [hex(d) for d in devices])
else:
    print("No I2C devices found.")
    raise SystemExit

CircuitPython

CircuitPython est une implémentation open-source de Python spécifiquement conçue pour les microcontrôleurs et les débutants, créée par Adafruit.

Nous utiliserons Thonny comme notre IDE pour CircuitPython.

Installer le logiciel

La première étape est de vous assurer que Thonny est installé et prêt – vous pouvez télécharger Thonny ici. L’installation est simple et bien documentée.

Installez Thonny, ouvrez le programme, puis passez à l’étape suivante une fois prêt.

Installer CircuitPython sur la Baguette S3

Connectez votre Baguette S3 à votre PC via USB-C, puis mettez votre carte en mode boot/programmation comme nous l’avons montré plus tôt.

Dans Thonny, cliquez sur cette section en bas à droite de l’interface, puis sélectionnez ‘Configure Interpreter’.

Vous devez maintenant sélectionner ‘CircuitPython (generic)’ dans la première liste déroulante, detection automatique dans la seconde boîte (par défaut généralement) :

ATTENTION ! Ne cliquez pas encore sur ‘OK’ ! Vous devez maintenant sélectionner le lien ‘(esptool)’.

Important ! Il y a trois liens ici – vous devez cliquer sur l’option du milieu (esptool) :

Cela ouvrira une autre fenêtre où vous devez sélectionner les options suivantes :

Port cible : Généralement, l’option ‘USB JTAG’
- Si vous voyez plusieurs options, sortez, débranchez d’autres appareils et réessayez.
Famille CircuitPython : ESP32-S3
Variante : Espressif – ESP32-S3-DevKitC-1-N8
Version : Sélectionnez la dernière version (9.2.9 au moment de la rédaction)

Sélectionnez maintenant ‘Install’ et Thonny installera la version appropriée de CircuitPython pour fonctionner avec votre Baguette S3.

Appuyez sur le bouton reset de votre Baguette S3, et votre carte devrait maintenant être automatiquement sélectionnée et affichée en bas à droite de Thonny, comme ci-dessous :

(si ce n’est pas le cas, cliquez sur ce texte et sélectionnez l’option CircuitPython – et si aucune option n’apparaît – sélectionnez ‘configure interpreter’ et sélectionnez CircuitPython à nouveau)

Vous constaterez également que vous avez maintenant un lecteur supplémentaire sur votre système (CIRCUITPY) créé par CircuitPython, où vous pouvez déposer du code et des bibliothèques.

Votre Baguette S3 a maintenant CircuitPython installé !

Installation des bibliothèques

Avant de pouvoir entrer dans quelques exemples, une dernière étape que nous devons accomplir est de télécharger les Bibliothèques CircuitPython, que nous utiliserons pour nos exemples.

Adafruit les regroupe aimablement toutes en un seul fichier, qui peut être téléchargé en un seul fichier zip.

Nous devons télécharger le “Bundle for Version 9.x”, disponible sur le site web de CircuitPython (descendez jusqu’à ‘Bundles’).

Téléchargez et dézippez/extrayez ce dossier, et nous vous indiquerons quels fichiers de bibliothèque copier sur votre Baguette S3 dans les exemples ci-dessous. Vous ne voulez pas vraiment tous les déplacer car vous n’aurez probablement pas assez d’espace sur la carte de toute façon (et c’est excessif de conserver 300+ bibliothèques alors que vous n’en avez besoin que de quelques-unes !)

LED RGB intégrée (WS2812C adressable)

Pour la LED RGB intégrée, nous utiliserons la bibliothèque neopixel.mpy, que vous pouvez trouver dans le fichier téléchargé précédemment que nous avons déplacé vers le dossier lib du lecteur CIRCUITPY. Copiez le fichier neopixel.mpy depuis le dossier lib téléchargé, et collez-le dans votre dossier lib de CIRCUITPY.

Voici un exemple de code utilisant cette bibliothèque, qui fait clignoter la LED RGB intégrée en rouge et bleu. Collez le code ci-dessous dans Thonny, puis sélectionnez le petit triangle vert (bouton d’exécution) ou sélectionnez Exécuter > Exécuter le script courant dans le menu :

# Required Library
# https://github.com/adafruit/Adafruit_NeoPixel
import time
import board
import digitalio
import neopixel
RED = (255, 0, 0)
BLUE = (0, 0, 255)
pixel_pin = board.IO8
num_pixels = 1
pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.3, auto_write=False)
while True:
    pixels.fill(RED)
    pixels.show()
    time.sleep(1)
    pixels.fill(BLUE)
    pixels.show()
    time.sleep(1)

Carte MicroSD

Insérez une carte MicroSD vide/nettoyée dans le slot.

Nous utiliserons la bibliothèque adafruit_sdcard.mpy et la bibliothèque Adafruit_bus_device (un dossier), que vous pouvez toutes deux trouver dans le fichier téléchargé précédemment.

Comme précédemment, celles-ci doivent être copiées sur la Baguette sous le dossier lib.

Cet exemple de code est modifié à partir de l’exemple SDCard d’Adafruit. Les changements les plus importants sont les assignations de broches, qui sont uniques à la Baguette S3 :

spi = busio.SPI(board.IO9, board.IO10, board.IO11)
cs = digitalio.DigitalInOut(board.IO7)

L’exemple de code ci-dessous écrit un fichier appelé test.txt et y insère “Hello World”, puis affiche un listing du répertoire du contenu de la carte SD.

# https://learn.adafruit.com/adafruit-micro-sd-breakout-board-card-tutorial/circuitpython
# The following libs need to be installed
# adafruit_bus_device
# adafruit_sdcard.mpy
import os
import adafruit_sdcard
import busio
import digitalio
import board
import storage
# Connect to the card and mount the filesystem.
spi = busio.SPI(board.IO9, board.IO10, board.IO11)
cs = digitalio.DigitalInOut(board.IO7)
sdcard = adafruit_sdcard.SDCard(spi, cs)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")
# Use the filesystem as normal.
with open("/sd/test.txt", "w") as f:
    f.write("Hello world\n")
def print_directory(path, tabs=0):
    for file in os.listdir(path):
        if file == "?":
            continue  # Issue noted in Learn
        stats = os.stat(path + "/" + file)
        filesize = stats[6]
        isdir = stats[0] & 0x4000
        if filesize < 1000:
            sizestr = str(filesize) + " by"
        elif filesize < 1000000:
            sizestr = "%0.1f KB" % (filesize / 1000)
        else:
            sizestr = "%0.1f MB" % (filesize / 1000000)
        prettyprintname = ""
        for _ in range(tabs):
            prettyprintname += "   "
        prettyprintname += file
        if isdir:
            prettyprintname += "/"
        print('{0:<40} Size: {1:>10}'.format(prettyprintname, sizestr))
        # recursively print directory contents
        if isdir:
            print_directory(path + "/" + file, tabs + 1)
print("Files on filesystem:")
print("====================")
print_directory("/sd")

Port Qwiic / I2C

Nous avons deux broches I2C dédiées sur le connecteur GPIO, étiquetées SDA et SCL, mais aussi un connecteur Qwiic (3,3V) qui partage les mêmes broches.

L’exemple de scanner I2C ci-dessous ne nécessite aucune bibliothèque externe et scannera le bus I2C puis affichera les adresses de tous les périphériques trouvés. Il est basé sur l’exemple d’Adafruit, avec le petit changement de configurer les broches utilisées pour l’I2C sur la carte Baguette S3

#https://learn.adafruit.com/scanning-i2c-addresses/circuitpython
# SPDX-FileCopyrightText: 2017 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: MIT
# pylint: disable=broad-except, eval-used, unused-import
"""CircuitPython I2C Device Address Scan"""
import time
import board
import busio
i2c = busio.I2C(board.IO48, board.IO47)
# List of potential I2C busses
ALL_I2C = ("i2c", "board.STEMMA_I2C()", "busio.I2C(board.GP1, board.GP0)")
# Determine which busses are valid
found_i2c = []
for name in ALL_I2C:
    try:
        print("Checking {}...".format(name), end="")
        bus = eval(name)
        bus.unlock()
        found_i2c.append((name, bus))
        print("ADDED.")
    except Exception as e:
        print("SKIPPED:", e)
# Scan valid busses
if len(found_i2c):
    print("-" * 40)
    print("I2C SCAN")
    print("-" * 40)
    while True:
        for bus_info in found_i2c:
            name = bus_info[0]
            bus = bus_info[1]
            while not bus.try_lock():
                pass
            print(
                name,
                "addresses found:",
                [hex(device_address) for device_address in bus.scan()],
            )
            bus.unlock()
        time.sleep(2)
else:
    print("No valid I2C bus found.")

Une chose à noter – si vous n’avez aucun périphérique connecté (pourquoi ?), vous verrez un message d’erreur quelque peu trompeur du style « No pull-up found on SDA or SCL ».

À vous de jouer !

Ce guide devrait vous donner tout ce dont vous avez besoin pour démarrer avec votre Baguette S3 – et maintenant, il est temps pour vous de passer à l’action et de CRÉER !

Nous aimerions voir vos projets Baguette sur plaque d’essai, vos intégrations de Baguette et même vos jolis travaux de soudure ! Partagez des photos sur nos réseaux sociaux et nous les partagerons avec nos abonnés pour inspirer d’autres personnes.

Si vous rencontrez des difficultés avec une partie de ce guide, laissez simplement un commentaire et nous vous aiderons.

Retrouvez l’histoire de Raspberry Pi dans cette vidéo :