diff options
Diffstat (limited to 'examples/stm32f1/src/bin/usb_serial.rs')
-rw-r--r-- | examples/stm32f1/src/bin/usb_serial.rs | 117 |
1 files changed, 117 insertions, 0 deletions
diff --git a/examples/stm32f1/src/bin/usb_serial.rs b/examples/stm32f1/src/bin/usb_serial.rs new file mode 100644 index 00000000..fe4aa4cc --- /dev/null +++ b/examples/stm32f1/src/bin/usb_serial.rs @@ -0,0 +1,117 @@ +#![no_std] +#![no_main] +#![feature(type_alias_impl_trait)] + +use defmt::panic; +use defmt::*; +use defmt_rtt as _; // global logger +use embassy::executor::Spawner; +use embassy::time::Duration; +use embassy::time::Timer; +use embassy_stm32::gpio::Level; +use embassy_stm32::gpio::Output; +use embassy_stm32::gpio::Speed; +use embassy_stm32::interrupt; +use embassy_stm32::time::Hertz; +use embassy_stm32::usb::{Driver, Instance}; +use embassy_stm32::{Config, Peripherals}; +use embassy_usb::driver::EndpointError; +use embassy_usb::Builder; +use embassy_usb_serial::{CdcAcmClass, State}; +use futures::future::join; +use panic_probe as _; + +fn config() -> Config { + let mut config = Config::default(); + config.rcc.hse = Some(Hertz(8_000_000)); + config.rcc.sys_ck = Some(Hertz(48_000_000)); + config.rcc.pclk1 = Some(Hertz(24_000_000)); + config +} + +#[embassy::main(config = "config()")] +async fn main(_spawner: Spawner, mut p: Peripherals) { + info!("Hello World!"); + + { + // BluePill board has a pull-up resistor on the D+ line. + // Pull the D+ pin down to send a RESET condition to the USB bus. + // This forced reset is needed only for development, without it host + // will not reset your device when you upload new firmware. + let _dp = Output::new(&mut p.PA12, Level::Low, Speed::Low); + Timer::after(Duration::from_millis(10)).await; + } + + // Create the driver, from the HAL. + let irq = interrupt::take!(USB_LP_CAN1_RX0); + let driver = Driver::new(p.USB, irq, p.PA12, p.PA11); + + // Create embassy-usb Config + let config = embassy_usb::Config::new(0xc0de, 0xcafe); + //config.max_packet_size_0 = 64; + + // Create embassy-usb DeviceBuilder using the driver and config. + // It needs some buffers for building the descriptors. + let mut device_descriptor = [0; 256]; + let mut config_descriptor = [0; 256]; + let mut bos_descriptor = [0; 256]; + let mut control_buf = [0; 7]; + + let mut state = State::new(); + + let mut builder = Builder::new( + driver, + config, + &mut device_descriptor, + &mut config_descriptor, + &mut bos_descriptor, + &mut control_buf, + None, + ); + + // Create classes on the builder. + let mut class = CdcAcmClass::new(&mut builder, &mut state, 64); + + // Build the builder. + let mut usb = builder.build(); + + // Run the USB device. + let usb_fut = usb.run(); + + // 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. + // If we had made everything `'static` above instead, we could do this using separate tasks instead. + join(usb_fut, echo_fut).await; +} + +struct Disconnected {} + +impl From<EndpointError> for Disconnected { + fn from(val: EndpointError) -> Self { + match val { + EndpointError::BufferOverflow => panic!("Buffer overflow"), + EndpointError::Disabled => Disconnected {}, + } + } +} + +async fn echo<'d, T: Instance + 'd>( + class: &mut CdcAcmClass<'d, Driver<'d, T>>, +) -> 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?; + } +} |