Struct device_driver::CommandOperation

pub struct CommandOperation<'a, D> { /* private fields */ }

Intermediate type for doing command operations

Implementations

impl<'a, D: CommandDevice> CommandOperation<'a, D>

pub fn dispatch(self) -> Result<(), D::Error>

Dispatch the command to the device

Examples found in repository

examples/test-macro-driver.rs (line 333)

fn main() {
    let mut test_device = TestDevice::new();

    println!("{:?}", test_device.id().read().unwrap());

    assert!(!test_device.int_flags().read().unwrap().rx());
    test_device.int_enable().write(|w| w.rx(true)).unwrap();
    assert!(test_device.int_enable().read().unwrap().rx());
    assert_eq!(test_device.device_memory[17], 1);

    test_device.baudrate().write(|w| w.value(12)).unwrap();

    write_baud(&mut test_device);
    assert_eq!(test_device.baudrate().read().unwrap().value(), 12);
    // Test it's actually doing little endian
    assert_eq!(test_device.device_memory[42], 12);
    assert_eq!(test_device.device_memory[43], 0);

    test_device
        .foo_0()
        .baudrate()
        .write(|w| w.value(12))
        .unwrap();
    assert_eq!(test_device.foo_0().baudrate().read().unwrap().value(), 12);
    assert_eq!(test_device.device_memory[64], 12);
    assert_eq!(test_device.device_memory[65], 0);

    test_device
        .foo_1()
        .baudrate()
        .write(|w| w.value(34))
        .unwrap();
    assert_eq!(test_device.foo_1().baudrate().read().unwrap().value(), 34);
    assert_eq!(test_device.device_memory[80], 34);
    assert_eq!(test_device.device_memory[81], 0);

    test_device.foo().clear().unwrap();
    assert_eq!(test_device.foo().read().unwrap().value(), 0x1234);

    test_device.foo().write(|w| w.value(5)).unwrap();
    assert_eq!(test_device.foo().read().unwrap().value(), 5);

    test_device.foo().write_with_zero(|w| w).unwrap();
    assert_eq!(test_device.foo().read().unwrap().value(), 0);

    test_device.foo().write(|w| w).unwrap();
    assert_eq!(test_device.foo().read().unwrap().value(), 0x1234);

    test_device.cfg_reg().clear().unwrap();
    #[cfg(windows)]
    assert_eq!(test_device.cfg_reg().read().unwrap().value(), 0x1234);
    #[cfg(not(windows))]
    assert_eq!(test_device.cfg_reg().read().unwrap().value(), 0x5678);

    test_device.sleep().dispatch().unwrap();
    assert_eq!(test_device.last_command, 0);

    test_device.burn().dispatch().unwrap();
    assert_eq!(test_device.last_command, 0xDEAD);

    let mut data = [1, 2, 3, 4, 5];
    test_device.fifo().write_all(&data).unwrap();
    test_device.fifo().read_exact(&mut data).unwrap();
    assert_eq!(data, [1, 2, 3, 4, 5]);
    assert_eq!(test_device.last_buffer, 124);

    // Create a mask
    let register_mask = registers::Baudrate::ZERO
        .into_w()
        .value(1234)
        .into_register();

    // Write test value
    test_device.baudrate().write(|w| w.value(u16::MAX)).unwrap();

    // Read back and apply mask
    let read_baud = (*test_device.baudrate().read().unwrap() & register_mask).into_r();
    assert_eq!(read_baud.value(), 1234);
}

impl<'a, D: AsyncCommandDevice> CommandOperation<'a, D>

pub async fn dispatch_async(self) -> Result<(), D::Error>

Dispatch the command to the device