Struct BinaryConnection 

pub struct BinaryConnection<S: Read + Write> { /* private fields */ }

Binary protocol connection to a Mevo+ device.

Generic over S: Read + Write so callers can use any stream type. For non-blocking usage, configure the stream’s read timeout externally and call recv() — it returns Ok(None) on WouldBlock/TimedOut instead of blocking.

Example (TcpStream)

use std::time::Duration;
use ironsight::{BinaryConnection, ConnError};

let mut conn = BinaryConnection::connect(ironsight::conn::DEFAULT_ADDR)?;
conn.stream_mut().set_read_timeout(Some(Duration::from_millis(100)))?;
loop {
    match conn.recv()? {
        Some(env) => println!("{:?}", env.message),
        None => { /* send keepalive */ }
    }
}

Implementations

impl<S: Read + Write> BinaryConnection<S>

pub fn new(stream: S) -> Self

Wrap any Read + Write stream as a binary protocol connection.

pub fn stream(&self) -> &S

Borrow the underlying stream (e.g. to query peer address).

pub fn stream_mut(&mut self) -> &mut S

Mutably borrow the underlying stream (e.g. to set read timeout).

Examples found in repository

examples/event_loop.rs (line 183)

fn run() -> Result<(), ConnError> {
    // 1. Connect
    let addr: SocketAddr = DEFAULT_ADDR.parse().unwrap();
    println!("Connecting to {addr}...");
    let mut conn = BinaryConnection::connect_timeout(&addr, Duration::from_secs(5))?;
    println!("Connected.");

    // Wire-level trace callbacks.
    conn.set_on_send(|cmd, dest| println!("\n>> {:?} [{}]", cmd, cmd.debug_hex(dest)));
    conn.set_on_recv(|env| println!("\n<< {env:?}"));

    // 2. Handshake (blocking via drive())
    println!("DSP sync...");
    let dsp = seq::sync_dsp(&mut conn)?;
    println!("AVR sync...");
    let avr = seq::sync_avr(&mut conn)?;
    println!("PI sync...");
    let pi = seq::sync_pi(&mut conn)?;
    print_handshake(&dsp, &avr, &pi);

    // 3. Configure
    let settings = default_avr_settings();
    println!(
        "Configuring... mode=Outdoor ball=RCT range={}mm height={}mm",
        settings.radar_cal.range_mm, settings.radar_cal.height_mm,
    );
    seq::configure_avr(&mut conn, &settings)?;
    seq::configure_camera(&mut conn, &default_cam_config())?;

    // 4. Arm
    seq::arm(&mut conn)?;
    println!("=== ARMED — waiting for shots ===");

    // 5. Non-blocking event loop
    conn.stream_mut()
        .set_read_timeout(Some(Duration::from_millis(1)))?;
    let mut last_keepalive = Instant::now();
    let mut shot: Option<ShotSequencer> = None;

    loop {
        if let Some(env) = conn.recv()? {
            // If a shot sequence is active, feed it first.
            if let Some(ref mut s) = shot {
                let actions = s.feed(&env);
                for a in actions {
                    send_action(&mut conn, a)?;
                }
                if s.is_complete() {
                    let data = shot.take().unwrap().into_result();
                    print_shot(&data);
                    continue;
                }
            }

            // Handle messages not consumed by the shot sequencer.
            match &env.message {
                Message::ShotText(st) if st.is_processed() && shot.is_none() => {
                    println!("  Shot processed — starting shot sequence...");
                    let (s, actions) = ShotSequencer::new();
                    for a in actions {
                        send_action(&mut conn, a)?;
                    }
                    shot = Some(s);
                }

                // --- Flight result (primary) ---
                Message::FlightResult(r) => {
                    println!("  Flight result (shot #{}):", r.total);
                    println!(
                        "    Ball speed: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.launch_speed),
                        r.launch_elevation,
                        r.launch_azimuth,
                    );
                    println!(
                        "    Carry: {:.1} yd  Total: {:.1} yd  Height: {:.1} ft",
                        m_to_yd(r.carry_distance),
                        m_to_yd(r.total_distance),
                        m_to_ft(r.max_height),
                    );
                    println!(
                        "    Backspin: {} rpm  Sidespin: {} rpm",
                        r.backspin_rpm, r.sidespin_rpm,
                    );
                    println!(
                        "    Club speed: {:.1} mph  Path: {:.1}°  AoA: {:.1}°",
                        ms_to_mph(r.clubhead_speed),
                        r.club_strike_direction,
                        r.club_attack_angle,
                    );
                    println!(
                        "    Face: {:.1}°  Loft: {:.1}°",
                        r.club_face_angle, r.club_effective_loft,
                    );
                }

                // --- Flight result v1 (early) ---
                Message::FlightResultV1(r) => {
                    println!("  Flight result v1 (shot #{}):", r.total);
                    println!(
                        "    Ball: {:.1} mph  Club: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.ball_velocity),
                        ms_to_mph(r.club_velocity),
                        r.elevation,
                        r.azimuth,
                    );
                    println!(
                        "    Dist: {:.1} yd  Height: {:.1} ft  Backspin: {} rpm",
                        m_to_yd(r.distance),
                        m_to_ft(r.height),
                        r.backspin_rpm,
                    );
                }

                // --- Club result ---
                Message::ClubResult(r) => {
                    println!("  Club result:");
                    println!(
                        "    Club speed: {:.1} mph (pre) / {:.1} mph (post)  Smash: {:.2}",
                        ms_to_mph(r.pre_club_speed),
                        ms_to_mph(r.post_club_speed),
                        r.smash_factor,
                    );
                    println!(
                        "    Path: {:.1}°  Face: {:.1}°  AoA: {:.1}°  Loft: {:.1}°",
                        r.strike_direction, r.face_angle, r.attack_angle, r.dynamic_loft,
                    );
                    println!(
                        "    Low point: {:.1} in  Club height: {:.1} in",
                        m_to_in(r.club_offset),
                        m_to_in(r.club_height),
                    );
                }

                // --- Spin result ---
                Message::SpinResult(r) => {
                    println!("  Spin result:");
                    println!(
                        "    Total spin: {} rpm (PM final)  Axis: {:.1}°  Method: {}",
                        r.pm_spin_final, r.spin_axis, r.spin_method,
                    );
                    println!(
                        "    AM: {} rpm  PM: {} rpm  Launch: {} rpm  AOD: {} rpm  PLL: {} rpm",
                        r.am_spin, r.pm_spin, r.launch_spin, r.aod_spin, r.pll_spin,
                    );
                }

                // --- Speed profile ---
                Message::SpeedProfile(r) => {
                    let peak = r.speeds.iter().copied().fold(0.0_f64, f64::max);
                    println!(
                        "  Speed profile: {} samples ({}+{})  peak: {:.1} mph",
                        r.speeds.len(),
                        r.num_pre,
                        r.num_post,
                        ms_to_mph(peak),
                    );
                }

                // --- Tracking status ---
                Message::TrackingStatus(r) => {
                    println!(
                        "  Tracking: iter={} quality={} prc_count={} trigger_idx={}",
                        r.processing_iteration,
                        r.result_quality,
                        r.prc_tracking_count,
                        r.trigger_idx,
                    );
                }

                // --- PRC data ---
                Message::PrcData(r) => {
                    println!("  PRC: seq={} points={}", r.sequence, r.points.len());
                }

                // --- Club PRC data ---
                Message::ClubPrc(r) => {
                    println!("  Club PRC: points={}", r.points.len());
                }

                // --- Camera image available ---
                Message::CamImageAvail(r) => {
                    println!(
                        "  Camera: streaming={} fusion={} video={}",
                        r.streaming_available, r.fusion_available, r.video_available,
                    );
                }

                // --- DspStatus from keepalive ---
                Message::DspStatus(s) => {
                    println!(
                        "[keepalive] battery={}%{}  temp={:.1}°C",
                        s.battery_percent(),
                        if s.external_power() {
                            " (plugged in)"
                        } else {
                            ""
                        },
                        s.temperature_c(),
                    );
                }
                Message::AvrStatus(s) => {
                    println!("[keepalive] tilt={:.1}° roll={:.1}°", s.tilt, -s.roll);
                }

                // --- Config ack / noise ---
                Message::ConfigAck(_) | Message::PiStatus(_) => {}

                // --- Everything else: debug line is enough ---
                _ => {}
            }
        }

        // Heartbeats always fire — even during shot sequencing.
        if last_keepalive.elapsed() >= Duration::from_secs(1) {
            for a in seq::keepalive_actions() {
                send_action(&mut conn, a)?;
            }
            last_keepalive = Instant::now();
        }
    }
}

pub fn set_on_send(&mut self, f: impl FnMut(&Command, BusAddr) + 'static)

Register a callback invoked at the top of every send() call.

Examples found in repository

examples/event_loop.rs (line 157)

fn run() -> Result<(), ConnError> {
    // 1. Connect
    let addr: SocketAddr = DEFAULT_ADDR.parse().unwrap();
    println!("Connecting to {addr}...");
    let mut conn = BinaryConnection::connect_timeout(&addr, Duration::from_secs(5))?;
    println!("Connected.");

    // Wire-level trace callbacks.
    conn.set_on_send(|cmd, dest| println!("\n>> {:?} [{}]", cmd, cmd.debug_hex(dest)));
    conn.set_on_recv(|env| println!("\n<< {env:?}"));

    // 2. Handshake (blocking via drive())
    println!("DSP sync...");
    let dsp = seq::sync_dsp(&mut conn)?;
    println!("AVR sync...");
    let avr = seq::sync_avr(&mut conn)?;
    println!("PI sync...");
    let pi = seq::sync_pi(&mut conn)?;
    print_handshake(&dsp, &avr, &pi);

    // 3. Configure
    let settings = default_avr_settings();
    println!(
        "Configuring... mode=Outdoor ball=RCT range={}mm height={}mm",
        settings.radar_cal.range_mm, settings.radar_cal.height_mm,
    );
    seq::configure_avr(&mut conn, &settings)?;
    seq::configure_camera(&mut conn, &default_cam_config())?;

    // 4. Arm
    seq::arm(&mut conn)?;
    println!("=== ARMED — waiting for shots ===");

    // 5. Non-blocking event loop
    conn.stream_mut()
        .set_read_timeout(Some(Duration::from_millis(1)))?;
    let mut last_keepalive = Instant::now();
    let mut shot: Option<ShotSequencer> = None;

    loop {
        if let Some(env) = conn.recv()? {
            // If a shot sequence is active, feed it first.
            if let Some(ref mut s) = shot {
                let actions = s.feed(&env);
                for a in actions {
                    send_action(&mut conn, a)?;
                }
                if s.is_complete() {
                    let data = shot.take().unwrap().into_result();
                    print_shot(&data);
                    continue;
                }
            }

            // Handle messages not consumed by the shot sequencer.
            match &env.message {
                Message::ShotText(st) if st.is_processed() && shot.is_none() => {
                    println!("  Shot processed — starting shot sequence...");
                    let (s, actions) = ShotSequencer::new();
                    for a in actions {
                        send_action(&mut conn, a)?;
                    }
                    shot = Some(s);
                }

                // --- Flight result (primary) ---
                Message::FlightResult(r) => {
                    println!("  Flight result (shot #{}):", r.total);
                    println!(
                        "    Ball speed: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.launch_speed),
                        r.launch_elevation,
                        r.launch_azimuth,
                    );
                    println!(
                        "    Carry: {:.1} yd  Total: {:.1} yd  Height: {:.1} ft",
                        m_to_yd(r.carry_distance),
                        m_to_yd(r.total_distance),
                        m_to_ft(r.max_height),
                    );
                    println!(
                        "    Backspin: {} rpm  Sidespin: {} rpm",
                        r.backspin_rpm, r.sidespin_rpm,
                    );
                    println!(
                        "    Club speed: {:.1} mph  Path: {:.1}°  AoA: {:.1}°",
                        ms_to_mph(r.clubhead_speed),
                        r.club_strike_direction,
                        r.club_attack_angle,
                    );
                    println!(
                        "    Face: {:.1}°  Loft: {:.1}°",
                        r.club_face_angle, r.club_effective_loft,
                    );
                }

                // --- Flight result v1 (early) ---
                Message::FlightResultV1(r) => {
                    println!("  Flight result v1 (shot #{}):", r.total);
                    println!(
                        "    Ball: {:.1} mph  Club: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.ball_velocity),
                        ms_to_mph(r.club_velocity),
                        r.elevation,
                        r.azimuth,
                    );
                    println!(
                        "    Dist: {:.1} yd  Height: {:.1} ft  Backspin: {} rpm",
                        m_to_yd(r.distance),
                        m_to_ft(r.height),
                        r.backspin_rpm,
                    );
                }

                // --- Club result ---
                Message::ClubResult(r) => {
                    println!("  Club result:");
                    println!(
                        "    Club speed: {:.1} mph (pre) / {:.1} mph (post)  Smash: {:.2}",
                        ms_to_mph(r.pre_club_speed),
                        ms_to_mph(r.post_club_speed),
                        r.smash_factor,
                    );
                    println!(
                        "    Path: {:.1}°  Face: {:.1}°  AoA: {:.1}°  Loft: {:.1}°",
                        r.strike_direction, r.face_angle, r.attack_angle, r.dynamic_loft,
                    );
                    println!(
                        "    Low point: {:.1} in  Club height: {:.1} in",
                        m_to_in(r.club_offset),
                        m_to_in(r.club_height),
                    );
                }

                // --- Spin result ---
                Message::SpinResult(r) => {
                    println!("  Spin result:");
                    println!(
                        "    Total spin: {} rpm (PM final)  Axis: {:.1}°  Method: {}",
                        r.pm_spin_final, r.spin_axis, r.spin_method,
                    );
                    println!(
                        "    AM: {} rpm  PM: {} rpm  Launch: {} rpm  AOD: {} rpm  PLL: {} rpm",
                        r.am_spin, r.pm_spin, r.launch_spin, r.aod_spin, r.pll_spin,
                    );
                }

                // --- Speed profile ---
                Message::SpeedProfile(r) => {
                    let peak = r.speeds.iter().copied().fold(0.0_f64, f64::max);
                    println!(
                        "  Speed profile: {} samples ({}+{})  peak: {:.1} mph",
                        r.speeds.len(),
                        r.num_pre,
                        r.num_post,
                        ms_to_mph(peak),
                    );
                }

                // --- Tracking status ---
                Message::TrackingStatus(r) => {
                    println!(
                        "  Tracking: iter={} quality={} prc_count={} trigger_idx={}",
                        r.processing_iteration,
                        r.result_quality,
                        r.prc_tracking_count,
                        r.trigger_idx,
                    );
                }

                // --- PRC data ---
                Message::PrcData(r) => {
                    println!("  PRC: seq={} points={}", r.sequence, r.points.len());
                }

                // --- Club PRC data ---
                Message::ClubPrc(r) => {
                    println!("  Club PRC: points={}", r.points.len());
                }

                // --- Camera image available ---
                Message::CamImageAvail(r) => {
                    println!(
                        "  Camera: streaming={} fusion={} video={}",
                        r.streaming_available, r.fusion_available, r.video_available,
                    );
                }

                // --- DspStatus from keepalive ---
                Message::DspStatus(s) => {
                    println!(
                        "[keepalive] battery={}%{}  temp={:.1}°C",
                        s.battery_percent(),
                        if s.external_power() {
                            " (plugged in)"
                        } else {
                            ""
                        },
                        s.temperature_c(),
                    );
                }
                Message::AvrStatus(s) => {
                    println!("[keepalive] tilt={:.1}° roll={:.1}°", s.tilt, -s.roll);
                }

                // --- Config ack / noise ---
                Message::ConfigAck(_) | Message::PiStatus(_) => {}

                // --- Everything else: debug line is enough ---
                _ => {}
            }
        }

        // Heartbeats always fire — even during shot sequencing.
        if last_keepalive.elapsed() >= Duration::from_secs(1) {
            for a in seq::keepalive_actions() {
                send_action(&mut conn, a)?;
            }
            last_keepalive = Instant::now();
        }
    }
}

pub fn set_on_recv(&mut self, f: impl FnMut(&Envelope) + 'static)

Register a callback invoked after every successful frame decode.

Examples found in repository

examples/event_loop.rs (line 158)

fn run() -> Result<(), ConnError> {
    // 1. Connect
    let addr: SocketAddr = DEFAULT_ADDR.parse().unwrap();
    println!("Connecting to {addr}...");
    let mut conn = BinaryConnection::connect_timeout(&addr, Duration::from_secs(5))?;
    println!("Connected.");

    // Wire-level trace callbacks.
    conn.set_on_send(|cmd, dest| println!("\n>> {:?} [{}]", cmd, cmd.debug_hex(dest)));
    conn.set_on_recv(|env| println!("\n<< {env:?}"));

    // 2. Handshake (blocking via drive())
    println!("DSP sync...");
    let dsp = seq::sync_dsp(&mut conn)?;
    println!("AVR sync...");
    let avr = seq::sync_avr(&mut conn)?;
    println!("PI sync...");
    let pi = seq::sync_pi(&mut conn)?;
    print_handshake(&dsp, &avr, &pi);

    // 3. Configure
    let settings = default_avr_settings();
    println!(
        "Configuring... mode=Outdoor ball=RCT range={}mm height={}mm",
        settings.radar_cal.range_mm, settings.radar_cal.height_mm,
    );
    seq::configure_avr(&mut conn, &settings)?;
    seq::configure_camera(&mut conn, &default_cam_config())?;

    // 4. Arm
    seq::arm(&mut conn)?;
    println!("=== ARMED — waiting for shots ===");

    // 5. Non-blocking event loop
    conn.stream_mut()
        .set_read_timeout(Some(Duration::from_millis(1)))?;
    let mut last_keepalive = Instant::now();
    let mut shot: Option<ShotSequencer> = None;

    loop {
        if let Some(env) = conn.recv()? {
            // If a shot sequence is active, feed it first.
            if let Some(ref mut s) = shot {
                let actions = s.feed(&env);
                for a in actions {
                    send_action(&mut conn, a)?;
                }
                if s.is_complete() {
                    let data = shot.take().unwrap().into_result();
                    print_shot(&data);
                    continue;
                }
            }

            // Handle messages not consumed by the shot sequencer.
            match &env.message {
                Message::ShotText(st) if st.is_processed() && shot.is_none() => {
                    println!("  Shot processed — starting shot sequence...");
                    let (s, actions) = ShotSequencer::new();
                    for a in actions {
                        send_action(&mut conn, a)?;
                    }
                    shot = Some(s);
                }

                // --- Flight result (primary) ---
                Message::FlightResult(r) => {
                    println!("  Flight result (shot #{}):", r.total);
                    println!(
                        "    Ball speed: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.launch_speed),
                        r.launch_elevation,
                        r.launch_azimuth,
                    );
                    println!(
                        "    Carry: {:.1} yd  Total: {:.1} yd  Height: {:.1} ft",
                        m_to_yd(r.carry_distance),
                        m_to_yd(r.total_distance),
                        m_to_ft(r.max_height),
                    );
                    println!(
                        "    Backspin: {} rpm  Sidespin: {} rpm",
                        r.backspin_rpm, r.sidespin_rpm,
                    );
                    println!(
                        "    Club speed: {:.1} mph  Path: {:.1}°  AoA: {:.1}°",
                        ms_to_mph(r.clubhead_speed),
                        r.club_strike_direction,
                        r.club_attack_angle,
                    );
                    println!(
                        "    Face: {:.1}°  Loft: {:.1}°",
                        r.club_face_angle, r.club_effective_loft,
                    );
                }

                // --- Flight result v1 (early) ---
                Message::FlightResultV1(r) => {
                    println!("  Flight result v1 (shot #{}):", r.total);
                    println!(
                        "    Ball: {:.1} mph  Club: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.ball_velocity),
                        ms_to_mph(r.club_velocity),
                        r.elevation,
                        r.azimuth,
                    );
                    println!(
                        "    Dist: {:.1} yd  Height: {:.1} ft  Backspin: {} rpm",
                        m_to_yd(r.distance),
                        m_to_ft(r.height),
                        r.backspin_rpm,
                    );
                }

                // --- Club result ---
                Message::ClubResult(r) => {
                    println!("  Club result:");
                    println!(
                        "    Club speed: {:.1} mph (pre) / {:.1} mph (post)  Smash: {:.2}",
                        ms_to_mph(r.pre_club_speed),
                        ms_to_mph(r.post_club_speed),
                        r.smash_factor,
                    );
                    println!(
                        "    Path: {:.1}°  Face: {:.1}°  AoA: {:.1}°  Loft: {:.1}°",
                        r.strike_direction, r.face_angle, r.attack_angle, r.dynamic_loft,
                    );
                    println!(
                        "    Low point: {:.1} in  Club height: {:.1} in",
                        m_to_in(r.club_offset),
                        m_to_in(r.club_height),
                    );
                }

                // --- Spin result ---
                Message::SpinResult(r) => {
                    println!("  Spin result:");
                    println!(
                        "    Total spin: {} rpm (PM final)  Axis: {:.1}°  Method: {}",
                        r.pm_spin_final, r.spin_axis, r.spin_method,
                    );
                    println!(
                        "    AM: {} rpm  PM: {} rpm  Launch: {} rpm  AOD: {} rpm  PLL: {} rpm",
                        r.am_spin, r.pm_spin, r.launch_spin, r.aod_spin, r.pll_spin,
                    );
                }

                // --- Speed profile ---
                Message::SpeedProfile(r) => {
                    let peak = r.speeds.iter().copied().fold(0.0_f64, f64::max);
                    println!(
                        "  Speed profile: {} samples ({}+{})  peak: {:.1} mph",
                        r.speeds.len(),
                        r.num_pre,
                        r.num_post,
                        ms_to_mph(peak),
                    );
                }

                // --- Tracking status ---
                Message::TrackingStatus(r) => {
                    println!(
                        "  Tracking: iter={} quality={} prc_count={} trigger_idx={}",
                        r.processing_iteration,
                        r.result_quality,
                        r.prc_tracking_count,
                        r.trigger_idx,
                    );
                }

                // --- PRC data ---
                Message::PrcData(r) => {
                    println!("  PRC: seq={} points={}", r.sequence, r.points.len());
                }

                // --- Club PRC data ---
                Message::ClubPrc(r) => {
                    println!("  Club PRC: points={}", r.points.len());
                }

                // --- Camera image available ---
                Message::CamImageAvail(r) => {
                    println!(
                        "  Camera: streaming={} fusion={} video={}",
                        r.streaming_available, r.fusion_available, r.video_available,
                    );
                }

                // --- DspStatus from keepalive ---
                Message::DspStatus(s) => {
                    println!(
                        "[keepalive] battery={}%{}  temp={:.1}°C",
                        s.battery_percent(),
                        if s.external_power() {
                            " (plugged in)"
                        } else {
                            ""
                        },
                        s.temperature_c(),
                    );
                }
                Message::AvrStatus(s) => {
                    println!("[keepalive] tilt={:.1}° roll={:.1}°", s.tilt, -s.roll);
                }

                // --- Config ack / noise ---
                Message::ConfigAck(_) | Message::PiStatus(_) => {}

                // --- Everything else: debug line is enough ---
                _ => {}
            }
        }

        // Heartbeats always fire — even during shot sequencing.
        if last_keepalive.elapsed() >= Duration::from_secs(1) {
            for a in seq::keepalive_actions() {
                send_action(&mut conn, a)?;
            }
            last_keepalive = Instant::now();
        }
    }
}

pub fn send(&mut self, cmd: &Command, dest: BusAddr) -> Result<(), ConnError>

Send a command to the given bus address.

pub fn send_raw(&mut self, frame: &RawFrame) -> Result<(), ConnError>

Send a pre-built raw frame (for messages not in Command, e.g. ClubPrc::encode_request()).

pub fn recv(&mut self) -> Result<Option<Envelope>, ConnError>

Try to receive the next complete frame.

• Ok(Some(env)) — decoded message.
• Ok(None) — no data available (WouldBlock/TimedOut from stream).
• Err(Disconnected) — stream closed by peer.
• Err(Wire|Io) — decode or I/O error.

The stream’s read timeout controls whether this blocks or returns Ok(None) immediately. Set the timeout on the stream before calling.

Examples found in repository

examples/event_loop.rs (line 189)

fn run() -> Result<(), ConnError> {
    // 1. Connect
    let addr: SocketAddr = DEFAULT_ADDR.parse().unwrap();
    println!("Connecting to {addr}...");
    let mut conn = BinaryConnection::connect_timeout(&addr, Duration::from_secs(5))?;
    println!("Connected.");

    // Wire-level trace callbacks.
    conn.set_on_send(|cmd, dest| println!("\n>> {:?} [{}]", cmd, cmd.debug_hex(dest)));
    conn.set_on_recv(|env| println!("\n<< {env:?}"));

    // 2. Handshake (blocking via drive())
    println!("DSP sync...");
    let dsp = seq::sync_dsp(&mut conn)?;
    println!("AVR sync...");
    let avr = seq::sync_avr(&mut conn)?;
    println!("PI sync...");
    let pi = seq::sync_pi(&mut conn)?;
    print_handshake(&dsp, &avr, &pi);

    // 3. Configure
    let settings = default_avr_settings();
    println!(
        "Configuring... mode=Outdoor ball=RCT range={}mm height={}mm",
        settings.radar_cal.range_mm, settings.radar_cal.height_mm,
    );
    seq::configure_avr(&mut conn, &settings)?;
    seq::configure_camera(&mut conn, &default_cam_config())?;

    // 4. Arm
    seq::arm(&mut conn)?;
    println!("=== ARMED — waiting for shots ===");

    // 5. Non-blocking event loop
    conn.stream_mut()
        .set_read_timeout(Some(Duration::from_millis(1)))?;
    let mut last_keepalive = Instant::now();
    let mut shot: Option<ShotSequencer> = None;

    loop {
        if let Some(env) = conn.recv()? {
            // If a shot sequence is active, feed it first.
            if let Some(ref mut s) = shot {
                let actions = s.feed(&env);
                for a in actions {
                    send_action(&mut conn, a)?;
                }
                if s.is_complete() {
                    let data = shot.take().unwrap().into_result();
                    print_shot(&data);
                    continue;
                }
            }

            // Handle messages not consumed by the shot sequencer.
            match &env.message {
                Message::ShotText(st) if st.is_processed() && shot.is_none() => {
                    println!("  Shot processed — starting shot sequence...");
                    let (s, actions) = ShotSequencer::new();
                    for a in actions {
                        send_action(&mut conn, a)?;
                    }
                    shot = Some(s);
                }

                // --- Flight result (primary) ---
                Message::FlightResult(r) => {
                    println!("  Flight result (shot #{}):", r.total);
                    println!(
                        "    Ball speed: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.launch_speed),
                        r.launch_elevation,
                        r.launch_azimuth,
                    );
                    println!(
                        "    Carry: {:.1} yd  Total: {:.1} yd  Height: {:.1} ft",
                        m_to_yd(r.carry_distance),
                        m_to_yd(r.total_distance),
                        m_to_ft(r.max_height),
                    );
                    println!(
                        "    Backspin: {} rpm  Sidespin: {} rpm",
                        r.backspin_rpm, r.sidespin_rpm,
                    );
                    println!(
                        "    Club speed: {:.1} mph  Path: {:.1}°  AoA: {:.1}°",
                        ms_to_mph(r.clubhead_speed),
                        r.club_strike_direction,
                        r.club_attack_angle,
                    );
                    println!(
                        "    Face: {:.1}°  Loft: {:.1}°",
                        r.club_face_angle, r.club_effective_loft,
                    );
                }

                // --- Flight result v1 (early) ---
                Message::FlightResultV1(r) => {
                    println!("  Flight result v1 (shot #{}):", r.total);
                    println!(
                        "    Ball: {:.1} mph  Club: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.ball_velocity),
                        ms_to_mph(r.club_velocity),
                        r.elevation,
                        r.azimuth,
                    );
                    println!(
                        "    Dist: {:.1} yd  Height: {:.1} ft  Backspin: {} rpm",
                        m_to_yd(r.distance),
                        m_to_ft(r.height),
                        r.backspin_rpm,
                    );
                }

                // --- Club result ---
                Message::ClubResult(r) => {
                    println!("  Club result:");
                    println!(
                        "    Club speed: {:.1} mph (pre) / {:.1} mph (post)  Smash: {:.2}",
                        ms_to_mph(r.pre_club_speed),
                        ms_to_mph(r.post_club_speed),
                        r.smash_factor,
                    );
                    println!(
                        "    Path: {:.1}°  Face: {:.1}°  AoA: {:.1}°  Loft: {:.1}°",
                        r.strike_direction, r.face_angle, r.attack_angle, r.dynamic_loft,
                    );
                    println!(
                        "    Low point: {:.1} in  Club height: {:.1} in",
                        m_to_in(r.club_offset),
                        m_to_in(r.club_height),
                    );
                }

                // --- Spin result ---
                Message::SpinResult(r) => {
                    println!("  Spin result:");
                    println!(
                        "    Total spin: {} rpm (PM final)  Axis: {:.1}°  Method: {}",
                        r.pm_spin_final, r.spin_axis, r.spin_method,
                    );
                    println!(
                        "    AM: {} rpm  PM: {} rpm  Launch: {} rpm  AOD: {} rpm  PLL: {} rpm",
                        r.am_spin, r.pm_spin, r.launch_spin, r.aod_spin, r.pll_spin,
                    );
                }

                // --- Speed profile ---
                Message::SpeedProfile(r) => {
                    let peak = r.speeds.iter().copied().fold(0.0_f64, f64::max);
                    println!(
                        "  Speed profile: {} samples ({}+{})  peak: {:.1} mph",
                        r.speeds.len(),
                        r.num_pre,
                        r.num_post,
                        ms_to_mph(peak),
                    );
                }

                // --- Tracking status ---
                Message::TrackingStatus(r) => {
                    println!(
                        "  Tracking: iter={} quality={} prc_count={} trigger_idx={}",
                        r.processing_iteration,
                        r.result_quality,
                        r.prc_tracking_count,
                        r.trigger_idx,
                    );
                }

                // --- PRC data ---
                Message::PrcData(r) => {
                    println!("  PRC: seq={} points={}", r.sequence, r.points.len());
                }

                // --- Club PRC data ---
                Message::ClubPrc(r) => {
                    println!("  Club PRC: points={}", r.points.len());
                }

                // --- Camera image available ---
                Message::CamImageAvail(r) => {
                    println!(
                        "  Camera: streaming={} fusion={} video={}",
                        r.streaming_available, r.fusion_available, r.video_available,
                    );
                }

                // --- DspStatus from keepalive ---
                Message::DspStatus(s) => {
                    println!(
                        "[keepalive] battery={}%{}  temp={:.1}°C",
                        s.battery_percent(),
                        if s.external_power() {
                            " (plugged in)"
                        } else {
                            ""
                        },
                        s.temperature_c(),
                    );
                }
                Message::AvrStatus(s) => {
                    println!("[keepalive] tilt={:.1}° roll={:.1}°", s.tilt, -s.roll);
                }

                // --- Config ack / noise ---
                Message::ConfigAck(_) | Message::PiStatus(_) => {}

                // --- Everything else: debug line is enough ---
                _ => {}
            }
        }

        // Heartbeats always fire — even during shot sequencing.
        if last_keepalive.elapsed() >= Duration::from_secs(1) {
            for a in seq::keepalive_actions() {
                send_action(&mut conn, a)?;
            }
            last_keepalive = Instant::now();
        }
    }
}

impl BinaryConnection<TcpStream>

pub fn connect(addr: impl ToSocketAddrs) -> Result<Self, ConnError>

Connect to a Mevo+ device with the system default timeout.

pub fn connect_timeout( addr: &SocketAddr, timeout: Duration, ) -> Result<Self, ConnError>

Connect with an explicit timeout.

Examples found in repository

examples/event_loop.rs (line 153)

fn run() -> Result<(), ConnError> {
    // 1. Connect
    let addr: SocketAddr = DEFAULT_ADDR.parse().unwrap();
    println!("Connecting to {addr}...");
    let mut conn = BinaryConnection::connect_timeout(&addr, Duration::from_secs(5))?;
    println!("Connected.");

    // Wire-level trace callbacks.
    conn.set_on_send(|cmd, dest| println!("\n>> {:?} [{}]", cmd, cmd.debug_hex(dest)));
    conn.set_on_recv(|env| println!("\n<< {env:?}"));

    // 2. Handshake (blocking via drive())
    println!("DSP sync...");
    let dsp = seq::sync_dsp(&mut conn)?;
    println!("AVR sync...");
    let avr = seq::sync_avr(&mut conn)?;
    println!("PI sync...");
    let pi = seq::sync_pi(&mut conn)?;
    print_handshake(&dsp, &avr, &pi);

    // 3. Configure
    let settings = default_avr_settings();
    println!(
        "Configuring... mode=Outdoor ball=RCT range={}mm height={}mm",
        settings.radar_cal.range_mm, settings.radar_cal.height_mm,
    );
    seq::configure_avr(&mut conn, &settings)?;
    seq::configure_camera(&mut conn, &default_cam_config())?;

    // 4. Arm
    seq::arm(&mut conn)?;
    println!("=== ARMED — waiting for shots ===");

    // 5. Non-blocking event loop
    conn.stream_mut()
        .set_read_timeout(Some(Duration::from_millis(1)))?;
    let mut last_keepalive = Instant::now();
    let mut shot: Option<ShotSequencer> = None;

    loop {
        if let Some(env) = conn.recv()? {
            // If a shot sequence is active, feed it first.
            if let Some(ref mut s) = shot {
                let actions = s.feed(&env);
                for a in actions {
                    send_action(&mut conn, a)?;
                }
                if s.is_complete() {
                    let data = shot.take().unwrap().into_result();
                    print_shot(&data);
                    continue;
                }
            }

            // Handle messages not consumed by the shot sequencer.
            match &env.message {
                Message::ShotText(st) if st.is_processed() && shot.is_none() => {
                    println!("  Shot processed — starting shot sequence...");
                    let (s, actions) = ShotSequencer::new();
                    for a in actions {
                        send_action(&mut conn, a)?;
                    }
                    shot = Some(s);
                }

                // --- Flight result (primary) ---
                Message::FlightResult(r) => {
                    println!("  Flight result (shot #{}):", r.total);
                    println!(
                        "    Ball speed: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.launch_speed),
                        r.launch_elevation,
                        r.launch_azimuth,
                    );
                    println!(
                        "    Carry: {:.1} yd  Total: {:.1} yd  Height: {:.1} ft",
                        m_to_yd(r.carry_distance),
                        m_to_yd(r.total_distance),
                        m_to_ft(r.max_height),
                    );
                    println!(
                        "    Backspin: {} rpm  Sidespin: {} rpm",
                        r.backspin_rpm, r.sidespin_rpm,
                    );
                    println!(
                        "    Club speed: {:.1} mph  Path: {:.1}°  AoA: {:.1}°",
                        ms_to_mph(r.clubhead_speed),
                        r.club_strike_direction,
                        r.club_attack_angle,
                    );
                    println!(
                        "    Face: {:.1}°  Loft: {:.1}°",
                        r.club_face_angle, r.club_effective_loft,
                    );
                }

                // --- Flight result v1 (early) ---
                Message::FlightResultV1(r) => {
                    println!("  Flight result v1 (shot #{}):", r.total);
                    println!(
                        "    Ball: {:.1} mph  Club: {:.1} mph  VLA: {:.1}°  HLA: {:.1}°",
                        ms_to_mph(r.ball_velocity),
                        ms_to_mph(r.club_velocity),
                        r.elevation,
                        r.azimuth,
                    );
                    println!(
                        "    Dist: {:.1} yd  Height: {:.1} ft  Backspin: {} rpm",
                        m_to_yd(r.distance),
                        m_to_ft(r.height),
                        r.backspin_rpm,
                    );
                }

                // --- Club result ---
                Message::ClubResult(r) => {
                    println!("  Club result:");
                    println!(
                        "    Club speed: {:.1} mph (pre) / {:.1} mph (post)  Smash: {:.2}",
                        ms_to_mph(r.pre_club_speed),
                        ms_to_mph(r.post_club_speed),
                        r.smash_factor,
                    );
                    println!(
                        "    Path: {:.1}°  Face: {:.1}°  AoA: {:.1}°  Loft: {:.1}°",
                        r.strike_direction, r.face_angle, r.attack_angle, r.dynamic_loft,
                    );
                    println!(
                        "    Low point: {:.1} in  Club height: {:.1} in",
                        m_to_in(r.club_offset),
                        m_to_in(r.club_height),
                    );
                }

                // --- Spin result ---
                Message::SpinResult(r) => {
                    println!("  Spin result:");
                    println!(
                        "    Total spin: {} rpm (PM final)  Axis: {:.1}°  Method: {}",
                        r.pm_spin_final, r.spin_axis, r.spin_method,
                    );
                    println!(
                        "    AM: {} rpm  PM: {} rpm  Launch: {} rpm  AOD: {} rpm  PLL: {} rpm",
                        r.am_spin, r.pm_spin, r.launch_spin, r.aod_spin, r.pll_spin,
                    );
                }

                // --- Speed profile ---
                Message::SpeedProfile(r) => {
                    let peak = r.speeds.iter().copied().fold(0.0_f64, f64::max);
                    println!(
                        "  Speed profile: {} samples ({}+{})  peak: {:.1} mph",
                        r.speeds.len(),
                        r.num_pre,
                        r.num_post,
                        ms_to_mph(peak),
                    );
                }

                // --- Tracking status ---
                Message::TrackingStatus(r) => {
                    println!(
                        "  Tracking: iter={} quality={} prc_count={} trigger_idx={}",
                        r.processing_iteration,
                        r.result_quality,
                        r.prc_tracking_count,
                        r.trigger_idx,
                    );
                }

                // --- PRC data ---
                Message::PrcData(r) => {
                    println!("  PRC: seq={} points={}", r.sequence, r.points.len());
                }

                // --- Club PRC data ---
                Message::ClubPrc(r) => {
                    println!("  Club PRC: points={}", r.points.len());
                }

                // --- Camera image available ---
                Message::CamImageAvail(r) => {
                    println!(
                        "  Camera: streaming={} fusion={} video={}",
                        r.streaming_available, r.fusion_available, r.video_available,
                    );
                }

                // --- DspStatus from keepalive ---
                Message::DspStatus(s) => {
                    println!(
                        "[keepalive] battery={}%{}  temp={:.1}°C",
                        s.battery_percent(),
                        if s.external_power() {
                            " (plugged in)"
                        } else {
                            ""
                        },
                        s.temperature_c(),
                    );
                }
                Message::AvrStatus(s) => {
                    println!("[keepalive] tilt={:.1}° roll={:.1}°", s.tilt, -s.roll);
                }

                // --- Config ack / noise ---
                Message::ConfigAck(_) | Message::PiStatus(_) => {}

                // --- Everything else: debug line is enough ---
                _ => {}
            }
        }

        // Heartbeats always fire — even during shot sequencing.
        if last_keepalive.elapsed() >= Duration::from_secs(1) {
            for a in seq::keepalive_actions() {
                send_action(&mut conn, a)?;
            }
            last_keepalive = Instant::now();
        }
    }
}

pub fn peer_addr(&self) -> Result<SocketAddr, ConnError>

The peer address of the underlying TCP connection.

pub fn shutdown(&self) -> Result<(), ConnError>

Shut down the TCP connection.

pub fn recv_timeout(&mut self, timeout: Duration) -> Result<Envelope, ConnError>

Block up to timeout for a complete frame.

Returns ConnError::Timeout if no complete frame arrives in time.

This is a convenience wrapper for callers that prefer the old timeout-per-call style. Prefer setting the stream read timeout once and using recv() directly.