Function decode_sb

sniffer/src/main.rs:265–453

(cmd: u8, len: usize, d: &[u8])

// ---------------------------------------------------------------------------

fn decode_sb(cmd: u8, len: usize, d: &[u8]) -> SbCommand {
    let g = |i: usize| d.get(i).copied().unwrap_or(0);
    let tail = |from: usize| hbs(&d[from.min(d.len())..]);

    match cmd {
        // DeviceAck: 5a 02 0a [echoed_cmd] 00 [payload_echo...]
        0x02 => SbCommand::DeviceAck { echoed_cmd: hb(g(3)) },

        // DeviceIdentify
        0x05 if len == 0 => SbCommand::DeviceIdentifyRequest,
        0x05             => SbCommand::DeviceIdentifyResponse { flags: hb(g(3)) },

        // Ping: 5a 06 01 01
        0x06 => SbCommand::Ping,

        // GetFirmwareString
        0x07 if len == 1 => SbCommand::GetFirmwareStringRequest { typ: hb(g(3)) },
        0x07 => {
            let end = (3 + len).min(d.len());
            SbCommand::GetFirmwareStringResponse {
                firmware: String::from_utf8_lossy(&d[3..end]).into_owned(),
            }
        }

        // GetSerial
        0x10 if len == 0 => SbCommand::GetSerialRequest,
        0x10 => {
            let end = (3 + len).min(d.len());
            SbCommand::GetSerialResponse { serial: hbs(&d[3..end]) }
        }

        // Status: LEN=3 → request; LEN≥8 → response (count at d[3], features at d[5])
        0x11 if len == 3 => SbCommand::StatusRequest {
            family:     hb(g(4)),
            feature_id: hb(g(5)),
        },
        0x11 => {
            let count = g(3) as usize;
            let mut features = Vec::with_capacity(count);
            let mut off = 5;
            for _ in 0..count {
                if off + 6 <= d.len() {
                    features.push(feature_at(d, off));
                    off += 6;
                }
            }
            SbCommand::StatusResponse { features }
        }

        // WriteSingleFeature: 5a 12 07 01 [family] [feature_id] 00 [f32_LE×4]
        0x12 if len == 7 => {
            let feature = if d.len() >= 11 {
                feature_raw(g(4), g(5), [g(7), g(8), g(9), g(10)])
            } else {
                FeatureEntry { family: "?".into(), name: "?".into(), value: None }
            };
            SbCommand::WriteSingleFeature { feature }
        }