Understanding Timers in Raspberry Pi Pico (RP2040)

The Raspberry Pi Pico, based on the RP2040 microcontroller, offers a flexible system of timers that allow precise time control for various applications such as event scheduling, task delays, input capture, and PWM signal generation. This detailed guide will cover the timers available in RP2040, their functionality, and the key registers used to configure them.

General Purpose Timers in RP2040

The RP2040 features four general-purpose 64-bit timers which can be used independently for timing tasks. Each timer has its own alarm, which can trigger interrupts at specific times. These general-purpose timers run continuously based on the system clock and provide high-precision timekeeping.

• Timer 0: First general-purpose timer used for standard timekeeping tasks, often used to generate periodic interrupts.
• Timer 1: Second general-purpose timer, similar to Timer 0, but can be used for separate tasks or events.
• Timer 2: Third general-purpose timer that can be configured for tasks requiring high timing precision.
• Timer 3: Fourth general-purpose timer, often used in multi-tasking applications where various time-critical events need to be tracked.

These timers share a common 64-bit counter, and each timer can trigger alarms, making them ideal for tasks requiring precise delays or periodic actions. The counters are derived from a 1 MHz clock, which provides microsecond precision, and the timer continues running even in low-power modes.

Key Registers for RP2040 Timers

The timers are configured and controlled using several registers. Here’s a breakdown of the key registers involved in managing the timers on the RP2040:

• TIMER_BASE (0x40054000): Base address for the timer peripheral, allowing access to the timer-specific registers.
• TIMEHW (0x40054000): This is the high 32-bit word of the 64-bit timer counter. It increments continuously and provides the higher-order bits of the time.
• TIMEHR (0x40054004): This is the low 32-bit word of the 64-bit timer counter, incrementing at a rate of 1 MHz. Together with TIMEHW, it provides the current value of the system-wide time, measured in microseconds.
• TIMER_ALARMn (0x40054010 + n*4): Four individual alarm registers (TIMER_ALARM0through TIMER_ALARM3) allow you to set a future time at which an interrupt or event will be triggered. These alarms correspond to each general-purpose timer (0-3).
• TIMER_INTR (0x40054040): This register holds the interrupt status for the four alarms. Each bit in this register indicates whether a specific alarm has triggered an interrupt.
• TIMER_ARMED (0x40054044): A register indicating whether any of the alarms are currently armed. This is useful for debugging or checking if a timer is still set to trigger in the future.
• TIMER_LOAD (0x40054048): Writing to this register allows you to load a specific value into the timer. This can be used to reset the timer to a known value or to simulate a timer event by setting a future time directly.
• TIMER_DBGPAUSE (0x40054054): This register allows you to pause the timer during debugging, preventing the timer from continuing to count while stepping through code in a debugging session.
• TIMER_PAUSE (0x40054058): The TIMER_PAUSEregister halts the timer when specific conditions are met, such as entering low-power or sleep modes, providing energy-saving benefits in battery-operated devices.

Timer Functionality

Each of the four general-purpose timers can be set to trigger an interrupt via their associated alarm register. When the current timer value matches the alarm register value, an interrupt is triggered. This allows for precise timing operations such as:

• Periodic Interrupts: You can set the alarm to trigger an interrupt at a specific interval, such as every 1 second or every millisecond, depending on the application.
• Single-Shot Interrupts: The alarm can be set to trigger once and then be disabled, which is useful for generating a time delay.

Steps to Configure a Timer

1. Set the current time in the TIMEHW and TIMEHR registers if necessary.
2. Write the desired alarm value into the corresponding TIMER_ALARM register.
3. Enable the interrupt for the timer by setting the correct bit in the interrupt enable register.
4. Wait for the timer to reach the set value and handle the interrupt in the ISR (Interrupt Service Routine).

Watchdog Timer (WDT)

In addition to the general-purpose timers, the RP2040 includes a watchdog timer (WDT) that can be used to reset the system in the event of a software crash or unexpected behavior. This ensures the device doesn’t lock up indefinitely if an error occurs. The watchdog timer can be configured to reset the system if a pre-defined timeout period elapses without the watchdog being reset.

PWM and Input Capture

RP2040 timers are often used in combination with the Pulse Width Modulation (PWM) and Input Capture peripherals. For PWM, the timer counts to a specified value, and the result is used to generate a PWM signal with a specific duty cycle. In input capture mode, the timer captures the time at which an external event (such as a signal edge) occurs, which is useful for measuring time intervals or frequency.

External Triggers

The RP2040 timers can be triggered by external signals or peripherals, allowing for flexible configuration in multi-tasking applications. This is particularly useful when synchronizing timers with external events like signals from sensors or other microcontrollers.

Conclusion

The RP2040’s timers provide essential functionality for any application that requires precise timing, whether for time delays, periodic task scheduling, or event-driven programming. Understanding how to configure and use these timers, along with their associated registers, is crucial for building efficient, real-time systems using the Raspberry Pi Pico.

Raspberry Pi Pico - Timer Examples

1. Generate a Square Wave Frequency

This example generates a square wave frequency on a specified pin using a simple toggle method.

const int frequencyPin = 15; // Pin for frequency output
const unsigned long interval = 500; // 500ms toggle interval

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

void loop() {
    digitalWrite(frequencyPin, HIGH);
    delay(interval);
    digitalWrite(frequencyPin, LOW);
    delay(interval);
}
        

2. PWM at 25 kHz

This example demonstrates how to set a PWM signal at a frequency of 25 kHz on a specific pin.

const int pwmPin = 16; // PWM output pin

void setup() {
    pinMode(pwmPin, OUTPUT);
    ledcSetup(0, 25000, 8); // Channel 0, 25 kHz, 8-bit resolution
    ledcAttachPin(pwmPin, 0);
}

void loop() {
    for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle++) {
        ledcWrite(0, dutyCycle); // Increase duty cycle
        delay(10);
    }
    for (int dutyCycle = 255; dutyCycle >= 0; dutyCycle--) {
        ledcWrite(0, dutyCycle); // Decrease duty cycle
        delay(10);
    }
}
        

const int pwmPin = 16; // PWM output pin
const int resetPin = 17; // External reset pin

void setup() {
    pinMode(pwmPin, OUTPUT);
    pinMode(resetPin, INPUT_PULLUP);
    ledcSetup(0, 25000, 8);
    ledcAttachPin(pwmPin, 0);
}

void loop() {
    if (digitalRead(resetPin) == LOW) {
        ledcWrite(0, 0); // Reset PWM to zero
    } else {
        for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle++) {
            ledcWrite(0, dutyCycle);
            delay(10);
        }
    }
}
        

const int signalPin = 15; // Signal input pin
volatile unsigned long count = 0;

void countFrequency() {
    count++; // Increment count on each interrupt
}

void setup() {
    pinMode(signalPin, INPUT);
    attachInterrupt(digitalPinToInterrupt(signalPin), countFrequency, RISING);
    Serial.begin(115200);
}

void loop() {
    unsigned long tempCount = count;
    delay(1000); // Measure frequency every second
    Serial.print("Frequency: ");
    Serial.println(tempCount);
    count = 0; // Reset count
}
        

unsigned long startTime;

void setup() {
    Serial.begin(115200);
    startTime = micros(); // Start time measurement
}

void loop() {
    if (digitalRead(15) == HIGH) { // Assuming a signal on pin 15
        unsigned long elapsedTime = micros() - startTime;
        Serial.print("Elapsed Time: ");
        Serial.println(elapsedTime);
        startTime = micros(); // Reset start time
    }
}
        

const int ledPin = 25; // LED pin
volatile bool ledState = false;

void setup() {
    pinMode(ledPin, OUTPUT);
    timer1_isr_init(); // Initialize timer interrupt
    timer1_attachInterrupt(toggleLED); // Attach interrupt handler
    timer1_enable(TIMER_1); // Enable timer
    timer1_set_period(TIMER_1, 1000000); // Set period to 1 second
}

void toggleLED() {
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Set LED state
}

void loop() {
    // Main loop does nothing, LED is controlled by interrupt
}
        

Timers as Triggers

Timer Triggers

Raspberry Pi Pico – Serial Communication (Arduino C)

The Raspberry Pi Pico supports multiple UARTs. In Arduino, the USB serial appears as Serialand UART0 (GPIO0/1) as Serial1. This example demonstrates simple communication and structured data transfer.

🔹 Simple Send and Receive (Text)

void setup() {
  Serial.begin(115200);  // USB Serial
  while (!Serial) delay(10);  // Wait for Serial ready
  Serial.println("Pico Arduino Serial Ready");
}

void loop() {
  Serial.println("Sending Hello");
  delay(1000);

  if (Serial.available()) {
    char c = Serial.read();
    Serial.print("Received: ");
    Serial.println(c);
  }
}
    

🔹 Send and Receive a Struct with CRC

This struct contains multiple data types and ends with a CRC-8 checksum for integrity checking.

#include <Arduino.h>

typedef struct {
  bool active;
  byte id;
  int16_t temperature;
  int32_t pressure;
  float voltage;
  char label[16];
  byte crc;
} __attribute__((packed)) DataPacket;

byte computeCRC8(const byte* data, size_t len) {
  byte crc = 0x00;
  for (size_t i = 0; i < len; i++) {
    crc ^= data[i];
    for (byte j = 0; j < 8; j++)
      crc = (crc & 0x80) ? (crc << 1) ^ 0x07 : (crc << 1);
  }
  return crc;
}

void sendPacket(Stream& port, DataPacket& pkt) {
  pkt.crc = computeCRC8((byte*)&pkt, sizeof(pkt) - 1);
  port.write((byte*)&pkt, sizeof(pkt));
}

bool receivePacket(Stream& port, DataPacket& pkt) {
  if (port.available() >= sizeof(pkt)) {
    port.readBytes((byte*)&pkt, sizeof(pkt));
    byte crc = computeCRC8((byte*)&pkt, sizeof(pkt) - 1);
    return (crc == pkt.crc);
  }
  return false;
}

DataPacket packet = {
  true, 1, 250, 101325, 3.3, "Pico Arduino", 0
};

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

void loop() {
  sendPacket(Serial, packet);
  delay(1000);

  DataPacket rx;
  if (receivePacket(Serial, rx)) {
    Serial.print("Received label: ");
    Serial.println(rx.label);
  }
}
    

Note: The Pico board must be selected as "Raspberry Pi Pico" in Arduino IDE with the arduino-picocore installed from https://github.com/earlephilhower/arduino-pico.

Understanding DMA (Direct Memory Access)

Direct Memory Access (DMA) is a feature used in microcontrollers and other computing systems to transfer data directly between peripherals and memory, bypassing the CPU. By offloading these data transfers to the DMA controller, the CPU can perform other tasks, significantly improving system performance, especially in real-time applications.

How DMA Works

In a typical embedded system without DMA, the CPU is responsible for reading data from a peripheral (e.g., an ADC, UART, or SPI) and writing it to memory, or vice versa. This process consumes significant CPU cycles, especially for high-frequency or large-volume data transfers. DMA automates these transfers by allowing peripherals to communicate directly with memory, reducing the CPU's involvement.

Basic DMA Operation

The DMA controller operates as a separate entity within the microcontroller, managing the data transfer between memory and peripherals. The following sequence outlines the basic operation of a DMA transfer:

1. Initialization: The CPU configures the DMA controller, specifying the source and destination addresses, the size of the data to be transferred, and the transfer mode.
2. Trigger: The DMA transfer is triggered by an event, such as a peripheral request (e.g., a timer, UART, or ADC) or a software trigger initiated by the CPU.
3. Transfer: Once triggered, the DMA controller reads the data from the source (peripheral or memory) and writes it to the destination (memory or peripheral), without CPU intervention.
4. Completion: After the transfer is complete, the DMA controller can generate an interrupt to notify the CPU, allowing the CPU to handle post-transfer processing if necessary.

DMA Transfer Modes

DMA supports several modes of operation, depending on the needs of the application:

• Normal Mode: The DMA controller transfers a specified number of data items, after which the transfer is completed, and no further transfers occur.
• Circular Mode: The DMA controller continuously transfers data in a circular buffer. This mode is ideal for real-time data streams, such as audio, video, or sensor data, where continuous data processing is required.
• Peripheral-to-Memory Mode: Data is transferred from a peripheral to memory (e.g., storing ADC data in RAM).
• Memory-to-Peripheral Mode: Data is transferred from memory to a peripheral (e.g., sending data from RAM to a UART for transmission).
• Memory-to-Memory Mode: The DMA controller can also transfer data between two memory regions, which is useful for fast data copying or rearrangement.

DMA Trigger Sources

DMA transfers can be triggered by a variety of sources, including:

• Peripheral Requests: Many peripherals can request a DMA transfer when data is ready to be sent or received (e.g., UART, SPI, ADC).
• Timer Events: Timers can trigger DMA transfers at specific intervals, ideal for time-sensitive data transfers.
• Software Triggers: The CPU can trigger DMA transfers directly using software commands.

Benefits of Using DMA

DMA provides several advantages over CPU-driven data transfers:

• Reduced CPU Load: The CPU is free to perform other tasks while the DMA controller handles data transfers.
• Higher Data Throughput: DMA allows high-speed, uninterrupted data transfers, crucial in applications like audio streaming, video processing, or real-time sensor data acquisition.
• Low Latency: DMA transfers occur with minimal latency, enabling more responsive systems, especially in real-time applications.

DMA Limitations

Despite its benefits, DMA has some limitations:

• Peripheral Compatibility: Not all peripherals are DMA-capable, so it’s essential to check whether the specific peripheral supports DMA.
• Memory Access Conflicts: While DMA is active, it competes with the CPU for access to the memory bus, which could impact system performance in memory-intensive applications.

Conclusion

DMA is an essential feature in embedded systems, offering improved data transfer efficiency, reduced CPU load, and enhanced real-time performance. By offloading data transfer tasks from the CPU to the DMA controller, system resources are optimized, allowing for more complex and responsive applications. Understanding how to configure and utilize DMA effectively is a key skill in embedded systems development.

DMA matrix

RP2040 DMA Peripheral to Channel Matrix

RP2040 DMA Channel to Peripheral Matrix

Raspberry Pi Pico Dual Core Example in Arduino C

This example demonstrates how to utilize the dual-core functionality of the Raspberry Pi Pico’s RP2040 microcontroller using Arduino C. The RP2040 features two cores:

• Core 0: Main core, usually for default tasks and interrupts, but can be used for user-defined tasks.
• Core 1: The secondary core, fully available for custom tasks, providing the ability to run parallel operations.

Code Description

We define two tasks in this code:

• Task1 runs on Core 0, where it toggles the state of an LED connected to GPIO pin 25 every 500 milliseconds.
• Task2 runs on Core 1, printing a message to the Serial Monitor every second.

We use FreeRTOS, which is supported by the RP2040, to manage these tasks and assign them to specific cores. The tasks run independently, allowing the Raspberry Pi Pico to perform multiple operations simultaneously on separate cores.

Key Functions Used:

• multicore_launch_core1: This function launches code to be executed on Core 1, allowing you to create tasks that run independently of Core 0.
• vTaskDelay: FreeRTOS function for non-blocking delays within tasks, enabling multitasking.
• Serial.print: Standard Arduino function used for outputting messages to the Serial Monitor.

Example Code

#include <Arduino.h>
#include <FreeRTOS.h>
#include <task.h>

// Pin for onboard LED
#define LED_PIN 25

// Task running on Core 1
void core1Task(void *pvParameters) {
    for (;;) {
        Serial.println("Task on Core 1 is running");
        vTaskDelay(1000 / portTICK_PERIOD_MS);  // Delay for 1 second
    }
}

void setup() {
    // Initialize Serial Monitor
    Serial.begin(115200);
    while (!Serial);

    // Configure LED pin as output
    pinMode(LED_PIN, OUTPUT);

    // Print which core the setup is running on (Core 0)
    Serial.print("Setup running on core ");
    Serial.println(xPortGetCoreID());

    // Start task on Core 1
    multicore_launch_core1([]() {
        core1Task(NULL);
    });

    // Create a task to toggle the LED on Core 0
    xTaskCreate([](void *pvParameters) {
        for (;;) {
            digitalWrite(LED_PIN, HIGH);
            vTaskDelay(500 / portTICK_PERIOD_MS);  // LED ON for 500ms
            digitalWrite(LED_PIN, LOW);
            vTaskDelay(500 / portTICK_PERIOD_MS);  // LED OFF for 500ms
        }
    }, "Core0Task", 1024, NULL, 1, NULL);
}

void loop() {
    // No code here, as tasks are handled by FreeRTOS
}
    

Steps to Run the Code:

1. Copy the code into the Arduino IDE.
2. Install the Raspberry Pi Pico board package from the board manager if you haven’t already.
3. Select the correct board (Raspberry Pi Pico) and upload the code.
4. Open the Serial Monitor (baud rate: 115200) to observe the output from Core 1.

Expected Output

In the Serial Monitor, you should see the following messages:

Setup running on core 0
Task on Core 1 is running
Task on Core 1 is running
...

Additionally, the onboard LED (GPIO pin 25) will blink every 500 milliseconds, running on Core 0.

Explanation of FreeRTOS Tasks

This example uses FreeRTOS to handle multitasking on the Raspberry Pi Pico. FreeRTOS allows you to run multiple tasks concurrently without the need for writing complex threading code. Each task is assigned to a specific core using the multicore_launch_core1function for Core 1 and xTaskCreatefor Core 0.

Understanding I/O State Machines in Raspberry Pi Pico (RP2040)

The Raspberry Pi Pico, based on the RP2040 microcontroller, features a unique I/O architecture that includes programmable state machines (SMs). These state machines allow for advanced I/O operations and can be programmed to handle various tasks such as protocol communication, signal generation, and other time-sensitive operations without burdening the main CPU. This guide provides a detailed overview of the I/O state machines and how to program them effectively.

Overview of I/O State Machines

The RP2040 microcontroller includes a total of 4 I/O state machines that can control up to 30 GPIO pins. Each state machine operates independently, executing its program, which is stored in the state machine's instruction memory. This allows for efficient and flexible I/O management, suitable for applications such as driving peripherals, generating signals, or implementing communication protocols like SPI, I2C, or UART.

Each state machine is essentially a simple finite state machine, capable of executing a sequence of instructions. It can be programmed to react to various inputs and produce outputs accordingly, making it highly versatile for handling complex I/O tasks.

Key Features of the I/O State Machines

• Independent Operation: Each state machine can run its program concurrently with the main CPU, allowing for multitasking without additional overhead.
• Simple Assembly Language: Programming the state machines involves using a lightweight assembly-like language designed for ease of use.
• Programmable I/O: State machines can control GPIO pins in various modes, including input, output, and alternate functions.
• Flexible Timing: The state machines can handle precise timing operations, making them suitable for high-speed communication and signal generation.

Architecture of I/O State Machines

Each state machine consists of the following key components:

• Instruction Memory: Each state machine has a limited instruction memory (up to 32 instructions) for storing the program code.
• Program Counter: A register that keeps track of the current instruction being executed.
• Control Signals: Signals for controlling the state machine's GPIO pins, including setting, clearing, and reading pin states.
• Input Signals: The state machine can react to changes in input signals, allowing it to respond dynamically to events.

Programming the I/O State Machines

Programming the I/O state machines typically involves writing a sequence of instructions that dictate how the state machine will behave. The RP2040 provides a dedicated assembler (part of the Pico SDK) to facilitate this process. Below are the steps to program an I/O state machine:

1. Install the Pico SDK

Before you can program the I/O state machines, ensure that you have set up the Raspberry Pi Pico SDK on your development environment. The SDK includes tools, libraries, and documentation to aid in programming the Pico.

2. Write the State Machine Code

The state machine code is typically written in a simplified assembly language called "Pico Assembly Language." Below is an example of a simple program that toggles a GPIO pin.

.program 0         ; Load program into State Machine 0
set(pindirs, 1<<0) ; Set GPIO 0 as output
loop:
    set(pins, 1<<0)  ; Set GPIO 0 high
    wait(1000)       ; Wait for 1000 cycles
    set(pins, 0)     ; Set GPIO 0 low
    wait(1000)       ; Wait for 1000 cycles
    jmp(loop)        ; Repeat loop
    

3. Load the Program into the State Machine

After writing your state machine code, you can load it into the desired state machine using the `state_machine` class in the Pico SDK. Here’s an example of how to load and start the program:

#include "pico/stdlib.h"
#include "pico/multicore.h"
#include "pico/state_machine.h"

// Define the state machine program
const uint8_t sm_program[] = {
    // Your program instructions (binary or hex)
};

// Initialize the state machine
state_machine_t sm;

int main() {
    stdio_init_all();           // Initialize standard I/O
    sm = state_machine_init(0); // Initialize State Machine 0
    state_machine_load(sm, sm_program, sizeof(sm_program)); // Load program
    state_machine_start(sm);    // Start the state machine

    while (1) {
        tight_loop_contents(); // Main loop can perform other tasks
    }
}

4. Control the State Machine

You can control the state machine programmatically through various commands, such as starting, stopping, or resetting the state machine. You can also read the state of GPIO pins or monitor events triggered by the state machine.

Examples of Applications Using I/O State Machines

• Driving LED Displays: State machines can be used to manage LED matrices or displays, generating the necessary timing for multiplexing.
• Communicating with Peripherals: Protocols like SPI or I2C can be implemented using state machines to handle timing and data transfer efficiently.
• Signal Generation: State machines can create PWM signals or generate specific waveforms for analog signal generation.

Conclusion

The I/O state machines in the Raspberry Pi Pico provide a powerful mechanism for handling I/O operations with minimal CPU intervention. By allowing precise control over GPIO pins and enabling complex timing operations, state machines enhance the functionality of the Pico for a wide range of applications. Understanding how to program and utilize these state machines opens up numerous possibilities for embedded systems development.