Struct Stream 

pub struct Stream { /* private fields */ }

A bi-directional communication stream between the user and a Dac.

Implementations

impl Stream

pub fn dac(&self) -> &Addressed

Borrow the inner DAC to examine its state.

Examples found in repository

examples/dac_stream.rs (line 26)

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 queue_commands(&mut self) -> CommandQueue<'_>

Queue one or more commands to be submitted to the DAC at once.

Examples found in repository

examples/dac_stream.rs (line 37)

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 set_nodelay(&self, b: bool) -> Result<()>

This directly calls set_nodelay on the inner TcpStream. In other words, this sets the value of the TCP_NODELAY option for this socket.

Note that due to the necessity for very low-latency communication with the DAC, this API enables TCP_NODELAY by default. This method is exposed in order to allow the user to disable this if they wish.

When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets. Although perhaps more efficient for the network, this may result in DAC underflows if Data commands are delayed for too long.

pub fn nodelay(&self) -> Result<bool>

Gets the value of the TCP_NODELAY option for this socket.

For more infnormation about this option, see set_nodelay.

pub fn set_ttl(&self, ttl: u32) -> Result<()>

This directly calls set_ttl on the inner TcpStream. In other words, this sets the value for the IP_TTL option on this socket.

This value sets the time-to-live field that is used in every packet sent from this socket. Time-to-live describes the number of hops between devices that a packet may make before it is discarded/ignored.

pub fn ttl(&self) -> Result<u32>

Gets the value of the IP_TTL option for this socket.

For more information about this option see set_ttl.

pub fn set_read_timeout(&self, duration: Option<Duration>) -> Result<()>

Sets the read timeout of the underlying TcpStream.

See the following for details:

• std::net::TcpStream::set_read_timeout

pub fn set_write_timeout(&self, duration: Option<Duration>) -> Result<()>

Sets the write timeout of the underlying TcpStream.

See the following for details:

• std::net::TcpStream::set_write_timeout

pub fn set_timeout(&self, duration: Option<Duration>) -> Result<()>

Sets the read and write timeout of the underlying TcpStream.

See the following for details:

• std::net::TcpStream::set_read_timeout
• std::net::TcpStream::set_write_timeout