bsp(arduino_mkr1000)!: Update to hal v0.16 (#878)

* chore(arduino_mkr1000): update to hal v0.16

Bring examples from arduino_mkrzero based on same hal version.

* fix: remove unexisting SD pins

These exist on MKRZERO, but not on MKR1000.

* fix: board led is D6

* feat: set pin for pwm sample

* Bump version

---------

Co-authored-by: Ian <[email protected]>

Author: ojob

boards/arduino_mkr1000/Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "arduino_mkr1000"
-version = "0.5.1"
-authors = ["Eric Rushing <[email protected]>"]
+version = "0.6.0"
+authors = [
+    "Eric Rushing <[email protected]>",
+    "Joël Bourgault <[email protected]>",
+]
 description = "Board Support crate for the Arduino MKR 1000 WiFi"
 keywords = ["no-std", "arm", "cortex-m", "embedded-hal"]
 categories = ["embedded", "hardware-support", "no-std"]
@@ -15,25 +18,47 @@ version = "0.7"
 optional = true
 
 [dependencies.atsamd-hal]
-version = "0.14"
+version = "0.16"
 default-features = false
 
 [dependencies.usb-device]
 version = "0.2"
 optional = true
 
 [dev-dependencies]
+cortex-m = "0.7"
+usbd-serial = "0.1"
 panic-halt = "0.2"
 panic-semihosting = "0.5"
+cortex-m-rtic = "1.0"
 
 [features]
 # ask the HAL to enable atsamd21g support
-default = ["rt", "atsamd-hal/samd21g"]
+default = ["rt", "atsamd-hal/samd21g", "usb"]
 rt = ["cortex-m-rt", "atsamd-hal/samd21g-rt"]
 usb = ["atsamd-hal/usb", "usb-device"]
 unproven = ["atsamd-hal/unproven"]
 use_semihosting = []
+rtic = ["atsamd-hal/rtic"]
 
 # for cargo flash
 [package.metadata]
 chip = "ATSAMD21G18A"
+
+[dependencies]
+embedded-hal = "0.2.7"
+
+[[example]]
+name = "blinky_basic"
+
+[[example]]
+name = "blinky_rtic"
+required-features = ["rtic", "unproven"]
+
+[[example]]
+name = "usb_logging"
+required-features = ["usb"]
+
+[[example]]
+name = "pwm"
+required-features = ["unproven"]

boards/arduino_mkr1000/examples/blinky_basic.rs

@@ -1,15 +1,15 @@
 #![no_std]
 #![no_main]
 
-use arduino_mkr1000 as bsp;
-use bsp::hal;
-
 #[cfg(not(feature = "use_semihosting"))]
 use panic_halt as _;
 #[cfg(feature = "use_semihosting")]
 use panic_semihosting as _;
 
-use bsp::entry;
+use arduino_mkr1000 as bsp;
+use bsp::hal;
+
+use bsp::{entry, pin_alias};
 use hal::clock::GenericClockController;
 use hal::delay::Delay;
 use hal::pac::{CorePeripherals, Peripherals};
@@ -25,9 +25,10 @@ fn main() -> ! {
         &mut peripherals.SYSCTRL,
         &mut peripherals.NVMCTRL,
     );
-    let mut pins = bsp::Pins::new(peripherals.PORT);
-    let mut led = pins.d6.into_open_drain_output(&mut pins.port);
+    let pins = bsp::pins::Pins::new(peripherals.PORT);
+    let mut led = pin_alias!(pins.led).into_push_pull_output();
     let mut delay = Delay::new(core.SYST, &mut clocks);
+
     loop {
         delay.delay_ms(200u8);
         led.set_high().unwrap();

boards/arduino_mkr1000/examples/blinky_rtic.rs

@@ -0,0 +1,73 @@
+//! Uses RTIC with the RTC as time source to blink an LED.
+//!
+//! The idle task is sleeping the CPU, so in practice this gives similar power
+//! figure as the "sleeping_timer_rtc" example.
+#![no_std]
+#![no_main]
+
+use arduino_mkr1000 as bsp;
+
+#[cfg(not(feature = "use_semihosting"))]
+use panic_halt as _;
+#[cfg(feature = "use_semihosting")]
+use panic_semihosting as _;
+use rtic::app;
+
+#[app(device = bsp::pac, peripherals = true, dispatchers = [EVSYS])]
+mod app {
+    use super::*;
+    use bsp::hal;
+    use hal::clock::{ClockGenId, ClockSource, GenericClockController};
+    use hal::pac::Peripherals;
+    use hal::prelude::*;
+    use hal::rtc::{Count32Mode, Duration, Rtc};
+
+    #[local]
+    struct Local {}
+
+    #[shared]
+    struct Shared {
+        // The LED could be a local resource, since it is only used in one task
+        // But we want to showcase shared resources and locking
+        led: bsp::pins::Led,
+    }
+
+    #[monotonic(binds = RTC, default = true)]
+    type RtcMonotonic = Rtc<Count32Mode>;
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        let mut peripherals: Peripherals = cx.device;
+        let pins = bsp::pins::Pins::new(peripherals.PORT);
+        let mut core: rtic::export::Peripherals = cx.core;
+        let mut clocks = GenericClockController::with_external_32kosc(
+            peripherals.GCLK,
+            &mut peripherals.PM,
+            &mut peripherals.SYSCTRL,
+            &mut peripherals.NVMCTRL,
+        );
+        let _gclk = clocks.gclk0();
+        let rtc_clock_src = clocks
+            .configure_gclk_divider_and_source(ClockGenId::GCLK2, 1, ClockSource::XOSC32K, false)
+            .unwrap();
+        clocks.configure_standby(ClockGenId::GCLK2, true);
+        let rtc_clock = clocks.rtc(&rtc_clock_src).unwrap();
+        let rtc = Rtc::count32_mode(peripherals.RTC, rtc_clock.freq(), &mut peripherals.PM);
+        let led = bsp::pin_alias!(pins.led).into();
+
+        // We can use the RTC in standby for maximum power savings
+        core.SCB.set_sleepdeep();
+
+        // Start the blink task
+        blink::spawn().unwrap();
+
+        (Shared { led }, Local {}, init::Monotonics(rtc))
+    }
+
+    #[task(shared = [led])]
+    fn blink(mut cx: blink::Context) {
+        // If the LED were a local resource, the lock would not be necessary
+        let _ = cx.shared.led.lock(|led| led.toggle());
+        blink::spawn_after(Duration::secs(3)).ok();
+    }
+}

boards/arduino_mkr1000/examples/pwm.rs

@@ -0,0 +1,53 @@
+#![no_std]
+#![no_main]
+
+use arduino_mkr1000 as bsp;
+use bsp::hal;
+
+#[cfg(not(feature = "use_semihosting"))]
+use panic_halt as _;
+#[cfg(feature = "use_semihosting")]
+use panic_semihosting as _;
+
+use bsp::entry;
+use hal::clock::{GenericClockController, Tcc0Tcc1Clock};
+use hal::delay::Delay;
+use hal::gpio::AlternateE;
+use hal::pac::{CorePeripherals, Peripherals};
+use hal::prelude::*;
+use hal::pwm::{Channel, Pwm0};
+
+#[entry]
+fn main() -> ! {
+    let mut peripherals = Peripherals::take().unwrap();
+    let core = CorePeripherals::take().unwrap();
+    let mut clocks = GenericClockController::with_external_32kosc(
+        peripherals.GCLK,
+        &mut peripherals.PM,
+        &mut peripherals.SYSCTRL,
+        &mut peripherals.NVMCTRL,
+    );
+    let pins = bsp::pins::Pins::new(peripherals.PORT);
+
+    // PWM0_CH0 is D11 on the board - pin PA08
+    let _d11 = pins.pa08.into_mode::<AlternateE>();
+    let mut delay = Delay::new(core.SYST, &mut clocks);
+    let gclk0 = clocks.gclk0();
+    let tcc0_tcc1_clock: &Tcc0Tcc1Clock = &clocks.tcc0_tcc1(&gclk0).unwrap();
+
+    let mut pwm0 = Pwm0::new(
+        &tcc0_tcc1_clock,
+        1u32.kHz(),
+        peripherals.TCC0,
+        &mut peripherals.PM,
+    );
+    let max_duty = pwm0.get_max_duty();
+    let channel = Channel::_0;
+    pwm0.enable(channel);
+    loop {
+        pwm0.set_duty(channel, max_duty);
+        delay.delay_ms(500u16);
+        pwm0.set_duty(channel, max_duty / 4);
+        delay.delay_ms(500u16);
+    }
+}

boards/arduino_mkr1000/examples/usb_logging.rs

@@ -0,0 +1,105 @@
+#![no_std]
+#![no_main]
+
+use arduino_mkr1000 as bsp;
+use bsp::hal;
+
+#[cfg(not(feature = "use_semihosting"))]
+use panic_halt as _;
+#[cfg(feature = "use_semihosting")]
+use panic_semihosting as _;
+
+use bsp::entry;
+use hal::clock::GenericClockController;
+use hal::delay::Delay;
+use hal::pac::{interrupt, CorePeripherals, Peripherals};
+use hal::prelude::*;
+
+use hal::usb::UsbBus;
+use usb_device::bus::UsbBusAllocator;
+use usb_device::prelude::*;
+use usbd_serial::{SerialPort, USB_CLASS_CDC};
+
+use cortex_m::peripheral::NVIC;
+
+static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
+static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
+static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+
+#[entry]
+fn main() -> ! {
+    let mut peripherals = Peripherals::take().unwrap();
+    let mut core = CorePeripherals::take().unwrap();
+    let mut clocks = GenericClockController::with_external_32kosc(
+        peripherals.GCLK,
+        &mut peripherals.PM,
+        &mut peripherals.SYSCTRL,
+        &mut peripherals.NVMCTRL,
+    );
+    let pins = bsp::pins::Pins::new(peripherals.PORT);
+    let mut led = bsp::pin_alias!(pins.led).into_push_pull_output();
+    let mut delay = Delay::new(core.SYST, &mut clocks);
+
+    let usb_n = bsp::pin_alias!(pins.usb_n);
+    let usb_p = bsp::pin_alias!(pins.usb_p);
+
+    let bus_allocator = unsafe {
+        USB_ALLOCATOR = Some(bsp::usb::usb_allocator(
+            peripherals.USB,
+            &mut clocks,
+            &mut peripherals.PM,
+            usb_n.into(),
+            usb_p.into(),
+        ));
+        USB_ALLOCATOR.as_ref().unwrap()
+    };
+
+    unsafe {
+        USB_SERIAL = Some(SerialPort::new(bus_allocator));
+        USB_BUS = Some(
+            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x2222, 0x3333))
+                .manufacturer("Fake company")
+                .product("Serial port")
+                .serial_number("TEST")
+                .device_class(USB_CLASS_CDC)
+                .build(),
+        );
+    }
+
+    unsafe {
+        core.NVIC.set_priority(interrupt::USB, 1);
+        NVIC::unmask(interrupt::USB);
+    }
+
+    loop {
+        delay.delay_ms(200u8);
+        led.set_high().unwrap();
+        delay.delay_ms(200u8);
+        led.set_low().unwrap();
+
+        // Turn off interrupts so we don't fight with the interrupt
+        cortex_m::interrupt::free(|_| unsafe {
+            if let Some(serial) = USB_SERIAL.as_mut() {
+                let _ = serial.write("log line\r\n".as_bytes());
+            }
+        });
+    }
+}
+
+fn poll_usb() {
+    unsafe {
+        if let Some(usb_dev) = USB_BUS.as_mut() {
+            if let Some(serial) = USB_SERIAL.as_mut() {
+                usb_dev.poll(&mut [serial]);
+                // Make the other side happy
+                let mut buf = [0u8; 16];
+                let _ = serial.read(&mut buf);
+            }
+        }
+    };
+}
+
+#[interrupt]
+fn USB() {
+    poll_usb();
+}