Struct CommandQueue

pub struct CommandQueue<'a> { /* private fields */ }

A queue of commands that are to be submitted at once before listening for their responses.

Implementations

impl<'a> CommandQueue<'a>

pub fn prepare_stream(self) -> Self

This command causes the playback system to enter the Prepared state. The DAC resets its buffer to be empty and sets “point_count” to 0.

This command may only be sent if the light engine is Ready and the playback system is Idle. If so, the DAC replies with ACK. Otherwise, it replies with NAK - Invalid.

Examples found in repository

examples/dac_stream.rs (line 38)

fn main() {
    println!("Listening for an Ether Dream DAC...");

    let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
        .expect("failed to bind to UDP socket")
        .filter_map(Result::ok)
        .next()
        .unwrap();
    let mac_address = dac::MacAddress(dac_broadcast.mac_address);

    println!(
        "Discovered DAC \"{}\" at \"{}\"! Connecting...",
        mac_address, source_addr
    );

    // Establish the TCP connection.
    let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();

    // If we want to create an animation (in our case a moving sine wave) we need a frame rate.
    let frames_per_second = 60.0;
    // Lets use the DAC at an eighth the maximum scan rate.
    let points_per_second = stream.dac().max_point_rate / 32;
    // Determine the number of points per frame given our target frame and point rates.
    let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;

    println!(
        "Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
        frames_per_second, points_per_second, points_per_frame
    );

    // Prepare the DAC's playback engine and await the repsonse.
    stream
        .queue_commands()
        .prepare_stream()
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting PREPARE_STREAM \
                      command and listening for response: {}",
                err
            );
        });

    println!("Beginning playback!");

    // The sine wave used to generate points.
    let mut sine_wave = SineWave {
        point: 0,
        points_per_frame,
        frames_per_second,
    };

    // Queue the initial frame and tell the DAC to begin producing output.
    let n_points = points_to_generate(stream.dac());
    stream
        .queue_commands()
        .data(sine_wave.by_ref().take(n_points))
        .begin(0, points_per_second)
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting initial DATA and BEGIN \
                      commands and listening for response: {}",
                err
            );
        });

    // Loop and continue to send points forever.
    loop {
        // Determine how many points the DAC can currently receive.
        let n_points = points_to_generate(stream.dac());
        if let Err(err) = stream
            .queue_commands()
            .data(sine_wave.by_ref().take(n_points))
            .submit()
        {
            eprintln!(
                "err occurred when submitting DATA command and listening \
                      for response: {}",
                err
            );
            break;
        }
    }

    // Tell the DAC to stop producing output and return to idle. Wait for the response.
    //
    // Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
    // produced are ignored.
    stream
        .queue_commands()
        .stop()
        .submit()
        .expect("err occurred when submitting STOP command and listening for response");
}

pub fn begin(self, low_water_mark: u16, point_rate: u32) -> Self

Causes the DAC to begin producing output.

low_water_mark

Currently unused.

point_rate

The number of points per second to be read from the buffer. If the playback system was Prepared and there was data in the buffer, then the DAC will reply with ACK. Otherwise, it replies with NAK - Invalid.

Examples found in repository

examples/dac_stream.rs (line 63)

fn main() {
    println!("Listening for an Ether Dream DAC...");

    let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
        .expect("failed to bind to UDP socket")
        .filter_map(Result::ok)
        .next()
        .unwrap();
    let mac_address = dac::MacAddress(dac_broadcast.mac_address);

    println!(
        "Discovered DAC \"{}\" at \"{}\"! Connecting...",
        mac_address, source_addr
    );

    // Establish the TCP connection.
    let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();

    // If we want to create an animation (in our case a moving sine wave) we need a frame rate.
    let frames_per_second = 60.0;
    // Lets use the DAC at an eighth the maximum scan rate.
    let points_per_second = stream.dac().max_point_rate / 32;
    // Determine the number of points per frame given our target frame and point rates.
    let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;

    println!(
        "Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
        frames_per_second, points_per_second, points_per_frame
    );

    // Prepare the DAC's playback engine and await the repsonse.
    stream
        .queue_commands()
        .prepare_stream()
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting PREPARE_STREAM \
                      command and listening for response: {}",
                err
            );
        });

    println!("Beginning playback!");

    // The sine wave used to generate points.
    let mut sine_wave = SineWave {
        point: 0,
        points_per_frame,
        frames_per_second,
    };

    // Queue the initial frame and tell the DAC to begin producing output.
    let n_points = points_to_generate(stream.dac());
    stream
        .queue_commands()
        .data(sine_wave.by_ref().take(n_points))
        .begin(0, points_per_second)
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting initial DATA and BEGIN \
                      commands and listening for response: {}",
                err
            );
        });

    // Loop and continue to send points forever.
    loop {
        // Determine how many points the DAC can currently receive.
        let n_points = points_to_generate(stream.dac());
        if let Err(err) = stream
            .queue_commands()
            .data(sine_wave.by_ref().take(n_points))
            .submit()
        {
            eprintln!(
                "err occurred when submitting DATA command and listening \
                      for response: {}",
                err
            );
            break;
        }
    }

    // Tell the DAC to stop producing output and return to idle. Wait for the response.
    //
    // Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
    // produced are ignored.
    stream
        .queue_commands()
        .stop()
        .submit()
        .expect("err occurred when submitting STOP command and listening for response");
}

pub fn point_rate(self, point_rate: u32) -> Self

Adds a new point rate to the point rate buffer.

Point rate changes are read out of the buffer when a point with an appropriate flag is played (see the WriteData command).

If the DAC’s playback state is not Prepared or Playing, it replies with NAK - Invalid.

If the point rate buffer is full, it replies with NAK - Full.

Otherwise, it replies with ACK.

pub fn data<I>(self, points: I) -> Self

where I: IntoIterator<Item = DacPoint>,

Indicates to the DAC to add the following point data into its buffer.

Examples found in repository

examples/dac_stream.rs (line 62)

fn main() {
    println!("Listening for an Ether Dream DAC...");

    let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
        .expect("failed to bind to UDP socket")
        .filter_map(Result::ok)
        .next()
        .unwrap();
    let mac_address = dac::MacAddress(dac_broadcast.mac_address);

    println!(
        "Discovered DAC \"{}\" at \"{}\"! Connecting...",
        mac_address, source_addr
    );

    // Establish the TCP connection.
    let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();

    // If we want to create an animation (in our case a moving sine wave) we need a frame rate.
    let frames_per_second = 60.0;
    // Lets use the DAC at an eighth the maximum scan rate.
    let points_per_second = stream.dac().max_point_rate / 32;
    // Determine the number of points per frame given our target frame and point rates.
    let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;

    println!(
        "Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
        frames_per_second, points_per_second, points_per_frame
    );

    // Prepare the DAC's playback engine and await the repsonse.
    stream
        .queue_commands()
        .prepare_stream()
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting PREPARE_STREAM \
                      command and listening for response: {}",
                err
            );
        });

    println!("Beginning playback!");

    // The sine wave used to generate points.
    let mut sine_wave = SineWave {
        point: 0,
        points_per_frame,
        frames_per_second,
    };

    // Queue the initial frame and tell the DAC to begin producing output.
    let n_points = points_to_generate(stream.dac());
    stream
        .queue_commands()
        .data(sine_wave.by_ref().take(n_points))
        .begin(0, points_per_second)
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting initial DATA and BEGIN \
                      commands and listening for response: {}",
                err
            );
        });

    // Loop and continue to send points forever.
    loop {
        // Determine how many points the DAC can currently receive.
        let n_points = points_to_generate(stream.dac());
        if let Err(err) = stream
            .queue_commands()
            .data(sine_wave.by_ref().take(n_points))
            .submit()
        {
            eprintln!(
                "err occurred when submitting DATA command and listening \
                      for response: {}",
                err
            );
            break;
        }
    }

    // Tell the DAC to stop producing output and return to idle. Wait for the response.
    //
    // Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
    // produced are ignored.
    stream
        .queue_commands()
        .stop()
        .submit()
        .expect("err occurred when submitting STOP command and listening for response");
}

pub fn stop(self) -> Self

Causes the DAC to immediately stop playing and return to the Idle playback state.

It is ACKed if the DAC was in the Playing or Prepared playback states.

Otherwise it is replied to with NAK - Invalid.

Examples found in repository

examples/dac_stream.rs (line 98)

fn main() {
    println!("Listening for an Ether Dream DAC...");

    let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
        .expect("failed to bind to UDP socket")
        .filter_map(Result::ok)
        .next()
        .unwrap();
    let mac_address = dac::MacAddress(dac_broadcast.mac_address);

    println!(
        "Discovered DAC \"{}\" at \"{}\"! Connecting...",
        mac_address, source_addr
    );

    // Establish the TCP connection.
    let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();

    // If we want to create an animation (in our case a moving sine wave) we need a frame rate.
    let frames_per_second = 60.0;
    // Lets use the DAC at an eighth the maximum scan rate.
    let points_per_second = stream.dac().max_point_rate / 32;
    // Determine the number of points per frame given our target frame and point rates.
    let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;

    println!(
        "Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
        frames_per_second, points_per_second, points_per_frame
    );

    // Prepare the DAC's playback engine and await the repsonse.
    stream
        .queue_commands()
        .prepare_stream()
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting PREPARE_STREAM \
                      command and listening for response: {}",
                err
            );
        });

    println!("Beginning playback!");

    // The sine wave used to generate points.
    let mut sine_wave = SineWave {
        point: 0,
        points_per_frame,
        frames_per_second,
    };

    // Queue the initial frame and tell the DAC to begin producing output.
    let n_points = points_to_generate(stream.dac());
    stream
        .queue_commands()
        .data(sine_wave.by_ref().take(n_points))
        .begin(0, points_per_second)
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting initial DATA and BEGIN \
                      commands and listening for response: {}",
                err
            );
        });

    // Loop and continue to send points forever.
    loop {
        // Determine how many points the DAC can currently receive.
        let n_points = points_to_generate(stream.dac());
        if let Err(err) = stream
            .queue_commands()
            .data(sine_wave.by_ref().take(n_points))
            .submit()
        {
            eprintln!(
                "err occurred when submitting DATA command and listening \
                      for response: {}",
                err
            );
            break;
        }
    }

    // Tell the DAC to stop producing output and return to idle. Wait for the response.
    //
    // Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
    // produced are ignored.
    stream
        .queue_commands()
        .stop()
        .submit()
        .expect("err occurred when submitting STOP command and listening for response");
}

pub fn emergency_stop(self) -> Self

Causes the light engine to enter the E-Stop state, regardless of its previous state.

This command is always ACKed.

pub fn clear_emergency_stop(self) -> Self

If the light engine was in E-Stop state due to an emergency stop command (either from a local stop condition or over the network), this command resets it to Ready.

It is ACKed if the DAC was previously in E-Stop.

Otherwise it is replied to with a NAK - Invalid.

If the condition that caused the emergency stop is still active (e.g. E-Stop input still asserted, temperature still out of bounds, etc) a NAK - Stop Condition is sent.

pub fn ping(self) -> Self

The DAC will reply to this with an ACK packet.

This serves as a keep-alive for the connection when the DAC is not actively streaming.

pub fn submit(self) -> Result<(), CommunicationError>

Finish queueing commands and send them to the DAC.

First all commands are written to the TCP stream, then we block waiting for a response to each from the DAC.

Examples found in repository

examples/dac_stream.rs (line 39)

fn main() {
    println!("Listening for an Ether Dream DAC...");

    let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
        .expect("failed to bind to UDP socket")
        .filter_map(Result::ok)
        .next()
        .unwrap();
    let mac_address = dac::MacAddress(dac_broadcast.mac_address);

    println!(
        "Discovered DAC \"{}\" at \"{}\"! Connecting...",
        mac_address, source_addr
    );

    // Establish the TCP connection.
    let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();

    // If we want to create an animation (in our case a moving sine wave) we need a frame rate.
    let frames_per_second = 60.0;
    // Lets use the DAC at an eighth the maximum scan rate.
    let points_per_second = stream.dac().max_point_rate / 32;
    // Determine the number of points per frame given our target frame and point rates.
    let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;

    println!(
        "Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
        frames_per_second, points_per_second, points_per_frame
    );

    // Prepare the DAC's playback engine and await the repsonse.
    stream
        .queue_commands()
        .prepare_stream()
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting PREPARE_STREAM \
                      command and listening for response: {}",
                err
            );
        });

    println!("Beginning playback!");

    // The sine wave used to generate points.
    let mut sine_wave = SineWave {
        point: 0,
        points_per_frame,
        frames_per_second,
    };

    // Queue the initial frame and tell the DAC to begin producing output.
    let n_points = points_to_generate(stream.dac());
    stream
        .queue_commands()
        .data(sine_wave.by_ref().take(n_points))
        .begin(0, points_per_second)
        .submit()
        .err()
        .map(|err| {
            eprintln!(
                "err occurred when submitting initial DATA and BEGIN \
                      commands and listening for response: {}",
                err
            );
        });

    // Loop and continue to send points forever.
    loop {
        // Determine how many points the DAC can currently receive.
        let n_points = points_to_generate(stream.dac());
        if let Err(err) = stream
            .queue_commands()
            .data(sine_wave.by_ref().take(n_points))
            .submit()
        {
            eprintln!(
                "err occurred when submitting DATA command and listening \
                      for response: {}",
                err
            );
            break;
        }
    }

    // Tell the DAC to stop producing output and return to idle. Wait for the response.
    //
    // Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
    // produced are ignored.
    stream
        .queue_commands()
        .stop()
        .submit()
        .expect("err occurred when submitting STOP command and listening for response");
}