RP2040#

rustup target add thumbv6m-none-eabi
cargo install picotool

use hal::gpio::{FunctionI2C, Pin};
use hal::uart::{DataBits, StopBits, UartConfig, UartPeripheral};
use pamoja_sensors::bme280::{Bme280, I2C_ADDRESS_PRIMARY};

#[hal::entry]
fn main() -> ! {
    {
        const HEAP_SIZE: usize = 4 * 1024;
        static mut HEAP_MEM: [core::mem::MaybeUninit<u8>; HEAP_SIZE] =
            [core::mem::MaybeUninit::uninit(); HEAP_SIZE];
        // SAFETY: the heap is initialized once, here, before anything allocates.
        unsafe { HEAP.init(core::ptr::addr_of_mut!(HEAP_MEM) as usize, HEAP_SIZE) }
    }

    let mut pac = hal::pac::Peripherals::take().expect("the peripherals are taken once");
    let mut watchdog = hal::Watchdog::new(pac.WATCHDOG);
    let clocks = hal::clocks::init_clocks_and_plls(
        XTAL_FREQ_HZ,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .expect("the clocks come up from the crystal");
    let sio = hal::Sio::new(pac.SIO);
    let pins = hal::gpio::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    // I2C0 on the pins the board's own SDK calls its default I2C, GP4 and GP5, at the
    // 400 kHz the BME280 accepts.
    let sda: Pin<_, FunctionI2C, _> = pins.gpio4.reconfigure();
    let scl: Pin<_, FunctionI2C, _> = pins.gpio5.reconfigure();
    let i2c = hal::I2C::i2c0(
        pac.I2C0,
        sda,
        scl,
        400.kHz(),
        &mut pac.RESETS,
        &clocks.system_clock,
    );

    // UART0 on GP0 and GP1 carries the readings to a serial adapter; the LED on GP25
    // toggles on each one.
    let uart_pins = (pins.gpio0.into_function(), pins.gpio1.into_function());
    let mut uart = UartPeripheral::new(pac.UART0, uart_pins, &mut pac.RESETS)
        .enable(
            UartConfig::new(115_200.Hz(), DataBits::Eight, None, StopBits::One),
            clocks.peripheral_clock.freq(),
        )
        .expect("a valid UART configuration");
    let mut led = pins.gpio25.into_push_pull_output();

    // The timer is the driver's delay: the datasheet's start-up and measurement waits.
    let mut timer = hal::Timer::new(pac.TIMER, &mut pac.RESETS, &clocks);
    let mut sensor = Bme280::i2c(i2c, I2C_ADDRESS_PRIMARY, timer);
    sensor.init().expect("the BME280 answers on I2C0");

    loop {
        let measurement = sensor.measure().expect("a measurement");
        let _ = writeln!(
            uart,
            "{:.2} C, {:.2} hPa, {:.2} % humidity\r",
            measurement.celsius(),
            measurement.hectopascals(),
            measurement.relative_humidity_percent()
        );
        let _ = led.toggle();
        timer.delay_ms(2000);
    }
}

cd examples/boards/rp2040
cargo run --release

use embedded_hal::spi::MODE_0;
use embedded_hal_bus::spi::ExclusiveDevice;
use hal::gpio::{FunctionSpi, Pin, PullNone};
use hal::uart::{DataBits, StopBits, UartConfig, UartPeripheral};
use pamoja_lora::LinkSettings;
use pamoja_radios::duty::DutyCycle;
use pamoja_radios::sx126x::config::{PowerAmplifier, TcxoVoltage, TxPower};
use pamoja_radios::sx126x::{Board, RadioConfig, Reception, Sx126x, DEFAULT_TCXO_SETTLE_US};

/// The channel this node uses, what it sends at, and the share of time it may hold the band.
const FREQUENCY_HZ: u32 = 868_100_000;
const OUTPUT_DBM: i8 = 14;
const DUTY_CYCLE_PERMILLE: u32 = 10;

/// How long the radio listens before it looks at its duty-cycle budget again, in microseconds.
const LISTEN_US: u64 = 10_000_000;

#[hal::entry]
fn main() -> ! {
    let mut pac = hal::pac::Peripherals::take().expect("the peripherals are taken once");
    let mut watchdog = hal::Watchdog::new(pac.WATCHDOG);
    let clocks = hal::clocks::init_clocks_and_plls(
        XTAL_FREQ_HZ,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .expect("the clocks come up from the crystal");
    let sio = hal::Sio::new(pac.SIO);
    let pins = hal::gpio::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    // SPI1 on the pins the board wires to the radio: GP10 the clock, GP11 out, GP12 in. Two
    // megahertz is far under the chip's 16 MHz limit and is what the reference drivers use.
    let sck: Pin<_, FunctionSpi, PullNone> = pins.gpio10.reconfigure();
    let mosi: Pin<_, FunctionSpi, PullNone> = pins.gpio11.reconfigure();
    let miso: Pin<_, FunctionSpi, PullNone> = pins.gpio12.reconfigure();
    let bus = hal::Spi::<_, _, _, 8>::new(pac.SPI1, (mosi, miso, sck)).init(
        &mut pac.RESETS,
        clocks.peripheral_clock.freq(),
        2.MHz(),
        MODE_0,
    );

    // The chip select is a plain output the bus drives around each transaction, which is what
    // an exclusive device does for a bus with one chip on it.
    let timer = hal::Timer::new(pac.TIMER, &mut pac.RESETS, &clocks);
    let cs = pins.gpio3.into_push_pull_output();
    let device = ExclusiveDevice::new(bus, cs, timer).expect("the chip select takes a level");

    // What the board wires around the chip, from its own example code: a 1.7 V TCXO powered
    // from DIO3, the antenna switch on DIO2, and the DC-DC regulator.
    let board = Board::new(PowerAmplifier::HighPower)
        .with_tcxo(TcxoVoltage::V1_7, DEFAULT_TCXO_SETTLE_US)
        .with_dio2_rf_switch()
        .with_dc_dc();
    let busy = pins.gpio2.into_floating_input();
    let reset = pins.gpio15.into_push_pull_output();
    let mut radio = Sx126x::new(device, busy, reset, timer, board);
    radio.init().expect("the SX1262 answers on SPI1");

    // SF9 at 125 kHz, which is DR3 in the European plan, at 14 dBm.
    let link = LinkSettings::new(9, 125_000);
    let power = TxPower::for_output(PowerAmplifier::HighPower, OUTPUT_DBM);
    radio
        .configure(RadioConfig::new(FREQUENCY_HZ, link, power))
        .expect("the chip takes the settings");

    // UART0 on GP0 and GP1 carries what the node hears and sends.
    let uart_pins = (pins.gpio0.into_function(), pins.gpio1.into_function());
    let mut uart = UartPeripheral::new(pac.UART0, uart_pins, &mut pac.RESETS)
        .enable(
            UartConfig::new(115_200.Hz(), DataBits::Eight, None, StopBits::One),
            clocks.peripheral_clock.freq(),
        )
        .expect("a valid UART configuration");
    let _ = writeln!(uart, "beacon on {FREQUENCY_HZ} Hz at SF9, {OUTPUT_DBM} dBm\r");

    // Each frame buys silence in proportion to its airtime, and the guard says when the next
    // one may go out. The chip's own timer counts microseconds, which is what it counts in.
    let mut duty = DutyCycle::new(DUTY_CYCLE_PERMILLE);
    let mut buffer = [0u8; 255];
    let mut reading = 0u32;

    loop {
        match radio.receive(&mut buffer, LISTEN_US) {
            Ok(Reception::Frame { len, status }) => {
                let heard = core::str::from_utf8(&buffer[..len]).unwrap_or("(not text)");
                let _ = writeln!(
                    uart,
                    "heard  {heard} at {} dBm, SNR {} dB\r",
                    status.rssi_dbm.round_db(),
                    status.snr_db.round_db()
                );
            }
            Ok(Reception::Corrupt) => {
                let _ = writeln!(uart, "heard  a frame whose CRC failed\r");
            }
            Ok(Reception::Timeout) => {}
            Err(_) => {
                let _ = writeln!(uart, "the radio stopped answering\r");
            }
        }

        let now_us = timer.get_counter().ticks();
        if duty.ready(now_us) {
            let mut frame = [0u8; 32];
            let len = beacon(&mut frame, reading);
            match radio.transmit(&frame[..len]) {
                Ok(airtime_us) => {
                    duty.transmitted(now_us, &link, len);
                    let _ = writeln!(uart, "sent   reading {reading} in {airtime_us} us on air\r");
                    reading += 1;
                }
                Err(_) => {
                    let _ = writeln!(uart, "the frame did not go out\r");
                }
            }
        }
    }
}

/// Writes a beacon into a buffer without allocating, and returns its length.
fn beacon(frame: &mut [u8; 32], reading: u32) -> usize {
    let mut cursor = Cursor { frame, len: 0 };
    let _ = write!(cursor, "pico reading {reading}");
    cursor.len
}

/// A writer over a fixed buffer, so a `no_std` node can format a frame.
struct Cursor<'a> {
    frame: &'a mut [u8; 32],
    len: usize,
}

impl Write for Cursor<'_> {
    fn write_str(&mut self, text: &str) -> core::fmt::Result {
        for byte in text.as_bytes() {
            if self.len == self.frame.len() {
                return Err(core::fmt::Error);
            }
            self.frame[self.len] = *byte;
            self.len += 1;
        }
        Ok(())
    }
}

cargo run --release --bin radio