Skip to content

Prerequisites

This page lists everything you need before the workshop. Complete all setup steps by April 17 so we can start building on Day 1 without delays.

Knowledge Requirements

Requirement Level Why You Need It
C programming basics Comfortable with structs, pointers, loops All ESP-IDF firmware is written in C
Terminal / command line Able to run commands, navigate directories Build, flash, and monitor from the terminal
Python basics Variables, functions, lists, loops Jupyter notebook sessions for TinyML training
Prior ESP32 / embedded experience Not required We start from zero on Day 1

Need a refresher?

We've prepared quick refresher guides:

Software Requirements

1. Docker Desktop

The entire ESP-IDF toolchain runs inside a Docker container — no need to install toolchains, compilers, or SDKs manually.
What Docker Desktop (or Docker Engine)
Why Runs the pre-built dev environment with ESP-IDF, toolchain, and all dependencies
Minimum version Docker 24.0+

Install:

  1. Download Docker Desktop for Windows
  2. Ensure WSL 2 is enabled: wsl --install in an Administrator PowerShell
  3. Restart your computer
  4. Launch Docker Desktop and verify: docker --version
  1. Download Docker Desktop for Mac
  2. Drag to Applications, launch Docker
  3. Verify: docker --version
# Ubuntu/Debian
sudo apt-get update
sudo apt-get install docker.io docker-compose
sudo usermod -aG docker $USER
# Log out and back in, then verify:
docker --version

Docker is mandatory

The workshop uses a pre-built Docker image (analogdata/esp32s3-devenv:latest) for the entire toolchain. You cannot participate without Docker installed. See the Docker Setup guide for full instructions.

2. USB Drivers

The XIAO ESP32-S3 uses a USB-C connection. You need the correct drivers for your OS to recognize the board.
Driver CP210x or CH340 (depending on your cable/adapter)
Download Silicon Labs CP210x

Note

macOS and Linux usually recognize the XIAO ESP32-S3 natively. Windows may require the CP210x driver. Connect your board and check if a serial port appears before the workshop.

3. Serial Terminal

You'll need a serial monitor to view firmware output and send commands.

The Docker image includes idf.py monitor. This is the recommended approach — no extra software needed.

OS Recommended Tool
Windows PuTTY or Arduino Serial Monitor
macOS screen /dev/tty.usbmodem* 115200 or CoolTerm
Linux minicom or picocom

4. Python 3.10+

Required for the Jupyter notebook sessions on Day 2 (TinyML training).
What Python 3.10 or later
Why Run Jupyter notebooks for data collection and model training
Install python.org or via your package manager

Verify: 

python3 --version
# Python 3.10.x or higher

5. Git

For cloning the workshop repository and version-controlling your code.
What Git 2.x
Install git-scm.com

Verify: 

git --version
# git version 2.x.x

6. picocom (Serial Terminal)

picocom is a lightweight serial terminal used to communicate with the ESP32 over USB. It's simpler than minicom and works well for flashing and monitoring.

sudo apt-get install picocom
# Usage:
picocom -b 115200 /dev/ttyUSB0

brew install picocom
# Usage:
picocom -b 115200 /dev/tty.usbmodem*

Use PuTTY instead — picocom is not available on Windows. Alternatively, the Docker image includes idf.py monitor which handles serial output.

Exiting picocom

Press Ctrl+A then Ctrl+Q to exit picocom. Ctrl+A is the escape key — all commands start with it.

7. xxd (Hex Dump Utility)

xxd creates hex dumps of binary files and can also convert hex back to binary. You'll use it to inspect firmware binaries, convert TFLite models to C arrays, and debug binary data.

# Usually pre-installed with vim-common
sudo apt-get install xxd
# Usage — view hex dump of a file:
xxd model.tflite | head -20

# Convert binary to C array (for embedding in firmware):
xxd -i model.tflite model.h

# Pre-installed on macOS (part of vim)
xxd -i model.tflite model.h

# Install via Git Bash or use the Docker container
# Inside Docker:
xxd -i model.tflite model.h

Converting a TFLite model to a C header

This is the most common use case — embedding a trained ML model into your ESP32 firmware: 

xxd -i model.tflite model.h
# Creates model.h containing:
# unsigned char model_tflite[] = { 0x1c, 0x00, 0x00, ... };
# unsigned int model_tflite_len = 3420;

Any editor works, but these have great C and ESP-IDF support:

  • VS Code with the C/C++ extension and ESP-IDF extension
  • Neovim / Vim with LSP configured for clangd

Hardware Requirements

All hardware is provided at the workshop. You do not need to purchase anything.

Hardware kit

See the Hardware Kit page for the full list of components you'll receive.

However, you must bring:

  • Your laptop (Windows, macOS, or Linux)
  • A USB-C cable (data-capable, not charge-only)
  • Docker installed and verified before arrival

Pre-Workshop Checklist

Use this checklist to confirm you're ready:

  • Docker Desktop installed and running (docker --version works)
  • Docker can pull images (docker pull hello-world succeeds)
  • USB-C data cable available
  • Python 3.10+ installed (python3 --version)
  • Git installed (git --version)
  • picocom installed (picocom --version or use idf.py monitor inside Docker)
  • xxd available (xxd -v or use inside Docker)
  • Serial port appears when XIAO ESP32-S3 is connected
  • C refresher reviewed — C Refresher
  • Python refresher reviewed — Python Refresher
  • Docker setup completed — Docker Setup

All checked?

You're ready for the workshop! Head to the Curriculum to see what's in store.