Merge pull request #2931 from timbod7/timbod7-rp-usb-serial-example

refactor rp usb_serial example to use a task to run the usb

examples/rp/src/bin/usb_serial.rs

@@ -5,15 +5,15 @@
 #![no_std]
 #![no_main]
 
-use defmt::{info, panic};
+use defmt::{info, panic, unwrap};
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::USB;
 use embassy_rp::usb::{Driver, Instance, InterruptHandler};
 use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
 use embassy_usb::driver::EndpointError;
-use embassy_usb::{Builder, Config};
+use embassy_usb::UsbDevice;
+use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -21,7 +21,7 @@ bind_interrupts!(struct Irqs {
 });
 
 #[embassy_executor::main]
-async fn main(_spawner: Spawner) {
+async fn main(spawner: Spawner) {
     info!("Hello there!");
 
     let p = embassy_rp::init(Default::default());
@@ -30,7 +30,8 @@ async fn main(_spawner: Spawner) {
     let driver = Driver::new(p.USB, Irqs);
 
     // Create embassy-usb Config
-    let mut config = Config::new(0xc0de, 0xcafe);
+    let config = {
+        let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
         config.manufacturer = Some("Embassy");
         config.product = Some("USB-serial example");
         config.serial_number = Some("12345678");
@@ -43,46 +44,55 @@ async fn main(_spawner: Spawner) {
         config.device_sub_class = 0x02;
         config.device_protocol = 0x01;
         config.composite_with_iads = true;
+        config
+    };
 
     // Create embassy-usb DeviceBuilder using the driver and config.
     // It needs some buffers for building the descriptors.
-    let mut config_descriptor = [0; 256];
+    let mut builder = {
-    let mut bos_descriptor = [0; 256];
+        static CONFIG_DESCRIPTOR: StaticCell<[u8; 256]> = StaticCell::new();
-    let mut control_buf = [0; 64];
+        static BOS_DESCRIPTOR: StaticCell<[u8; 256]> = StaticCell::new();
+        static CONTROL_BUF: StaticCell<[u8; 64]> = StaticCell::new();
 
-    let mut state = State::new();
+        let builder = embassy_usb::Builder::new(
-
-    let mut builder = Builder::new(
             driver,
             config,
-        &mut config_descriptor,
+            CONFIG_DESCRIPTOR.init([0; 256]),
-        &mut bos_descriptor,
+            BOS_DESCRIPTOR.init([0; 256]),
             &mut [], // no msos descriptors
-        &mut control_buf,
+            CONTROL_BUF.init([0; 64]),
         );
+        builder
+    };
 
     // Create classes on the builder.
-    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
+    let mut class = {
+        static STATE: StaticCell<State> = StaticCell::new();
+        let state = STATE.init(State::new());
+        CdcAcmClass::new(&mut builder, state, 64)
+    };
 
     // Build the builder.
-    let mut usb = builder.build();
+    let usb = builder.build();
 
     // Run the USB device.
-    let usb_fut = usb.run();
+    unwrap!(spawner.spawn(usb_task(usb)));
 
     // Do stuff with the class!
-    let echo_fut = async {
     loop {
         class.wait_connection().await;
         info!("Connected");
         let _ = echo(&mut class).await;
         info!("Disconnected");
     }
-    };
+}
 
-    // Run everything concurrently.
+type MyUsbDriver = Driver<'static, USB>;
-    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+type MyUsbDevice = UsbDevice<'static, MyUsbDriver>;
-    join(usb_fut, echo_fut).await;
+
+#[embassy_executor::task]
+async fn usb_task(mut usb: MyUsbDevice) -> ! {
+    usb.run().await
 }
 
 struct Disconnected {}