#![no_std]
#![no_main]
use panic_halt as _;
#[link_section = ".boot2"]
#[used]
pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER_GENERIC_03H;
#[rtic::app(device = rp2040_hal::pac)]
mod app {
use core::fmt::Write;
use fugit::RateExtU32;
use hal::Clock;
use rp2040_hal as hal;
const XTAL_FREQ_HZ: u32 = 12_000_000u32;
const SAMPLE_COUNT: usize = 1000;
type Uart = hal::uart::UartPeripheral<
hal::uart::Enabled,
hal::pac::UART0,
(
hal::gpio::Pin<hal::gpio::bank0::Gpio0, hal::gpio::FunctionUart, hal::gpio::PullDown>,
hal::gpio::Pin<hal::gpio::bank0::Gpio1, hal::gpio::FunctionUart, hal::gpio::PullDown>,
),
>;
#[shared]
struct Shared {
done: bool,
buf: [u16; SAMPLE_COUNT],
uart: Uart,
}
#[local]
struct Local {
adc_fifo: Option<hal::adc::AdcFifo<'static, u16>>,
}
#[init(local = [adc: Option<hal::Adc> = None])]
fn init(c: init::Context) -> (Shared, Local, init::Monotonics) {
unsafe {
hal::sio::spinlock_reset();
}
let mut resets = c.device.RESETS;
let mut watchdog = hal::Watchdog::new(c.device.WATCHDOG);
let clocks = hal::clocks::init_clocks_and_plls(
XTAL_FREQ_HZ,
c.device.XOSC,
c.device.CLOCKS,
c.device.PLL_SYS,
c.device.PLL_USB,
&mut resets,
&mut watchdog,
)
.unwrap();
let sio = hal::Sio::new(c.device.SIO);
let pins = hal::gpio::Pins::new(
c.device.IO_BANK0,
c.device.PADS_BANK0,
sio.gpio_bank0,
&mut resets,
);
let uart_pins = (
pins.gpio0.into_function::<hal::gpio::FunctionUart>(),
pins.gpio1.into_function::<hal::gpio::FunctionUart>(),
);
let uart = hal::uart::UartPeripheral::new(c.device.UART0, uart_pins, &mut resets)
.enable(
hal::uart::UartConfig::new(
115200.Hz(),
hal::uart::DataBits::Eight,
None,
hal::uart::StopBits::One,
),
clocks.peripheral_clock.freq(),
)
.unwrap();
*c.local.adc = Some(hal::Adc::new(c.device.ADC, &mut resets));
let adc = c.local.adc.as_mut().unwrap();
let mut adc_pin_0 = hal::adc::AdcPin::new(pins.gpio26.into_floating_input()).unwrap();
uart.write_full_blocking(b"ADC FIFO interrupt example\r\n");
let adc_fifo = adc
.build_fifo()
.clock_divider(47999, 0)
.set_channel(&mut adc_pin_0)
.enable_interrupt(1)
.start();
(
Shared {
done: false,
buf: [0; SAMPLE_COUNT],
uart,
},
Local {
adc_fifo: Some(adc_fifo),
},
init::Monotonics(),
)
}
#[idle(shared = [done, buf, uart])]
fn idle(mut c: idle::Context) -> ! {
loop {
let finished = (&mut c.shared.done, &mut c.shared.buf, &mut c.shared.uart).lock(
|done, buf, uart| {
if *done {
for sample in buf {
writeln!(uart, "Sample: {}\r", sample).unwrap();
}
writeln!(uart, "All done, going to sleep 😴\r").unwrap();
true
} else {
false
}
},
);
if finished {
break;
}
}
#[allow(clippy::empty_loop)]
loop {}
}
#[task(
binds = ADC_IRQ_FIFO,
priority = 1,
shared = [done, buf],
local = [adc_fifo, counter: usize = 0]
)]
fn adc_irq_fifo(mut c: adc_irq_fifo::Context) {
let sample = c.local.adc_fifo.as_mut().unwrap().read();
let i = *c.local.counter;
c.shared.buf.lock(|buf| buf[i] = sample);
*c.local.counter += 1;
if *c.local.counter == SAMPLE_COUNT {
c.local.adc_fifo.take().unwrap().stop();
c.shared.done.lock(|done| *done = true);
}
}
}