We have UART IRQs and blinking!

Turns out TIM6 isn't available on an F031, only the F051 and F061. The PAC didn't
know this though.

Author: thejpster

src/main.rs

@@ -3,7 +3,7 @@
 
 use neotron_bmc as _;
 
-use neotron_bmc::monotonic::{Tim6Monotonic, U16Ext};
+use neotron_bmc::monotonic::{Instant, Tim3Monotonic, U16Ext};
 
 use cortex_m_rt::exception;
 
@@ -24,7 +24,7 @@ static VERSION: &'static str = include_str!(concat!(env!("OUT_DIR"), "/version.t
 
 const PERIOD_MS: u16 = 1000;
 
-#[app(device = crate::pac, peripherals = true,  monotonic = crate::Tim6Monotonic)]
+#[app(device = crate::pac, peripherals = true,  monotonic = crate::Tim3Monotonic)]
 const APP: () = {
 	struct Resources {
 		uart_cts: PA11<Alternate<AF1>>,
@@ -49,8 +49,8 @@ const APP: () = {
 			.sysclk(48.mhz())
 			.freeze(&mut flash);
 
-		defmt::info!("Configuring TIM6 at 7.8125 kHz...");
-		crate::Tim6Monotonic::initialize(dp.TIM6);
+		defmt::info!("Configuring TIM3 at 7.8125 kHz...");
+		crate::Tim3Monotonic::initialize(dp.TIM3);
 
 		defmt::info!("Creating pins...");
 		let gpioa = dp.GPIOA.split(&mut rcc);
@@ -69,7 +69,10 @@ const APP: () = {
 
 		defmt::info!("Creating UART...");
 
-		let serial = serial::Serial::usart1(dp.USART1, (uart_tx, uart_rx), 115_200.bps(), &mut rcc);
+		let mut serial =
+			serial::Serial::usart1(dp.USART1, (uart_tx, uart_rx), 115_200.bps(), &mut rcc);
+
+		serial.listen(serial::Event::Rxne);
 
 		ctx.spawn.led_status_blink().unwrap();
 
@@ -90,29 +93,25 @@ const APP: () = {
 	fn idle(_: idle::Context) -> ! {
 		defmt::info!("Idle is running...");
 		loop {
-			cortex_m::asm::nop();
-			// defmt::info!("Idle is asleep...");
-			// cortex_m::asm::wfi();
-			// defmt::info!("Idle is awake...");
+			cortex_m::asm::wfi();
+			defmt::info!("It is now {}", crate::Instant::now().counts());
+		}
+	}
+
+	#[task(binds = USART1, resources=[serial])]
+	fn usart1_interrupt(ctx: usart1_interrupt::Context) {
+		// Reading the register clears the RX-Not-Empty-Interrupt flag.
+		match ctx.resources.serial.read() {
+			Ok(b) => {
+				defmt::info!("<< UART {:x}", b);
+			}
+			Err(_) => {
+				defmt::warn!("<< UART None?");
+			}
 		}
 	}
 
-	// #[task(binds = USART1, resources=[serial])]
-	// fn usart1_interrupt(ctx: usart1_interrupt::Context) {
-	// 	defmt::info!("USART1 IRQ!");
-	// 	// Reading the register clears the RX-Not-Empty-Interrupt flag.
-	// 	match ctx.resources.serial.read()
-	// 	{
-	// 		Ok(b) => {
-	// 			defmt::info!("Read byte {:x}", b);
-	// 		}
-	// 		Err(_) => {
-	// 			defmt::warn!("No byte available?");
-	// 		}
-	// 	}
-	// }
-
-	#[task(resources = [led_status], schedule = [led_status_blink])]
+	#[task(schedule = [led_status_blink], resources = [led_status])]
 	fn led_status_blink(ctx: led_status_blink::Context) {
 		// Use the safe local `static mut` of RTIC
 		static mut LED_STATE: bool = false;
@@ -126,9 +125,9 @@ const APP: () = {
 			ctx.resources.led_status.set_high().unwrap();
 			*LED_STATE = true;
 		}
-		ctx.schedule
-			.led_status_blink(ctx.scheduled + PERIOD_MS.millis())
-			.unwrap();
+		let next = ctx.scheduled + PERIOD_MS.millis();
+		defmt::info!("Next blink at {}", next.counts());
+		ctx.schedule.led_status_blink(next).unwrap();
 	}
 
 	// Let it use the USB interrupt as a generic software interrupt.

src/monotonic.rs

@@ -1,4 +1,4 @@
-//! Using STM32F0 TIM6 as monotonic 16 bit timer.
+//! Using STM32F0 TIM3 as monotonic 16 bit timer.
 //!
 //! ## Prescaler Calculations
 //!
@@ -25,34 +25,37 @@ use stm32f0xx_hal::pac;
 /// Implementor of the `rtic::Monotonic` traits and used to consume the timer
 /// to not allow for erroneous configuration.
 ///
-/// This uses TIM6 internally.
-pub struct Tim6Monotonic;
+/// This uses TIM3 internally.
+pub struct Tim3Monotonic;
 
 const CORE_CLOCK: u32 = 48_000_000;
 const PRESCALER: u32 = 6144;
 const HZ: u32 = CORE_CLOCK / PRESCALER;
 
-impl Tim6Monotonic {
+impl Tim3Monotonic {
 	/// Initialize the timer instance.
-	pub fn initialize(timer: pac::TIM6) {
-		// Enable and reset TIM6 in RCC
+	pub fn initialize(timer: pac::TIM3) {
+		// Enable and reset TIM3 in RCC
 		//
-		// Correctness: Since we only modify TIM6 related registers in the RCC
-		// register block, and since we own pac::TIM6, we should be safe.
+		// Correctness: Since we only modify TIM3 related registers in the RCC
+		// register block, and since we own pac::TIM3, we should be safe.
 		unsafe {
 			let rcc = &*pac::RCC::ptr();
 
 			// Enable timer
-			rcc.apb1enr.modify(|_, w| w.tim6en().set_bit());
+			rcc.apb1enr.modify(|_, w| w.tim3en().set_bit());
 
 			// Reset timer
-			rcc.apb1rstr.modify(|_, w| w.tim6rst().set_bit());
-			rcc.apb1rstr.modify(|_, w| w.tim6rst().clear_bit());
+			rcc.apb1rstr.modify(|_, w| w.tim3rst().set_bit());
+			rcc.apb1rstr.modify(|_, w| w.tim3rst().clear_bit());
 		}
 
 		// Set up prescaler
 		timer.psc.write(|w| w.psc().bits(PRESCALER as u16));
 
+		// Update prescaler
+		timer.egr.write(|w| w.ug().update());
+
 		// Enable counter
 		timer.cr1.modify(|_, w| w.cen().set_bit());
 
@@ -61,7 +64,7 @@ impl Tim6Monotonic {
 	}
 }
 
-impl Monotonic for Tim6Monotonic {
+impl Monotonic for Tim3Monotonic {
 	type Instant = Instant;
 
 	fn ratio() -> rtic::Fraction {
@@ -91,7 +94,7 @@ impl Monotonic for Tim6Monotonic {
 	/// before tasks can start; this is also the case in multi-core applications. User code must
 	/// *never* call this function.
 	unsafe fn reset() {
-		let tim = &*pac::TIM6::ptr();
+		let tim = &*pac::TIM3::ptr();
 
 		// Pause
 		tim.cr1.modify(|_, w| w.cen().clear_bit());
@@ -122,7 +125,7 @@ impl Instant {
 	/// Returns an instant corresponding to "now".
 	pub fn now() -> Self {
 		let now = {
-			let tim = unsafe { &*pac::TIM6::ptr() };
+			let tim = unsafe { &*pac::TIM3::ptr() };
 			tim.cnt.read().cnt().bits()
 		};