Enum DspStatus 

pub enum DspStatus {
    V80(DspStatus80),
    V46(DspStatus46),
}

DSP status response. Type 0xAA, SRC=0x40.

Two formats keyed by payload[0] (version byte):

• 0x80 (128): Gen1 Mevo+, 129 bytes. Fully decoded.
• 0x46 (70): Gen2 Mevo, 71 bytes. Field layout differs; raw bytes preserved.

Variants

V80(DspStatus80)

Gen1 Mevo+ (version 0x80, 129 bytes). All fields decoded.

V46(DspStatus46)

Gen2 Mevo (version 0x46, 71 bytes). Raw payload preserved until field mapping is done.

Implementations

impl DspStatus

pub fn decode(payload: &[u8]) -> Result<Self>

pub fn state(&self) -> u8

State byte (available on both variants).

pub fn battery_percent(&self) -> u8

Battery percentage (0-100). Returns 0 for Gen2 (field offsets TBD).

Examples found in repository

examples/event_loop.rs (line 125)

fn print_handshake(dsp: &DspSync, avr: &AvrSync, pi: &PiSync) {
    println!("--- Handshake complete ---");
    println!(
        "  DSP: type=0x{:02X} pcb={}",
        dsp.hw_info.dsp_type, dsp.hw_info.pcb
    );
    println!("  DSP info: {}", dsp.dev_info.text);
    println!("  AVR info: {}", avr.dev_info.text);
    println!(
        "  AVR tilt={:.1}° roll={:.1}°",
        avr.status.tilt, -avr.status.roll
    );
    println!("  PI info: {}", pi.dev_info.text);
    println!("  SSID: {}  password: {}", pi.ssid, pi.password);
    println!(
        "  Battery: {}%  {}",
        dsp.status.battery_percent(),
        if dsp.status.external_power() {
            "(plugged in)"
        } else {
            ""
        },
    );
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

fn main() {
    if let Err(e) = run() {
        eprintln!("error: {e}");
        process::exit(1);
    }
}

fn send_action(conn: &mut BinaryConnection<std::net::TcpStream>, action: Action) -> Result<(), ConnError> {
    seq::send_action(conn, action)
}

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 external_power(&self) -> bool

External power connected. Returns false for Gen2 (field offsets TBD).

Examples found in repository

examples/event_loop.rs (line 126)

fn print_handshake(dsp: &DspSync, avr: &AvrSync, pi: &PiSync) {
    println!("--- Handshake complete ---");
    println!(
        "  DSP: type=0x{:02X} pcb={}",
        dsp.hw_info.dsp_type, dsp.hw_info.pcb
    );
    println!("  DSP info: {}", dsp.dev_info.text);
    println!("  AVR info: {}", avr.dev_info.text);
    println!(
        "  AVR tilt={:.1}° roll={:.1}°",
        avr.status.tilt, -avr.status.roll
    );
    println!("  PI info: {}", pi.dev_info.text);
    println!("  SSID: {}  password: {}", pi.ssid, pi.password);
    println!(
        "  Battery: {}%  {}",
        dsp.status.battery_percent(),
        if dsp.status.external_power() {
            "(plugged in)"
        } else {
            ""
        },
    );
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

fn main() {
    if let Err(e) = run() {
        eprintln!("error: {e}");
        process::exit(1);
    }
}

fn send_action(conn: &mut BinaryConnection<std::net::TcpStream>, action: Action) -> Result<(), ConnError> {
    seq::send_action(conn, action)
}

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 temperature_c(&self) -> f64

Temperature in degrees C. Returns 0.0 for Gen2 (field offsets TBD).

Examples found in repository

examples/event_loop.rs (line 347)

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();
        }
    }
}

Trait Implementations

impl Clone for DspStatus

fn clone(&self) -> DspStatus

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DspStatus

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.