Embedded Programming

Following Henk's example and the instructions at gitlab / Quentin Bolsee / qpad-xiao (from the QR-code on the back of the board), I soldered on the resistors, XIAO and the OLED modules (ours came with headers preinstalled, Henk got them here).

Those 1206 resistors were quite small (0.12 inches long and 0.06 inches wide), but soldering them was easier than I expected. The solder iron temperature was set to 78 (see figure 3) but it was unclear what this actually means (my guess: 378°C).

After connecting the USB to a power source (my laptop) the NeoPixel started blinking red, green and blue so at least the XIAO survived the soldering!

Next we were instructed to install MicroPython on the XIAO to allow programming it in Python. The RP2040 comes with a bootloader which allows it to startup in "boot mode" (named BOOTSEL in the documentation) when powering up with the "B" button pressed, it presents itself as a USB drive named "RPI-RP2" to a computer. It contains two files:

• INDEX.HTM

  Opening this in a web browser redirects to Raspberry Pi Documentation.

• INFO_UF2.TXT

  Contains information about the board and the bootloader.

  UF2 Bootloader v3.0
  Model: Raspberry Pi RP2
  Board-ID: RPI-RP2
  

This drive accepts files with the extension .uf2 and installs them as the main program when copied in, and then reboot thes board.

I later found out that pressing "B" and then "R" (reset) also resets it into BOOTSEL mode.

It was suggested to use Thonny to install MicroPython, but I decided to just install the UF2-file myself. Looking at the Seeed Studio documentation for this board (which uses Thonny) I found that I need the standard Raspberry Pi PICO installation. I downloaded it and copied it to the drive.

After rebooting, the RGB blinking was gone and the /dev/ttyACM0 showed up again in the kernel messages.

[145640.984952] usb 1-1: new full-speed USB device number 43 using xhci_hcd
[145641.123057] usb 1-1: New USB device found, idVendor=2e8a, idProduct=0005, bcdDevice= 1.00
[145641.123076] usb 1-1: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[145641.123082] usb 1-1: Product: Board in FS mode
[145641.123087] usb 1-1: Manufacturer: MicroPython
[145641.123091] usb 1-1: SerialNumber: 4250304638313309
[145641.126853] cdc_acm 1-1:1.0: ttyACM0: USB ACM device

I tried connecting to this serial port in Emacs with M-x serial-term (with the suggested baud rate of 9600) and got a Python REPL (Read-Eval-Print Loop). I worked!

MicroPython v1.27.0 on 2025-12-09; Raspberry Pi Pico with RP2040
Type "help()" for more information.
>>> help()
Welcome to MicroPython!

For online docs please visit http://docs.micropython.org/

For access to the hardware use the 'machine' module.  RP2 specific commands
are in the 'rp2' module.

Quick overview of some objects:
  machine.Pin(pin) -- get a pin, eg machine.Pin(0)
  machine.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p
    methods: init(..), value([v]), high(), low(), irq(handler)
  machine.ADC(pin) -- make an analog object from a pin
    methods: read_u16()
  machine.PWM(pin) -- make a PWM object from a pin
    methods: deinit(), freq([f]), duty_u16([d]), duty_ns([d])
  machine.I2C(id) -- create an I2C object (id=0,1)
    methods: readfrom(addr, buf, stop=True), writeto(addr, buf, stop=True)
             readfrom_mem(addr, memaddr, arg), writeto_mem(addr, memaddr, arg)
  machine.SPI(id, baudrate=1000000) -- create an SPI object (id=0,1)
    methods: read(nbytes, write=0x00), write(buf), write_readinto(wr_buf, rd_buf)
  machine.Timer(freq, callback) -- create a software timer object
    eg: machine.Timer(freq=1, callback=lambda t:print(t))

Pins are numbered 0-29, and 26-29 have ADC capabilities
Pin IO modes are: Pin.IN, Pin.OUT, Pin.ALT
Pin pull modes are: Pin.PULL_UP, Pin.PULL_DOWN

Useful control commands:
  CTRL-C -- interrupt a running program
  CTRL-D -- on a blank line, do a soft reset of the board
  CTRL-E -- on a blank line, enter paste mode

For further help on a specific object, type help(obj)
For a list of available modules, type help('modules')
>>>

Next, I tried to toggle the LED pin. I found the pin number in the XIAO RP2040 pin map on the Seeed Studio site.

In the Raspberry Pi Pico Pinout there's also a LED on pin 25, but apparently at XIAO they decided to combine it with pin 16 and 17 into a RGB LED.

>>> from machine import Pin
>>> led = Pin(25, Pin.OUT)
>>> led.value(1)
>>> led.value(0)

Interestingly, turning the pin "on" (1) makes the LED glow yellow (blue is turned "off") and turning the pin "off" (0) makes it white.

Reading through the RP2040 datasheet I found out about the Pice SDK and decided I want to try it out. It is very well documented!

Following the instructions at Pico SDK, I did the following to create blink firmware but now written in C. First I needed to install the required packages to use the SDK. Since I am using Guix, I can't use the example apt install command but need to create a Guix manifest.

(use-package-modules cmake
                     commencement
                     embedded
                     nss
                     python
                     version-control)

(packages->manifest
 (list cmake
       gcc-toolchain
       git
       gnu-make
       python
       nss-certs
       (make-arm-none-eabi-nano-toolchain-12.3.rel1)))

I found the above make-arm-none-eabi-nano-toolchain method by browsing the Guix source code in the embedded packages file. Finally something that works without depending on Nix or containers! Note: the above is the full list of packages needed to build a basic C program using the Pico SDK and can be used completely containerized (with guix shell -CPN).

Next, I pulled in the SDK as a git submodule.

git submodule add https://github.com/raspberrypi/pico-sdk

# the SDK also has submodules
(cd pico-sdk; git submodule update --init)

This SDK is based on CMake. I worked with CMake before but without really understanding it.

I downloaded the blink_simple.c file from the Pico Examples repository and followed the SDK instructions to set up a CMakeLists.txt file following the SDK instructions.

cmake_minimum_required(VERSION 3.13...3.27)

# initialize pico-sdk from submodule
# note: this must happen before project()
include(../pico-sdk/pico_sdk_init.cmake)

project(my_project)

# initialize the Raspberry Pi Pico SDK
pico_sdk_init()

# rest of your project
add_executable(blink_simple
    blink_simple.c
)

# Add pico_stdlib library which aggregates commonly used features
target_link_libraries(blink_simple pico_stdlib)

# create map/bin/hex/uf2 file in addition to ELF.
pico_add_extra_outputs(blink_simple)

Finally I could start building firmware – well, setup the build directory for building.

cmake -S . -B build -DPICO_BOARD=seeed_xiao_rp2040

This generated a lot of output but it was successful. It did warn about not finding picotool but will build it from source, which is fine.

The PICO_BOARD parameter ensures the seeed_xiao_rp2040.h is automatically included for the correct pin numbers, etc. Interestingly, the XIAO header file defines PICO_DEFAULT_LED_PIN_INVERTED which, I think, relates to my earlier discovery that the LED is turn on by setting the pin to low.

Now I could start building the firmware!

cmake --build build --target blink_simple

This took awhile because it needed to compile picotool but I got a bunch variants of the compiled source files:

$ file build/blink_simple.*
build/blink_simple.bin:     Raspberry Pi RP2040 firmware, initial SP at 0x20042000, reset at 0x100001f6, NMI at 0x100001ca, HardFault at 0x100001cc, SVCall at 0x100001ce, PendSV at 0x100001d0, with binary_info
build/blink_simple.dis:     ASCII text
build/blink_simple.elf:     ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, with debug_info, not stripped
build/blink_simple.elf.map: ASCII text
build/blink_simple.hex:     Intel hexadecimal object, 0x02 record length, 0x0000 offset, '04' type, data+checksum 1000EA
build/blink_simple.uf2:     UF2 firmware image, family Raspberry Pi RP2040, base address 0x10000000, 27 total blocks

I copied the build/blink_simple.uf2 and got a blinking led. It toggled between yellow and white because only pin 25 is toggled. I fixed this by also toggling pins 16 and 17.

#include "pico/stdlib.h"

#ifndef LED_DELAY_MS
#define LED_DELAY_MS 250
#endif

void pico_led_init(void) {
    gpio_init(PICO_DEFAULT_LED_PIN);
    gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);

    gpio_init(16);
    gpio_set_dir(16, GPIO_OUT);

    gpio_init(17);
    gpio_set_dir(17, GPIO_OUT);
}

void pico_set_led(bool led_on) {
    gpio_put(PICO_DEFAULT_LED_PIN, led_on);
    gpio_put(16, led_on);
    gpio_put(17, led_on);
}

int main() {
    pico_led_init();
    while (true) {
        pico_set_led(true);
        sleep_ms(LED_DELAY_MS);
        pico_set_led(false);
        sleep_ms(LED_DELAY_MS);
    }
}