Usb example passing build

Author: supersimple33

boards/grand_central_m4/examples/usb_serial.rs

@@ -14,67 +14,62 @@
 //! Note leds may appear white during debug. Either build for release or add
 //! opt-level = 2 to profile.dev in Cargo.toml
 
-use bsp::hal;
 use grand_central_m4 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 cortex_m::interrupt::free as disable_interrupts;
+use cortex_m::asm::delay as cycle_delay;
 use cortex_m::peripheral::NVIC;
-use hal::clock::GenericClockController;
-use hal::pac::{interrupt, CorePeripherals, Peripherals};
-use hal::prelude::*;
-use hal::time::Hertz;
-use hal::timer::TimerCounter;
-use hal::timer_traits::InterruptDrivenTimer;
-use hal::usb::UsbBus;
-use smart_leds::{colors, hsv::RGB8, SmartLedsWrite};
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
-use ws2812_timer_delay as ws2812;
+
+use bsp::clock::gclk::Gclk1Id;
+use bsp::entry;
+use hal::clock::v2::clock_system_at_reset;
+use hal::pac::{interrupt, CorePeripherals, Peripherals};
+use hal::prelude::*;
+use hal::usb::UsbBus;
 
 #[entry]
 fn main() -> ! {
     let mut peripherals = Peripherals::take().unwrap();
     let mut core = CorePeripherals::take().unwrap();
-    let mut clocks = GenericClockController::with_internal_32kosc(
+    let (_buses, clocks, tokens) = clock_system_at_reset(
+        peripherals.oscctrl,
+        peripherals.osc32kctrl,
         peripherals.gclk,
-        &mut peripherals.mclk,
-        &mut peripherals.osc32kctrl,
-        &mut peripherals.oscctrl,
+        peripherals.mclk,
         &mut peripherals.nvmctrl,
     );
-    let gclk0 = clocks.gclk0();
-    let tc2_3 = clocks.tc2_tc3(&gclk0).unwrap();
-    let mut timer = TimerCounter::tc3_(&tc2_3, peripherals.tc3, &mut peripherals.mclk);
-    InterruptDrivenTimer::start(&mut timer, Hertz::MHz(3).into_duration());
 
     let pins = bsp::Pins::new(peripherals.port);
-    let neopixel_pin = pins.neopixel.into_push_pull_output();
-    let mut neopixel = ws2812::Ws2812::new(timer, neopixel_pin);
-    let _ = neopixel.write((0..5).map(|_| RGB8::default()));
+    let mut red_led: bsp::RedLed = pins.d13.into();
 
     let bus_allocator = unsafe {
         USB_ALLOCATOR = Some(bsp::usb_allocator(
             peripherals.usb,
-            &mut clocks,
-            &mut peripherals.mclk,
+            clocks.dfll,
+            tokens.gclks.gclk1,
+            tokens.pclks.usb,
+            clocks.ahbs.usb,
+            tokens.apbs.usb,
             pins.usb_dm,
             pins.usb_dp,
         ));
         USB_ALLOCATOR.as_ref().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(&bus_allocator));
+        USB_SERIAL = Some(SerialPort::new(bus_allocator));
         USB_BUS = Some(
-            UsbDeviceBuilder::new(&bus_allocator, UsbVidPid(0x16c0, 0x27dd))
-                .strings(&[StringDescriptors::new(LangID::EN_US)
+            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x2222, 0x3333))
+                .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
                     .product("Serial port")
                     .serial_number("TEST")])
@@ -85,66 +80,66 @@ fn main() -> ! {
     }
 
     unsafe {
-        core.NVIC.set_priority(interrupt::USB_OTHER, 1);
         core.NVIC.set_priority(interrupt::USB_TRCPT0, 1);
-        core.NVIC.set_priority(interrupt::USB_TRCPT1, 1);
-        NVIC::unmask(interrupt::USB_OTHER);
         NVIC::unmask(interrupt::USB_TRCPT0);
+        core.NVIC.set_priority(interrupt::USB_TRCPT1, 1);
         NVIC::unmask(interrupt::USB_TRCPT1);
+        core.NVIC.set_priority(interrupt::USB_SOF_HSOF, 1);
+        NVIC::unmask(interrupt::USB_SOF_HSOF);
+        core.NVIC.set_priority(interrupt::USB_OTHER, 1);
+        NVIC::unmask(interrupt::USB_OTHER);
     }
 
+    // Flash the LED in a spin loop to demonstrate that USB is
+    // entirely interrupt driven.
     loop {
-        let pending = disable_interrupts(|_| unsafe {
-            let pending = PENDING_COLOR;
-            PENDING_COLOR = None;
-            pending
+        cycle_delay(5 * 1024 * 1024);
+        red_led.toggle().unwrap();
+        // Turn off interrupts so we don't fight with the interrupt
+        cortex_m::interrupt::free(|_| unsafe {
+            if USB_BUS.as_mut().is_some() {
+                if let Some(serial) = USB_SERIAL.as_mut() {
+                    let _ = serial.write("Hello USB\n".as_bytes());
+                }
+            }
         });
-        if let Some(color) = pending {
-            let _ = neopixel.write((0..5).map(|_| color));
-        }
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
-static mut PENDING_COLOR: Option<RGB8> = None;
+static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus<Gclk1Id>>> = None;
+static mut USB_BUS: Option<UsbDevice<UsbBus<Gclk1Id>>> = None;
+static mut USB_SERIAL: Option<SerialPort<UsbBus<Gclk1Id>>> = None;
 
 fn poll_usb() {
     unsafe {
-        USB_BUS.as_mut().map(|usb_dev| {
-            USB_SERIAL.as_mut().map(|serial| {
+        if let Some(usb_dev) = USB_BUS.as_mut() {
+            if let Some(serial) = USB_SERIAL.as_mut() {
                 usb_dev.poll(&mut [serial]);
 
-                let mut buf = [0u8; 64];
-
-                if let Ok(count) = serial.read(&mut buf) {
-                    let last = buf[count - 1] as char;
-                    let color = match last {
-                        'R' => colors::RED,
-                        'G' => colors::GREEN,
-                        'O' => colors::ORANGE,
-                        _ => RGB8::default(),
-                    };
-
-                    PENDING_COLOR = Some(color);
-                };
-            });
-        });
+                // Make the other side happy
+                let mut buf = [0u8; 16];
+                let _ = serial.read(&mut buf);
+            };
+        }
     };
 }
 
 #[interrupt]
-fn USB_OTHER() {
+fn USB_TRCPT0() {
     poll_usb();
 }
 
 #[interrupt]
-fn USB_TRCPT0() {
+fn USB_TRCPT1() {
     poll_usb();
 }
 
 #[interrupt]
-fn USB_TRCPT1() {
+fn USB_SOF_HSOF() {
+    poll_usb();
+}
+
+#[interrupt]
+fn USB_OTHER() {
     poll_usb();
 }