link correction

Author: robamu

README.md

@@ -98,6 +98,8 @@ example.
 
 Assuming a working debug connection to your VA108xx board, you can debug using VS Code with
 the [`Cortex-Debug` plugin](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug).
+Please make sure that [`objdump-multiarch` and `nm-multiarch`](https://forums.raspberrypi.com/viewtopic.php?t=333146)
+are installed as well.
 
 Some sample configuration files for VS code were provided and can be used by running
 `cp -rT vscode .vscode` like specified above. After that, you can use `Run and Debug`
@@ -112,4 +114,5 @@ configuration variables in your `settings.json`:
 - `"cortex-debug.gdbPath.osx"`
 
 The provided VS Code configurations also provide an integrated RTT logger, which you can access
-via the terminal at `RTT Ch:0 console`.
+via the terminal at `RTT Ch:0 console`. In order for the RTT block address detection to
+work properly, `objdump-multiarch` and `nm-multiarch` need to be installed.

examples/embassy/src/main.rs

@@ -18,7 +18,15 @@ async fn main(_spawner: Spawner) {
     let mut dp = pac::Peripherals::take().unwrap();
 
     // Safety: Only called once here.
-    unsafe { embassy_example::init(&mut dp.sysconfig, SYSCLK_FREQ, dp.tim23, dp.tim22) };
+    unsafe {
+        embassy_example::init(
+            &mut dp.sysconfig,
+            &dp.irqsel,
+            SYSCLK_FREQ,
+            dp.tim23,
+            dp.tim22,
+        )
+    };
 
     let porta = PinsA::new(&mut dp.sysconfig, Some(dp.ioconfig), dp.porta);
     let mut led0 = porta.pa10.into_readable_push_pull_output();

examples/embassy/src/time_driver.rs

@@ -1,4 +1,4 @@
-//! This is a sample time driver implementation for the VA416xx family of devices, supporting
+//! This is a sample time driver implementation for the VA108xx family of devices, supporting
 //! one alarm and requiring/reserving 2 TIM peripherals. You could adapt this implementation to
 //! support more alarms.
 //!
@@ -12,30 +12,36 @@ use portable_atomic::{AtomicU32, AtomicU8, Ordering};
 use embassy_time_driver::{time_driver_impl, AlarmHandle, Driver, TICK_HZ};
 use once_cell::sync::OnceCell;
 use va108xx_hal::{
+    clock::enable_peripheral_clock,
     enable_interrupt,
     pac::{self, interrupt},
     prelude::*,
     timer::{enable_tim_clk, ValidTim},
+    PeripheralSelect,
 };
 
 pub type TimekeeperClk = pac::Tim23;
 pub type AlarmClk0 = pac::Tim22;
 pub type AlarmClk1 = pac::Tim21;
 pub type AlarmClk2 = pac::Tim20;
 
+const TIMEKEEPER_IRQ: pac::Interrupt = pac::Interrupt::OC31;
+const ALARM_IRQ: pac::Interrupt = pac::Interrupt::OC30;
+
 /// Initialization method for embassy
 ///
 /// # Safety
 /// This has to be called once at initialization time to initiate the time driver for
 /// embassy.
 pub unsafe fn init(
     syscfg: &mut pac::Sysconfig,
+    irqsel: &pac::Irqsel,
     sysclk: impl Into<Hertz>,
     timekeeper: TimekeeperClk,
     alarm_tim: AlarmClk0,
 ) {
     //enable_and_init_irq_router(syscfg, irq_router);
-    DRIVER.init(syscfg, sysclk, timekeeper, alarm_tim)
+    DRIVER.init(syscfg, irqsel, sysclk, timekeeper, alarm_tim)
 }
 
 time_driver_impl!(
@@ -114,10 +120,12 @@ impl TimerDriverEmbassy {
     fn init(
         &self,
         syscfg: &mut pac::Sysconfig,
+        irqsel: &pac::Irqsel,
         sysclk: impl Into<Hertz>,
         timekeeper: TimekeeperClk,
         alarm_tim: AlarmClk0,
     ) {
+        enable_peripheral_clock(syscfg, PeripheralSelect::Irqsel);
         enable_tim_clk(syscfg, TimekeeperClk::TIM_ID);
         let sysclk = sysclk.into();
         // Initiate scale value here. This is required to convert timer ticks back to a timestamp.
@@ -130,8 +138,11 @@ impl TimerDriverEmbassy {
             .cnt_value()
             .write(|w| unsafe { w.bits(u32::MAX) });
         // Switch on. Timekeeping should always be done.
+        irqsel
+            .tim0(TimekeeperClk::TIM_ID as usize)
+            .write(|w| unsafe { w.bits(TIMEKEEPER_IRQ as u32) });
         unsafe {
-            enable_interrupt(pac::Interrupt::OC31);
+            enable_interrupt(TIMEKEEPER_IRQ);
         }
         timekeeper.ctrl().modify(|_, w| w.irq_enb().set_bit());
         timekeeper.enable().write(|w| unsafe { w.bits(1) });
@@ -145,8 +156,11 @@ impl TimerDriverEmbassy {
         });
         // Enable general interrupts. The IRQ enable of the peripheral remains cleared.
         unsafe {
-            enable_interrupt(pac::Interrupt::OC30);
+            enable_interrupt(ALARM_IRQ);
         }
+        irqsel
+            .tim0(AlarmClk0::TIM_ID as usize)
+            .write(|w| unsafe { w.bits(ALARM_IRQ as u32) });
     }
 
     // Should be called inside the IRQ of the timekeeper timer.

examples/rtic/src/bin/uart.rs renamed to examples/rtic/src/bin/uart-rtic.rs

@@ -14,6 +14,7 @@
 mod app {
     use embedded_io::Write;
     use panic_rtt_target as _;
+    use rtic_example::SYSCLK_FREQ;
     use rtic_sync::make_channel;
     use rtt_target::{rprintln, rtt_init_print};
     use va108xx_hal::{
@@ -47,9 +48,10 @@ mod app {
     #[init]
     fn init(cx: init::Context) -> (Shared, Local) {
         rtt_init_print!();
-        //set_print_channel(channels.up.0);
         rprintln!("-- VA108xx UART IRQ example application--");
 
+        Mono::start(cx.core.SYST, SYSCLK_FREQ.raw());
+
         let mut dp = cx.device;
         let gpiob = PinsB::new(&mut dp.sysconfig, Some(dp.ioconfig), dp.portb);
         let tx = gpiob.pb21.into_funsel_1();
@@ -66,7 +68,6 @@ mod app {
 
         let (rx_info_tx, rx_info_rx) = make_channel!(RxInfo, 3);
         let rx_buf: [u8; 64] = [0; 64];
-        //reply_handler::spawn().expect("spawning reply handler failed");
         (
             Shared { irq_uart, rx_buf },
             Local {

examples/rtic/src/lib.rs

@@ -0,0 +1,4 @@
+#![no_std]
+use va108xx_hal::time::Hertz;
+
+pub const SYSCLK_FREQ: Hertz = Hertz::from_raw(50_000_000);

examples/rtic/src/main.rs

@@ -7,9 +7,10 @@ mod app {
     use cortex_m::asm;
     use embedded_hal::digital::StatefulOutputPin;
     use panic_rtt_target as _;
+    use rtic_example::SYSCLK_FREQ;
     use rtic_monotonics::systick::prelude::*;
     use rtic_monotonics::Monotonic;
-    use rtt_target::{rprintln, rtt_init_default};
+    use rtt_target::{rprintln, rtt_init_print};
     use va108xx_hal::{
         gpio::{OutputReadablePushPull, Pin, PinsA, PA10, PA6, PA7},
         pac,
@@ -25,15 +26,20 @@ mod app {
     #[shared]
     struct Shared {}
 
-    rtic_monotonics::systick_monotonic!(Mono, 10_000);
+    rtic_monotonics::systick_monotonic!(Mono);
 
     #[init]
-    fn init(_ctx: init::Context) -> (Shared, Local) {
-        rtt_init_default!();
+    fn init(mut cx: init::Context) -> (Shared, Local) {
+        rtt_init_print!();
         rprintln!("-- Vorago VA108xx RTIC template --");
-        let mut dp = pac::Peripherals::take().unwrap();
 
-        let porta = PinsA::new(&mut dp.sysconfig, Some(dp.ioconfig), dp.porta);
+        Mono::start(cx.core.SYST, SYSCLK_FREQ.raw());
+
+        let porta = PinsA::new(
+            &mut cx.device.sysconfig,
+            Some(cx.device.ioconfig),
+            cx.device.porta,
+        );
         let led0 = porta.pa10.into_readable_push_pull_output();
         let led1 = porta.pa7.into_readable_push_pull_output();
         let led2 = porta.pa6.into_readable_push_pull_output();
@@ -55,10 +61,11 @@ mod app {
     )]
     async fn blinky(cx: blinky::Context) {
         loop {
+            rprintln!("toggling LEDs");
             cx.local.led0.toggle().ok();
             cx.local.led1.toggle().ok();
             cx.local.led2.toggle().ok();
-            Mono::delay(200.millis()).await;
+            Mono::delay(1000.millis()).await;
         }
     }
 }

examples/simple/Cargo.toml

@@ -8,6 +8,7 @@ cortex-m = {version = "0.7", features = ["critical-section-single-core"]}
 cortex-m-rt = "0.7"
 panic-halt = "0.2"
 panic-rtt-target = "0.1"
+critical-section = "1"
 rtt-target = "0.5"
 embedded-hal = "1"
 embedded-hal-nb = "1"

examples/simple/examples/timer-ticks.rs

@@ -3,8 +3,8 @@
 #![no_std]
 
 use core::cell::Cell;
-use cortex_m::interrupt::Mutex;
 use cortex_m_rt::entry;
+use critical_section::Mutex;
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
 use va108xx_hal::{
@@ -83,11 +83,12 @@ fn main() -> ! {
         }
     }
     loop {
-        let current_ms = cortex_m::interrupt::free(|cs| MS_COUNTER.borrow(cs).get());
+        let current_ms = critical_section::with(|cs| MS_COUNTER.borrow(cs).get());
         if current_ms - last_ms >= 1000 {
-            last_ms = current_ms;
+            // To prevent drift.
+            last_ms += 1000;
             rprintln!("MS counter: {}", current_ms);
-            let second = cortex_m::interrupt::free(|cs| SEC_COUNTER.borrow(cs).get());
+            let second = critical_section::with(|cs| SEC_COUNTER.borrow(cs).get());
             rprintln!("Second counter: {}", second);
         }
         cortex_m::asm::delay(10000);
@@ -110,7 +111,7 @@ fn OC0() {
 #[interrupt]
 #[allow(non_snake_case)]
 fn OC1() {
-    cortex_m::interrupt::free(|cs| {
+    critical_section::with(|cs| {
         let mut sec = SEC_COUNTER.borrow(cs).get();
         sec += 1;
         SEC_COUNTER.borrow(cs).set(sec);

va108xx-hal/Cargo.toml

@@ -19,6 +19,7 @@ embedded-hal-nb = "1"
 embedded-io = "0.6"
 fugit = "0.3"
 typenum = "1"
+critical-section = "1"
 delegate = "0.12"
 
 [dependencies.va108xx]

va108xx-hal/src/timer.rs

@@ -20,7 +20,7 @@ use crate::{
     typelevel::Sealed,
 };
 use core::cell::Cell;
-use cortex_m::interrupt::Mutex;
+use critical_section::Mutex;
 use fugit::RateExtU32;
 
 const IRQ_DST_NONE: u32 = 0xffffffff;
@@ -729,7 +729,7 @@ pub fn set_up_ms_delay_provider<TIM: ValidTim>(
 /// This function can be called in a specified interrupt handler to increment
 /// the MS counter
 pub fn default_ms_irq_handler() {
-    cortex_m::interrupt::free(|cs| {
+    critical_section::with(|cs| {
         let mut ms = MS_COUNTER.borrow(cs).get();
         ms += 1;
         MS_COUNTER.borrow(cs).set(ms);
@@ -738,7 +738,7 @@ pub fn default_ms_irq_handler() {
 
 /// Get the current MS tick count
 pub fn get_ms_ticks() -> u32 {
-    cortex_m::interrupt::free(|cs| MS_COUNTER.borrow(cs).get())
+    critical_section::with(|cs| MS_COUNTER.borrow(cs).get())
 }
 
 //==================================================================================================