Baguette S3 User Guide

This guide will show you how to use your shiny new Baguette S3 ESP32-S3 development board, from the hardware features and specifications through to software setup and example code.

Once you're set up and have completed the examples here, why not also check out our post where we vibe code a web server interface for the Baguette S3? There's also a great CircuitPython Baguette S3 article from Les Pounder showing even more CircuitPython examples.

Contents

• Board features
• Powering the board
• GPIO Pins
• Mounting holes
• Boot/programming mode 👉do this first 👈
• Programming the Baguette S3
  • Arduino IDE
  • ESPHome via Home Assistant
  • MicroPython
  • CircuitPython

Board features

A quick reminder of the board's features that we will be showing you how to use:

Powering the board

The easiest way to power the board is to use the USB-C port, which also allows a data connection to your PC for programming. An onboard regulator drops this down to 3.3V for the ESP32-S3 module.

When powered, the board's blue 'PWR' LED will be lit.

Powering via pins

If you would prefer to power the board via the pins directly, you have a couple of options here:

• 5V pin - you can connect a regulated 5V power source to the 5V pin (and GND to the G pin)
  • This option will then use the onboard regulator to provide 3.3V to the ESP32-S3 module
• 3V pin - you can connect a regulated 3.3V power source to the 3V pin (and GND to the G pin)
  • We don't generally recommend this option, as it's best to stick to the 5V pads and let that run through the onboard ME6211 LDO regulator.

Power consumption example

We ran a simple 'real-world' test using the board alongside an mmWave sensor and SD card, to give you an idea of power consumption, using our fancy power profiler tool.

We averaged ~130mA current draw, with a max of ~139mA. Your mileage may vary, as it all depends on what your Baguette S3 is doing and what other hardware it's powering.

GPIO Pins

The Baguette S3 has a 30-pin header, which breaks out:

• 23 General-purpose GPIO
• I2C (SDA and SCL)
• UART (TX and RX)
• Power (5V, 3.3V and GND)

I2C/SDA pins

The I2C and UART pins have been separated from the general-purpose GPIO on the board; however, you can use these as GPIO pins if you wish. Their pin numbers are:

TX	GPIO43
RX	GPIO44
SCL	GPIO48
SDA	GPIO47

Other pins

A number of other pins are consumed by the MicroSD port and RGB LED. Whilst these are not broken out, we're adding them here for completeness:

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

Pin current limits

Like most development boards, you need to be aware of how much current each pin can consume. Drawing too much current from a GPIO pin may permanently damage your board!

• Each pin can draw up to 40mA absolute maximum, but try to keep it to around 20mA
• The 3V (3.3V) pin runs off the onboard regulator and provides up to 500mA; however, bear in mind that this also powers the ESP module
• The 5V pin - the board can draw up to 3A from the USB-C connector, although it is recommended to keep usage to around 1.5A or lower

Header strip

A header strip is included in the package, which you can solder on for breadboard usage if that's your intended use:

You can also fit compact 2.54mm terminal blocks if you prefer, an example of which can be seen in the image below (note that two blocks won't fit next to each other perfectly. We're using a 10-way block here to use specific pins):

Underside pads

If you plan to solder wires directly to the board, we recommend soldering wires directly to the flat, oval underside pads. They're a lot easier to work with and rework later on vs soldering into the pad holes.

Mounting holes

A quick note on mounting - the board features two M2.5 mounting holes, giving you an option to secure the board inside an enclosure or to a panel.

We stock M2.5 fixings in the store if you need any, including affordable nylon standoff packs and screws/nuts.

Boot/programming mode

If you're using the Baguette S3 for the first time or switching platforms, you may need to put the board into programming mode.  This can be achieved by holding the BOOT button down during power-on (connecting the USB-C cable).

However, the easiest way to achieve this (and minimise wear and tear on the USB connector) is to hold down the BOOT button and then press the RESET button while still keeping the BOOT button held down.

After pressing RESET, you can then release the boot button, and the board should now be in programming mode. This process should be the same regardless of your host computer's operating system.

Programming the Baguette S3

This section will cover how to program your Baguette S3 using popular options for ESP-based boards - click a link below to jump to that section:

• Arduino
• ESPHome via Home Assistant
• MicroPython
• CircuitPython

We won't be covering generic basics such as "how to install the Arduino IDE" or similar topics that are not specific to the Baguette S3, as these are already well-documented.

All examples and screenshots in this guide are from a Windows environment.

---

Other platforms - If you would like to see examples for other platforms, please add a comment at the end of this article.

---

Arduino IDE

The Baguette S3 uses an ESP32-S3 module, which is supported from the Arduino board package 2.0 and later, so we are focusing the guide on at least version 2.0. The screenshots below may look different as new versions are released, but the process should remain fairly consistent.

Install the software

The first step is to ensure you have the Arduino IDE installed and ready to go - you can download the software from Arduino here.

Board manager definition

Once installed, we need to ensure that we have the ESP32 defined in the board manager.

Navigate to Tools -> Board -> Board Manager - this will show a sidebar on the left-hand side, and if we type "ESP32" into the search, we can then select to install the “esp32 by Espressif Systems”:

Once this is added, you will now see a new 'esp32' menu when you go to Tools -> Board. We need to select ESP32 -> ESP32 S3 Dev Module, as per the screenshot below:

Serial configuration

We now need to make a change so that we can get serial output onto the console for debugging.

Since we’ve selected the “ESP32 S3 Dev Module”, we will now have more options under tools. We need to change the option “USB CDC On Boot:” to enabled, like this:

This setting allows the USB port to also be used for a serial console.  This is needed as there is no discrete USB-Serial chip, as it’s built into the ESPS3 line of chips.

Port selection

Lastly, we need to confirm the correct port is selected under Tools -> Port. The ports listed, and port number, will depend on your platform and how many other devices you have connected; however, you may find that your baguette shows up as an 'ESP32 Family device'.

Sometimes other devices will show up as COM ports, which can be confusing. The best way to figure out which one is your Baguette S3 is to disconnect it and see which port disappears from the list (then reconnect it).

Important: Disconnect any other development boards to avoid erasing another board!

We are now at a point where we can use our board with the Arduino IDE!

Onboard RGB LED (Addressable WS2812C)

We are going to be using the Neopixel example from Adafruit, who have created a great library that does a lot of the heavy lifting for us.

In the Arduino IDE, we need to go to Sketch -> include library -> Manage Libraries, like this:

Similar to the board manager, it will bring up a side pane where we can search for “Adafruit neopixel”:

Once the library has been installed, we can open one of the newly installed examples by going to File -> Examples -> Adafruit Neopixel -> Simple example.

We have to make two changes to the file to make it work with our Baguette S3 to indicate that our RGB LED is connected on pin 8, and we have a single 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

To explain the example, we have three main commands for controlling the LED.

pixels.clear();

This command sets the pixel colours to off.

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

Here we can set the desired colour of the LED.  The three supplied numbers are in an RGB (Red, Green and Blue) format and can range from 0 (off) to 255 (full brightness).  So the above line will set the colour to be green at just above half brightness.

pixels.show();

Before we can see the colour, we have to include pixels.show to send the data to the LED. 

MicroSD Card

You can add a MicroSD card in to the onboard MicroSD slot, which can be useful for long-term storage requirements, or where you need more than could be stored internally for projects that require datalogging.

To get you started, we are going to use the built-in example, which can be found at Examples for ESP32S3 Dev Board -> SD -> SD_Test.

We need to find the section shown below to modify it:

/*
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;
*/

These are the pins which tell the code which pins to use when using the SD card.  We need to modify the code, as shown below, which sets the pins correctly for the Baguette S3, and also uncomments the code to enable the pin change:

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

With these pins correctly configured, the 'SD.h library' can be used to interact with the file system on the SD card.  

The code examples show how to perform standard operations such as working with directories as well as manipulating files.  It will show output on the serial monitor of the IDE.  This can be enabled with the option in the top right, using this icon:

The start of the serial output will be similar to the following (your output will differ depending on the contents of your SD card). The keen-eyed among you will spot that we had a Raspberry Pi SD card fitted for testing:

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

Qwiic Port / I2C

We have two dedicated I2C pins on the GPIO header, labelled SDA and SCL, but also a Qwiic (3.3V) connector which shares the same pins.

To show these pins, we are going to use the simple I2C scanner example available from randomnerd tutorials. We're going to use their code example, but we need to tweak it to work with our board first.

Start by adding our I2C pin definitions as new lines (after the #include line is good): 

#define I2C_SDA 47
#define I2C_SCL 48

Then we need to specify the pins by modifying the existing Wire.begin(): line to the following:

Wire.begin(I2C_SDA, I2C_SCL);

With those in place, if you have a device plugged into the Qwiic port, or into the dedicated header pins, when you run your code, the Serial Monitor should now display something similar to this:

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

The address shown will differ depending on the device you have connected (many Qwiic devices have a fixed address and are sometimes printed on the PCB).

If you see no addresses, check your wiring and make sure you have 'USB CDC on boot enabled' in the IDE (which we set earlier).

---

ESPHome via Home Assistant

Working with ESPHome can be a little more intricate, but also a lot simpler in some ways.

The examples below are using version 2025.8.3. As new versions are released, things may change, look different or just plain ol' break! Let us know in the comments if you experience any issues.

For our example, we are going to add the board from within the Home Assistant ESPHome addon. We're assuming that you already have ESPHome running on your Home Assistant host device, if not, you can follow the instructions here.

Add Baguette S3 to ESPHome

To begin, we navigate to the ESPHome Add-on page and click “New Device” (bottom right corner currently):

You will be asked for a new name for your device. For our example, we'll name the board “baguette-s3”:

At this point, we'll be asked to connect the Baguette S3 board to the computer we are running the configuration from, and select “Connect”:

We then need to select the serial port, which will show up as USB JTAG/Serial or similar, depending on the platform you are using.

After clicking connect, it will then show “Preparing Installation”. This can take some time.

If you receive a warning that the operation was successful but the board could not be reconnected, pressing the RESET button usually resumes communication.

Once the process has finished, you will now have a new entry for the board in your ESPHome dashboard within Home Assistant:

From here, you can click edit and view the default YAML config. It’s recommended to add it in this manner as the items, such as the api key and OTA password, are unique for your setup.

Board definition

The board definition we require is installed by default; however, we need to specify the board by configuring the following in our example:

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

We also need to set the web server to be active so we can see our options and interact with the board. This can be achieved by inserting the following into our config:

web_server:
  port: 80

Onboard RGB LED (Addressable WS2812C)

To use the onboard RGB LED, we need to define which pin we are using and the number of LEDs, like this:

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

With this configuration, we can visit the board in ESPHome, which will give us the following webpage, where we can see the RGB LED state and toggle it as well as set the brightness level:

MicroSD Card

To utilise a MicroSD in ESPHome, we require the use of an 'external component' which is introduced by adding the link from the component's GitHub page.

We also need to tweak the way we define the board by adding a small 'external components' section after the board type, as shown below:

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

For the config, we will define the pins our SD card is using and some basic sensors to show information about our SD card:

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"

If you visit the board in ESPHome, this will now show the following on the web page (what you see will be different depending on your SD card):

More SD card operations and examples can be found on the component's GitHub page.

Qwiic Port / I2C

We have two dedicated I2C pins on the GPIO header, labelled SDA and SCL, but also a Qwiic (3.3V) connector which shares the same pins.

For the I2C/Qwiic port, we are going to configure the pins required and then run a scan for connected I2C devices. We need to include the following config:

Web_server:
  port: 80

i2c:
    sda: 47
    scl: 48
    scan: True

It's as simple as that, and if you now visit the board in ESPHome or bring up the logs, you will see output similar to below (but with the address of your device):

[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

As usual, we'll be using Thonny as our IDE for MicroPython. Not the most fashionable, but it's widely used by beginners and experienced alike.

Install the software

The first step is to ensure you have Thonny installed and ready to go - you can download Thonny here. Setup is straightforward and well-documented.

Install Thonny, open the program, then move on to the next step once you're ready.

Install MicroPython on the Baguette S3

Connect your Baguette S3 to your PC via USB-C, then put your board into boot/programming mode as we showed you earlier.

In Thonny, click this section at the bottom-right corner of the interface, then select 'Configure Interpreter'.

You now need to select 'MicroPython (ESP32)' in the first drop-down box, automatic detection in the second box (usually defaults to this):

WAIT! Don't click 'OK' yet! You now need to select the 'Install or update MicroPython (esptool)' link:

This will bring up another window where you need to select the following options:

• Target port: Usually, the 'USB JTAG' option
  • If you see multiple options, come out, disconnect other devices, and try again.
• MicroPython family: ESP32-S3
• Variant: Espressif-ESP32-S3
• Version: Select the latest version (1.26.1 at the time of writing)

Now select 'Install' and Thonny will install the correct flavour of MicroPython to work with your Baguette S3.

You'll see a progress bar at the bottom-left of the window, which will eventually show 'Done!'. You can now close that window, then select 'OK' to close down the interpreter window, returning you to the main Thonny interface.

Your board should now be automatically selected and showing at the bottom-right of Thonny like this (if not, click on that text and select the correct port/ESP32 option):

Your Baguette S3 is now ready with MicroPython installed!

Onboard RGB LED (Addressable WS2812C)

A Neopixel library is already built into MicroPython for our use. Below you'll find some example code to try this out.

Paste the code below into Thonny, then select the little green triangle (run button) or Select Run > Run current script from the 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)

As a quick breakdown of the main elements here, the following line defines that we have one neopixel on pin 8, which we are calling np1:

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

The following line sets the neopixel to full brightness with red:

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

And this line then instructs the neopixel to set the colour we have selected.:

np1.write()

MicroSD Card

Pop a blank/empty MicroSD card into the slot, and we'll show you some examples using the built-in SD card MicroPython class. Grab parts of these code examples for your own projects to write data to a MicroSD card:

The following code mounts the SD card using the pins the Baguette S3 utilises for the SD slot, writes a new line of text to a test file (test.txt), then unmounts the SD card.

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()

If you want to read the contents of that exact file, use the code below.

Tip: run the first example above a few times to see multiple lines of text here:

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()

Here's another example that lists the file contents of the Micro SD card:

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()

Qwiic Port / I2C

We have two dedicated I2C pins on the GPIO header, labelled SDA and SCL, but also a Qwiic (3.3V) connector which shares the same pins.

The code below will scan for connected I2C devices. This is a nice and simple, self-contained example.  We set up the I2C pins that the Baguette S3 is using, then use the built-in i2c.scan() command, which will scan for any I2C devices and report their addresses:

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 is an open-source implementation of Python specifically designed for microcontrollers and beginners, made by Adafruit.

We'll be using Thonny as our IDE for CircuitPython.

Install the software

The first step is to ensure you have Thonny installed and ready to go - you can download Thonny here. Setup is straightforward and well-documented.

Install Thonny, open the program, then move on to the next step once you're ready.

Install CircuitPython on the Baguette S3

Connect your Baguette S3 to your PC via USB-C, then put your board into boot/programming mode as we showed you earlier.

In Thonny, click this section at the bottom-right corner of the interface, then select 'Configure Interpreter'.

You now need to select 'CircuitPython (generic)' in the first drop-down box, automatic detection in the second box (usually defaults to this):

WAIT! Don't click 'OK' yet! You now need to select the '(esptool)' link.

Important! There are three links here - you must click the middle (esptool) option:

This will bring up another window where you need to select the following options:

• Target port: Usually, the 'USB JTAG' option
  • If you see multiple options, come out, disconnect other devices, and try again.
• CircuitPython family: ESP32-S3
• Variant: Espressif - ESP32-S3-DevKitC-1-N8
• Version: Select the latest version (9.2.9 at the time of writing)

Now select 'Install' and Thonny will install the correct flavour of CircuitPython to work with your Baguette S3.

You'll see a progress bar at the bottom-left of the window, which will eventually show 'Done!'. You can now close that window, then select 'OK' to close down the interpreter window, returning you to the main Thonny interface.

Hit the reset button on your Baguette S3, and your board should now be automatically selected and showing at the bottom-right of Thonny, like below:

(if not, click on that text and select the CircuitPython option - and if no option shows - select 'configure interpreter' and select CircuitPython again)

You'll also find that you now have an extra drive on your system (CIRCUITPY) created by CircuitPython, where you can drop code and libraries.

Your Baguette S3 now has CircuitPython installed!

Library Installation

Before we can get into some examples, one last step we must complete is to download the CircuitPython Libraries, which we will be using for our examples.

Adafruit kindly bunches these all into one file, which can be downloaded in a single zip file.

We need to download the “Bundle for Version 9.x”, which is available from the CircuitPython website (scroll down to 'Bundles').

Download and unzip/extract this folder, and we'll tell you which library files to copy over to your Baguette S3 in the examples below. You don't really want to be moving them all over as you'll likely not have enough space on the board anyway (and it's excessive to hold 300+ libraries when you only need a handful!)

Onboard RGB LED (Addressable WS2812C)

For the onboard RGB LED, we will be using the neopixel.mpy library, which you can find in the file downloaded earlier that we moved over to the CIRCUITPY drive lib folder. Copy the neopixel.mpy file from the downloaded lib folder, and paste it into your CIRCUITPY lib folder.

Here's example code using that library, that flashes the onboard RGB LED red and blue. Paste the code below into Thonny, then select the little green triangle (run button) or Select Run > Run current script from the 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)

MicroSD Card

Pop a blank/empty MicroSD card into the slot.

We'll be using the adafruit_sdcard.mpy library and the Adafruit_bus_device library (a folder), both of which you can find in the file downloaded earlier.

As before, these must be copied onto the Baguette under the lib folder.

This code example is modified from the Adafruit SDCard example. The most important changes are the pin assignments, which are unique to the Baguette S3:

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

The code example below writes one file called test.txt and inserts “Hello World” into it, and then outputs a directory listing of the contents of the SDCard.

# 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")

Qwiic Port / I2C

We have two dedicated I2C pins on the GPIO header, labelled SDA and SCL, but also a Qwiic (3.3V) connector which shares the same pins.

The I2C scanner example below does not require any external libraries and will scan the I2C bus and then output the addresses of any devices found. It's based on the Adafruit example, with the small change to configure the pins used for I2C on the Baguette S3 board

#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.")

One thing to note - if you have no devices connected (why?), you'll see a slightly misleading error message along the lines of "No pull-up found on SDA or SCL".

Over to you!

This guide should give you everything you need to get started with your Baguette S3 - and now it's time for you to go forth and MAKE!

We'd love to see your breadboarded Baguette projects, where you've embedded a Baguette and even your lovely solder jobs! Share pics on our socials and we'll share them with our followers for inspiration.

If you get stuck with any part of this guide, just leave a comment and we'll help.