USB Device with embassy-usb

[package]
name = "usb-composite"
version = "0.1.0"
edition = "2021"

[dependencies]
embassy-executor = { version = "0.7", features = ["arch-cortex-m", "executor-thread"] }
embassy-rp = { version = "0.3", features = ["time-driver", "rp2040"] }
embassy-usb = { version = "0.4" }
embassy-time = { version = "0.4" }
embassy-futures = { version = "0.1" }
embassy-sync = { version = "0.6" }

usbd-hid = { version = "0.8" }

defmt = "0.3"
defmt-rtt = "0.4"
panic-probe = { version = "0.3", features = ["print-defmt"] }

cortex-m = "0.7"
cortex-m-rt = "0.7"

static_cell = "2"
portable-atomic = { version = "1", features = ["critical-section"] }

[profile.release]
debug = 2
lto = true
opt-level = "s"

fn main() {
    println!("cargo:rustc-link-arg-bins=--nmagic");
    println!("cargo:rustc-link-arg-bins=-Tlink.x");
    println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
}

MEMORY {
    BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
    FLASH : ORIGIN = 0x10000100, LENGTH = 2048K - 0x100
    RAM   : ORIGIN = 0x20000000, LENGTH = 256K
}

[target.thumbv6m-none-eabi]
runner = "probe-rs run --chip RP2040 --protocol swd"

[build]
target = "thumbv6m-none-eabi"

[env]
DEFMT_LOG = "debug"

#![no_std]
#![no_main]

use defmt::*;
use defmt_rtt as _;
use panic_probe as _;

use embassy_executor::Spawner;
use embassy_rp::adc::{Adc, Channel, Config as AdcConfig, InterruptHandler as AdcIrq};
use embassy_rp::bind_interrupts;
use embassy_rp::gpio::Pull;
use embassy_rp::peripherals::USB;
use embassy_rp::usb::{Driver, InterruptHandler as UsbIrq};
use embassy_time::Timer;
use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
use embassy_usb::UsbDevice;

use static_cell::StaticCell;

bind_interrupts!(struct Irqs {
    USBCTRL_IRQ => UsbIrq<USB>;
    ADC_IRQ_FIFO => AdcIrq;
});

#[embassy_executor::task]
async fn usb_task(mut usb: UsbDevice<'static, Driver<'static, USB>>) {
    usb.run().await;
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    // Create USB driver
    let driver = Driver::new(p.USB, Irqs);

    // Configure USB device descriptor
    let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
    config.manufacturer = Some("Pico Workshop");
    config.product = Some("Pico CDC Sensor");
    config.serial_number = Some("001");
    config.max_power = 100; // 100 mA
    config.max_packet_size_0 = 64;

    // Allocate buffers for the USB stack
    static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
    static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
    static CONTROL_BUF: StaticCell<[u8; 64]> = StaticCell::new();
    static CDC_STATE: StaticCell<State> = StaticCell::new();

    let config_desc = CONFIG_DESC.init([0; 256]);
    let bos_desc = BOS_DESC.init([0; 256]);
    let control_buf = CONTROL_BUF.init([0; 64]);
    let cdc_state = CDC_STATE.init(State::new());

    // Build the USB device
    let mut builder = embassy_usb::Builder::new(
        driver,
        config,
        config_desc,
        bos_desc,
        &mut [], // no msos descriptors
        control_buf,
    );

    // Create CDC ACM class
    let mut cdc = CdcAcmClass::new(&mut builder, cdc_state, 64);

    // Build and spawn the USB device task
    let usb = builder.build();
    spawner.spawn(usb_task(usb)).unwrap();

    // Set up ADC for potentiometer on GP26
    let mut adc = Adc::new(p.ADC, Irqs, AdcConfig::default());
    let mut pot_pin = Channel::new_pin(p.PIN_26, Pull::None);

    // Main loop: read ADC and write to USB serial
    let mut buf = [0u8; 64];
    loop {
        // Wait for the host to open the serial port
        cdc.wait_connection().await;
        info!("CDC connected");

        loop {
            let adc_val = adc.read(&mut pot_pin).await.unwrap_or(0);
            let voltage_mv = (adc_val as u32 * 3300) / 4095;

            // Format the output string
            let msg = format_msg(&mut buf, adc_val, voltage_mv);

            // Write to USB CDC; break if disconnected
            if cdc.write_packet(msg).await.is_err() {
                info!("CDC disconnected");
                break;
            }

            Timer::after_millis(500).await;
        }
    }
}

fn format_msg(buf: &mut [u8; 64], raw: u16, mv: u32) -> &[u8] {
    // Manual formatting since we are in no_std
    let mut pos = 0;

    let prefix = b"ADC: ";
    buf[pos..pos + prefix.len()].copy_from_slice(prefix);
    pos += prefix.len();

    pos += write_u32(&mut buf[pos..], raw as u32);

    let mid = b" | ";
    buf[pos..pos + mid.len()].copy_from_slice(mid);
    pos += mid.len();

    pos += write_u32(&mut buf[pos..], mv);

    let suffix = b" mV\r\n";
    buf[pos..pos + suffix.len()].copy_from_slice(suffix);
    pos += suffix.len();

    &buf[..pos]
}

fn write_u32(buf: &mut [u8], val: u32) -> usize {
    if val == 0 {
        buf[0] = b'0';
        return 1;
    }
    let mut tmp = [0u8; 10];
    let mut n = val;
    let mut i = 0;
    while n > 0 {
        tmp[i] = b'0' + (n % 10) as u8;
        n /= 10;
        i += 1;
    }
    for j in 0..i {
        buf[j] = tmp[i - 1 - j];
    }
    i
}

#![no_std]
#![no_main]

use defmt::*;
use defmt_rtt as _;
use panic_probe as _;

use embassy_executor::Spawner;
use embassy_rp::adc::{Adc, Channel, Config as AdcConfig, InterruptHandler as AdcIrq};
use embassy_rp::bind_interrupts;
use embassy_rp::gpio::{Input, Pull};
use embassy_rp::peripherals::USB;
use embassy_rp::usb::{Driver, InterruptHandler as UsbIrq};
use embassy_time::Timer;
use embassy_usb::class::cdc_acm::{CdcAcmClass, State as CdcState};
use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State as HidState};
use embassy_usb::control::OutResponse;
use embassy_usb::UsbDevice;

use static_cell::StaticCell;

bind_interrupts!(struct Irqs {
    USBCTRL_IRQ => UsbIrq<USB>;
    ADC_IRQ_FIFO => AdcIrq;
});

// ── HID Report Descriptor ──────────────────────────────────────────

const KEYBOARD_REPORT_DESC: &[u8] = &[
    0x05, 0x01,        // Usage Page (Generic Desktop)
    0x09, 0x06,        // Usage (Keyboard)
    0xA1, 0x01,        // Collection (Application)

    // Modifier keys (8 bits: L-Ctrl, L-Shift, L-Alt, L-GUI, R-Ctrl, ...)
    0x05, 0x07,        //   Usage Page (Key Codes)
    0x19, 0xE0,        //   Usage Minimum (Left Control)
    0x29, 0xE7,        //   Usage Maximum (Right GUI)
    0x15, 0x00,        //   Logical Minimum (0)
    0x25, 0x01,        //   Logical Maximum (1)
    0x75, 0x01,        //   Report Size (1)
    0x95, 0x08,        //   Report Count (8)
    0x81, 0x02,        //   Input (Data, Variable, Absolute)

    // Reserved byte (padding)
    0x95, 0x01,        //   Report Count (1)
    0x75, 0x08,        //   Report Size (8)
    0x81, 0x01,        //   Input (Constant)

    // Key codes (6 key rollover)
    0x95, 0x06,        //   Report Count (6)
    0x75, 0x08,        //   Report Size (8)
    0x15, 0x00,        //   Logical Minimum (0)
    0x25, 0x65,        //   Logical Maximum (101)
    0x05, 0x07,        //   Usage Page (Key Codes)
    0x19, 0x00,        //   Usage Minimum (0)
    0x29, 0x65,        //   Usage Maximum (101)
    0x81, 0x00,        //   Input (Data, Array)

    0xC0,              // End Collection
];

// ── Keyboard Report Structure ──────────────────────────────────────

#[derive(Clone, Copy)]
#[repr(C, packed)]
struct KeyboardReport {
    modifier: u8,
    reserved: u8,
    keycodes: [u8; 6],
}

impl KeyboardReport {
    const fn empty() -> Self {
        Self {
            modifier: 0,
            reserved: 0,
            keycodes: [0; 6],
        }
    }

    fn as_bytes(&self) -> &[u8; 8] {
        unsafe { &*(self as *const Self as *const [u8; 8]) }
    }
}

// ── HID Request Handler ────────────────────────────────────────────

struct MyRequestHandler;

impl RequestHandler for MyRequestHandler {
    fn get_report(&mut self, _id: ReportId, _buf: &mut [u8]) -> Option<usize> {
        None
    }

    fn set_report(&mut self, _id: ReportId, _data: &[u8]) -> OutResponse {
        OutResponse::Accepted
    }

    fn set_idle_ms(&mut self, _id: Option<ReportId>, _dur: u32) {}
    fn get_idle_ms(&mut self, _id: Option<ReportId>) -> Option<u32> {
        None
    }
}

// ── USB Background Task ────────────────────────────────────────────

#[embassy_executor::task]
async fn usb_task(mut usb: UsbDevice<'static, Driver<'static, USB>>) {
    usb.run().await;
}

// ── CDC Serial Task ────────────────────────────────────────────────

#[embassy_executor::task]
async fn cdc_task(
    mut cdc: CdcAcmClass<'static, Driver<'static, USB>>,
    mut adc: Adc<'static, embassy_rp::adc::Async>,
    mut pot_pin: Channel<'static>,
) {
    loop {
        cdc.wait_connection().await;
        info!("CDC: host connected");

        loop {
            let raw = adc.read(&mut pot_pin).await.unwrap_or(0);
            let mv = (raw as u32 * 3300) / 4095;

            let mut buf = [0u8; 48];
            let len = format_reading(&mut buf, raw, mv);

            if cdc.write_packet(&buf[..len]).await.is_err() {
                info!("CDC: host disconnected");
                break;
            }

            Timer::after_millis(500).await;
        }
    }
}

fn format_reading(buf: &mut [u8], raw: u16, mv: u32) -> usize {
    let mut pos = 0;

    let prefix = b"ADC: ";
    buf[pos..pos + prefix.len()].copy_from_slice(prefix);
    pos += prefix.len();
    pos += write_u32(&mut buf[pos..], raw as u32);

    let mid = b" | ";
    buf[pos..pos + mid.len()].copy_from_slice(mid);
    pos += mid.len();
    pos += write_u32(&mut buf[pos..], mv);

    let suffix = b" mV\r\n";
    buf[pos..pos + suffix.len()].copy_from_slice(suffix);
    pos += suffix.len();

    pos
}

fn write_u32(buf: &mut [u8], val: u32) -> usize {
    if val == 0 {
        buf[0] = b'0';
        return 1;
    }
    let mut tmp = [0u8; 10];
    let mut n = val;
    let mut i = 0;
    while n > 0 {
        tmp[i] = b'0' + (n % 10) as u8;
        n /= 10;
        i += 1;
    }
    for j in 0..i {
        buf[j] = tmp[i - 1 - j];
    }
    i
}

// ── HID Keyboard Task ─────────────────────────────────────────────

#[embassy_executor::task]
async fn hid_task(
    hid: HidReaderWriter<'static, Driver<'static, USB>, 1, 8>,
    mut button: Input<'static>,
) {
    let (reader, mut writer) = hid.split();

    // We only use the writer; spawn a task to drain the reader
    // so the host does not stall on SET_REPORT/OUTPUT reports.
    let _reader = reader;

    // The string to type when the button is pressed
    let message: &[u8] = b"Hello from Pico!";

    loop {
        // Wait for button press (falling edge: high to low)
        button.wait_for_falling_edge().await;
        info!("Button pressed, typing message");

        // Type each character
        for &ch in message {
            let keycode = ascii_to_hid(ch);
            let needs_shift = ch.is_ascii_uppercase()
                || matches!(ch, b'!' | b'@' | b'#' | b'$' | b'%'
                    | b'^' | b'&' | b'*' | b'(' | b')');

            // Key down
            let report = KeyboardReport {
                modifier: if needs_shift { 0x02 } else { 0x00 },
                reserved: 0,
                keycodes: [keycode, 0, 0, 0, 0, 0],
            };
            let _ = writer.write(report.as_bytes()).await;

            // Small delay between key down and key up
            Timer::after_millis(10).await;

            // Key up (empty report)
            let empty = KeyboardReport::empty();
            let _ = writer.write(empty.as_bytes()).await;

            // Delay between characters
            Timer::after_millis(30).await;
        }

        // Debounce: wait before accepting the next press
        Timer::after_millis(300).await;
    }
}

/// Convert an ASCII character to a USB HID keycode.
fn ascii_to_hid(ch: u8) -> u8 {
    match ch {
        b'a'..=b'z' => ch - b'a' + 0x04,
        b'A'..=b'Z' => ch - b'A' + 0x04,
        b'1'..=b'9' => ch - b'1' + 0x1E,
        b'0' => 0x27,
        b' ' => 0x2C,
        b'!' => 0x1E, // Shift + 1
        b'@' => 0x1F, // Shift + 2
        b'#' => 0x20, // Shift + 3
        b'.' => 0x37,
        b',' => 0x36,
        b'\n' => 0x28, // Enter
        b'-' => 0x2D,
        b'=' => 0x2E,
        b'[' => 0x2F,
        b']' => 0x30,
        b'\\' => 0x31,
        b';' => 0x33,
        b'\'' => 0x34,
        b'/' => 0x38,
        _ => 0x00, // No key
    }
}

// ── Main ───────────────────────────────────────────────────────────

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    // ── USB Device Configuration ───────────────────────────────────

    let driver = Driver::new(p.USB, Irqs);

    let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
    config.manufacturer = Some("Pico Workshop");
    config.product = Some("Pico CDC+Keyboard");
    config.serial_number = Some("RUST-001");
    config.max_power = 100;
    config.max_packet_size_0 = 64;
    // Composite device: class defined at interface level
    config.device_class = 0xEF;    // Miscellaneous
    config.device_sub_class = 0x02; // Common Class
    config.device_protocol = 0x01;  // Interface Association Descriptor

    // ── Static Buffers ─────────────────────────────────────────────

    static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
    static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
    static MSOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
    static CONTROL_BUF: StaticCell<[u8; 64]> = StaticCell::new();
    static CDC_STATE: StaticCell<CdcState> = StaticCell::new();
    static HID_STATE: StaticCell<HidState> = StaticCell::new();

    let config_desc = CONFIG_DESC.init([0; 256]);
    let bos_desc = BOS_DESC.init([0; 256]);
    let msos_desc = MSOS_DESC.init([0; 256]);
    let control_buf = CONTROL_BUF.init([0; 64]);
    let cdc_state = CDC_STATE.init(CdcState::new());
    let hid_state = HID_STATE.init(HidState::new());

    // ── Build USB Device ───────────────────────────────────────────

    let mut builder = embassy_usb::Builder::new(
        driver,
        config,
        config_desc,
        bos_desc,
        msos_desc,
        control_buf,
    );

    // Add CDC ACM class (virtual serial port)
    let cdc = CdcAcmClass::new(&mut builder, cdc_state, 64);

    // Add HID class (keyboard)
    let hid_config = embassy_usb::class::hid::Config {
        report_descriptor: KEYBOARD_REPORT_DESC,
        request_handler: None,
        poll_ms: 10,
        max_packet_size: 8,
    };
    let hid = HidReaderWriter::<_, 1, 8>::new(&mut builder, hid_state, hid_config);

    // Build the USB device
    let usb = builder.build();

    // ── Peripherals ────────────────────────────────────────────────

    // ADC for potentiometer
    let adc = Adc::new(p.ADC, Irqs, AdcConfig::default());
    let pot_pin = Channel::new_pin(p.PIN_26, Pull::None);

    // Button on GP15 with internal pull-up
    let button = Input::new(p.PIN_15, Pull::Up);

    // ── Spawn Tasks ────────────────────────────────────────────────

    spawner.spawn(usb_task(usb)).unwrap();
    spawner.spawn(cdc_task(cdc, adc, pot_pin)).unwrap();
    spawner.spawn(hid_task(hid, button)).unwrap();

    info!("USB composite device started: CDC + HID Keyboard");

    // Main task has nothing else to do; it can idle forever.
    // The executor will run the spawned tasks.
    loop {
        Timer::after_millis(1000).await;
    }
}

// Must manually calculate CONFIG_TOTAL_LEN
#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_DESC_LEN)

static const uint8_t desc_configuration[] = {
    TUD_CONFIG_DESCRIPTOR(1, 3, 0, CONFIG_TOTAL_LEN, 0x00, 100),
    TUD_CDC_DESCRIPTOR(0, 4, 0x81, 8, 0x02, 0x82, 64),
    TUD_HID_DESCRIPTOR(2, 5, HID_ITF_PROTOCOL_NONE,
                       sizeof(desc_hid_report), 0x83, 8, 10),
};

let mut builder = embassy_usb::Builder::new(driver, config, ...);

// Each call automatically:
//   - Allocates the next available interface numbers
//   - Allocates the next available endpoint numbers
//   - Computes the correct descriptor lengths
//   - Adds the Interface Association Descriptor for CDC
let cdc = CdcAcmClass::new(&mut builder, cdc_state, 64);
let hid = HidReaderWriter::new(&mut builder, hid_state, hid_config);

let usb = builder.build(); // Finalizes CONFIG_TOTAL_LEN automatically