max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Trait for UsbSupply

Browse Source 
Eliminated a signal by using a simpler trait method that returns whether VBus power is available. Also includes a UsbSupply that can be signalled for use with the nRF softdevice. Includes the requirement for waiting for power to become available.
This commit is contained in:
huntc
2022-07-09 16:40:10 +10:00
parent 81796d29b4
commit 8785fbc6f1
6 changed files with 173 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
examples/nrf/src/bin/usb_ethernet.rs
View File

@ -15,14 +15,14 @@ use embassy::util::Forever;
use embassy_net::tcp::TcpSocket;
use embassy_net::{PacketBox, PacketBoxExt, PacketBuf, Stack, StackResources};
use embassy_nrf::rng::Rng;
use embassy_nrf::usb::Driver;
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
use embassy_usb::{Builder, Config, UsbDevice};
use embassy_usb_ncm::{CdcNcmClass, Receiver, Sender, State};
use embedded_io::asynch::{Read, Write};
use {defmt_rtt as _, panic_probe as _};
type MyDriver = Driver<'static, peripherals::USBD>;
type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
macro_rules! forever {
($val:expr) => {{
@ -84,19 +84,15 @@ async fn net_task(stack: &'static Stack<Device>) -> ! {
#[embassy::main]
async fn main(spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
let power: pac::POWER = unsafe { mem::transmute(()) };
info!("Enabling ext hfosc...");
clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
while clock.events_hfclkstarted.read().bits() != 1 {}
info!("Waiting for vbus...");
while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
info!("vbus OK");
// Create the driver, from the HAL.
let irq = interrupt::take!(USBD);
let driver = Driver::new(p.USBD, irq);
let power_irq = interrupt::take!(POWER_CLOCK);
let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);

71
examples/nrf/src/bin/usb_hid_keyboard.rs
View File

@ -10,10 +10,9 @@ use defmt::*;
use embassy::channel::signal::Signal;
use embassy::executor::Spawner;
use embassy::time::Duration;
use embassy::util::{select, select3, Either, Either3};
use embassy::util::{select, Either};
use embassy_nrf::gpio::{Input, Pin, Pull};
use embassy_nrf::interrupt::InterruptExt;
use embassy_nrf::usb::Driver;
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::control::OutResponse;
use embassy_usb::{Builder, Config, DeviceStateHandler};
@ -22,29 +21,11 @@ use futures::future::join;
use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
use {defmt_rtt as _, panic_probe as _};
static ENABLE_USB: Signal<bool> = Signal::new();
static SUSPENDED: AtomicBool = AtomicBool::new(false);
fn on_power_interrupt(_: *mut ()) {
let regs = unsafe { &*pac::POWER::ptr() };
if regs.events_usbdetected.read().bits() != 0 {
regs.events_usbdetected.reset();
info!("Vbus detected, enabling USB...");
ENABLE_USB.signal(true);
}
if regs.events_usbremoved.read().bits() != 0 {
regs.events_usbremoved.reset();
info!("Vbus removed, disabling USB...");
ENABLE_USB.signal(false);
}
}
#[embassy::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
let power: pac::POWER = unsafe { mem::transmute(()) };
info!("Enabling ext hfosc...");
clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
@ -52,7 +33,8 @@ async fn main(_spawner: Spawner, p: Peripherals) {
// Create the driver, from the HAL.
let irq = interrupt::take!(USBD);
let driver = Driver::new(p.USBD, irq);
let power_irq = interrupt::take!(POWER_CLOCK);
let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);
@ -100,31 +82,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
// Run the USB device.
let usb_fut = async {
enable_command().await;
loop {
match select(usb.run_until_suspend(), ENABLE_USB.wait()).await {
Either::First(_) => {}
Either::Second(enable) => {
if enable {
warn!("Enable when already enabled!");
} else {
usb.disable().await;
enable_command().await;
}
}
}
match select3(usb.wait_resume(), ENABLE_USB.wait(), remote_wakeup.wait()).await {
Either3::First(_) => (),
Either3::Second(enable) => {
if enable {
warn!("Enable when already enabled!");
} else {
usb.disable().await;
enable_command().await;
}
}
Either3::Third(_) => unwrap!(usb.remote_wakeup().await),
usb.run_until_suspend().await;
match select(usb.wait_resume(), remote_wakeup.wait()).await {
Either::First(_) => (),
Either::Second(_) => unwrap!(usb.remote_wakeup().await),
}
}
};
@ -174,28 +136,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
reader.run(false, &request_handler).await;
};
let power_irq = interrupt::take!(POWER_CLOCK);
power_irq.set_handler(on_power_interrupt);
power_irq.unpend();
power_irq.enable();
power.intenset.write(|w| w.usbdetected().set().usbremoved().set());
// Run everything concurrently.
// If we had made everything `'static` above instead, we could do this using separate tasks instead.
join(usb_fut, join(in_fut, out_fut)).await;
}
async fn enable_command() {
loop {
if ENABLE_USB.wait().await {
break;
} else {
warn!("Received disable signal when already disabled!");
}
}
}
struct MyRequestHandler {}
impl RequestHandler for MyRequestHandler {

10
examples/nrf/src/bin/usb_hid_mouse.rs
View File

@ -8,7 +8,7 @@ use core::mem;
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_nrf::usb::Driver;
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::control::OutResponse;
use embassy_usb::{Builder, Config};
@ -20,19 +20,15 @@ use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
let power: pac::POWER = unsafe { mem::transmute(()) };
info!("Enabling ext hfosc...");
clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
while clock.events_hfclkstarted.read().bits() != 1 {}
info!("Waiting for vbus...");
while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
info!("vbus OK");
// Create the driver, from the HAL.
let irq = interrupt::take!(USBD);
let driver = Driver::new(p.USBD, irq);
let power_irq = interrupt::take!(POWER_CLOCK);
let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);

8
examples/nrf/src/bin/usb_serial.rs
View File

@ -7,7 +7,7 @@ use core::mem;
use defmt::{info, panic};
use embassy::executor::Spawner;
use embassy_nrf::usb::{Driver, Instance};
use embassy_nrf::usb::{Driver, Instance, PowerUsb, UsbSupply};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::driver::EndpointError;
use embassy_usb::{Builder, Config};
@ -26,7 +26,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
// Create the driver, from the HAL.
let irq = interrupt::take!(USBD);
let power_irq = interrupt::take!(POWER_CLOCK);
let driver = Driver::with_power_management(p.USBD, irq, power_irq);
let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);
@ -97,7 +97,9 @@ impl From<EndpointError> for Disconnected {
}
}
async fn echo<'d, T: Instance + 'd>(class: &mut CdcAcmClass<'d, Driver<'d, T>>) -> Result<(), Disconnected> {
async fn echo<'d, T: Instance + 'd, P: UsbSupply + '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?;

13
examples/nrf/src/bin/usb_serial_multitask.rs
View File

@ -8,14 +8,14 @@ use core::mem;
use defmt::{info, panic, unwrap};
use embassy::executor::Spawner;
use embassy::util::Forever;
use embassy_nrf::usb::Driver;
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
use embassy_usb::driver::EndpointError;
use embassy_usb::{Builder, Config, UsbDevice};
use embassy_usb_serial::{CdcAcmClass, State};
use {defmt_rtt as _, panic_probe as _};
type MyDriver = Driver<'static, peripherals::USBD>;
type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
#[embassy::task]
async fn usb_task(mut device: UsbDevice<'static, MyDriver>) {
@ -35,19 +35,14 @@ async fn echo_task(mut class: CdcAcmClass<'static, MyDriver>) {
#[embassy::main]
async fn main(spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
let power: pac::POWER = unsafe { mem::transmute(()) };
info!("Enabling ext hfosc...");
clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
while clock.events_hfclkstarted.read().bits() != 1 {}
info!("Waiting for vbus...");
while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
info!("vbus OK");
// Create the driver, from the HAL.
let irq = interrupt::take!(USBD);
let driver = Driver::new(p.USBD, irq);
let power_irq = interrupt::take!(POWER_CLOCK);
let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
// Create embassy-usb Config
let mut config = Config::new(0xc0de, 0xcafe);