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, why not also check out our post where we vibe code a web server interface for the Baguette S3?

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 (coming soon!)
  • CircuitPython (coming soon - until then, Big Les has written a great guide)

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:

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:

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 - Arduino IDE and ESPHome.

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 - We are working on adding MicroPython and CircuitPython guides, which are coming soon. 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

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.