valentine

muxcheck.rs (4673B)

---

 //! Routing-write SAFETY probe (READ-ONLY — never writes to the device).
 //!
 //! Proves the mux encoder is trustworthy before we ever send a SET_MUX:
 //!   1. Read the device's current routing (GET_MUX).
 //!   2. Decode it into our MuxState (port-number model).
 //!   3. Re-encode all 3 sample-rate tables.
 //!   4. Read the routing AGAIN and confirm our re-encode, when decoded, matches
 //!      the device byte-for-byte at the entry level — i.e. writing our encoding
 //!      would be a no-op. If this passes, an actual edit-then-write is safe.
 //!
 //! Run with Focusrite Control quit:  cargo run -p spike --bin muxcheck
 
 use std::collections::HashMap;
 
 use scarlett_core::matrix::MuxEntry;
 use scarlett_core::model::S18I20_GEN3;
 use scarlett_core::mux::{mux_assignment_18i20_gen3, MuxState, PORT_COUNT_18I20_GEN3};
 use scarlett_core::{Scarlett, UsbTransport};
 
 fn main() {
     if let Err(e) = run() {
         eprintln!("\x1b[31mMUXCHECK FAILED:\x1b[0m {e}");
         std::process::exit(1);
     }
 }
 
 fn run() -> Result<(), Box<dyn std::error::Error>> {
     let mut dev = Scarlett::new(UsbTransport::open_default()?);
     dev.init()?;
     println!("connected: {}", S18I20_GEN3.name);
 
     let count = S18I20_GEN3.mux_dst_count();
     let before = dev.get_mux(count)?;
 
     // Decode → model → re-encode all tables.
     let state = MuxState::from_entries(PORT_COUNT_18I20_GEN3, &before);
     let assign = mux_assignment_18i20_gen3();
     let tables: Vec<Vec<u32>> = assign.iter().map(|a| state.encode_table(a)).collect();
 
     // The device reports routing as a flat dst→src map; build it from `before`.
     let mut device_map: HashMap<u16, u16> = HashMap::new();
     for e in &before {
         device_map.insert(e.dest, e.source);
     }
 
     // Decode our re-encoded TABLE 0 (the band that covers all destinations) and
     // compare every non-empty entry to what the device currently reports.
     let mut mism = 0usize;
     let mut checked = 0usize;
     for v in &tables[0] {
         let dst_id = (v & 0xfff) as u16;
         let src_id = ((v >> 12) & 0xfff) as u16;
         if dst_id == 0 {
             continue; // empty slot
         }
         checked += 1;
         let dev_src = device_map.get(&dst_id).copied().unwrap_or(0);
         if dev_src != src_id {
             if mism < 12 {
                 println!(
                     "  MISMATCH dst {dst_id:#05x}: device src {dev_src:#05x} != ours {src_id:#05x}"
                 );
             }
             mism += 1;
         }
     }
 
     println!("\nchecked {checked} routed destinations in table 0");
     if mism == 0 {
         println!("\x1b[32mMUXCHECK PASSED\x1b[0m — our re-encode reproduces the device routing exactly.");
         println!("→ writing our encoding would be a no-op; routing edit is safe to enable.");
     } else {
         println!("\x1b[31mMUXCHECK: {mism} mismatches\x1b[0m — DO NOT enable routing write yet.");
     }
 
     // Show a small sample so the human can eyeball it too.
     println!("\nsample of current routing (first 6 routed):");
     let mut shown = 0;
     for e in &before {
         if e.source != 0 && shown < 6 {
             println!("  dst {:#05x} ← src {:#05x}", e.dest, e.source);
             shown += 1;
         }
     }
     let _ = MuxEntry { dest: 0, source: 0 }; // keep import meaningful
 
     // OPTIONAL no-op write test: only with `--write-noop`, and only if the
     // re-encode matched (mism==0). Writes the CURRENT routing back unchanged,
     // then re-reads to confirm nothing changed. This exercises the real write
     // path on hardware with zero risk of altering the setup.
     let do_write = std::env::args().any(|a| a == "--write-noop");
     if do_write && mism == 0 {
         println!("\n--write-noop: writing current routing back UNCHANGED…");
         dev.write_routing_tables(&tables)?;
         let after = dev.get_mux(count)?;
         let mut after_map: HashMap<u16, u16> = HashMap::new();
         for e in &after {
             after_map.insert(e.dest, e.source);
         }
         let changed = device_map
             .iter()
             .filter(|(d, s)| after_map.get(d).copied().unwrap_or(0) != **s)
             .count();
         if changed == 0 {
             println!("\x1b[32mNO-OP WRITE OK\x1b[0m — routing identical after write. Write path verified.");
         } else {
             println!("\x1b[31mNO-OP WRITE CHANGED {changed} routes!\x1b[0m — investigate before edits.");
         }
     } else if do_write {
         println!("\n--write-noop skipped: re-encode had mismatches; not writing.");
     } else {
         println!("\n(READ-ONLY — nothing was written. Add --write-noop to test the write path.)");
     }
     Ok(())
 }