diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/simple/logger.rs | 139 | ||||
| -rw-r--r-- | examples/simple/macros.rs | 15 | ||||
| -rwxr-xr-x | examples/simple/main.rs | 189 | ||||
| -rw-r--r-- | examples/simple/rtc.rs | 74 |
4 files changed, 0 insertions, 417 deletions
diff --git a/examples/simple/logger.rs b/examples/simple/logger.rs deleted file mode 100644 index 9fbba77..0000000 --- a/examples/simple/logger.rs +++ /dev/null @@ -1,139 +0,0 @@ -use crate::rtc; -use starb::{Reader, RingBuffer, Writer}; - -use core::cell::UnsafeCell; -use core::fmt::{self, Write}; -use embedded_hal::{digital::v2::OutputPin, serial}; -use log::{Metadata, Record}; -use trinket_m0::{ - gpio::{Pa6, Pa7, PfD}, - sercom::{Sercom0Pad2, Sercom0Pad3, UART0}, -}; - -static mut UART0: 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(); -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> -where - W: serial::Write<u8>, -{ - pub fn new(writer: W) -> Self { - Self { w: writer } - } -} -unsafe impl<W> Sync for WriteWrapper<W> {} - -pub struct SerialLogger<W, L> { - writer: UnsafeCell<WriteWrapper<W>>, - led: UnsafeCell<L>, -} - -impl<W, L> SerialLogger<W, L> -where - W: serial::Write<u8>, - L: OutputPin + Send + Sync, -{ - pub fn new(writer: WriteWrapper<W>, led: L) -> Self { - // Stash this for unsafe usage in case there's an issue with - // the rest of the logging. - unsafe { UART0 = core::mem::transmute(&writer.w) }; - Self { - writer: UnsafeCell::new(writer), - led: UnsafeCell::new(led), - } - } -} -unsafe impl<W, L> Send for SerialLogger<W, L> {} -unsafe impl<W, L> Sync for SerialLogger<W, L> {} - -impl<W, L> log::Log for SerialLogger<W, L> -where - W: serial::Write<u8>, - L: OutputPin + Send + Sync, -{ - 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 led = unsafe { &mut (*self.led.get()) }; - let writer = unsafe { &mut (*self.writer.get()) }; - - led.set_high().ok(); - while let Some(b) = jrb.lbr.shift() { - nb::block!(writer.w.write(b)).ok(); - } - led.set_low().ok(); - } -} - -// 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 UART0 == 0 { - return; - } - let uart: &mut UART0<Sercom0Pad3<Pa7<PfD>>, Sercom0Pad2<Pa6<PfD>>, (), ()> = - core::mem::transmute(UART0); - 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/examples/simple/macros.rs b/examples/simple/macros.rs deleted file mode 100644 index 46d2d07..0000000 --- a/examples/simple/macros.rs +++ /dev/null @@ -1,15 +0,0 @@ -#[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/examples/simple/main.rs b/examples/simple/main.rs deleted file mode 100755 index 8fbf0ea..0000000 --- a/examples/simple/main.rs +++ /dev/null @@ -1,189 +0,0 @@ -#![no_std] -#![no_main] - -mod logger; -mod macros; -mod rtc; - -use atsamd_usb_host::SAMDHost; -use bootkbd::BootKeyboard; -use clint::HandlerArray; -use cortex_m::asm::wfi; -use cortex_m_rt::{entry, exception, ExceptionFrame}; -use embedded_hal::digital::v2::OutputPin; -use log::{debug, info, LevelFilter}; -use trinket_m0::{ - self as hal, - clock::GenericClockController, - gpio::{OpenDrain, Output, Pa10, Pa6, Pa7, PfD}, - sercom, - target_device::{interrupt, Interrupt}, - time::*, - CorePeripherals, Peripherals, -}; -use usb_host::Driver; - -static HANDLERS: HandlerArray = HandlerArray::new(); - -static mut LED: usize = 0; - -#[entry] -fn main() -> ! { - let mut peripherals = Peripherals::take().expect("taking peripherals"); - let mut core = CorePeripherals::take().expect("taking core peripherals"); - - let mut clocks = GenericClockController::with_internal_32kosc( - peripherals.GCLK, - &mut peripherals.PM, - &mut peripherals.SYSCTRL, - &mut peripherals.NVMCTRL, - ); - - let mut pins = hal::Pins::new(peripherals.PORT); - - let uart = hal::uart( - &mut clocks, - 115_200.hz(), - peripherals.SERCOM0, - &mut core.NVIC, - &mut peripherals.PM, - pins.d3, - pins.d4, - &mut pins.port, - ); - - let mut red_led = pins.d13.into_open_drain_output(&mut pins.port); - red_led.set_low().expect("turning off red LED"); - unsafe { LED = core::mem::transmute(&red_led) } - - // We do the transmute because, while all the underlying data is - // static, we're unable to get a referecence to the UART or LED - // until run-time. Another option would be to use Option in the - // SerialLogger definition, but that requires a check every time - // they might be used. - let uart_wrapped = logger::WriteWrapper::new(uart); - let logger = logger::SerialLogger::new(uart_wrapped, red_led); - - // Wow, would I love to not be annotating this type. - let logger_ref: &'static logger::SerialLogger< - sercom::UART0<sercom::Sercom0Pad3<Pa7<PfD>>, sercom::Sercom0Pad2<Pa6<PfD>>, (), ()>, - Pa10<Output<OpenDrain>>, - > = unsafe { core::mem::transmute(&logger) }; - unsafe { log::set_logger_racy(logger_ref).expect("couldn't set logger") }; - log::set_max_level(LevelFilter::Info); - - info!("setting up timer"); - let mut rtc_handler = rtc::setup(peripherals.RTC, &mut clocks); - - info!("setting up usb host"); - let (mut usb_host, mut usb_handler) = SAMDHost::new( - peripherals.USB, - pins.usb_sof, - pins.usb_dm, - pins.usb_dp, - Some(pins.usb_host_enable), - &mut pins.port, - &mut clocks, - &mut peripherals.PM, - &rtc::millis, - ); - - let mut bootkbd = BootKeyboard::new(); - let mut drivers: [&mut dyn Driver; 1] = [&mut bootkbd]; - - info!("setting up handlers"); - HANDLERS.with_overrides(|hs| { - hs.register(0, &mut rtc_handler); - core.NVIC.enable(Interrupt::RTC); - - hs.register(1, &mut usb_handler); - unsafe { core.NVIC.set_priority(Interrupt::USB, 0) }; - core.NVIC.enable(Interrupt::USB); - - info!("Boot up complete."); - - loop { - usb_host.task(&mut drivers[..]); - wfi(); - } - }); - unreachable!(); -} - -#[panic_handler] -fn panic_handler(pi: &core::panic::PanicInfo) -> ! { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - logln_now!("~~~ PANIC ~~~"); - logln_now!("{}", pi); - logln_now!("flushing log"); - loop { - log::logger().flush(); - wfi() - } -} - -#[exception] -fn HardFault(ef: &ExceptionFrame) -> ! { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - log::logger().flush(); - logln_now!("!!! Hard Fault - ef: {:?} !!!", ef); - logln_now!("flushing log"); - loop { - log::logger().flush(); - wfi() - } -} - -#[exception] -fn DefaultHandler(interrupt: i16) { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - debug!("*** Default Handler: {} ***", interrupt); -} - -#[exception] -fn NonMaskableInt() { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - debug!("+++ NonMaskableInt +++"); -} - -#[exception] -fn SVCall() { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - debug!("+++ SVCall +++"); -} - -#[exception] -fn PendSV() { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - debug!("+++ PendSV +++"); -} - -#[exception] -fn SysTick() { - let red_led: &mut Pa10<Output<OpenDrain>> = unsafe { core::mem::transmute(LED) }; - red_led.set_high().ok(); - - debug!("+++ SysTick +++"); -} - -#[interrupt] -fn RTC() { - HANDLERS.call(0); -} - -#[interrupt] -fn USB() { - HANDLERS.call(1); -} diff --git a/examples/simple/rtc.rs b/examples/simple/rtc.rs deleted file mode 100644 index 79e450a..0000000 --- a/examples/simple/rtc.rs +++ /dev/null @@ -1,74 +0,0 @@ -use core::sync::atomic::{AtomicUsize, Ordering}; -use log; -use trinket_m0::{clock::GenericClockController, RTC}; - -struct Clock(AtomicUsize); -impl Clock { - const fn new() -> Self { - Self(AtomicUsize::new(0)) - } - - fn set(&self, millis: usize) { - self.0.store(millis, 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: Clock = Clock::new(); - -// Set to run every ~500µs. -static COUNTER: u32 = 16; // 32 ticks requires 1024 cycles at 32,768Hz for 1 second. - -pub fn setup(mut rtc: RTC, clocks: &mut GenericClockController) -> impl FnMut() { - let rtc_clock = &clocks.gclk1(); - clocks.rtc(&rtc_clock); - - rtc.mode0().ctrl.write(|w| w.swrst().set_bit()); - while rtc.mode0().status.read().syncbusy().bit_is_set() {} - - rtc.mode0().ctrl.write(|w| { - w.mode().count32(); - - // Neither the prescaler nor matchlr values seem to work. Not - // sure why. - //w.prescaler().div1024(); - w.matchclr().set_bit() // Reset on match for periodic - }); - - rtc.mode0().comp[0].write(|w| unsafe { w.bits(COUNTER) }); - rtc.mode0().intflag.write(|w| w.cmp0().set_bit()); - rtc.mode0().intenset.write(|w| w.cmp0().set_bit()); - - // Enable the RTC and wait for sync. - rtc.mode0().ctrl.write(|w| w.enable().set_bit()); - while rtc.mode0().status.read().syncbusy().bit_is_set() {} - - move || handler(&mut rtc) -} - -pub fn millis() -> usize { - CLOCK.millis() -} - -fn handler(rtc: &mut RTC) { - // FIXME: matchclr doesn't seem to work to reset the counter? - rtc.mode0().count.write(|w| unsafe { w.bits(0) }); - rtc.mode0().intflag.write(|w| w.cmp0().set_bit()); - - static mut TICKS: usize = 0; - static mut ADD: bool = false; - unsafe { - if ADD { - TICKS += 1; - CLOCK.set(TICKS); - } - ADD = !ADD; - - log::logger().flush(); - } -} |