summaryrefslogtreecommitdiffstats
path: root/ble/src
diff options
context:
space:
mode:
Diffstat (limited to 'ble/src')
-rw-r--r--ble/src/logger.rs127
-rw-r--r--ble/src/macros.rs15
-rw-r--r--ble/src/main.rs70
-rw-r--r--ble/src/rtc.rs68
4 files changed, 263 insertions, 17 deletions
diff --git a/ble/src/logger.rs b/ble/src/logger.rs
new file mode 100644
index 0000000..f102b74
--- /dev/null
+++ b/ble/src/logger.rs
@@ -0,0 +1,127 @@
+use crate::rtc;
+
+use core::cell::UnsafeCell;
+use core::fmt::{self, Write};
+use log::{Metadata, Record};
+use nrf52840_hal::{target::UARTE0, uarte, Uarte};
+use starb::{Reader, RingBuffer, Writer};
+
+static mut UARTE0: usize = 0;
+
+struct JoinedRingBuffer<'a> {
+ lbr: Reader<'a, u8>,
+ lbw: Writer<'a, u8>,
+}
+
+impl<'a> JoinedRingBuffer<'a> {
+ const fn new(rb: &'a RingBuffer<u8>) -> Self {
+ let (lbr, lbw) = rb.split();
+ Self { lbr: lbr, lbw: lbw }
+ }
+}
+
+impl fmt::Write for JoinedRingBuffer<'_> {
+ fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
+ for b in s.bytes() {
+ if let Err(_) = self.lbw.unshift(b) {
+ // Ignore buffer full errors for logging.
+ return Ok(());
+ }
+ }
+ Ok(())
+ }
+}
+
+static mut LB: RingBuffer<u8> = RingBuffer::<u8>::new(0);
+static mut JRB: JoinedRingBuffer = unsafe { JoinedRingBuffer::new(&LB) };
+
+// The UART isn't necessarily Sync, so wrap it in something that
+// is. As long as flush() is only called from one thread, we're fine,
+// but this is a guarantee that the logger module doesn't make.
+pub struct WriteWrapper<W> {
+ w: W,
+}
+impl<W> WriteWrapper<W> {
+ pub fn new(writer: W) -> Self {
+ Self { w: writer }
+ }
+}
+unsafe impl<W> Sync for WriteWrapper<W> {}
+
+pub struct SerialLogger<W> {
+ writer: UnsafeCell<WriteWrapper<Uarte<W>>>,
+}
+
+impl<W> SerialLogger<W>
+where
+ W: uarte::Instance,
+{
+ pub fn new(writer: WriteWrapper<Uarte<W>>) -> Self {
+ // Stash this for unsafe usage in case there's an issue with
+ // the rest of the logging.
+ unsafe { UARTE0 = core::mem::transmute(&writer.w) };
+ Self {
+ writer: UnsafeCell::new(writer),
+ }
+ }
+}
+unsafe impl<W> Send for SerialLogger<W> {}
+unsafe impl<W> Sync for SerialLogger<W> {}
+
+impl<W> log::Log for SerialLogger<W>
+where
+ W: uarte::Instance,
+{
+ fn enabled(&self, metadata: &Metadata) -> bool {
+ metadata.level() <= log::max_level()
+ }
+
+ fn log(&self, record: &Record) {
+ if !self.enabled(record.metadata()) {
+ return;
+ }
+
+ let jrb = unsafe { &mut JRB };
+ write!(
+ jrb,
+ "[{}] {} {} -- {}\r\n",
+ rtc::millis(),
+ record.level(),
+ record.target(),
+ record.args()
+ )
+ .ok();
+ }
+
+ fn flush(&self) {
+ // Unsafe due to mutable static. We can only deal with the
+ // tail position of the buffer here to keep things safe.
+ let jrb = unsafe { &mut JRB };
+ if jrb.lbr.is_empty() {
+ return;
+ }
+
+ let writer = unsafe { &mut (*self.writer.get()) };
+ while let Some(b) = jrb.lbr.shift() {
+ // TODO: The UARTE peripheral uses DMA to send a bunch of
+ // stuff at speed, in hardware. It would be nice to use
+ // it, but we can't just take a slice of the ring buffer,
+ // since we don't know about its internal structure here.
+ writer.w.write(&[b]).expect("writing log");
+ }
+ }
+}
+
+// Write to the UART right now, instead of putting it on a ring
+// buffer. This function is a huge hack, and only useful for debugging
+// either before the main loop starts or if the ring buffer is broken.
+pub unsafe fn write_fmt_now(args: fmt::Arguments, nl: bool) {
+ if UARTE0 == 0 {
+ return;
+ }
+ let uart: &mut Uarte<UARTE0> = core::mem::transmute(UARTE0);
+ fmt::write(uart, args).expect("writing fmt now to uart");
+ if nl {
+ uart.write_str("\r\n").expect("writing nl now to uart");
+ }
+}
diff --git a/ble/src/macros.rs b/ble/src/macros.rs
new file mode 100644
index 0000000..46d2d07
--- /dev/null
+++ b/ble/src/macros.rs
@@ -0,0 +1,15 @@
+#[macro_export]
+macro_rules! logln_now {
+ ($($arg:tt)*) => {
+ unsafe {crate::logger::write_fmt_now(format_args!($($arg)*), true);}
+ };
+ (_) => {};
+}
+
+#[macro_export]
+macro_rules! log_now {
+ ($($arg:tt)*) => {
+ unsafe {crate::logger::write_fmt_now(format_args!($($arg)*), false);}
+ };
+ (_) => {};
+}
diff --git a/ble/src/main.rs b/ble/src/main.rs
index 8b8c513..6f167a5 100644
--- a/ble/src/main.rs
+++ b/ble/src/main.rs
@@ -1,39 +1,75 @@
//! BLE interface.
+
#![no_std]
#![no_main]
-use core::fmt::Write;
+mod logger;
+mod macros;
+mod rtc;
+
+use clint::HandlerArray;
+use core::mem;
+use cortex_m::asm::wfi;
use cortex_m_rt::entry;
-use nb::block;
+use log::{info, trace, LevelFilter};
#[allow(unused_imports)]
extern crate panic_semihosting;
use nrf52840_mdk_bsp::{
hal::{
- prelude::*,
- timer::{self, Timer},
+ target::{interrupt, Interrupt, UARTE0},
+ Clocks, Rtc,
},
Board,
};
+// TODO:
+// * set up serial reader for trinket
+// * set up i²c interface for keyboard reports
+// * and, finally, bluetooth
+
+// Interrupt handler table.
+static HANDLERS: HandlerArray = HandlerArray::new();
+
#[entry]
fn main() -> ! {
- let mut nrf52 = Board::take().unwrap();
+ let nrf52 = Board::take().unwrap();
+
+ let uart_wrapped = logger::WriteWrapper::new(nrf52.cdc);
+ let logger = logger::SerialLogger::new(uart_wrapped);
+ let logger_ref: &'static logger::SerialLogger<UARTE0> = unsafe { mem::transmute(&logger) };
+ log::set_logger(logger_ref).expect("setting logger");
+ log::set_max_level(LevelFilter::Trace);
+
+ nrf52.RTC0.intenset.write(|w| w.tick().set());
+
+ let mut nvic = nrf52.NVIC;
+ let mut rtc_handler = rtc::setup(Rtc::new(nrf52.RTC0), Clocks::new(nrf52.CLOCK));
- let mut timer = Timer::new(nrf52.TIMER0);
+ logln_now!("logln_now?");
+ HANDLERS.with_overrides(|hs| {
+ hs.register(0, &mut rtc_handler);
+ nvic.enable(Interrupt::RTC0);
- write!(nrf52.cdc, "Bootstrap complete.").ok();
- loop {
- write!(nrf52.cdc, ".").ok();
- delay(&mut timer, 1_000_000); // 1s
- }
+ info!("Bootstrap complete.");
+ let mut last_tick = rtc::millis();
+ last_tick -= last_tick % 1024;
+ loop {
+ let tick = rtc::millis();
+ if tick >= last_tick + 1024 {
+ last_tick = tick;
+ last_tick -= last_tick % 1024;
+ trace!(".");
+ }
+ wfi();
+ }
+ });
+ unreachable!();
}
-fn delay<T>(timer: &mut Timer<T>, cycles: u32)
-where
- T: timer::Instance,
-{
- timer.start(cycles);
- let _ = block!(timer.wait());
+// TODO: RTC0/1/2 exist. See which is best, if it matters.
+#[interrupt]
+fn RTC0() {
+ HANDLERS.call(0);
}
diff --git a/ble/src/rtc.rs b/ble/src/rtc.rs
new file mode 100644
index 0000000..8fe581f
--- /dev/null
+++ b/ble/src/rtc.rs
@@ -0,0 +1,68 @@
+use core::sync::atomic::{AtomicUsize, Ordering};
+use log::trace;
+use nrf52840_hal::{
+ clocks::LfOscStopped,
+ rtc::{self, RtcInterrupt},
+ Clocks, Rtc,
+};
+
+struct MilliClock(AtomicUsize);
+impl MilliClock {
+ const fn new() -> Self {
+ Self(AtomicUsize::new(0))
+ }
+
+ #[allow(unused)]
+ fn set(&self, millis: usize) {
+ self.0.store(millis, Ordering::SeqCst)
+ }
+
+ #[allow(unused)]
+ fn add(&self, val: usize) -> usize {
+ self.0.fetch_add(val, Ordering::SeqCst)
+ }
+
+ // Slightly less than 1ms, due to using a 32,768Hz clock, we can't
+ // hit exactly 1ms, so we shoot for a bit under.
+ fn millis(&self) -> usize {
+ self.0.load(Ordering::SeqCst)
+ }
+}
+
+static CLOCK: MilliClock = MilliClock::new();
+
+pub fn setup<R, H, L>(
+ mut rtc: Rtc<R, rtc::Stopped>,
+ clock: Clocks<H, L, LfOscStopped>,
+) -> impl FnMut()
+where
+ R: rtc::Instance,
+{
+ trace!("setting up clock");
+
+ clock.set_lfclk_src_rc().start_lfclk();
+
+ // Try to set clock to 1kHz.
+ match rtc.set_prescaler(32) {
+ Ok(()) => trace!("set prescaler!"),
+ Err(x) => trace!("couldn't set prescaler: {:?}", x),
+ }
+ // Make sure event is cleared before start.
+ let _ = rtc.get_event_triggered(RtcInterrupt::Tick, true);
+
+ let mut rtc = rtc.enable_counter();
+ move || handler(&mut rtc)
+}
+
+pub fn millis() -> usize {
+ CLOCK.millis()
+}
+
+fn handler<R>(rtc: &mut Rtc<R, rtc::Started>)
+where
+ R: rtc::Instance,
+{
+ let _ = rtc.get_event_triggered(RtcInterrupt::Tick, true);
+ CLOCK.add(1);
+ log::logger().flush();
+}