4. Embedded Programming

PIO (Programmable Input/Output) in the RP2040 microcontroller is a specialized hardware feature that allows for the creation of custom digital interfaces using a mini processor inside the chip.

🧠 In Simple Terms:

It's like having tiny co-processors inside the RP2040 that can control pins very precisely — without using your main program's CPU.

🔧 What Can It Do?

• Control LEDs with very accurate timing
• Communicate with devices (like displays or sensors) in custom formats
• Implement custom communication protocols (like SPI, I2C, or others)

💡 Why It's Useful

Normally, timing-critical operations (like blinking an LED with exact delay) take up CPU time. PIO allows the CPU to perform other tasks while the PIO handles those operations independently.

🚀 Summary

PIO is a special programmable unit in the RP2040 that helps interact with the outside world (pins) with speed, accuracy, and flexibility.

A state machine in the context of the RP2040's PIO is a small, independent engine that runs your PIO program — like a mini-processor inside the chip that follows instructions repeatedly and predictably.

🧠 In Basic Terms:

It's a little helper that can:

• Read or write to pins
• Follow a list of simple instructions
• Repeat actions in a loop

🔄 Example:

If you want an LED to blink on and off forever — you can load a tiny blinking program into a state machine. Then it will run independently without affecting the main Python program.

🚀 Why It's Useful

• Frees up the main processor (no need for sleep or timing logic)
• Provides precise timing control
• Can run multiple programs in parallel (you can have up to 8 state machines)

The decorator @rp2.asm_pio(set_init=rp2.PIO.OUT_LOW) is used in MicroPython to define a PIO (Programmable Input/Output) program for the RP2040 microcontroller.

🧩 Breakdown:

• @rp2.asm_pio: This decorator indicates that the following function is a PIO assembly program.
• set_init=rp2.PIO.OUT_LOW: This parameter sets the initial state of the 'set' pins to a low logic level (0) when the state machine is initialized.

✅ Purpose:

This setup ensures that the specified GPIO pins controlled by the PIO program start in a known low state, which can be important for predictable behavior in hardware applications.

In PIO assembly for the RP2040, wrap_target and wrap are used to define a loop in your program.

🧩 Breakdown:

• wrap_target: Marks the beginning of the loop.
• wrap: Marks the end of the loop. When the program counter reaches this point, it wraps back to wrap_target.

✅ Purpose:

This mechanism allows the PIO program to execute a set of instructions repeatedly, which is essential for tasks like continuous data transmission or signal generation.

Imagine you have a helper who can perform a specific task repeatedly without you having to tell them each time. You give them a simple set of instructions, and they follow them over and over again.

In the RP2040 microcontroller, this helper is called a state machine. It's like a mini-worker inside the chip that can control things like lights or motors by following the instructions you provided.

This allows the main part of the microcontroller to focus on other tasks, while the state machine handles its job independently and efficiently.

In the RP2040's PIO (Programmable Input/Output) system, each PIO block has a shared instruction memory that can hold up to 32 instructions. These instructions are written in a simple assembly language specific to PIO.

Each of the four state machines within a PIO block can execute these instructions. However, the total number of unique instructions across all state machines in a PIO block cannot exceed 32.

This limitation encourages efficient programming and reuse of instructions among state machines when possible.

Each instruction in the RP2040's PIO system is 16 bits wide. The instruction memory can hold up to 32 such instructions.

Therefore, the total size of the instruction memory per PIO block is 32 instructions × 16 bits = 512 bits or 64 bytes.

This compact size is sufficient for many simple I/O tasks that PIO is designed to handle.

A bit is the most basic unit of information in computing and digital communications. It can have a value of either 0 or 1.

Bits are the building blocks of all digital data, representing binary states such as on/off, true/false, or yes/no.

A byte consists of 8 bits. It is a standard unit of data in computer systems and is used to represent a wide range of information, such as a single character in text.

For example, the letter 'A' is represented by the byte 01000001 in binary.

In the context of the RP2040 microcontroller, a state machine within the Programmable I/O (PIO) subsystem refers to a specialized hardware component designed to execute a sequence of instructions that control input/output operations with precise timing. These state machines are not "states" in the traditional sense of state diagrams but are autonomous processors that manage I/O tasks independently of the main CPU.

Each RP2040 contains two PIO blocks, and each block comprises four state machines, totaling eight per device. These state machines can be programmed with up to 32 instructions stored in a shared instruction memory. They operate independently, allowing for concurrent handling of multiple I/O protocols or tasks.

Key features of RP2040's PIO state machines include:

• Independent Execution: Each state machine can run its own program, enabling parallel processing of I/O operations.
• Shared Instruction Memory: The four state machines within a PIO block share a 32-instruction memory, allowing for efficient code reuse and compact program design.
• FIFO Buffers: Each state machine has transmit (TX) and receive (RX) FIFO buffers to facilitate data exchange with the main processor.
• Shift Registers: Input Shift Register (ISR) and Output Shift Register (OSR) are used for serial data handling, enabling bit-level manipulation.
• Scratch Registers: X and Y registers serve as general-purpose storage for temporary data or loop counters.
• GPIO Control: State machines can directly control General Purpose Input/Output (GPIO) pins, allowing for custom protocol implementation.
• Deterministic Timing: Operating independently from the main CPU ensures consistent timing, crucial for protocols requiring precise signal control.

By leveraging these state machines, developers can offload time-critical I/O tasks from the main processor, enabling efficient and reliable communication with various peripherals.

In the RP2040's Programmable I/O (PIO) system, instructions are simple commands that control the behavior of state machines. Each instruction is 16 bits wide, and a PIO program can contain up to 32 such instructions. These instructions enable the state machines to perform tasks like reading from or writing to GPIO pins, moving data between registers, and controlling program flow.

The PIO instruction set includes commands such as IN, OUT, PUSH, PULL, MOV, IRQ, WAIT, JMP, and SET. Despite the limited number of instructions, they are powerful enough to implement complex I/O protocols and timing-sensitive operations.

FIFO stands for "First-In, First-Out." In the context of the RP2040's PIO system, each state machine has two FIFOs: a transmit (TX) FIFO and a receive (RX) FIFO. These FIFOs are used to buffer data between the main processor and the PIO state machines.

Data written to the TX FIFO by the main processor can be read by the state machine using the pull instruction. Conversely, the state machine can write data to the RX FIFO using the push instruction, and the main processor can read this data. This mechanism allows for efficient and asynchronous data exchange between the CPU and the PIO.

IO Mapping in the RP2040 refers to the association between PIO state machine instructions and specific GPIO pins. When configuring a state machine, you can specify base pins for various operations:

• set_base: Base pin for set instructions.
• out_base: Base pin for out instructions.
• in_base: Base pin for in instructions.
• sideset_base: Base pin for side-set operations.

By setting these base pins, you define which GPIOs the state machine will control or monitor. This mapping is crucial for ensuring that the PIO program interacts with the correct physical pins on the microcontroller.

The RP2040's PIO system includes an instruction memory that stores the programs executed by the state machines. Each PIO block has a shared instruction memory capable of holding up to 32 instructions, with each instruction being 16 bits wide.

Key features of the instruction memory include:

• Shared among all four state machines within a PIO block.
• Allows for efficient use of memory by sharing common instructions.
• Supports a limited yet powerful set of instructions tailored for I/O operations.
• Facilitates precise timing and control over GPIO interactions.

This design enables the RP2040 to handle complex I/O tasks with minimal CPU intervention.

Each PIO state machine in the RP2040 has several registers that facilitate its operation:

• Input Shift Register (ISR): Temporarily holds data shifted in from GPIO pins using the in instruction.
• Output Shift Register (OSR): Holds data to be shifted out to GPIO pins using the out instruction.
• X and Y Scratch Registers: General-purpose registers used for temporary storage and loop counters.
• Program Counter (PC): Keeps track of the current instruction being executed.

These registers work together to enable the state machine to perform complex I/O operations with precise timing and minimal CPU involvement.

The X and Y registers in the RP2040's PIO state machines serve as general-purpose scratch registers. They are essential for implementing loops, counters, and conditional operations within PIO programs.

For example, you can use the jmp x-- instruction to create a loop that executes a specific number of times. By initializing the X register with a value and decrementing it with each iteration, the loop continues until X reaches zero. This mechanism allows for precise control over the number of repetitions in timing-critical applications.

The instruction set(pins, 10) [31] in a PIO program performs the following actions:

• set(pins, 10): Sets the output pins to the binary value 1010. This means that the corresponding GPIO pins will be set high or low according to this pattern.
• [31]: Introduces a delay of 31 cycles after executing the instruction. This delay ensures that the output state is maintained for a specific duration.

This instruction is useful for generating precise timing signals, such as square waves or custom communication protocols, by controlling the duration of high and low states on the output pins.

In the context of the instruction set(pins, 10), the value 10 is a binary representation (1010) that sets specific GPIO pins high or low. Each bit corresponds to a pin, with 1 indicating high and 0 indicating low.

If the LED is connected to a pin corresponding to a 0 in this pattern, that pin will be set low, turning the LED off. Conversely, a 1 would set the pin high, potentially turning the LED on, depending on the circuit configuration.

Therefore, the value 10 sets certain pins low, which can result in turning off LEDs connected to those pins.

This line of code initializes a Programmable I/O (PIO) state machine on the Raspberry Pi Pico using MicroPython:

• sm = rp2.StateMachine(0, blink, freq=2000, set_base=machine.Pin(25)):
  • 0: Specifies that state machine 0 is being used.
  • blink: The PIO program to be executed by the state machine.
  • freq=2000: Sets the execution frequency of the state machine to 2000 Hz.
  • set_base=machine.Pin(25): Assigns GPIO pin 25 as the base pin for the set instructions in the PIO program.

This configuration allows the state machine to control GPIO pin 25 based on the instructions defined in the blink PIO program.

Yes, in the line sm = rp2.StateMachine(0, blink, freq=2000, set_base=machine.Pin(25)), state machine 0 is being utilized. The first argument 0 passed to rp2.StateMachine specifies that state machine number 0 is to be used. The RP2040 microcontroller has multiple state machines, and this line selects the first one for the blink program.

The line sm.active(1) activates the state machine that was previously configured. Here's what it does:

• sm: Refers to the state machine instance created earlier.
• .active(1): Starts the execution of the PIO program associated with the state machine. Passing 1 as an argument sets the state machine to active mode.

Once activated, the state machine begins executing its PIO program independently of the main CPU, allowing for precise and efficient control of GPIO operations.

    #include <Wire.h>

    void setup()
    {
    Serial.begin (115200);
    while (!Serial)
    {
    }

    Serial.println ();
    Serial.println ("I2C scanner. Scanning ...");
    byte count = 0;
    pinMode(13,OUTPUT); 
    digitalWrite(13,HIGH);
    Wire.begin();
    for (byte i = 1; i < 120; i++)
    {
        Wire.beginTransmission (i);
        if (Wire.endTransmission () == 0)
        {
        Serial.print ("Found address: ");
        Serial.print (i, DEC);
        Serial.print (" (0x");
        Serial.print (i, HEX);
        Serial.println (")");
        count++;
        delay (1); 
        } 
    } 
    Serial.println ("Done.");
    Serial.print ("Found ");
    Serial.print (count, DEC);
    Serial.println (" device(s).");
    } 

    void loop() {}
            

This is an I2C scanner program written for an Arduino. It scans for devices connected to the I2C (Inter-Integrated Circuit) bus and prints their addresses to the serial monitor.

1. Including the Required Library

#include <Wire.h>

Includes the Wire library to enable I2C communication.

2. Setup Function

void setup()

The setup() function runs once at the start.

3. Initializing Serial Communication

Serial.begin(115200);

Starts serial communication at 115200 baud rate.

while (!Serial) {}

Waits for the Serial Monitor to open (useful for some boards).

4. Starting the Scan

Serial.println("I2C scanner. Scanning ...");

Prints a message indicating that the I2C scan is starting.

byte count = 0;

Initializes a variable to count detected I2C devices.

5. Configuring an LED Indicator

pinMode(13, OUTPUT);
                    digitalWrite(13, HIGH);

Turns on the built-in LED on pin 13.

6. Initializing I2C Communication

Wire.begin();

Starts the I2C communication.

7. Scanning for I2C Devices

for (byte i = 1; i < 120; i++)

Loops through all possible I2C addresses (1 to 119).

Wire.beginTransmission(i);

Attempts to start communication with the device at address i.

if (Wire.endTransmission() == 0)

Checks if the device acknowledges communication.

Serial.print("Found address: ");

Prints the detected I2C device address.

delay(1);

Adds a 1-millisecond delay to avoid overloading the I2C bus.

8. Completing the Scan

Serial.println("Done.");

Indicates that the scan is complete.

9. Loop Function

void loop() {}

The loop() function is empty since the scan is done only once.

10. Usage

• Upload the code to an Arduino board.
• Open the Serial Monitor (set baud rate to 115200).
• See detected I2C addresses of connected devices.

11. Why is this useful?

It helps find the I2C addresses of unknown devices, which is useful for working with sensors, displays, or motor controllers.

The variable byte is used in this Arduino I2C scanner program for efficiency and to match the expected data type for I2C addresses. Here’s why:

1. Memory Efficiency

• A byte in Arduino is an 8-bit unsigned integer (0-255).
• I2C addresses range from 0 to 127, which fits within a byte.
• Using a byte instead of an int (which is 16-bit) saves memory.

2. Matching I2C Address Format

• The function Wire.beginTransmission(i) expects an 8-bit address.
• Since byte is 8-bit, it avoids unnecessary type conversions.

3. Faster Execution

• On 8-bit microcontrollers (e.g., ATmega328P in Arduino Uno), byte operations are faster.
• Using an int (16-bit) would require extra processing, slightly slowing execution.

Alternative:

If working with 10-bit I2C addressing, uint16_t (16-bit unsigned integer) would be a better choice.

Conclusion: Using byte in this case is memory-efficient, type-appropriate, and optimized for performance. 🚀

An unsigned integer is a type of integer that only stores non-negative values (0 and positive numbers). Unlike signed integers, which can be positive or negative, unsigned integers do not have a sign.

1. No Negative Numbers

• Signed integers store both negative and positive numbers (e.g., -10, 0, 25).
• Unsigned integers only store positive numbers and zero (e.g., 0, 1, 255).

2. Increased Positive Range

• Since no bits are used for the sign, unsigned integers can store larger positive values in the same memory space.
• Example (for an 8-bit integer):
  • Signed 8-bit integer: -128 to 127
  • Unsigned 8-bit integer: 0 to 255

3. Common Use Cases

• When negative numbers aren’t needed, using unsigned integers saves memory and extends the range.
• Examples:
  • I2C addresses (0-127)
  • Sensor readings (e.g., distance in millimeters)
  • Loop counters (if always positive)

4. Example in Arduino

                    byte value = 200;  // 'byte' is an 8-bit unsigned integer (0-255)
                    unsigned int largeValue = 50000;  // 16-bit unsigned integer (0-65535)
                            

If you try to store -5 in an unsigned integer, it will wrap around to a large positive number due to underflow.

Let me know if you need more details! 🚀

This line of code initializes an Adafruit SSD1306 OLED display object using the Adafruit_SSD1306 library.

Adafruit_SSD1306 display(Height, Width, &Wire, -1);

Explanation of Parameters:

• Height → The height (in pixels) of the OLED display (e.g., 32 or 64).
• Width → The width (in pixels) of the OLED display (e.g., 128).
• &Wire → A reference to the I2C communication interface. Wire is the default I2C object for communication.
• -1 → The reset pin number.
  • If -1, the display does not have a dedicated reset pin, and a software reset is used.
  • Otherwise, you should specify the GPIO pin number connected to the display’s reset pin.

Example Initialization:

For a 128x64 OLED display using I2C:

Adafruit_SSD1306 display(128, 64, &Wire, -1);

For a 128x32 OLED display using I2C:

Adafruit_SSD1306 display(128, 32, &Wire, -1);

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
                            Serial.println(F("SSD1306 allocation failed"));
                            for(;;);
                        }

Understanding the Code

This block of code initializes an SSD1306 OLED display and checks whether the initialization was successful.

Breaking It Down

1️⃣ display.begin(SSD1306_SWITCHCAPVCC, 0x3C)

• Initializes the OLED display.
• Parameters:
  • SSD1306_SWITCHCAPVCC → Uses an internal charge pump for power.
  • 0x3C → I2C address of the display (some models use 0x3D).

2️⃣ if (!display.begin(...))

• The ! (logical NOT) operator negates the result of display.begin().
• If the initialization fails, display.begin() returns false, making !false → true.
• This triggers the error-handling block.

3️⃣ Serial.println(F("SSD1306 allocation failed"));

• Prints an error message to the Serial Monitor if initialization fails.
• F("...") stores the string in Flash memory (PROGMEM) to save RAM.

4️⃣ for(;;); → Infinite Loop (Halt Execution)

• for(;;); is an infinite loop that prevents further code execution.
• If the display fails, the program stays in this loop to prevent further errors.

What Happens in Different Scenarios?

OLED Initialization	display.begin() Returns	if(!display.begin(...)) Evaluates To	Outcome
Successful	true	false	Code continues normally
Failed	false	true	Error message printed, program halts

This error in Wokwi is a linker error, meaning the compiler successfully compiled your code, but the linker failed to resolve a reference to the function _Z4loopv. Let's break it down:

Understanding the Error

• The error mentions an "undefined reference to `_Z4loopv`".
• _Z4loopv is the mangled name of the function loop() in C++.
• This means the linker couldn't find an implementation of the loop() function.

The error originates from main.cpp in the ESP32 core, specifically from loopTaskPv, which is the FreeRTOS task responsible for running the loop() function.

Possible Causes & Fixes

1. Missing loop() Function

The Arduino framework requires both setup() and loop() functions. If loop() is missing, the linker will fail.

Fix: Add the missing loop() function in your sketch.

                        void setup() {
                            Serial.begin(115200);
                            Serial.println("Setup complete.");
                        }
                        
                        void loop() {
                            Serial.println("Loop running...");
                            delay(1000);
                        }
                                

2. Incorrect Function Signature

Even if you define loop(), the function signature must be:

                        void loop() {
                            // Your code here
                        }
                                

If you accidentally define it incorrectly (e.g., int loop() or void loop(int)), the linker won't recognize it.

Fix: Ensure loop() has the correct signature.

3. Corrupt or Incomplete Wokwi Project

Sometimes, Wokwi might not properly load all required files.

Fix: Try the following:

• Refresh Wokwi (Ctrl+Shift+R).
• Create a new ESP32 project in Wokwi and copy your code.
• Ensure you are using the correct ESP32 board in Wokwi.

4. Custom main() Instead of Arduino Framework

If you're writing custom ESP32 code (not using the Arduino framework), you must provide your own loop() or redefine the main execution.

Fix: Either:

• Stick to the standard setup() and loop().
• If you're using main(), you need to handle the main execution loop yourself.

Conclusion

This error happens because the ESP32 Arduino core expects a loop() function, and it’s missing. The simplest fix is to define a valid loop() function in your code. If the problem persists, try resetting Wokwi or using a fresh ESP32 project.

Let me know if you need more help! 🚀

This error occurs because SCLpin is being used incorrectly in the code.

Issue:

• The macro definition #define SCLpin 6 is conflicting with existing identifiers.
• In C++, predefined macros or function names cannot be redefined as constants.

Fix:

Use uppercase naming conventions to avoid conflicts:

#define SCL_PIN 6
                        #define SDA_PIN 5

This error occurs when the compiler cannot find the definition of the loop() function.

Possible Causes:

• The loop() function is missing.
• The function name is misspelled.
• There is a missing function prototype or implementation.

Fix:

Ensure that loop() is defined in the sketch:

void loop() {
                            // Your code here
                        }

If the display is not showing anything, the issue could be due to incorrect wiring, incorrect I2C address, or missing initialization.

Debugging Steps:

1. Check the I2C pins: ESP32 default I2C pins are SDA: GPIO 21, SCL: GPIO 22.
2. Run an I2C scanner to find the display address:

#include <Wire.h>
                        
                        void setup() {
                            Serial.begin(115200);
                            Wire.begin(21, 22);
                            Serial.println("Scanning I2C devices...");
                            for (byte address = 1; address < 127; address++) {
                                Wire.beginTransmission(address);
                                if (Wire.endTransmission() == 0) {
                                    Serial.print("I2C device found at 0x");
                                    Serial.println(address, HEX);
                                }
                                delay(10);
                            }
                        }
                        
                        void loop() {}

Fix:

• Verify power connections: VCC → 3.3V or 5V, GND → GND.
• Use correct I2C address in the initialization.