I2C and SPI with embedded-hal

// From embedded-hal (v1.0)
pub trait I2c {
    type Error;

    fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error>;
    fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error>;
    fn write_read(
        &mut self,
        address: u8,
        write: &[u8],
        read: &mut [u8],
    ) -> Result<(), Self::Error>;
}

pub trait SpiDevice {
    type Error;

    fn transaction(
        &mut self,
        operations: &mut [Operation<'_, u8>],
    ) -> Result<(), Self::Error>;
}

let mut bme = Bme280::new(i2c, 0x76);

// From embedded-hal-async
pub trait I2c {
    type Error;

    async fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error>;
    async fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error>;
    async fn write_read(
        &mut self,
        address: u8,
        write: &[u8],
        read: &mut [u8],
    ) -> Result<(), Self::Error>;
}

use embassy_rp::i2c::{self, Config as I2cConfig, InterruptHandler as I2cInterruptHandler};
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::I2C0;

// Bind the I2C0 interrupt to Embassy's handler
bind_interrupts!(struct Irqs {
    I2C0_IRQ => I2cInterruptHandler<I2C0>;
});

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    // Configure I2C0 on GP4 (SDA) and GP5 (SCL) at 400 kHz
    let mut i2c_config = I2cConfig::default();
    i2c_config.frequency = 400_000;

    let i2c = i2c::I2c::new_async(
        p.I2C0,
        p.PIN_5,  // SCL
        p.PIN_4,  // SDA
        Irqs,
        i2c_config,
    );
}

use embedded_hal_async::i2c::I2c as AsyncI2c;

async fn scan_i2c_bus<T: AsyncI2c>(i2c: &mut T) {
    defmt::info!("Scanning I2C bus...");
    let mut found = 0u8;

    for addr in 0x08..=0x77 {
        let mut buf = [0u8; 1];
        if i2c.read(addr, &mut buf).await.is_ok() {
            defmt::info!("  Device found at address 0x{:02X}", addr);
            found += 1;
        }
    }

    defmt::info!("Scan complete. {} device(s) found.", found);
}

Scanning I2C bus...
  Device found at address 0x3C
  Device found at address 0x76
Scan complete. 2 device(s) found.

[dependencies]
embassy-executor = { version = "0.7", features = ["arch-cortex-m", "executor-thread"] }
embassy-rp = { version = "0.3", features = ["time-driver", "rp2040"] }
embassy-time = { version = "0.4", features = ["generic-queue-8"] }
embassy-sync = "0.6"

cortex-m = { version = "0.7", features = ["inline-asm"] }
cortex-m-rt = "0.7"
panic-halt = "1.0"
defmt = "0.3"
defmt-rtt = "0.4"

# BME280 driver (uses embedded-hal traits)
bme280 = "0.5"

# SSD1306 OLED driver
ssd1306 = "0.9"

# Graphics primitives for the display
embedded-graphics = "0.8"

# Shared I2C bus (allows multiple devices on one bus)
embedded-hal-bus = "0.2"

portable-atomic = { version = "1.10", features = ["critical-section"] }
static_cell = "2.1"

use bme280::i2c::BME280;
use embassy_time::Delay;

// Create the BME280 driver instance
// The second argument is the I2C address (0x76 or 0x77)
let mut bme = BME280::new_primary(i2c);
// new_primary = 0x76, new_secondary = 0x77

// Initialize the sensor (reads calibration data, sets oversampling)
bme.init(&mut Delay).unwrap();

// Read all measurements in one transaction
let measurements = bme.measure(&mut Delay).unwrap();

defmt::info!("Temperature: {} C", measurements.temperature);
defmt::info!("Humidity:    {} %", measurements.humidity);
defmt::info!("Pressure:    {} hPa", measurements.pressure / 100.0);

use embedded_hal_bus::i2c::RefCellDevice;
use core::cell::RefCell;

// Create the I2C peripheral
let i2c = i2c::I2c::new_blocking(p.I2C0, p.PIN_5, p.PIN_4, i2c_config);

// Wrap it in a RefCell so multiple drivers can share it
let i2c_bus = RefCell::new(i2c);

// Create shared references for each device
let bme_i2c = RefCellDevice::new(&i2c_bus);
let display_i2c = RefCellDevice::new(&i2c_bus);

// Now both drivers can use the bus
let mut bme = BME280::new_primary(bme_i2c);
let mut display = build_display(display_i2c);

use ssd1306::prelude::*;
use ssd1306::I2CDisplayInterface;
use ssd1306::Ssd1306;
use ssd1306::mode::BufferedGraphicsMode;
use ssd1306::size::DisplaySize128x64;
use ssd1306::rotation::DisplayRotation;

fn build_display<I: embedded_hal::i2c::I2c>(
    i2c: I,
) -> Ssd1306<I2CInterface<I>, DisplaySize128x64, BufferedGraphicsMode<DisplaySize128x64>> {
    let interface = I2CDisplayInterface::new(i2c);

    let mut display = Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
        .into_buffered_graphics_mode();

    display.init().unwrap();
    display.clear_buffer();
    display.flush().unwrap();

    display
}

use embedded_graphics::mono_font::ascii::FONT_6X10;
use embedded_graphics::mono_font::MonoTextStyleBuilder;
use embedded_graphics::pixelcolor::BinaryColor;
use embedded_graphics::prelude::*;
use embedded_graphics::text::{Baseline, Text};

fn draw_readings<D: DrawTarget<Color = BinaryColor>>(
    display: &mut D,
    temperature: f32,
    humidity: f32,
    pressure: f32,
) {
    let text_style = MonoTextStyleBuilder::new()
        .font(&FONT_6X10)
        .text_color(BinaryColor::On)
        .build();

    // Clear the display
    display.clear(BinaryColor::Off).unwrap();

    // Format strings (no_std, so we use fixed buffers)
    let mut temp_buf = [0u8; 32];
    let mut hum_buf = [0u8; 32];
    let mut pres_buf = [0u8; 32];

    let temp_str = format_f32(&mut temp_buf, "Temp: ", temperature, " C");
    let hum_str = format_f32(&mut hum_buf, "Hum:  ", humidity, " %");
    let pres_str = format_f32(&mut pres_buf, "Pres: ", pressure, " hPa");

    // Draw each line at a different Y position
    Text::with_baseline(temp_str, Point::new(0, 0), text_style, Baseline::Top)
        .draw(display)
        .unwrap();

    Text::with_baseline(hum_str, Point::new(0, 16), text_style, Baseline::Top)
        .draw(display)
        .unwrap();

    Text::with_baseline(pres_str, Point::new(0, 32), text_style, Baseline::Top)
        .draw(display)
        .unwrap();

    Text::with_baseline("SiliconWit Weather", Point::new(0, 52), text_style, Baseline::Top)
        .draw(display)
        .unwrap();
}

/// Format a floating-point value into a fixed buffer for no_std display.
/// Returns the formatted string slice.
fn format_f32<'a>(
    buf: &'a mut [u8; 32],
    prefix: &str,
    value: f32,
    suffix: &str,
) -> &'a str {
    let integer = value as i32;
    let decimal = ((value - integer as f32) * 10.0) as i32;
    let decimal = if decimal < 0 { -decimal } else { decimal };

    let mut pos = 0usize;

    // Write prefix
    for b in prefix.bytes() {
        if pos < buf.len() {
            buf[pos] = b;
            pos += 1;
        }
    }

    // Write integer part (handle negative)
    if integer < 0 {
        if pos < buf.len() {
            buf[pos] = b'-';
            pos += 1;
        }
    }
    let abs_int = if integer < 0 { -integer } else { integer } as u32;
    pos = write_u32(buf, pos, abs_int);

    // Write decimal point and one decimal digit
    if pos < buf.len() {
        buf[pos] = b'.';
        pos += 1;
    }
    pos = write_u32(buf, pos, decimal as u32);

    // Write suffix
    for b in suffix.bytes() {
        if pos < buf.len() {
            buf[pos] = b;
            pos += 1;
        }
    }

    core::str::from_utf8(&buf[..pos]).unwrap_or("ERR")
}

fn write_u32(buf: &mut [u8; 32], start: usize, val: u32) -> usize {
    if val == 0 {
        if start < buf.len() {
            buf[start] = b'0';
            return start + 1;
        }
        return start;
    }

    let mut digits = [0u8; 10];
    let mut n = val;
    let mut count = 0;
    while n > 0 {
        digits[count] = b'0' + (n % 10) as u8;
        n /= 10;
        count += 1;
    }

    let mut pos = start;
    for i in (0..count).rev() {
        if pos < buf.len() {
            buf[pos] = digits[i];
            pos += 1;
        }
    }
    pos
}

[package]
name = "weather-station"
version = "0.1.0"
edition = "2021"

[dependencies]
embassy-executor = { version = "0.7", features = ["arch-cortex-m", "executor-thread"] }
embassy-rp = { version = "0.3", features = ["time-driver", "rp2040"] }
embassy-time = { version = "0.4", features = ["generic-queue-8"] }
embassy-sync = "0.6"

cortex-m = { version = "0.7", features = ["inline-asm"] }
cortex-m-rt = "0.7"
panic-halt = "1.0"
defmt = "0.3"
defmt-rtt = "0.4"

bme280 = "0.5"
ssd1306 = "0.9"
embedded-graphics = "0.8"
embedded-hal-bus = "0.2"

portable-atomic = { version = "1.10", features = ["critical-section"] }
static_cell = "2.1"

[profile.release]
opt-level = "s"
debug = true
lto = true
codegen-units = 1

// Async I2C requires the interrupt binding
bind_interrupts!(struct Irqs {
    I2C0_IRQ => I2cInterruptHandler<I2C0>;
});

// Use new_async instead of new_blocking
let i2c = i2c::I2c::new_async(
    p.I2C0,
    p.PIN_5,
    p.PIN_4,
    Irqs,
    i2c_config,
);

use embassy_rp::spi::{self, Config as SpiConfig, Spi};
use embassy_rp::gpio::{Level, Output};

// SPI0 pin configuration
// GP18: SCK
// GP19: MOSI (TX)
// GP16: MISO (RX)
// GP17: CS (manual chip select)

let mut spi_config = SpiConfig::default();
spi_config.frequency = 1_000_000; // 1 MHz

let spi = Spi::new_blocking(
    p.SPI0,
    p.PIN_18, // SCK
    p.PIN_19, // MOSI
    p.PIN_16, // MISO
    spi_config,
);

// Chip select is managed manually
let cs = Output::new(p.PIN_17, Level::High);

use embedded_hal_bus::spi::ExclusiveDevice;
use embassy_time::Delay;

let spi_device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
// Pass spi_device to any driver that expects impl SpiDevice

match bme.measure(&mut Delay) {
    Ok(m) => {
        // Use measurements
    }
    Err(bme280::Error::Bus(_)) => {
        // I2C communication error. Sensor disconnected?
        // Try reinitializing after a delay.
        Timer::after_secs(5).await;
        let _ = bme.init(&mut Delay);
    }
    Err(bme280::Error::InvalidData) => {
        // Sensor returned garbage. Skip this reading.
    }
    Err(_) => {
        // Other error
    }
}