Struct helios_dac::wrapper::HeliosDacWrapper

source ·

pub struct HeliosDacWrapper { /* private fields */ }

Implementations§

source §

impl HeliosDacWrapper

source

pub fn new() -> Self

Examples found in repository ?

examples/list_devices.rs (line 5)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        let name = controller.name(i).unwrap();
        let status = controller.status(i);

        println!("{}: {:?}", name, status);
    }
}

More examples

Hide additional examples

examples/frames.rs (line 9)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let frames = get_frames();

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        for frame in frames.clone() {
            controller.write_frame(i, frame).unwrap();
        }

        controller.stop(i).unwrap();
    }
}

source

pub fn open_devices(&mut self) -> Result<u32, HeliosError>

Initializes drivers, opens connection to all devices Returns number of all available devices. NB: To re-scan for newly connected DACs after this function has once been called before, you must first call CloseDevices()

Examples found in repository ?

examples/list_devices.rs (line 6)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        let name = controller.name(i).unwrap();
        let status = controller.status(i);

        println!("{}: {:?}", name, status);
    }
}

More examples

Hide additional examples

examples/frames.rs (line 10)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let frames = get_frames();

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        for frame in frames.clone() {
            controller.write_frame(i, frame).unwrap();
        }

        controller.stop(i).unwrap();
    }
}

source

pub fn close_devices(&mut self) -> Result<(), HeliosError>

Closes and frees all devices

source

pub fn write_frame(
 &mut self,
 device_number: u32,
 frame: Frame
) -> Result<(), HeliosError>

Writes and outputs a frame to the specified dac

device_number: dac number (0 to n where n+1 is the return value from open_devices )

Examples found in repository ?

examples/frames.rs (line 14)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let frames = get_frames();

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        for frame in frames.clone() {
            controller.write_frame(i, frame).unwrap();
        }

        controller.stop(i).unwrap();
    }
}

source

pub fn status(&mut self, device_number: u32) -> Result<DeviceStatus, HeliosError>

Gets status of DAC

Examples found in repository ?

examples/list_devices.rs (line 10)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        let name = controller.name(i).unwrap();
        let status = controller.status(i);

        println!("{}: {:?}", name, status);
    }
}

source

pub fn firmware_version(
&mut self,
device_number: u32
) -> Result<u32, HeliosError>

Returns firmware version of DAC

source

pub fn name(&mut self, device_number: u32) -> Result<String, HeliosError>

Gets name of DAC (populates name with max 32 characters)

Examples found in repository ?

examples/list_devices.rs (line 9)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        let name = controller.name(i).unwrap();
        let status = controller.status(i);

        println!("{}: {:?}", name, status);
    }
}

source

pub fn set_name(
 &mut self,
 device_number: u32,
 name: String
) -> Result<(), HeliosError>

Sets name of DAC (name must be max 31 characters incl. null terminator)

source

pub fn stop(&mut self, device_number: u32) -> Result<(), HeliosError>

Stops output of DAC until new frame is written (NB: blocks for 100ms)

Examples found in repository ?

examples/frames.rs (line 17)

pub fn main() {
    use helios_dac::wrapper::HeliosDacWrapper;

    let frames = get_frames();

    let mut controller = HeliosDacWrapper::new();
    let device_count = controller.open_devices().unwrap();

    for i in 0..device_count {
        for frame in frames.clone() {
            controller.write_frame(i, frame).unwrap();
        }

        controller.stop(i).unwrap();
    }
}