Blinking an LED on an Embedded Microcontroller with Rust

This challenge will guide you through setting up a basic embedded Rust environment to blink an LED. This is a fundamental "hello world" for embedded systems, demonstrating how to interact with hardware peripherals using Rust's safety features and abstractions. Successfully completing this will provide you with a foundational understanding of embedded Rust development.

Problem Description

Your goal is to write a Rust program that runs on a microcontroller (specifically, we'll target a common development board like an ESP32-C3 or a Raspberry Pi Pico) and blinks an onboard LED. This involves:

1. Setting up the development environment: This includes installing the necessary Rust toolchain extensions for embedded development (like rustup target add and cargo-generate) and configuring your project for a specific target microcontroller.
2. Accessing GPIO pins: You'll need to configure a General Purpose Input/Output (GPIO) pin to act as an output.
3. Controlling the LED: Write code to toggle the state of the configured GPIO pin (high to turn the LED on, low to turn it off).
4. Implementing a delay: Introduce a delay between toggling the pin to create the blinking effect.

Key Requirements:

• The program must compile for a specific embedded target.
• The program must successfully flash to the target microcontroller.
• An onboard LED (or an external LED connected to a GPIO pin) must blink at a regular interval (e.g., approximately 1 second on, 1 second off).
• The code should leverage the embedded-hal traits for peripheral access to ensure portability and good practice.

Expected Behavior:

Upon flashing the compiled Rust program to the microcontroller, the LED connected to the designated GPIO pin should begin to blink.

Edge Cases/Considerations:

• Target Board Specifics: GPIO pin numbers and peripheral configurations can vary significantly between microcontroller families. You will need to select a specific board and use its corresponding "board-support-package" (BSP) crate.
• Toolchain Configuration: Ensuring the correct RUSTFLAGS and target architecture are set is crucial.
• Flashing Mechanism: The method for flashing the compiled binary to the microcontroller can differ (e.g., espflash, probe-rs). You'll need to familiarize yourself with the recommended flashing tool for your chosen board.

Examples

Since this is an embedded challenge, traditional input/output examples are not applicable. Instead, we will describe the setup and expected result.

Example 1: Basic LED Blink (ESP32-C3 DevKitC)

• Setup:
  • Target Board: ESP32-C3 DevKitC-02
  • LED Location: Onboard LED, typically connected to GPIO2.
  • Development Environment: Rust toolchain configured for riscv32imc-esp-espidf.
  • Project Template: espflash new or a similar embedded template.
  • Code: A Rust program configuring GPIO2 as an output and toggling it with a delay.
• Expected Result: The onboard LED on the ESP32-C3 DevKitC-02 blinks, turning on and off approximately every second.

Example 2: LED Blink on Raspberry Pi Pico (RP2040)

• Setup:
  • Target Board: Raspberry Pi Pico (RP2040 microcontroller)
  • LED Location: Onboard LED, typically connected to GPIO25.
  • Development Environment: Rust toolchain configured for thumbv6m-none-eabi (or thumbv7em-none-eabi depending on specific RP2040 setup).
  • Project Template: cargo generate --git https://github.com/rust-embedded/cortex-m-quickstart
  • Code: A Rust program configuring GPIO25 as an output and toggling it with a delay using systick or a similar timer.
• Expected Result: The onboard LED on the Raspberry Pi Pico blinks, turning on and off approximately every second.

Constraints

• Target Hardware: You must select a supported embedded development board (e.g., ESP32-C3, RP2040, STM32F4 Discovery). The solution should be specific to your chosen board.
• Rust Toolchain: Use the latest stable Rust toolchain with the appropriate embedded target.
• Dependencies: You are encouraged to use established embedded Rust crates such as cortex-m, cortex-m-rt, embedded-hal, and board-specific BSP crates. Avoid "bare metal" register manipulation where safe abstractions exist.
• Code Size: While not strictly enforced for this introductory challenge, aim for reasonably optimized code, as embedded systems often have limited memory.
• Runtime: The program should run indefinitely without crashing or panicking.

Notes

• This challenge assumes you have a basic familiarity with Rust syntax and concepts.
• You will need to install a debug probe (like a J-Link, ST-Link, or a USB-to-serial adapter for some boards) and the corresponding flashing software for your chosen board.
• Consult the documentation for your specific development board and its corresponding BSP crate. These often provide examples and clear pin mappings.
• The embedded-hal crate provides a set of traits for common hardware peripherals (like GPIO, SPI, I2C). Implementing these traits for your specific hardware makes your code more portable. For this challenge, focus on the OutputPin and StatefulOutputPin traits from embedded_hal::digital::v2.
• For delays, look into using the microcontroller's SysTick timer or similar hardware timers, or leverage the delay abstractions provided by the BSP or cortex-m-hal.