update package

- Add embassy example
- improve timer API
- restructure examples
- restructure and improve SPI
- Add REB1 M95M01 NVM module

vorago-reb1/examples/adxl343-accelerometer.rs

@@ -5,15 +5,16 @@
 #![no_main]
 #![no_std]
 use cortex_m_rt::entry;
-use embedded_hal::spi::SpiBus;
+use embedded_hal::spi::{SpiBus, MODE_3};
 use embedded_hal::{delay::DelayNs, digital::OutputPin};
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
+use va108xx_hal::spi::SpiClkConfig;
 use va108xx_hal::{
     gpio::PinsA,
     pac,
     prelude::*,
-    spi::{Spi, SpiConfig, TransferConfig},
+    spi::{Spi, SpiConfig},
     timer::set_up_ms_delay_provider,
 };
 
@@ -31,7 +32,6 @@ fn main() -> ! {
     let mut dp = pac::Peripherals::take().unwrap();
     let mut delay = set_up_ms_delay_provider(&mut dp.sysconfig, 50.MHz(), dp.tim0);
     let pinsa = PinsA::new(&mut dp.sysconfig, None, dp.porta);
-    let spi_cfg = SpiConfig::default();
     let (sck, mosi, miso) = (
         pinsa.pa20.into_funsel_2(),
         pinsa.pa19.into_funsel_2(),
@@ -45,21 +45,20 @@ fn main() -> ! {
         .set_high()
         .expect("Setting ADC chip select high failed");
 
-    let transfer_cfg = TransferConfig::new(
-        1.MHz(),
-        embedded_hal::spi::MODE_3,
-        Some(cs_pin),
-        false,
-        true,
-    );
+    let spi_cfg = SpiConfig::default()
+        .clk_cfg(
+            SpiClkConfig::from_clk(50.MHz(), 1.MHz()).expect("creating SPI clock config failed"),
+        )
+        .mode(MODE_3)
+        .slave_output_disable(true);
     let mut spi = Spi::new(
         &mut dp.sysconfig,
         50.MHz(),
         dp.spib,
         (sck, miso, mosi),
         spi_cfg,
-        Some(&transfer_cfg.downgrade()),
     );
+    spi.cfg_hw_cs_with_pin(&cs_pin);
 
     let mut tx_rx_buf: [u8; 3] = [0; 3];
     tx_rx_buf[0] = READ_MASK | DEVID_REG;

vorago-reb1/examples/blinky-button-rtic.rs

@@ -1,153 +0,0 @@
-//! Blinky button application for the REB1 board using RTIC
-#![no_main]
-#![no_std]
-
-#[rtic::app(device = pac)]
-mod app {
-    use panic_rtt_target as _;
-    use rtic_monotonics::systick::Systick;
-    use rtt_target::{rprintln, rtt_init_default, set_print_channel};
-    use va108xx_hal::{
-        clock::{set_clk_div_register, FilterClkSel},
-        gpio::{FilterType, InterruptEdge, PinsA},
-        pac,
-        prelude::*,
-        timer::{default_ms_irq_handler, set_up_ms_tick, IrqCfg},
-    };
-    use vorago_reb1::button::Button;
-    use vorago_reb1::leds::Leds;
-
-    #[derive(Debug, PartialEq)]
-    pub enum PressMode {
-        Toggle,
-        Keep,
-    }
-
-    #[derive(Debug, PartialEq)]
-    pub enum CfgMode {
-        Prompt,
-        Fixed,
-    }
-
-    const CFG_MODE: CfgMode = CfgMode::Fixed;
-    // You can change the press mode here
-    const DEFAULT_MODE: PressMode = PressMode::Toggle;
-
-    #[local]
-    struct Local {
-        leds: Leds,
-        button: Button,
-        mode: PressMode,
-    }
-
-    #[shared]
-    struct Shared {}
-
-    #[init]
-    fn init(ctx: init::Context) -> (Shared, Local) {
-        let channels = rtt_init_default!();
-        set_print_channel(channels.up.0);
-        rprintln!("-- Vorago Button IRQ Example --");
-        // Initialize the systick interrupt & obtain the token to prove that we did
-        let systick_mono_token = rtic_monotonics::create_systick_token!();
-        Systick::start(
-            ctx.core.SYST,
-            Hertz::from(50.MHz()).raw(),
-            systick_mono_token,
-        );
-
-        let mode = match CFG_MODE {
-            // Ask mode from user via RTT
-            CfgMode::Prompt => prompt_mode(channels.down.0),
-            // Use mode hardcoded in `DEFAULT_MODE`
-            CfgMode::Fixed => DEFAULT_MODE,
-        };
-        rprintln!("Using {:?} mode", mode);
-
-        let mut dp = ctx.device;
-        let pinsa = PinsA::new(&mut dp.sysconfig, Some(dp.ioconfig), dp.porta);
-        let edge_irq = match mode {
-            PressMode::Toggle => InterruptEdge::HighToLow,
-            PressMode::Keep => InterruptEdge::BothEdges,
-        };
-
-        // Configure an edge interrupt on the button and route it to interrupt vector 15
-        let mut button = Button::new(pinsa.pa11.into_floating_input()).edge_irq(
-            edge_irq,
-            IrqCfg::new(pac::interrupt::OC15, true, true),
-            Some(&mut dp.sysconfig),
-            Some(&mut dp.irqsel),
-        );
-
-        if mode == PressMode::Toggle {
-            // This filter debounces the switch for edge based interrupts
-            button = button.filter_type(FilterType::FilterFourClockCycles, FilterClkSel::Clk1);
-            set_clk_div_register(&mut dp.sysconfig, FilterClkSel::Clk1, 50_000);
-        }
-        let mut leds = Leds::new(
-            pinsa.pa10.into_push_pull_output(),
-            pinsa.pa7.into_push_pull_output(),
-            pinsa.pa6.into_push_pull_output(),
-        );
-        for led in leds.iter_mut() {
-            led.off();
-        }
-        set_up_ms_tick(
-            IrqCfg::new(pac::Interrupt::OC0, true, true),
-            &mut dp.sysconfig,
-            Some(&mut dp.irqsel),
-            50.MHz(),
-            dp.tim0,
-        );
-        (Shared {}, Local { leds, button, mode })
-    }
-
-    // `shared` cannot be accessed from this context
-    #[idle]
-    fn idle(_cx: idle::Context) -> ! {
-        loop {
-            cortex_m::asm::nop();
-        }
-    }
-
-    #[task(binds = OC15, local=[button, leds, mode])]
-    fn button_task(cx: button_task::Context) {
-        let leds = cx.local.leds;
-        let button = cx.local.button;
-        let mode = cx.local.mode;
-        if *mode == PressMode::Toggle {
-            leds[0].toggle();
-        } else {
-            if button.released() {
-                leds[0].off();
-            } else {
-                leds[0].on();
-            }
-        }
-    }
-
-    #[task(binds = OC0)]
-    fn ms_tick(_cx: ms_tick::Context) {
-        default_ms_irq_handler();
-    }
-
-    fn prompt_mode(mut down_channel: rtt_target::DownChannel) -> PressMode {
-        rprintln!("Using prompt mode");
-        rprintln!("Please enter the mode [0: Toggle, 1: Keep]");
-        let mut read_buf: [u8; 16] = [0; 16];
-        let mut read;
-        loop {
-            read = down_channel.read(&mut read_buf);
-            for i in 0..read {
-                let val = read_buf[i] as char;
-                if val == '0' || val == '1' {
-                    return if val == '0' {
-                        PressMode::Toggle
-                    } else {
-                        PressMode::Keep
-                    };
-                }
-            }
-        }
-    }
-}

vorago-reb1/examples/max11619-adc.rs

@@ -9,19 +9,19 @@ use core::convert::Infallible;
 
 use cortex_m_rt::entry;
 use embedded_hal::digital::OutputPin;
-use embedded_hal::spi::{SpiBus, SpiDevice};
+use embedded_hal::spi::{SpiBus, SpiDevice, MODE_0};
 use embedded_hal::{delay::DelayNs, spi};
 use max116xx_10bit::VoltageRefMode;
 use max116xx_10bit::{AveragingConversions, AveragingResults};
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
-use va108xx_hal::spi::{NoneT, OptionalHwCs};
+use va108xx_hal::spi::{OptionalHwCs, SpiClkConfig};
 use va108xx_hal::timer::CountDownTimer;
 use va108xx_hal::{
     gpio::PinsA,
     pac::{self, interrupt},
     prelude::*,
-    spi::{Spi, SpiBase, SpiConfig, TransferConfig},
+    spi::{Spi, SpiBase, SpiConfig},
     timer::{default_ms_irq_handler, set_up_ms_tick, DelayMs, IrqCfg},
 };
 use va108xx_hal::{port_mux, FunSel, PortSel};
@@ -103,6 +103,8 @@ impl<Delay: DelayNs, HwCs: OptionalHwCs<pac::Spib>> SpiDevice for SpiWithHwCs<De
     }
 }
 
+const SYS_CLK: Hertz = Hertz::from_raw(50_000_000);
+
 #[entry]
 fn main() -> ! {
     rtt_init_print!();
@@ -113,7 +115,7 @@ fn main() -> ! {
         IrqCfg::new(pac::Interrupt::OC0, true, true),
         &mut dp.sysconfig,
         Some(&mut dp.irqsel),
-        50.MHz(),
+        SYS_CLK,
         dp.tim0,
     );
     let delay = DelayMs::new(tim0).unwrap();
@@ -122,7 +124,10 @@ fn main() -> ! {
     }
 
     let pinsa = PinsA::new(&mut dp.sysconfig, None, dp.porta);
-    let spi_cfg = SpiConfig::default();
+    let spi_cfg = SpiConfig::default()
+        .clk_cfg(SpiClkConfig::from_clk(SYS_CLK, 3.MHz()).unwrap())
+        .mode(MODE_0)
+        .blockmode(true);
     let (sck, mosi, miso) = (
         pinsa.pa20.into_funsel_2(),
         pinsa.pa19.into_funsel_2(),
@@ -141,14 +146,12 @@ fn main() -> ! {
         .set_high()
         .expect("Setting accelerometer chip select high failed");
 
-    let transfer_cfg = TransferConfig::<NoneT>::new(3.MHz(), spi::MODE_0, None, true, false);
     let spi = Spi::new(
         &mut dp.sysconfig,
         50.MHz(),
         dp.spib,
         (sck, miso, mosi),
         spi_cfg,
-        Some(&transfer_cfg.downgrade()),
     )
     .downgrade();
     let delay_provider = CountDownTimer::new(&mut dp.sysconfig, 50.MHz(), dp.tim1);

vorago-reb1/examples/nvm.rs

@@ -0,0 +1,64 @@
+//! Example application which interfaces with the boot EEPROM.
+#![no_main]
+#![no_std]
+
+use cortex_m_rt::entry;
+use embedded_hal::delay::DelayNs;
+use panic_rtt_target as _;
+use rtt_target::{rprintln, rtt_init_print};
+use va108xx_hal::{pac, pwm::CountDownTimer, time::Hertz};
+use vorago_reb1::m95m01::M95M01;
+
+const CLOCK_FREQ: Hertz = Hertz::from_raw(50_000_000);
+
+#[entry]
+fn main() -> ! {
+    rtt_init_print!();
+    rprintln!("-- VA108XX REB1 NVM example --");
+
+    let mut dp = pac::Peripherals::take().unwrap();
+
+    let mut timer = CountDownTimer::new(&mut dp.sysconfig, CLOCK_FREQ, dp.tim0);
+    let mut nvm = M95M01::new(&mut dp.sysconfig, CLOCK_FREQ, dp.spic);
+    let status_reg = nvm.read_status_reg().expect("reading status reg failed");
+    if status_reg.zero_segment() == 0b111 {
+        panic!("status register unexpected values");
+    }
+
+    let mut orig_content: [u8; 16] = [0; 16];
+    let mut read_buf: [u8; 16] = [0; 16];
+    let write_buf: [u8; 16] = [0; 16];
+    for (idx, val) in read_buf.iter_mut().enumerate() {
+        *val = idx as u8;
+    }
+    nvm.read(0x4000, &mut orig_content).unwrap();
+
+    // One byte write and read.
+    nvm.write(0x4000, &write_buf[0..1]).unwrap();
+    nvm.read(0x4000, &mut read_buf[0..1]).unwrap();
+    assert_eq!(write_buf[0], read_buf[0]);
+    read_buf.fill(0);
+
+    // Four bytes write and read.
+    nvm.write(0x4000, &write_buf[0..4]).unwrap();
+    nvm.read(0x4000, &mut read_buf[0..4]).unwrap();
+    assert_eq!(&read_buf[0..4], &write_buf[0..4]);
+    read_buf.fill(0);
+
+    // Full sixteen bytes
+    nvm.write(0x4000, &write_buf).unwrap();
+    nvm.read(0x4000, &mut read_buf).unwrap();
+    assert_eq!(&read_buf, &write_buf);
+    read_buf.fill(0);
+
+    // 3 bytes
+    nvm.write(0x4000, &write_buf[0..3]).unwrap();
+    nvm.read(0x4000, &mut read_buf[0..3]).unwrap();
+    assert_eq!(&read_buf[0..3], &write_buf[0..3]);
+
+    // Write back original content.
+    nvm.write(0x4000, &orig_content).unwrap();
+    loop {
+        timer.delay_ms(500);
+    }
+}