Specification

RP2040

RP2040 is a dual-core microcontroller designed by Raspberry Pi for low-cost, high-performance embedded projects.

Why is the chip called RP2040?

The post-fix numeral on RP2040 comes from the following,

RP2040 Pinout

The image above shows the top view pin configuration of the RP2040 microcontroller. Each pin has a specific function such as GPIO, power, ground, ADC, SPI, I2C, and more. Understanding the pinout is important for correctly connecting components like buttons, OLED displays, sensors, and other peripherals.

1. GPIO Pins (General Purpose Input/Output)

GPIO pins are the most commonly used pins in microcontroller projects. They can be configured as:

• Digital Input (for buttons, sensors)
• Digital Output (for LEDs, buzzers)
• Communication Pins (I2C, SPI, UART)

In the diagram, GPIO pins are labeled as:

• GPIO0 – GPIO29

For example:

• GPIO2 → Can be used as digital pin D2
• GPIO26–GPIO29 → Can also function as ADC inputs

2. Power Pins

Power pins provide voltage to the microcontroller.

• IOVDD – I/O voltage supply
• DVDD – Digital core voltage
• USB_VDD – USB power supply
• ADC_AVDD – Analog voltage supply

These pins should not be used as normal GPIO pins.

3. Ground (GND)

The large center pad labeled GND is the ground connection. All external components must share a common ground with the microcontroller.

4. ADC Pins (Analog Input)

The following pins support analog input:

• GPIO26 (ADC0)
• GPIO27 (ADC1)
• GPIO28 (ADC2)
• GPIO29 (ADC3)

These pins can read analog voltages (for sensors like temperature, light, potentiometers).

5. Communication Pins

I2C Communication

Used for devices like OLED displays. SDA and SCL lines are mapped to specific GPIO pins depending on configuration.

SPI Communication

Pins labeled SPI_SCLK, SPI_SD0, SPI_SD1, SPI_SS_N are used for SPI communication.

SWD (Debugging)

• SWCLK
• SWDIO

These are used for programming and debugging the microcontroller.

6. Using GPIO2 for Button Example

If using a push button connected to GPIO2:

• Connect one side of the button to GPIO2
• Connect the other side to GND
• Use pinMode(GPIO2, INPUT_PULLUP);

When using INPUT_PULLUP:

• Button not pressed → HIGH
• Button pressed → LOW

7. Important Notes

• Always verify the board pin mapping (GPIO vs D-number).
• Never connect 5V directly to GPIO pins (RP2040 is 3.3V logic).
• Always connect GND of external devices to board GND.

Summary

The RP2040 microcontroller provides flexible GPIO pins that can function as digital input/output, analog input, or communication interfaces. Understanding the pinout ensures correct hardware connections and prevents damage to the board.

Key features

• Dual Arm Cortex-M0+ @ 133 MHz
• 264 kB on-chip SRAM in six independent banks
• Support for up to 16 MB of off-chip Flash via dedicated QSPI bus
• DMA controller
• Fully-connected AHB crossbar
• Interpolator and integer divider peripherals
• On-chip programmable LDO to generate core voltage
• 2 on-chip PLLs for USB and core clocks
• 30 GPIO pins (4 can be used as analogue inputs)

Peripherals

• 2 UARTs
• 2 SPI controllers
• 2 I2C controllers
• 16 PWM channels
• USB 1.1 controller & PHY (host and device support)
• 8 PIO state machines

One of my doubts was, how and why can I use Arduino on a Rasberry Pi board?

Here's what I learned:

Your XIAO RP2040 uses the RP2040 chip made by Raspberry Pi, but it's a microcontroller board (like an Arduino), NOT a Raspberry Pi computer.

Arduino isn't just hardware - it's also:

• A programming language (based on C++)
• A development environment (Arduino IDE)
• A set of libraries that make programming easier

Arduino IDE can program many different microcontroller chips, including:

• ATmega (original Arduino)
• ESP32 (WiFi boards)
• SAMD (Arduino Zero, MKR boards)
• RP2040 (Raspberry Pi chips)

Prerequisites

To get started, ensure you have:

• An RP2040 board
• The Arduino IDE
• A USB cable

Setting Up the Software

Install the Arduino IDE

Download and install the latest Arduino IDE from the official site: Arduino Software.

Arduino IDE Interface Overview

1. Menu Bar

   The Menu Bar contains the main control options for the Arduino IDE. It includes menus such as File, Edit, Sketch, Tools, and Help.

   • Create new sketches
   • Open and save files
   • Access example programs
   • Select board type
   • Select serial port
   • Configure preferences

2. Horizontal Toolbar

   The horizontal toolbar provides quick access to commonly used functions.

   • Verify – Compiles the code to check for errors.
   • Upload – Uploads the program to the connected board.
   • Debug – Starts debugging (if supported).
   • Board Selection – Displays and selects the active board.
   • Serial Plotter – Opens the serial data graph window.
   • Serial Monitor – Opens the serial communication window.

3. Vertical Toolbar

   The vertical toolbar provides shortcuts for project management and development tools.

   • Project Folder – View and manage sketch files.
   • Board Manager – Install and manage board packages.
   • Library Manager – Install and manage libraries.
   • Debug – Access debugging tools.
   • Search – Search within the code.

4. Code Editing Area

   The code editing area is where program code is written and modified. It functions like a standard text editor, similar to typing in a word processor. All sketch files are written in this area.

5. Serial Monitor and Output Window

   The Serial Monitor and output window allow communication between the computer and the microcontroller.

   • The Serial Monitor displays data sent from the board.
   • It can also send data to the board.
   • The output window shows compilation messages and errors.

   The Serial Monitor can be opened or closed using the button located on the right side of the horizontal toolbar.

Add RP2040 Board Support

Open the Arduino IDE and navigate to File > Preferences.

In the Additional Boards Manager URLs field, add this URL:

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Click OK to save your settings.

Go to Tools > Board > Boards Manager.

In the Boards Manager, search for pico and click Install.

After installation, go to Tools > Board and select the board shown below as your board.

Note: 
 Ensure you install version 4.2.0 or later for full support of the XIAO RP2040 board.

What is a Board Manager?

Board Manager is like an app store for microcontroller boards inside Arduino IDE.

Why Do We Need It?

Arduino IDE doesn't come with support for every microcontroller board in the world pre-installed. That would make it huge and slow! Instead, it comes with just the basic Arduino boards (like Uno, Mega).

When you want to program a different board (like your XIAO RP2040), you need to download and install the support package for that specific chip/board family.

What Does a Board Package Include?

When you install a board package (like "Raspberry Pi Pico/RP2030"), you get:

• Compiler - Converts your Arduino code into machine code for that specific chip
• Pin definitions - Tells Arduino IDE which pins are which (D0, D1, A0, etc.)
• Libraries - Special functions that work with that chip's hardware (WiFi, USB, etc.)
• Upload tools - Software to transfer your program to the board
• Board configuration - Settings specific to different boards using the same chip

Entering BOOT Mode on the XIAO RP2040

To place your XIAO RP2040 into BOOT mode, use one of the methods below:

Method 1: Before Connecting to Computer

Use this when your board is NOT plugged in yet

1. Locate the BOOT button on your XIAO RP2040 (small button, often labeled "B" or "BOOT")
2. Press and HOLD the BOOT button with your finger
3. While still holding BOOT, plug the USB-C cable into your board
4. Keep holding BOOT for about 2 seconds after plugging in
5. Release the BOOT button

If the process is successful, your computer will make the USB connection sound and a new drive will appear, similar to a USB flash drive. The drive is typically named "RPI-RP2" or something similar. This indicates that the board has successfully entered BOOT mode and is ready to receive a program.

This method is recommended when programming the board for the first time, when the board is currently unplugged, or when you want the simplest way to start fresh.

Method 2: While Connected to Computer

Use this when your board is ALREADY plugged in

1. Your XIAO RP2040 is already connected via USB
2. Press and HOLD the BOOT button
3. While holding BOOT, do ONE of these:
   • Option A: Press and release the RESET button (if your board has one)
   • Option B: Unplug and replug the USB cable
4. Release the BOOT button

When the procedure is successful, the board will restart while entering BOOT mode. A new drive will appear on your computer, similar to a USB flash drive. This indicates that the board is now ready to receive a program.

This method is useful when the board is already plugged into the computer, when you need to re-enter BOOT mode, or when an upload has failed and you need to try again.

Visual Comparison:

Method 1:
Unplugged → Hold BOOT → Plug USB → Wait 2 sec → Release BOOT

Method 2:
Already plugged in → Hold BOOT → Press RESET (or unplug/replug) → Release BOOT

You can see a power LED turn on when you connect your PC to the board via USB.

• Open the Arduino IDE and create a new sketch.

Arduino Program Structure

Every Arduino sketch (program) has two main functions that are required.

1. void setup()

void setup() {// Runs ONCE when the board starts}

The setup() function runs only once, either when you power on the board or press the reset button. It is primarily used for initialization, setting up components and configurations before the main program starts.

Common tasks performed in setup() include:

Setting pin modes as input or output, starting serial communication, initializing sensors or displays, and assigning initial values to variables.

2. void loop()

void loop() { // Runs OVER and OVER forever}

What it does:

• Runs continuously after setup() finishes
• Repeats forever in a loop: runs → finishes → runs again ...
• This is where your main program logic goes

Common things you put in loop():

• Read sensors
• Turn LEDs on/off
• Check button presses
• Send/receive data
• Make decisions based on inputs

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

                    // the loop function runs repeatedly
                    void loop() {
                        digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on
                        delay(1000);                      // wait for 1 second
                        digitalWrite(LED_BUILTIN, LOW);   // turn the LED off
                        delay(1000);                      // wait for 1 second
                    }

pinMode(LED_BUILTIN, OUTPUT);

digitalWrite(LED_BUILTIN, HIGH);

delay(1000);

digitalWrite(LED_BUILTIN, LOW);

                        D0 ---- Resistor ---- Anode (+)
                        Cathode (−) --------- GND
                    

                    const int ledPin = 2;  // GPIO pin connected to external LED

                    void setup() {
                        pinMode(ledPin, OUTPUT);  // Set the LED pin as output
                    }

                    void loop() {
                        digitalWrite(ledPin, HIGH);  // Turn LED ON
                        delay(1000);                 // Wait 1 second
                        digitalWrite(ledPin, LOW);   // Turn LED OFF
                        delay(1000);                 // Wait 1 second
                    }
                

                    const int ledPin = 2;  // GPIO pin connected to LED

                    void setup() {
                        pinMode(ledPin, OUTPUT);
                    }

                    void loop() {
                        // First quick flash
                        digitalWrite(ledPin, HIGH);
                        delay(100);
                        digitalWrite(ledPin, LOW);
                        delay(100);

                        // Second quick flash
                        digitalWrite(ledPin, HIGH);
                        delay(100);
                        digitalWrite(ledPin, LOW);
                        delay(1000);  // Longer pause before repeating
                    }
                

                    int Delay = 1000;
                    void setup() {
                        // initialize digital pin LED_BUILTIN as an output.
                        pinMode(D0, OUTPUT);
                        pinMode(D1, OUTPUT);
                        pinMode(D2, OUTPUT);
                        pinMode(D3, OUTPUT);
                        pinMode(D4, OUTPUT);
                    }

                    // the loop function runs over and over again forever
                    void loop() {
                        digitalWrite(D0, LOW);  // turn the LED on (LOW is the voltage level)
                        delay(Delay);  
                        digitalWrite(D0, HIGH);            // wait for a second
                        digitalWrite(D1, LOW);                    
                        delay(Delay);
                        digitalWrite(D1, HIGH);  
                        digitalWrite(D2, LOW);  
                        delay(Delay);    
                        digitalWrite(D2, HIGH);                   
                        digitalWrite(D3, LOW);   
                        delay(Delay);
                        digitalWrite(D3, HIGH);  
                        digitalWrite(D4, LOW);   
                        delay(Delay);
                        digitalWrite(D4, HIGH);  
                    }       
                

                    int led = D0;
                    int button = D1;
                

                    void setup() {
                        pinMode(led, OUTPUT);
                        pinMode(button, INPUT_PULLUP);
                    }
                

                    void loop() {
                        int button_state = digitalRead(button);
                    }
                

                    if (button_state == LOW){
                        digitalWrite(led, HIGH);
                    }
                    else {
                        digitalWrite(led, LOW);
                    }
                

                    if (button_state == LOW){
                        digitalWrite(led, HIGH);
                    }
                    else {
                        digitalWrite(led, LOW);
                    }
                

                    int led = D0;
                    int button = D1;

                    void setup() {
                        pinMode(led, OUTPUT);
                        pinMode(button, INPUT_PULLUP);
                    }

                    void loop() {

                        int button_state = digitalRead(button);

                        if (button_state == LOW){
                            digitalWrite(led, HIGH);
                        }
                        else {
                            digitalWrite(led, LOW);
                        }

                    }
                

                    (leg1) —— —— —— (leg2)
                        |          |
                        |  SWITCH  |
                        |          |
                    (leg3) —— —— —— (leg4)
                

Interfacing a 0.96" I2C OLED Display with RP2040

Component Description

The display used is a 0.96" I2C OLED module (128 × 64 resolution), commonly based on the SSD1306 driver. The module communicates using the I2C protocol, which requires only two signal wires.

• Resolution: 128 × 64 pixels
• Communication Protocol: I2C
• Driver IC: SSD1306
• Operating Voltage: 3.3V

Learn more about Communication Protocols

Pin Configuration

The OLED module has four pins:

                    GND   → Ground
                    VCC   → 3.3V Power
                    SCL   → I2C Clock Line
                    SDA   → I2C Data Line
                

Wiring Connections

The OLED was connected to the RP2040 board as follows:

                OLED        →    RP2040
                -----------------------------
                GND         →    GND
                VCC         →    3.3V
                SCL         →    SCL pin
                SDA         →    SDA pin
                

Only four wires are required due to I2C communication. No external resistors are needed for this module.

I2C Address

The module includes an address selection option labeled:

                    0x3C  (default)
                    0x3D  (alternative address)
                

In this setup, the default address 0x3C is used.

To learn more about I2C addresses and OLED modules, refer the link here.

SCL and SDA Pins on the Seeed XIAO RP2040

On the Seeed XIAO RP2040 board, the I2C pins are already labeled. You do not need to guess them.

I2C Default Pins

• SDA → D4
• SCL → D5

So when connecting your OLED:

• OLED SDA connects to D4
• OLED SCL connects to D5

What Do These Pins Do?

• SDA (D4) carries the data.
• SCL (D5) provides the clock signal (timing).

Complete Wiring for XIAO RP2040

• OLED GND → XIAO GND
• OLED VCC → XIAO 3.3V
• OLED SDA → XIAO D4
• OLED SCL → XIAO D5

Only four wires are needed because I2C uses just two communication lines.

Library Installation

To control the OLED, the following libraries were installed using Arduino Library Manager:

• Adafruit SSD1306
• Adafruit GFX

Step 1: Open the Library Manager

First, open the Arduino IDE on your computer.

At the top of the window, you will see a menu bar.

Click on:

Sketch → Include Library → Manage Libraries...

This will open the Library Manager.

What is the Library Manager?

The Library Manager is where you can search for and install extra libraries. Libraries are collections of pre-written code that help you control hardware easily — like OLED displays.

In the search bar of the Library Manager, type:

U8G2

Find the library named U8g2 by oliver.

Click Install and make sure you install the latest version.

Step 2: Upload the Example Code

1. Copy the code below.

2. Paste it into a new Arduino sketch.

3. Click the Upload button to upload the program to your board.

                #include <Arduino.h>
                #include <U8g2lib.h>
                #include <Wire.h>

                // Use Hardware I2C
                U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

                void setup() {
                    u8g2.begin();
                }

                void loop() {
                    u8g2.clearBuffer();
                    u8g2.setFont(u8g2_font_ncenB08_tr);
                    u8g2.drawStr(0, 20, "Hello Guyzz!");
                    u8g2.drawStr(0, 40, "It's Merin!");
                    u8g2.sendBuffer();
                    delay(1000);
                }
                

Code Explanation

Including Libraries

                #include <Arduino.h>
                #include <U8g2lib.h>
                #include <Wire.h>
                

These lines add special libraries (tools) to our project.

• Arduino.h → Basic Arduino functions
• U8g2lib.h → Library to control the OLED display
• Wire.h → Allows communication using I2C

Creating the OLED Object

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

This line creates an OLED display object named u8g2.

• SSD1306 → OLED controller type
• 128X64 → Screen resolution
• HW_I2C → Uses hardware I2C communication

Setup Function

                void setup() {
                    u8g2.begin();
                }
                

The setup() function runs only once when the Arduino starts.

u8g2.begin(); initializes (starts) the OLED display.

Loop Function

                void loop() {
                    u8g2.clearBuffer();
                    u8g2.setFont(u8g2_font_ncenB08_tr);
                    u8g2.drawStr(0, 20, "Hello Guyzz!");
                    u8g2.drawStr(0, 40, "It's Merin!");
                    u8g2.sendBuffer();
                    delay(1000);
                }
                

The loop() function runs again and again forever.

Explanation of Each Line:

• clearBuffer() → Clears the screen before writing new text
• setFont() → Sets the font style for the text
• drawStr(x, y, text) → Displays text at position (x, y)
• sendBuffer() → Sends all text to the OLED screen
• delay(1000) → Waits for 1 second

How the Program Works

1. Arduino starts
2. OLED initializes
3. Screen clears
4. Text is written
5. Text appears on screen
6. Wait 1 second
7. Repeat forever

Final Output

The OLED screen displays:

Hello Guyzz!
It's Merin!

                    #include <Arduino.h>
                    #include <U8g2lib.h>
                    #include <Wire.h>

                    U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

                    const int buttonPin = 2;

                    void setup() {
                        pinMode(buttonPin, INPUT_PULLUP);
                        u8g2.begin();
                    }

                    void loop() {

                        int buttonState = digitalRead(buttonPin);

                        u8g2.clearBuffer();
                        u8g2.setFont(u8g2_font_ncenB08_tr);

                        if (buttonState == LOW) {
                            u8g2.drawStr(0, 30, "Button Pressed!");
                        } 
                        
                        else {
                            u8g2.drawStr(0, 30, "Press the Button");
                        }

                        u8g2.sendBuffer();
                    }
                

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

                const int buttonPin = 2;
                

u8g2.begin();

int buttonState = digitalRead(buttonPin);

u8g2.clearBuffer();

u8g2.setFont(u8g2_font_ncenB08_tr);

                if (buttonState == LOW) {
                    u8g2.drawStr(0, 30, "Button Pressed!");
                }
                else {
                    u8g2.drawStr(0, 30, "Press the Button");
                }

u8g2.sendBuffer();