embassy/examples/nrf52840/src/bin/usb_serial.rs

116 lines
3.4 KiB
Rust
Raw Normal View History

2022-03-09 01:34:35 +01:00
#![no_std]
#![no_main]
#![feature(type_alias_impl_trait)]
use core::mem;
2022-06-12 22:15:44 +02:00
use defmt::{info, panic};
use embassy_executor::Spawner;
use embassy_futures::join::join;
use embassy_nrf::usb::vbus_detect::{HardwareVbusDetect, VbusDetect};
use embassy_nrf::usb::{Driver, Instance};
use embassy_nrf::{bind_interrupts, pac, peripherals, usb};
use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
use embassy_usb::driver::EndpointError;
use embassy_usb::{Builder, Config};
use {defmt_rtt as _, panic_probe as _};
2022-03-09 01:34:35 +01:00
bind_interrupts!(struct Irqs {
USBD => usb::InterruptHandler<peripherals::USBD>;
POWER_CLOCK => usb::vbus_detect::InterruptHandler;
});
#[embassy_executor::main]
async fn main(_spawner: Spawner) {
let p = embassy_nrf::init(Default::default());
2022-03-09 01:34:35 +01:00
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
2022-03-09 01:34:35 +01:00
info!("Enabling ext hfosc...");
clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
while clock.events_hfclkstarted.read().bits() != 1 {}
2022-03-10 01:10:53 +01:00
// Create the driver, from the HAL.
let driver = Driver::new(p.USBD, Irqs, HardwareVbusDetect::new(Irqs));
2022-03-10 01:10:53 +01:00
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);
config.manufacturer = Some("Embassy");
config.product = Some("USB-serial example");
config.serial_number = Some("12345678");
config.max_power = 100;
config.max_packet_size_0 = 64;
2022-03-10 01:10:53 +01:00
2023-05-08 23:25:01 +02:00
// Required for windows compatibility.
// https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
config.device_class = 0xEF;
config.device_sub_class = 0x02;
config.device_protocol = 0x01;
config.composite_with_iads = true;
2022-03-10 01:10:53 +01:00
// Create embassy-usb DeviceBuilder using the driver and config.
// It needs some buffers for building the descriptors.
2022-03-09 01:34:35 +01:00
let mut device_descriptor = [0; 256];
let mut config_descriptor = [0; 256];
let mut bos_descriptor = [0; 256];
let mut msos_descriptor = [0; 256];
let mut control_buf = [0; 64];
let mut state = State::new();
let mut builder = Builder::new(
2022-03-09 01:34:35 +01:00
driver,
config,
&mut device_descriptor,
&mut config_descriptor,
&mut bos_descriptor,
&mut msos_descriptor,
2022-03-29 21:09:24 +02:00
&mut control_buf,
2022-03-09 01:34:35 +01:00
);
2022-03-10 01:10:53 +01:00
// Create classes on the builder.
let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
2022-03-09 01:34:35 +01:00
2022-03-10 01:10:53 +01:00
// Build the builder.
let mut usb = builder.build();
2022-03-09 23:06:27 +01:00
2022-03-10 01:10:53 +01:00
// Run the USB device.
2022-03-30 02:16:34 +02:00
let usb_fut = usb.run();
2022-03-10 01:10:53 +01:00
2022-03-30 02:16:34 +02:00
// Do stuff with the class!
let echo_fut = async {
2022-03-09 23:06:27 +01:00
loop {
class.wait_connection().await;
info!("Connected");
let _ = echo(&mut class).await;
info!("Disconnected");
2022-03-10 01:05:33 +01:00
}
};
2022-03-09 23:06:27 +01:00
2022-03-10 01:10:53 +01:00
// Run everything concurrently.
// If we had made everything `'static` above instead, we could do this using separate tasks instead.
2022-03-30 02:16:34 +02:00
join(usb_fut, echo_fut).await;
2022-03-09 01:34:35 +01:00
}
struct Disconnected {}
impl From<EndpointError> for Disconnected {
fn from(val: EndpointError) -> Self {
match val {
EndpointError::BufferOverflow => panic!("Buffer overflow"),
EndpointError::Disabled => Disconnected {},
}
}
}
2023-02-01 00:48:33 +01:00
async fn echo<'d, T: Instance + 'd, P: VbusDetect + 'd>(
class: &mut CdcAcmClass<'d, Driver<'d, T, P>>,
) -> Result<(), Disconnected> {
let mut buf = [0; 64];
loop {
let n = class.read_packet(&mut buf).await?;
let data = &buf[..n];
info!("data: {:x}", data);
class.write_packet(data).await?;
}
}