Week 4 – Embedded Programming

Group Assignment

In this week’s group assignment, we explored, demonstrated and compared the toolchains and development workflows for different embedded architectures.

Group Assignment

Below is my take away and reflection on group assignment.

Toolchain: The Complete Pipeline from Code to Silicon, a toolchain converts human-readable code into machine instructions and uploads it to the microcontroller.

Toolchain includes:

• Programming Language
• Compiler / Interpreter
• Board Support Packages (BSPs)
• Upload Tools

We compared four microcontroller platforms based on how easy it was to set up the toolchain and create a simple LED blink program.

Comparison Table from Group Assignment

Individual Assignment

Getting Started with Embedded Systems

“From silicon chips to maker boards, today’s class connected the hidden world of microelectronics to hands-on microcontroller programming.”

This session focused on understanding how modern computing systems are built, starting from microscopic semiconductor devices and progressing toward the microcontroller platforms commonly used in digital fabrication, embedded systems, and rapid prototyping.

🧠 From Microelectronics to Computer Systems

We began by exploring microelectronics and semiconductor manufacturing, watching industry videos that demonstrated how billions of transistors are fabricated onto silicon wafers using advanced processes such as photolithography, deposition, etching, and packaging.

To appreciate the incredible scale of modern integrated circuits, imagine fitting an entire city into an area no larger than the cross-section of a few human hairs. Modern microchips contain billions of nanoscopic transistors packed into an extremely small area, enabling remarkable computing power within compact devices.

We then expanded our perspective from individual chips to complete computer systems and discussed the relationship between:

• Input Devices – keyboards, mice, sensors, cameras, and microphones.
• Output Devices – displays, speakers, motors, LEDs, and actuators.
• Motherboards – the central communication platform connecting all system components.

Additional hardware components discussed during the session included:

• CPU (Central Processing Unit)
• GPU (Graphics Processing Unit)
• RAM (Random Access Memory)
• Network Interfaces
• Storage Technologies – Floppy Disk 💾 → CD/DVD 📀 → HDD → SSD

Microprocessor (CPU) vs Microcontroller (MCU)

One of the key topics covered was the distinction between a microprocessor and a microcontroller.

In Summary:

• 👉 CPUs are designed to run complete computer systems.
• 👉 MCUs are designed to control dedicated devices and embedded applications.

⚡ Datasheet Study and Maker Board Evolution: From Arduino to RP2040

We explored the evolution of popular maker platforms and their increasing capabilities:

• Arduino Boards – simple, beginner-friendly microcontroller platforms.
• Raspberry Pi – powerful single-board computers capable of running a full operating system.
• Seeed Studio XIAO RP2040 – a compact yet powerful microcontroller board based on the Raspberry Pi RP2040 chip.

To better understand modern embedded platforms, I compared the Arduino Uno, RP2040, and ESP32-S3 based on their processing power, memory, connectivity, and application areas.

I compared Arduino Uno, RP2040, and ESP32-S3 in terms of processing power, memory, connectivity, and application capabilities.

The Arduino Uno is an 8-bit microcontroller that is well-suited for basic input/output operations and embedded control applications with minimal overhead. The Raspberry Pi Pico, based on the RP2040, provides a more powerful 32-bit dual-core platform that is ideal for real-time applications, signal processing, and multimedia interfacing. The Seeed Studio XIAO ESP32-S3 Sense combines high processing performance with built-in Wi-Fi, Bluetooth, onboard sensors, and camera support, making it suitable for advanced IoT, sensing, computer vision, and edge machine learning projects.

The RP2040 offers an excellent balance between performance and size. Its compact form factor, combined with its dual-core architecture and rich peripheral support, makes it particularly attractive for embedded, portable, and wearable electronics projects.

⏱ What Does MHz Actually Mean?

MHz (Megahertz) represents how many clock cycles occur every second.

For example:

• 5 Hz = 5 cycles per second
• 10 Hz = 10 cycles per second
• 1 MHz = 1 million cycles per second

A higher clock frequency generally allows a processor to execute more instructions within the same amount of time.

⚡ Relating MHz to the RP2040

To better understand the performance of the RP2040, let's look at how much data it can process and how quickly it operates.

• 👉 Bit = A single binary switch (0 or 1)
• 👉 Byte = 8 bits grouped together
• 👉 RP2040 is a 32-bit microcontroller, meaning it can process 32 bits of data in a single operation
• 👉 The RP2040 operates at up to 133 MHz, which means it can perform approximately 133 million 32-bit operations per second

In simple terms:

• 133,000,000 × 32 bits = approximately 4.25 billion bits per second
• 4.25 billion bits ÷ 8 = approximately 531 MB/s of theoretical data throughput

Therefore, under ideal conditions, the RP2040 is theoretically capable of processing approximately 531 MB of data per second. In practice, the actual throughput is lower due to instruction overhead, memory access time, peripheral operations, and software execution constraints.

📚 ESP32-S3 Datasheet Study and 🔌 Hands-on with Seeed Studio XIAO RP2040

I explored the datasheet of the ESP32-S3 to better understand its architecture, memory organization, communication interfaces, and processing capabilities.

ESP32-S3 Datasheet

Official Datasheet: https://documentation.espressif.com/esp32-s3_datasheet_en.pdf

ESP32-S3 Overview

• Processor – Dual-core Xtensa LX7 CPU (32-bit)
• Clock Speed – Up to 240 MHz
• SRAM – 512 KB
• Flash Memory – 4 MB to 16 MB
• Operating Voltage – 3.3 V
• GPIO Pins – 45
• Analog Inputs (ADC) – Up to 20 channels, 12-bit
• PWM Channels – 8
• Communication Interfaces – 3 UART, 2 I²C, 2 SPI
• Programming Languages – C/C++, MicroPython, and CircuitPython
• Wi-Fi – IEEE 802.11 b/g/n
• Bluetooth – Bluetooth® 5 LE
• Camera Support – 8-bit to 16-bit DVP Camera Interface
• Onboard Sensors – IMU, Microphone, etc.

Functional Block Diagram of the SoC (System on Chip)

The dark gray blocks represent low-power components that remain operational during Deep Sleep mode.

Functional Block Diagram of ESP32-S3

Image Source

Xtensa® 32-bit LX7 Dual-Core Processor

• Two processor cores operate in parallel.
• Maximum clock speed of 240 MHz.

Memory Architecture

• ROM: 384 KB
• SRAM: 512 KB (shared and accessible by both cores)
• RTC SRAM: 16 KB
• 128-bit Data Bus
• DMA Controller (Direct Memory Access)
• Flash Memory: 4 MB to 16 MB

Memory Organization

The following diagram illustrates the address mapping structure of the ESP32-S3.

ESP32-S3 Memory Organization

Image Source

GPIO Pin Layout

ESP32-S3 GPIO Layout

Image Source

During the lab session, we received a Seeed Studio XIAO RP2040, LEDs, jumper wires, and a breadboard. We studied the RP2040 pinout and familiarized ourselves with breadboard connections before beginning our programming exercises.

Seeed Studio XIAO RP2040 Pinout

Image Source

Seeed Studio XIAO RP2040 Development Board

Image Source

⚠️ Important RP2040 Safety Guidelines

Caution the 3.3 V operating voltage and GPIO limitations of the RP2040.

3.3 V Logic

• GPIO pins are NOT 5 V tolerant.
• Applying 5 V directly to a GPIO pin can permanently damage the board.
• Use level shifters when interfacing with 5 V sensors, Arduino modules, or other 5 V devices.
• The RP2040 microcontroller can be damaged instantly if 5 V is applied to any GPIO pin.

Current Limits

• Each GPIO pin should be limited to approximately 12 mA for safe operation.
• Do not drive high-power loads directly from GPIO pins. Use transistors, relays, or MOSFETs instead.
• Always use a current-limiting resistor (typically 220 Ω to 1 kΩ) when driving LEDs.
• Motors and servos should be powered using an external power supply and appropriate driver circuitry.

🧰 Toolchain: The Complete Pipeline from Code to Silicon

A toolchain converts human-readable source code into machine instructions and uploads them to a microcontroller.

The toolchain includes:

• Programming Language
• Compiler / Interpreter
• Board Support Packages (BSPs)
• Upload Tools

🔌 Hardware Connection

I connected the Seeed Studio XIAO RP2040 to my computer using a USB Type-C cable. Once powered, I observed that the onboard RGB LED, the Power LED, and the User LED were illuminated. This indicates that the board is shipped with a factory-programmed default firmware.

To upload new firmware, I pressed and held the BOOT button while connecting the USB cable between the XIAO RP2040 and my computer. The board entered bootloader mode, and a new removable storage device named "RPI-RP2" appeared on the system.

The illuminated Power LED confirms that the board is receiving power correctly and has been successfully connected to the computer.

XIAO RP2040 in Bootloader Mode Showing the RPI-RP2 Drive

💻 Software Setup

I downloaded and installed the latest version of the Arduino IDE compatible with my operating system.

After launching the Arduino IDE, I added support for the Seeed Studio XIAO RP2040 board package by following these steps:

1. Navigate to File → Preferences.
2. In the Additional Boards Manager URLs field, add the following URL:
   https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
3. Click OK to save the settings.

Adding the RP2040 Board Manager URL in Arduino IDE Preferences

Next, I installed the required RP2040 board package:

1. Navigate to Tools → Board → Boards Manager.
2. Search for "RP2040".
3. Install the latest version of Raspberry Pi Pico/RP2040.

Installing the Raspberry Pi Pico / RP2040 Board Package

First Blink Code Test

The first code that I tried was the blink LED code. Below is the code that I generated it using reference of example blink code.

Circuit connection : D0 pin of XIAO RP2040 is connected to positive leg of LED, the negative leg of LED is connected to 1K resistor and the other end of resistor is connected to the GND. The Breadboard GND Bus is connected to Ground of XAIO RP2040's GND.

// the setup function runs once when you press reset or power the board
void setup() 
{
  pinMode(D0, OUTPUT);      // initialize digital pin D0 as an output.
}

// the loop function runs over and over again forever
void loop() {

  digitalWrite(D0, HIGH);   // turn the LED On (LOW is the voltage level)
  delay(100);               // wait for a second
  digitalWrite(D0, LOW);    // turn the LED Off (HIGH is the voltage level)
  delay(100);               // wait for a second
  digitalWrite(D0, HIGH);   // turn the LED ON (LOW is the voltage level)
  delay(100);               // wait for a second

  digitalWrite(D0, LOW);    // turn the LED off by making the voltage HIGH
  delay(2000);              // wait for a second
}
          

🔧 Assembling an Embedded System

I assembled an embedded system using a push button as the input device and an LED and OLED display as the output devices. All components were connected on a breadboard using jumper wires.

• Resistors – Used to limit current flow and protect electronic components.
• Push Buttons – Used as input devices to send user commands to the microcontroller.
• LEDs – Light Emitting Diodes used as visual output indicators.
• Jumper Wires – Used to make temporary electrical connections between components.
• Breadboard – A prototyping board used for building and testing circuits. Below image explains the breadboard internal connections, supply bus and ground bus.
• Microcontroller – A programmable electronic device that reads inputs, processes data, and controls outputs.

Embedded System Assembly Using Seeed Studio XIAO RP2040, Push Button, LED, and OLED Display

Circuit Diagram for Reference

💻 Programming the Embedded System

Using example programs from wiki.seeedstudio.com , I developed and uploaded a program that detects the push button state and turns on the LED while displaying "FAB LAB Kerala" on the OLED display when the button is pressed.

Wired communication using I²C is used between the Seeed Studio XIAO RP2040 and the OLED display.

Arduino-style C/C++ Code

/* Task :  Write and test a program for an embedded system using a microcontroller to interact with input and / or output devices and communicate with wired or wireless devices. Flash LED and display something on serial monitor and OLED Display when the Push button is pressed.

  Hardware assembly description 
  Development Board   : Seeed Studio XIAO RP2040
  Inputs              : PIN D7 Push button
  Outputs             : PIN D0 Blue LED 
  Wired Communication : I2C with OLED Display                    

  Created on          : 14 Feb 2026 
  Author              : Abhishek
  Modification History: 17 Feb 2026 
  
  Library installed for this code are U8g2 by Oliver. (You can install Library Sketch > Include Library > Manage Libraries > Search U8g2 > Install)
  Arduino Programming Reference : https://docs.arduino.cc/language-reference/
  Seed Studio Reference : https://wiki.seeedstudio.com/XIAO-RP2040-with-Arduino/
*/

#include <Arduino.h>           // this header file provides access to all the standard, built-in Arduino functions, variables, and constants. Without it, the compiler would not recognize basic Arduino commands. it is must include for VS Code and other programing environments. 
#include <U8g2lib.h>            // this header file provides a preprocessor directive in Arduino/C++ programming that imports the U8g2 library.
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C         // this header checks if token U8X8_HAVE_HW_I2C has been defined earlier and check if OLED display supports I2C communication, if yes then include Wire.h library. 
#include <Wire.h>
#endif

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

const int BlueLED = D0;         // the number of Blue LED pin
const int PushButton = D7;      // the number of PushB Button pin, note that here const mean "read-only" variable its value is set at initialization and cannot be changed later in the program, which helps prevent accidental modification of important values.

int ButtonStatus = LOW;         // Variable for reading the pushbutton status
int i;                          // counter for for loop

void setup() // the setup function runs once when you press reset or power the board
{
  pinMode(BlueLED, OUTPUT);     // initialize digital PIN D0 as output 
  pinMode(PushButton, INPUT);   // initialize digital PIN D7 as Input
  Serial.begin(115200);         // Set the data rate 115200 baud (bits per second) for serial data transmission.
  Wire.begin();                 // Activates the I2C hardware peripheral, Assigns SDA & SCL pins to I2C mode, Gets ready to send/receive data
  u8g2.begin();                 // initialize the display and prepare it for drawing with u8g2 Arduino graphics library
}

void loop() // the loop function runs over and over again forever
{
  ButtonStatus = digitalRead(PushButton);   //read the digital status of Push Button 
  
  if (ButtonStatus == LOW)                 //if Push Button Status in LOW then flash the LED as Airbus Strobe lights pattern for 5 times 
  {
    for (i = 0; i<10; i++)
    {
      Serial.println("FABLAB Kerala!");   // this prints "FABLAB Kerala!" on the serial monitor
    
      digitalWrite(BlueLED, HIGH);           // turn ON Blue LED
      delay(100);                            // delay of 0.1 second

      digitalWrite(BlueLED, LOW);            // turn OFF Blue LED
      delay(100);                            // delay of 0.1 second

      digitalWrite(BlueLED, HIGH);           // turn ON Blue LED
      delay(100);                            // delay of 0.1 second

      digitalWrite(BlueLED, LOW);            // turn OFF Blue LED
      delay(400);                            // delay of 0.7 second

      u8g2.setFont(u8g2_font_ncenB08_tr);       // ncenB: New Century Schoolbook (font name), Bold (weight). Height of the font is 8 pixels
      u8g2.drawStr(0,10,"Airbus Strobe light..");   // draw string at x = 0 and y = 10
      u8g2.drawStr(0,30,"By");                      // draw string at x = 0 and y = 30
      u8g2.drawStr(0,50,"FAB LAB Kerala!");         // draw string at x = 0 and y = 50
      u8g2.sendBuffer();                         // transfer internal memory to the display
      u8g2.clearBuffer();                       // clear the internal memory
      delay(700);
    }
    u8g2.sendBuffer();                         // transfer internal memory to the display
  }
  
  else 
  {
    digitalWrite(BlueLED, LOW);              // turn Off Red LED
  }

}
        
          

📖 Learning Note

Today, I learned how to quickly rename variables and perform bulk editing in Visual Studio Code.

1. Place the cursor on a word (for example, ledPin).
2. Press Ctrl + D to select the current occurrence.
3. Press Ctrl + D again to select the next matching occurrence.
4. Continue pressing Ctrl + D to select all matching occurrences and edit them simultaneously.

🤖 Using AI for Troubleshooting

While developing the program, I combined code snippets from three different examples available on wiki.seeedstudio.com . When the OLED display failed to show any output, I used AI to help identify the issue.

After reviewing the code, the AI identified that the OLED example used an incorrect constructor configuration and suggested adding Wire.begin() inside the setup() function to properly initialize I²C communication.

The ChatGPT prompt I used was:

"What is wrong in this code? It is not working, and the OLED is not displaying anything!"

I then pasted the complete source code into the AI chat for analysis.

AI-Assisted Troubleshooting of the OLED Display Issue

⬆️ Uploading the Program

Before uploading the program, make sure that the correct Board and Port are selected from the Tools menu. These settings can also be accessed from the top-left corner of the Arduino IDE, as shown below.

Selecting the Correct Board in Arduino IDE

Selecting the Correct Serial Port in Arduino IDE

🖥️ Exploring the Serial Monitor

Before using the Serial Monitor, the microcontroller must be connected to the computer and configured with the correct baud rate. In the Arduino IDE, the Serial Monitor can be opened by navigating to Tools → Serial Monitor.

The baud rate defines the speed of serial communication between the microcontroller and the computer, measured in bits per second (bps).

In simple terms, the baud rate determines how fast bits travel across the communication channel.

The Serial Monitor was used to establish two-way communication between the computer and the RP2040 microcontroller. Text commands were transmitted from the computer and interpreted by the microcontroller to control multiple LEDs and update the OLED display in real time. This exercise demonstrated serial communication, real-time debugging, user interaction, and serial-based device control.

Arduino-style C/C++ Code

/* Exploring Serial Monitor
Baud rate = how many bits are sent per second
*/

#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

const int RED = D0;
const int GREEN = D1;
const int BLUE = D2;
const int YELLOW = D3;
char cmd;

void setup()
{
  pinMode(RED, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(BLUE, OUTPUT);
  pinMode(YELLOW, OUTPUT);

  Serial.begin(115200);
  while (!Serial);

  Serial.println("Send R G B Y or O : ");

  Wire.begin();
  u8g2.begin();
  delay(1000);
}

void loop()
{
  u8g2.setFont(u8g2_font_ncenB08_tr);
  u8g2.drawStr(0,10,"Enter R G B Y or O :");
  u8g2.drawStr(0,20,"Command:");

  u8g2.sendBuffer();

  if (Serial.available())
  {
    char cmd = Serial.read();

    u8g2.drawStr(0,40,String(cmd).c_str());
    u8g2.sendBuffer();

    digitalWrite(RED, LOW);
    digitalWrite(GREEN, LOW);
    digitalWrite(BLUE, LOW);
    digitalWrite(YELLOW, LOW);

    if (cmd == 'R') digitalWrite(RED, HIGH);
    if (cmd == 'G') digitalWrite(GREEN, HIGH);
    if (cmd == 'B') digitalWrite(BLUE, HIGH);
    if (cmd == 'Y') digitalWrite(YELLOW, HIGH);

    Serial.print("Command received: ");
    Serial.println(cmd);
  }
}

          

🤖 Asking AI to Generate Code

To explore AI-assisted programming, I provided the following prompt to an AI model:

Prompt ChatGPT:
"I have an LED connected to D3 and a push button connected to D0 on a Seeed Studio XIAO RP2040. I want a program that allows me to press the button once to start blinking the LED and press it again to stop blinking. The program should also print the LED status on the Serial Monitor."

I submitted the same prompt to multiple AI assistants. The response from Claude.ai was particularly interesting because, in addition to generating the code, it also provided a wiring diagram showing the required hardware connections based on the generated program.

The generated program uses a toggle mechanism to switch between blinking and non-blinking states. It also implements software debouncing and uses the millis() function for non-blocking timing instead of relying on delay-based execution.

Arduino-style C/C++ Code Generated by AI

// ═══════════════════════════════════════════════════════
//   XIAO RP2040 - Button Toggle LED Blink
//   LED    → D3
//   Button → D0 (Active LOW, Internal Pull-up Enabled)
// ═══════════════════════════════════════════════════════

// ── Pin Definitions ───────────────────────────────────
#define LED_PIN    D3
#define BUTTON_PIN D0

// ── Timing Configuration ──────────────────────────────
const unsigned long BLINK_INTERVAL = 500;
const unsigned long DEBOUNCE_DELAY = 50;

// ── State Variables ───────────────────────────────────
bool blinking = false;
bool ledState = false;
int lastBtnState = HIGH;

unsigned long lastBlinkTime = 0;
unsigned long lastDebounceTime = 0;

// ═══════════════════════════════════════════════════════
void setup()
{
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  digitalWrite(LED_PIN, LOW);

  Serial.begin(115200);
  while (!Serial);

  Serial.println("=====================================");
  Serial.println(" XIAO RP2040 - LED Toggle Blink");
  Serial.println("=====================================");
  Serial.println(" LED Pin  : D3");
  Serial.println(" BTN Pin  : D0");
  Serial.println(" Press button to START / STOP blinking");
  Serial.println("=====================================");
  Serial.println(" LED Status : OFF");
  Serial.println();
}

// ═══════════════════════════════════════════════════════
void loop()
{
  int currentBtnState = digitalRead(BUTTON_PIN);

  if (currentBtnState != lastBtnState)
  {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY)
  {
    if (currentBtnState == LOW && lastBtnState == HIGH)
    {
      blinking = !blinking;

      if (blinking)
      {
        Serial.println(" LED Status : BLINKING ✓");
      }
      else
      {
        digitalWrite(LED_PIN, LOW);
        ledState = false;
        Serial.println(" LED Status : OFF");
      }
    }
  }

  lastBtnState = currentBtnState;

  if (blinking)
  {
    if (millis() - lastBlinkTime >= BLINK_INTERVAL)
    {
      lastBlinkTime = millis();
      ledState = !ledState;
      digitalWrite(LED_PIN, ledState);
    }
  }
}
          

Claude.ai Generated Code and Wiring Diagram for the XIAO RP2040 LED Toggle Project

🐍 Exploring MicroPython with Thonny IDE

I explored MicroPython using the Thonny IDE, a different programming language and development environment for programming the Seeed Studio XIAO RP2040.

First, I downloaded and installed the latest version of Thonny for my operating system and launched the IDE.

Next, I navigated to Tools → Options → Interpreter, selected MicroPython (Raspberry Pi Pico) as the interpreter, and set the port to Try to detect automatically.

I then pressed and held the BOOT button while connecting the board to my computer using a USB Type-C cable. The appearance of the "RPI-RP2" drive confirmed that the board had successfully entered bootloader mode.

Returning to Tools → Options → Interpreter, I clicked Install or Update MicroPython, allowing Thonny to automatically detect the connected device. Under the version selection menu, I chose Raspberry Pi Pico / Pico H, clicked Install, and waited until the installation status displayed Done. Once completed, a firmware installation confirmation message appeared, as shown below.

Installing MicroPython Firmware on the Seeed Studio XIAO RP2040 Using Thonny IDE

With the development environment ready, I tested my first MicroPython program using the onboard NeoPixel example available on the Seeed Studio Wiki .

Since controlling the NeoPixel requires an external library, I downloaded the ws2812.py library file.

In Thonny, I navigated to File → Open, selected the downloaded ws2812.py file, and saved it directly onto the board by choosing Raspberry Pi Pico as the target location. It is important to keep the filename unchanged as ws2812.py.

Saving the ws2812.py Library to the RP2040 Board

Next, I copied the NeoPixel example code from the Seeed Studio Wiki and used AI assistance to obtain a line-by-line explanation, helping me better understand how the program works.

In this example, Pin 11 is configured as a power output because it is connected to the VIN pin of the NeoPixel LED. The code sets this pin HIGH to supply power to the LED.

Pin 12 is passed to the WS2812() constructor because it is connected to the NeoPixel's data input pin, which is responsible for receiving color and control information.

NeoPixel Connection Diagram for the XIAO RP2040, Image credit Seeed Studio Wiki

MicroPython Code

# Import WS2812 class from the ws2812 library/module.
# This class is used to control WS2812 RGB LEDs (NeoPixels).
from ws2812 import WS2812

# Import the utime module for time-related functions.
import utime

# Import the machine module to access hardware features such as GPIO pins.
import machine

# Configure GPIO Pin 11 as an output and assign it to the variable power.
power = machine.Pin(11, machine.Pin.OUT)

# Set Pin 11 HIGH to provide power to the NeoPixel circuit.
power.value(1)

# RGB color definitions.
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)

# Create a collection of colors for easy iteration.
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)

# Create a WS2812 object connected to Pin 12 controlling one LED.
led = WS2812(12, 1)

# Infinite loop.
while True:

    print("Beautiful color")

    for color in COLORS:

        led.pixels_fill(color)

        led.pixels_show()

        utime.sleep(0.2)
          

To upload and run the code, I first clicked the "Run Current Script" button in Thonny.

During the first execution, Thonny prompted me to choose where to save the script file. Both This Computer and Raspberry Pi Pico are valid locations. However, if the program is intended to run independently without a computer connection, it must be saved directly on the board as main.py.

After saving the file, I clicked Run Current Script again to execute the program.

🏁 LED Racer

LED Racer Game Built Using a 5 m WS2812B LED Strip and Seeed Studio XIAO RP2040

🎯 Game Settings

Download Arduino Code

Game Configuration Parameters

LED Racer Track Layout and Gameplay Settings

LED Racer Circuit Diagram

I used Claude.ai to help develop this game. Special thanks to Nadec Biju for introducing me to Claude.

The final game was developed through an iterative conversation with Claude.ai. Below are the prompts I provided step by step, which gradually evolved into the final version of the game.

Claude Prompt 1: Do you know what a WS2812B LED strip is?

Claude Prompt 2: Does the length of a WS2812B strip matter?

Claude Prompt 3: It has 60 LEDs per meter.

Claude Prompt 4: Could you please provide the code and the required libraries? I have connected the LED strip data line to pin D3 and supplied 5 V and GND from an external DC power source.

Claude Prompt 5: I am using a Seeed Studio XIAO RP2040 and Arduino IDE.

Claude Prompt 6:

Prompt 6 Submitted to Claude.ai

Claude Prompt 7:

Claude.ai Response During Game Development

Claude Prompt 8: OK, great! It's working.

Claude Prompt 9: Now comes the exciting part. I have created a race track using this 5 m WS2812B LED strip, and I want to build a racing game using two push buttons. One button acts as the Forward button (connected to pin D0). Each press should move the red LED forward by one position. For example, after 300 presses, the LED should move from position 1 to position 300 incrementally.

I have also connected a second push button called the Booster button to pin D1. When the Booster button and Forward button are pressed together, the LED should move forward faster, for example by 5 LEDs per button press.

The above functionality is for the Red player. I would also like to create a three-player game by adding a Green player and a Blue player. Could you please help with the code?

Claude Prompt 10: Can you modify the game so that instead of having a separate Booster button, a long press of the Forward button activates the Boost feature?

Claude Prompt 11: Hello Claude, I have created a track where LEDs 17–31 form a hill, LEDs 33–54 form another hill, LEDs 127–183 form a three-loop spiral entered from the top and exited at LED 183, and LEDs 223–273 form another three-loop spiral oriented vertically. Could you make the game more interesting by modifying the speed behavior in these sections?

Claude Prompt 12: Can you divide each hill into uphill and downhill sections? For uphill movement, use a speed factor of 0.5, and for downhill movement, use a speed factor of 2.

Additionally:

• If the Red player finishes first, LED 300 should remain Red.
• If the Green player finishes second, LED 299 should remain Green.
• If the Blue player finishes third, LED 298 should remain Blue.

I also needed one improvement. When the Red, Green, or Blue player enters Hill 1, Spiral 1, or Spiral 2, the player should always retain their original color. Previously, the track effect colors were mixing with the player colors and creating unintended colors.

Finally, instead of blinking only the first LED three times during startup, I requested that the entire track flash white three times before the race begins.

I also asked Claude.ai for suggestions on what to name the game.

🌟 Reflection

Thursday: This session beautifully connected invisible microelectronics → real-world embedded systems. Understanding how silicon devices, processors, toolchains, and firmware work together provided valuable insight into the foundations of embedded programming.

Friday: One important lesson I learned is to avoid trying to take three or four steps at once. It is better to learn concepts step by step, understand the fundamentals thoroughly, and then use advanced tools and shortcuts to improve productivity.

📁 References and Downloads

• Fab Academy – Computer-Aided Design
• Seeed Studio XIAO RP2040 Documentation
• Arduino IDE
• Thonny IDE
• Arduino Code – Airbus Strobe Light Project
• MicroPython Code – NeoPixel Example