Embedded-Hacking/drivers/0x07_i2c_rust/README.md

# 0x07 I2C Rust Driver

This repository contains a Bare-Metal Rust driver for the I2C (Inter-Integrated Circuit) peripheral on the **RP2350** (and RP2040) microcontrollers.

It includes:
- A thin demo (`src/main.rs`) that continuously scans the I2C bus and prints out a nicely formatted hex grid of all connected devices over UART.
- A reusable library module (`src/i2c.rs`) providing a hardware-agnostic `i2c_lib` with helper math and string formatting functions to neatly layout the scan grid.
- Board initialization logic (`src/board.rs`).

## 🚀 Getting Started from Scratch

If you're starting with a fresh machine, follow these exact steps to install the toolchain, build the code, and flash it to your microcontroller.

### 1. Install Rust
First, install `rustup` (the Rust toolchain installer) if you haven't already:
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
*Note: Restart your terminal or run `source $HOME/.cargo/env` after this finishes.*

Ensure your Rust compiler is up to date:
```bash
rustup update
```

### 2. Install the Target Architecture
This project is configured for the **RP2350** (ARM Cortex-M33). We need to install the cross-compilation target for it:
```bash
rustup target add thumbv8m.main-none-eabihf
```
*(If you were targeting the RP2040, you would use `thumbv6m-none-eabi` instead).*

### 3. Install Build Tools
You will need a few extra tools to help link and format the firmware for the RP-series chips.

Install `flip-link` (adds zero-cost stack overflow protection):
```bash
cargo install flip-link
```

Install `picotool` (used by `cargo run` to flash the chip):
- **macOS:** `brew install picotool`
- **Linux/Windows:** Follow the official Raspberry Pi documentation to install `picotool` or build it from source.

### 4. Building the Code
To compile the code for the microcontroller, simply run:
```bash
cargo build
```

To build a highly optimized release version (smaller and faster):
```bash
cargo build --release
```

### 5. Flashing to the Microcontroller
This project is pre-configured in `.cargo/config.toml` to use `picotool` as the custom runner. 

To flash the code:
1. Hold down the **BOOTSEL** button on your RP2350 board.
2. Plug it into your computer via USB (or press the RUN/RESET button while holding BOOTSEL).
3. Run the following command:

```bash
cargo run --release
```
*`cargo` will compile the code and automatically use `picotool` to upload the `.elf` file directly to your board and start executing it!*

### 6. Testing on the Host
Because the I2C grid string formatting logic is separated into a reusable math library without touching hardware registers, you can run the unit tests natively on your computer!

However, because this project sets a default bare-metal target (`thumbv8m.main-none-eabihf`) in `.cargo/config.toml`, running a plain `cargo test` will fail because the standard library doesn't exist on the microcontroller. You must explicitly tell Cargo to compile the tests for your host computer's processor architecture:

**Mac (Apple Silicon):**
```bash
cargo test --lib --target aarch64-apple-darwin
```

**Linux (Intel/AMD 64-bit):**
```bash
cargo test --lib --target x86_64-unknown-linux-gnu
```

**Windows (64-bit):**
```bash
cargo test --lib --target x86_64-pc-windows-msvc
```

## 🧠 Code Walkthrough

This section explains exactly how the code works, where the entry point is, and traces the flow of execution as if you were stepping through it line-by-line.

### 1. The Entry Point (`src/main.rs`)
Unlike a standard computer program, bare-metal microcontrollers do not have an operating system to call `main()`. Instead, we use the `#[entry]` macro from the HAL (Hardware Abstraction Layer) to define the very first function that runs after the chip boots up.

*   **`main() -> !`**: This is the absolute start of our code. It takes ownership of all the hardware peripherals (`hal::pac::Peripherals::take().unwrap()`) and immediately passes them into `board::run(...)`. The `-> !` means this function never returns (because embedded devices run in an infinite loop).

### 2. Board Initialization (`src/board.rs`)
Once execution enters `board.rs`, we initialize the system clocks, pins, UART (for logging), SysTick (for delay), and the I2C peripheral (for scanning).

*   **`run(...)`**: The master setup function. Calls the helper initialization functions below, prints an announcement over UART, and enters the infinite I2C scanning loop.
*   **`init_clocks(...)`**: Wakes up the external 12 MHz crystal (`XOSC`) and configures the PLLs (Phase-Locked Loops) to drive the system clock at its maximum speed.
*   **`init_pins(...)`**: Takes control of physical pins across `IO_BANK0`.
*   **`init_uart(...)`**: Configures the hardware `UART0` peripheral to operate at a standard `115200` baud rate with an `8N1` configuration for debug printing.
*   **`init_i2c(...)`**: Initializes the hardware `I2C1` peripheral, reconfigures `GPIO 2` and `GPIO 3` as `SDA` and `SCL` lines (with internal pull-ups enabled), and sets the clock speed to 100 kHz (standard mode).
*   **`scan_loop(...)`**: Loops infinitely, printing the table header, iterating through all 128 possible addresses to probe them, and sleeping for `SCAN_DELAY_MS` (5 seconds).
*   **`scan_addresses(...)`**: Loops from 0x00 to 0x7F, ignoring reserved addresses, and uses `probe_addr` to see if a device ACKs a 1-byte read.
*   **`probe_addr(...)`**: The core interaction. Attempts to read exactly 1 byte from a target 7-bit address. If the HAL's `i2c.read()` succeeds without error, we know a device exists at that address.

### 3. The Reusable I2C String Formatting Library (`src/i2c.rs`)
Because formatting a 16x8 hex grid in standard Rust would usually require `alloc`, `String`, and `format!()` (which we do not have), this module provides a lightweight, zero-allocation way to generate the table bytes.

*   **`format_scan_header(...)`**: Injects the table column headers (`0  1  2  3 ... F`).
*   **`format_scan_entry(...)`**: Determines if the current address is at the beginning of a row (adds `XX:` prefix) or at the end (adds `\r\n`).
*   **`cell_bytes(...)`**: Given a specific address and whether a device was found there, returns a fixed 3-byte array like `51 ` (found), `-- ` (not found), or `   ` (reserved address block).
*   **`is_reserved(...)`**: True for addresses strictly less than 0x08 and strictly greater than 0x77 (these ranges are globally reserved by the I2C spec).