From 52a324c2c4f3fb2798b4685876de1d17874c6067 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Wed, 8 Jul 2026 21:41:58 +0200 Subject: [PATCH 01/13] start work on 0.5.0 and Victor 86 series support --- CHANGELOG.md | 9 +++++++-- Cargo.lock | 2 +- Cargo.toml | 2 +- README.md | 11 ++++++----- 4 files changed, 15 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index db8b152..9507758 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,13 @@ # CHANGELOG -## 0.4.7 +## 0.5.0 -- WIP +- add support for Victor (RuoShui) 86B/C/D/E handheld DMMs (read only) + +This release adds a whole new device class to Rusty Meter. +These Victor DMMs can be read out, but due to their nature +with a twist knob for the modes they can only be read out +and not remote controlled. ## 0.4.6 diff --git a/Cargo.lock b/Cargo.lock index a092453..24abd35 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4101,7 +4101,7 @@ checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2" [[package]] name = "rusty_meter" -version = "0.4.6" +version = "0.5.0" dependencies = [ "arboard", "chrono", diff --git a/Cargo.toml b/Cargo.toml index 746234d..8550858 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rusty_meter" -version = "0.4.6" +version = "0.5.0" authors = ["Markus Krause "] edition = "2024" rust-version = "1.92" # when updating here, also update release.yml and rust-toolchain file diff --git a/README.md b/README.md index d211dcf..54c5593 100644 --- a/README.md +++ b/README.md @@ -5,14 +5,15 @@ If you like this, a small donation is appreciated: [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R8DQO8C) RustyMeter is a GUI application written in Rust powered by the awesome egui framework and builds -on the work of @TheHWCave to turn your OWON XDM multimeter into a PC-based powerhouse +on the work of @TheHWCave to turn your OWON XDM or Victor multimeter into a PC-based powerhouse with neat graphing, recording, using it on stream etc. Meters which have been confirmed working already: -- XDM1041 -- XDM1241 -- XDM2041 (except 4W resistance, not yet implemented) +- Owon XDM1041 +- Owon XDM1241 +- Owon XDM2041 (except 4W resistance, not yet implemented) +- Victor 86 series Looking for testers for the XDM3000 series! @@ -20,7 +21,7 @@ Looking for testers for the XDM3000 series! ![recorder](assets/recorder.png) -Eventually, as this is all SCPI based, it could also be extended to other meters that have SCPI interfaces. +Eventually, as this is all SCPI based (except the Victor driver), it could also be extended to other meters that have SCPI interfaces. Maybe some stuff even works out of the box. **NOTE:** This is work and progress and I have more features for this in mind. what works right now is connecting to the multimeter, switching modes and ranges as well as sampling rates. You also get nice graphing for a configureable amount of last samples and you can record samples to CSV, XLSX and JSON. From 5bbedae49012c101101f17d4ca8d0721360198bf Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Wed, 8 Jul 2026 22:49:12 +0200 Subject: [PATCH 02/13] first draft of Victor HID mode support --- Cargo.lock | 14 +++ Cargo.toml | 1 + src/app/hid.rs | 150 ++++++++++++++++++++++++ src/app/mod.rs | 25 ++++ src/app/ui.rs | 168 ++++++++++++++++++++++----- src/lib.rs | 2 + src/victor.rs | 308 +++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 640 insertions(+), 28 deletions(-) create mode 100644 src/app/hid.rs create mode 100644 src/victor.rs diff --git a/Cargo.lock b/Cargo.lock index 24abd35..11cdbb9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1977,6 +1977,19 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" +[[package]] +name = "hidapi" +version = "2.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c78dadfc12f865bc3fcac3897e64533b930737ceb9ef245c8277de98d0b010e9" +dependencies = [ + "cc", + "cfg-if", + "libc", + "pkg-config", + "windows-sys 0.61.2", +] + [[package]] name = "home" version = "0.5.9" @@ -4116,6 +4129,7 @@ dependencies = [ "env_logger", "epaint", "glob", + "hidapi", "image", "indexmap", "log", diff --git a/Cargo.toml b/Cargo.toml index 8550858..1e57d56 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -48,6 +48,7 @@ rfd = "0.17.2" # For file dialogs # native: [target.'cfg(not(target_arch = "wasm32"))'.dependencies] env_logger = "0.11.10" +hidapi = "2.6.3" # web: [target.'cfg(target_arch = "wasm32")'.dependencies] diff --git a/src/app/hid.rs b/src/app/hid.rs new file mode 100644 index 0000000..d6caa95 --- /dev/null +++ b/src/app/hid.rs @@ -0,0 +1,150 @@ +use std::ffi::CString; +use std::time::Duration; + +use hidapi::HidApi; +use tokio::sync::{mpsc, oneshot}; + +use crate::multimeter::MeterMode; +use crate::victor::{self, VICTOR_PRODUCT_ID, VICTOR_VENDOR_ID}; + +impl super::MyApp { + pub fn refresh_hid_devices(&mut self) { + self.hid_devicelist.clear(); + match HidApi::new() { + Ok(api) => { + for device in api.device_list() { + if device.vendor_id() == VICTOR_VENDOR_ID + && device.product_id() == VICTOR_PRODUCT_ID + { + let path = device.path().to_string_lossy().into_owned(); + let label = format!( + "{} {} ({:04x}:{:04x})", + device + .manufacturer_string() + .unwrap_or("Victor"), + device.product_string().unwrap_or("Multimeter"), + device.vendor_id(), + device.product_id(), + ); + self.hid_devicelist.push_back((path, label)); + } + } + } + Err(e) => { + if self.value_debug { + println!("Failed to enumerate HID devices: {}", e); + } + } + } + if self.hid_device_path.is_empty() { + if let Some((path, _)) = self.hid_devicelist.front() { + self.hid_device_path = path.clone(); + } + } + } + + pub fn spawn_hid_task(&mut self) { + let (tx_data, rx_data) = mpsc::channel::>(100); + let (tx_mode, rx_mode) = mpsc::channel::(10); + let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); + + self.serial_rx = Some(rx_data); + self.mode_rx = Some(rx_mode); + self.shutdown_tx = Some(shutdown_tx); + // Victor meters are read-only; no command channel. + self.serial_tx = None; + + let device_path = self.hid_device_path.clone(); + let value_debug_shared = self.value_debug_shared.clone(); + let poll_interval_shared = self.poll_interval_shared.clone(); + let device_shared = self.device.clone(); + + tokio::task::spawn_blocking(move || { + let api = match HidApi::new() { + Ok(api) => api, + Err(e) => { + if *value_debug_shared.lock().unwrap() { + println!("Failed to create HID API: {}", e); + } + return; + } + }; + + let c_path = match CString::new(device_path.as_bytes()) { + Ok(path) => path, + Err(e) => { + if *value_debug_shared.lock().unwrap() { + println!("Invalid Victor HID device path: {}", e); + } + return; + } + }; + let device = match api.open_path(&c_path) { + Ok(device) => device, + Err(e) => { + if *value_debug_shared.lock().unwrap() { + println!("Failed to open Victor HID device: {}", e); + } + return; + } + }; + + { + let mut dev = device_shared.lock().unwrap(); + *dev = "Victor 86 series (read only)".to_owned(); + } + + if *value_debug_shared.lock().unwrap() { + println!("Victor HID device opened"); + } + + let mut readbuf = [0u8; 64]; + let mut shutting_down = false; + let mut last_mode = None::; + + loop { + if shutdown_rx.try_recv().is_ok() { + shutting_down = true; + } + if shutting_down { + break; + } + + let interval = *poll_interval_shared.lock().unwrap(); + let timeout_ms = interval.max(50) as i32; + + match device.read_timeout(&mut readbuf, timeout_ms) { + Ok(0) => continue, + Ok(len) => { + if *value_debug_shared.lock().unwrap() { + println!("Victor HID received {} bytes", len); + } + if let Some(reading) = victor::parse_hid_buffer(&readbuf[..len]) { + if *value_debug_shared.lock().unwrap() { + println!( + "Victor reading: {} {:?}", + reading.value, reading.mode + ); + } + let _ = tx_data.blocking_send(Some(reading.value)); + if last_mode != Some(reading.mode) { + last_mode = Some(reading.mode); + let _ = tx_mode.blocking_send(reading.mode); + } + } + } + Err(e) => { + if *value_debug_shared.lock().unwrap() { + println!("Victor HID read error: {}", e); + } + std::thread::sleep(Duration::from_millis(interval)); + } + } + } + + if *value_debug_shared.lock().unwrap() { + println!("Victor HID task shutting down"); + } + }); + } +} \ No newline at end of file diff --git a/src/app/mod.rs b/src/app/mod.rs index 010c7e0..8a53aee 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -14,12 +14,22 @@ use tokio::sync::{mpsc, oneshot}; use crate::multimeter::{MeterMode, RangeCmd, RateCmd, ScpiMode}; // Submodules for split impl blocks +#[cfg(not(target_arch = "wasm32"))] +mod hid; mod graph; mod recording; mod serial; mod settings; mod ui; +#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Default)] +pub enum ConnectionType { + #[default] + Serial, + #[cfg(not(target_arch = "wasm32"))] + VictorHid, +} + const VERSION: &str = env!("CARGO_PKG_VERSION"); const MEM_DEPTH_DEFAULT: usize = 100; // Default slider value @@ -64,7 +74,10 @@ struct ModeDisplaySettings { #[derive(Serialize, Deserialize)] #[serde(default)] // if we add new fields, give them default values when deserializing old state pub struct MyApp { + connection_type: ConnectionType, serial_port: String, + #[cfg(not(target_arch = "wasm32"))] + hid_device_path: String, baud_rate: u32, bits: u32, stop_bits: u32, @@ -122,6 +135,9 @@ pub struct MyApp { readbuf: [u8; 1024], #[serde(skip)] portlist: VecDeque, + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + hid_devicelist: VecDeque<(String, String)>, #[serde(skip)] values: VecDeque, #[serde(skip)] @@ -188,7 +204,10 @@ enum ConnectionState { impl Default for MyApp { fn default() -> Self { Self { + connection_type: ConnectionType::default(), serial_port: "".to_owned(), + #[cfg(not(target_arch = "wasm32"))] + hid_device_path: "".to_owned(), baud_rate: 115200, bits: 8, stop_bits: 1, @@ -210,6 +229,8 @@ impl Default for MyApp { issue_new_write: false, readbuf: [0u8; 1024], portlist: VecDeque::with_capacity(11), + #[cfg(not(target_arch = "wasm32"))] + hid_devicelist: VecDeque::with_capacity(4), values: VecDeque::with_capacity(MEM_DEPTH_DEFAULT + 1), hist_values: VecDeque::with_capacity(MEM_DEPTH_DEFAULT + 1), // Initialize histogram buffer poll: Poll::new().unwrap(), @@ -404,4 +425,8 @@ impl MyApp { .auto_scale_units = enabled; // Optional: self.save_settings() if you have an immediate-save helper } + + pub fn is_read_only(&self) -> bool { + matches!(self.connection_type, ConnectionType::VictorHid) + } } diff --git a/src/app/ui.rs b/src/app/ui.rs index 2c6b15b..0770027 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -97,6 +97,8 @@ impl super::MyApp { self.portlist.push_front(p.port_name); } } + #[cfg(not(target_arch = "wasm32"))] + self.refresh_hid_devices(); // Apply initial sampling rate self.confstring = self .ratecmd @@ -251,18 +253,78 @@ impl super::MyApp { ui.vertical(|ui| { ui.horizontal(|ui| { - ui.label("Serial port: "); - ui.add( - DropDownBox::from_iter( - &self.portlist, - "portlistbox", - &mut self.serial_port, - |ui, text| ui.selectable_label(false, text), - ) - .desired_width(150.0) - .select_on_focus(true) - .filter_by_input(false), - ); + #[cfg(not(target_arch = "wasm32"))] + { + ui.label("Connection:"); + egui::ComboBox::from_id_salt("connection_type") + .selected_text(match self.connection_type { + super::ConnectionType::Serial => "SCPI Serial", + super::ConnectionType::VictorHid => "Victor USB HID", + }) + .show_ui(ui, |ui| { + ui.selectable_value( + &mut self.connection_type, + super::ConnectionType::Serial, + "SCPI Serial", + ); + ui.selectable_value( + &mut self.connection_type, + super::ConnectionType::VictorHid, + "Victor USB HID", + ); + }); + } + + match self.connection_type { + super::ConnectionType::Serial => { + ui.label("Serial port:"); + ui.add( + DropDownBox::from_iter( + &self.portlist, + "portlistbox", + &mut self.serial_port, + |ui, text| ui.selectable_label(false, text), + ) + .desired_width(150.0) + .select_on_focus(true) + .filter_by_input(false), + ); + } + #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::VictorHid => { + ui.label("HID device:"); + let mut selected_idx = self + .hid_devicelist + .iter() + .position(|(path, _)| path == &self.hid_device_path) + .unwrap_or(0); + egui::ComboBox::from_id_salt("hid_devicelist") + .selected_text( + self.hid_devicelist + .get(selected_idx) + .map(|(_, l)| l.as_str()) + .unwrap_or("No Victor device found"), + ) + .show_ui(ui, |ui| { + for (idx, (path, label)) in + self.hid_devicelist.iter().enumerate() + { + if ui + .selectable_value(&mut selected_idx, idx, label) + .clicked() + { + self.hid_device_path = path.clone(); + } + } + }); + if let Some((path, _)) = self.hid_devicelist.get(selected_idx) { + self.hid_device_path = path.clone(); + } + if ui.button("Refresh").clicked() { + self.refresh_hid_devices(); + } + } + } match self.connection_state { super::ConnectionState::Disconnected => { @@ -270,26 +332,54 @@ impl super::MyApp { connect_now = false; self.connection_state = super::ConnectionState::Connecting; self.connection_error = None; - match mio_serial::new(&self.serial_port, self.baud_rate) - .open_native_async() - { - Ok(serial) => { - self.serial = Some(serial); - if let Some(ref mut serial) = self.serial { - let _ = serial.set_data_bits(DataBits::Eight); - let _ = serial.set_stop_bits(mio_serial::StopBits::One); - let _ = serial.set_parity(mio_serial::Parity::None); + + match self.connection_type { + super::ConnectionType::Serial => { + match mio_serial::new(&self.serial_port, self.baud_rate) + .open_native_async() + { + Ok(serial) => { + self.serial = Some(serial); + if let Some(ref mut serial) = self.serial { + let _ = + serial.set_data_bits(DataBits::Eight); + let _ = serial.set_stop_bits( + mio_serial::StopBits::One, + ); + let _ = + serial.set_parity(mio_serial::Parity::None); + self.connection_state = + super::ConnectionState::Connected; + self.curr_meter = "OWON XDM1041".to_owned(); + self.spawn_serial_task(); + } + } + Err(e) => { + self.connection_state = + super::ConnectionState::Disconnected; + self.connection_error = Some(format!( + "Failed to connect: {}", + e + )); + } + } + } + #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::VictorHid => { + if self.hid_device_path.is_empty() { + self.connection_state = + super::ConnectionState::Disconnected; + self.connection_error = Some( + "No Victor HID device selected".to_owned(), + ); + } else { self.connection_state = super::ConnectionState::Connected; - self.spawn_serial_task(); + self.curr_meter = "Victor 86 series".to_owned(); + self.rangecmd = None; + self.spawn_hid_task(); } } - Err(e) => { - self.connection_state = - super::ConnectionState::Disconnected; - self.connection_error = - Some(format!("Failed to connect: {}", e)); - } } } } @@ -423,7 +513,17 @@ impl super::MyApp { }; control_frame.show(ui, |ui| { ui.vertical(|ui| { + if self.is_read_only() { + ui.label( + egui::RichText::new( + "Read only — change mode on the meter", + ) + .italics(), + ); + } let btn_size = Vec2 { x: 70.0, y: 20.0 }; + let read_only = self.is_read_only(); + ui.add_enabled_ui(!read_only, |ui| { ui.horizontal(|ui| { let vdc_btn = egui::Button::new("VDC") .selected(self.metermode == MeterMode::Vdc) @@ -556,6 +656,7 @@ impl super::MyApp { ); } }); + }); // add_enabled_ui }); }); @@ -574,6 +675,17 @@ impl super::MyApp { }; options_frame.show(ui, |ui| { ui.vertical(|ui| { + if self.is_read_only() { + ui.label("Mode/range controlled on device"); + let mut auto_scale = self.auto_scale_units(&self.metermode); + if ui + .checkbox(&mut auto_scale, "Auto-scale units") + .changed() + { + self.set_auto_scale_units(self.metermode, auto_scale); + } + return; + } let ratebox = egui::ComboBox::from_label("Sampling Rate").show_index( ui, &mut self.curr_rate, diff --git a/src/lib.rs b/src/lib.rs index adfb9f9..a8be4d2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,3 +5,5 @@ mod app; pub use app::MyApp; mod helpers; mod multimeter; +#[cfg(not(target_arch = "wasm32"))] +mod victor; diff --git a/src/victor.rs b/src/victor.rs new file mode 100644 index 0000000..2f91804 --- /dev/null +++ b/src/victor.rs @@ -0,0 +1,308 @@ +//! Victor (RuoShui) 86-series USB HID protocol support. +//! Deobfuscation followed by Fortune Semiconductor FS9922-DMM4 +//! chip packet decode. + +use crate::multimeter::MeterMode; + +pub const VICTOR_VENDOR_ID: u16 = 0x1244; +pub const VICTOR_PRODUCT_ID: u16 = 0xd237; +pub const PACKET_LEN: usize = 14; + +const OBFUSCATION: [u8; PACKET_LEN] = *b"jodenxunickxia"; +const SHUFFLE: [u8; PACKET_LEN] = [6, 13, 5, 11, 2, 7, 9, 8, 3, 10, 12, 0, 4, 1]; + +#[derive(Debug, Clone, PartialEq)] +pub struct VictorReading { + pub value: f64, + pub mode: MeterMode, + pub unit: String, +} + +#[derive(Debug, Clone, Default)] +struct Fs9922Flags { + is_nano: bool, + is_micro: bool, + is_milli: bool, + is_kilo: bool, + is_mega: bool, + is_volt: bool, + is_ampere: bool, + is_ohm: bool, + is_hertz: bool, + is_farad: bool, + is_celsius: bool, + is_fahrenheit: bool, + is_beep: bool, + is_diode: bool, + is_percent: bool, + is_ac: bool, + is_dc: bool, +} + +fn bit_reverse(b: u8) -> u8 { + const REV_NIBBLE: [u8; 16] = [ + 0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e, 0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, + 0x0f, + ]; + REV_NIBBLE[(b >> 4) as usize] | (REV_NIBBLE[(b & 0xf) as usize] << 4) +} + +/// Undo the Victor USB cable's obfuscation to recover the FS9922 packet. +pub fn deobfuscate(raw: &[u8]) -> Option<[u8; PACKET_LEN]> { + if raw.len() != PACKET_LEN { + return None; + } + if raw.iter().all(|&b| b == 0) { + return None; + } + + let mut out = [0u8; PACKET_LEN]; + for (idx, &byte) in raw.iter().enumerate() { + let to_idx = PACKET_LEN - 1 - SHUFFLE[idx] as usize; + out[to_idx] = bit_reverse(byte.wrapping_sub(OBFUSCATION[idx])); + } + Some(out) +} + +/// Extract the 14-byte Victor payload from a HID read buffer. +pub fn extract_packet(buf: &[u8]) -> Option<&[u8; PACKET_LEN]> { + match buf.len() { + PACKET_LEN => Some(buf.try_into().ok()?), + n if n > PACKET_LEN => { + // Some platforms prepend a report ID byte. + if buf[0] == 0 { + buf.get(1..=PACKET_LEN)?.try_into().ok() + } else { + buf.get(..PACKET_LEN)?.try_into().ok() + } + } + _ => None, + } +} + +fn flags_valid(flags: &Fs9922Flags) -> bool { + let mult = [ + flags.is_nano, + flags.is_micro, + flags.is_milli, + flags.is_kilo, + flags.is_mega, + ] + .into_iter() + .filter(|&b| b) + .count(); + if mult > 1 { + return false; + } + + let modes = [ + flags.is_percent, + flags.is_volt, + flags.is_ampere, + flags.is_ohm, + flags.is_hertz, + flags.is_farad, + flags.is_celsius, + flags.is_fahrenheit, + ] + .into_iter() + .filter(|&b| b) + .count(); + if modes > 1 { + return false; + } + + !(flags.is_ac && flags.is_dc || flags.is_celsius && flags.is_fahrenheit) +} + +fn parse_flags(buf: &[u8; PACKET_LEN]) -> Fs9922Flags { + Fs9922Flags { + is_dc: buf[7] & (1 << 4) != 0, + is_ac: buf[7] & (1 << 3) != 0, + is_nano: buf[8] & (1 << 1) != 0, + is_micro: buf[9] & (1 << 7) != 0, + is_milli: buf[9] & (1 << 6) != 0, + is_kilo: buf[9] & (1 << 5) != 0, + is_mega: buf[9] & (1 << 4) != 0, + is_beep: buf[9] & (1 << 3) != 0, + is_diode: buf[9] & (1 << 2) != 0, + is_percent: buf[9] & (1 << 1) != 0, + is_volt: buf[10] & (1 << 7) != 0, + is_ampere: buf[10] & (1 << 6) != 0, + is_ohm: buf[10] & (1 << 5) != 0, + is_hertz: buf[10] & (1 << 3) != 0, + is_farad: buf[10] & (1 << 2) != 0, + is_celsius: buf[10] & (1 << 1) != 0, + is_fahrenheit: buf[10] & (1 << 0) != 0, + } +} + +fn parse_value(buf: &[u8; PACKET_LEN]) -> Option<(f64, i32)> { + let sign = match buf[0] { + b'+' => 1.0, + b'-' => -1.0, + _ => return None, + }; + + if buf[1] == b'?' && buf[2] == b'0' && buf[3] == b':' && buf[4] == b'?' { + return Some((f64::INFINITY, 0)); + } + + if !buf[1].is_ascii_digit() + || !buf[2].is_ascii_digit() + || !buf[3].is_ascii_digit() + || !buf[4].is_ascii_digit() + { + return None; + } + + let intval = (buf[1] - b'0') as i32 * 1000 + + (buf[2] - b'0') as i32 * 100 + + (buf[3] - b'0') as i32 * 10 + + (buf[4] - b'0') as i32; + + let exponent = match buf[6] { + b'0' => 0, + b'1' => -3, + b'2' => -2, + b'4' => -1, + _ => return None, + }; + + Some((sign * intval as f64, exponent)) +} + +fn apply_multipliers(value: f64, exponent: i32, flags: &Fs9922Flags) -> f64 { + let mut exp = exponent; + if flags.is_nano { + exp -= 9; + } + if flags.is_micro { + exp -= 6; + } + if flags.is_milli { + exp -= 3; + } + if flags.is_kilo { + exp += 3; + } + if flags.is_mega { + exp += 6; + } + value * 10f64.powi(exp) +} + +fn mode_from_flags(flags: &Fs9922Flags) -> Option<(MeterMode, &'static str)> { + if flags.is_beep { + return Some((MeterMode::Cont, "Ohm")); + } + if flags.is_diode { + return Some((MeterMode::Diod, "V")); + } + if flags.is_percent { + return Some((MeterMode::Freq, "Hz")); // duty cycle; closest existing mode + } + if flags.is_volt { + if flags.is_ac { + return Some((MeterMode::Vac, "VAC")); + } + return Some((MeterMode::Vdc, "VDC")); + } + if flags.is_ampere { + if flags.is_ac { + return Some((MeterMode::Aac, "AAC")); + } + return Some((MeterMode::Adc, "ADC")); + } + if flags.is_ohm { + return Some((MeterMode::Res, "Ohm")); + } + if flags.is_farad { + return Some((MeterMode::Cap, "F")); + } + if flags.is_hertz { + return Some((MeterMode::Freq, "Hz")); + } + if flags.is_celsius || flags.is_fahrenheit { + return Some((MeterMode::Temp, "°C")); + } + None +} + +/// Parse a deobfuscated FS9922 packet into a measurement reading. +pub fn parse_packet(buf: &[u8; PACKET_LEN]) -> Option { + if buf[12] != b'\r' || buf[13] != b'\n' { + return None; + } + + let flags = parse_flags(buf); + if !flags_valid(&flags) { + return None; + } + + let (mut value, exponent) = parse_value(buf)?; + value = apply_multipliers(value, exponent, &flags); + + if flags.is_beep { + value = if value.is_infinite() { 0.0 } else { 1.0 }; + } + + let (mode, unit) = mode_from_flags(&flags)?; + + Some(VictorReading { + value, + mode, + unit: unit.to_owned(), + }) +} + +/// Process a raw HID read buffer end-to-end. +pub fn parse_hid_buffer(buf: &[u8]) -> Option { + let packet = extract_packet(buf)?; + let deobfuscated = deobfuscate(packet)?; + parse_packet(&deobfuscated) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_all_zero_packet() { + assert!(deobfuscate(&[0u8; PACKET_LEN]).is_none()); + } + + #[test] + fn rejects_invalid_fs9922_footer() { + let mut pkt = [0u8; PACKET_LEN]; + pkt[0] = b'+'; + pkt[1] = b'1'; + pkt[2] = b'2'; + pkt[3] = b'3'; + pkt[4] = b'4'; + pkt[6] = b'4'; + pkt[12] = b'X'; + pkt[13] = b'Y'; + assert!(parse_packet(&pkt).is_none()); + } + + #[test] + fn parses_simple_voltage_reading() { + let mut pkt = [0u8; PACKET_LEN]; + pkt[0] = b'+'; + pkt[1] = b'1'; + pkt[2] = b'2'; + pkt[3] = b'3'; + pkt[4] = b'4'; + pkt[6] = b'4'; // one decimal place -> 123.4 + pkt[7] = 1 << 4; // DC + pkt[10] = 1 << 7; // volt + pkt[12] = b'\r'; + pkt[13] = b'\n'; + + let reading = parse_packet(&pkt).unwrap(); + assert!((reading.value - 123.4).abs() < f64::EPSILON); + assert_eq!(reading.mode, MeterMode::Vdc); + assert_eq!(reading.unit, "VDC"); + } +} \ No newline at end of file From 866a937f6c3f10b86ce8503c7ddc7e0f1ea07f94 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Thu, 9 Jul 2026 00:19:32 +0200 Subject: [PATCH 03/13] add support for Duty cycle mode --- src/app/mod.rs | 17 +++++++++++++++++ src/app/ui.rs | 12 ++++++++++++ src/helpers.rs | 1 + src/multimeter.rs | 1 + src/victor.rs | 25 ++++++++++++++++++++++++- 5 files changed, 55 insertions(+), 1 deletion(-) diff --git a/src/app/mod.rs b/src/app/mod.rs index 8a53aee..6cc23cf 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -429,4 +429,21 @@ impl MyApp { pub fn is_read_only(&self) -> bool { matches!(self.connection_type, ConnectionType::VictorHid) } + + /// Whether a mode button should appear in the control panel for the current connection. + pub fn mode_visible_in_ui(&self, mode: MeterMode) -> bool { + match mode { + MeterMode::Duty => { + #[cfg(not(target_arch = "wasm32"))] + { + matches!(self.connection_type, ConnectionType::VictorHid) + } + #[cfg(target_arch = "wasm32")] + { + false + } + } + _ => true, + } + } } diff --git a/src/app/ui.rs b/src/app/ui.rs index 0770027..44d72f9 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -172,6 +172,10 @@ impl super::MyApp { self.curr_unit = "s".to_owned(); self.rangecmd = None; } + MeterMode::Duty => { + self.curr_unit = "%".to_owned(); + self.rangecmd = None; + } MeterMode::Diod => { self.curr_unit = "V".to_owned(); self.rangecmd = None; @@ -617,6 +621,14 @@ impl super::MyApp { if ui.add(per_btn).clicked() { self.set_mode(MeterMode::Per, "s", "CONF:PER\n", Some("PER"), None); } + if self.mode_visible_in_ui(MeterMode::Duty) { + let duty_btn = egui::Button::new("Duty") + .selected(self.metermode == MeterMode::Duty) + .min_size(btn_size); + if ui.add(duty_btn).clicked() { + self.set_mode(MeterMode::Duty, "%", "", None, None); + } + } }); ui.horizontal(|ui| { let diod_btn = egui::Button::new("Diode") diff --git a/src/helpers.rs b/src/helpers.rs index 465f890..e345a67 100644 --- a/src/helpers.rs +++ b/src/helpers.rs @@ -33,6 +33,7 @@ pub fn format_measurement( MeterMode::Cap => "F", MeterMode::Freq => "Hz", MeterMode::Per => "s", + MeterMode::Duty => "%", MeterMode::Diod => "V", MeterMode::Cont => "Ohm", MeterMode::Temp => "°C", diff --git a/src/multimeter.rs b/src/multimeter.rs index 0a6cc5e..c9d4be1 100644 --- a/src/multimeter.rs +++ b/src/multimeter.rs @@ -25,6 +25,7 @@ pub enum MeterMode { Cap, Freq, Per, + Duty, Diod, Cont, Temp, diff --git a/src/victor.rs b/src/victor.rs index 2f91804..dbc2dac 100644 --- a/src/victor.rs +++ b/src/victor.rs @@ -200,7 +200,7 @@ fn mode_from_flags(flags: &Fs9922Flags) -> Option<(MeterMode, &'static str)> { return Some((MeterMode::Diod, "V")); } if flags.is_percent { - return Some((MeterMode::Freq, "Hz")); // duty cycle; closest existing mode + return Some((MeterMode::Duty, "%")); } if flags.is_volt { if flags.is_ac { @@ -286,6 +286,29 @@ mod tests { assert!(parse_packet(&pkt).is_none()); } + #[test] + fn parses_duty_cycle_reading() { + let mut pkt = [0u8; PACKET_LEN]; + pkt[0] = b'+'; + pkt[1] = b'5'; + pkt[2] = b'2'; + pkt[3] = b'3'; + pkt[4] = b'0'; + pkt[6] = b'2'; // two decimal places -> 52.30 + pkt[9] = 1 << 1; // duty cycle (%) + pkt[12] = b'\r'; + pkt[13] = b'\n'; + + let reading = parse_packet(&pkt).unwrap(); + assert!( + (reading.value - 52.3).abs() < 1e-6, + "expected 52.3, got {}", + reading.value + ); + assert_eq!(reading.mode, MeterMode::Duty); + assert_eq!(reading.unit, "%"); + } + #[test] fn parses_simple_voltage_reading() { let mut pkt = [0u8; PACKET_LEN]; From 9c39b09634b030e96fe65c1ead08d9e5fa6a8c65 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Sun, 12 Jul 2026 22:45:02 +0200 Subject: [PATCH 04/13] add support for Victor 86E --- src/app/hid.rs | 4 +- src/app/mod.rs | 30 +++- src/app/serial.rs | 22 ++- src/app/ui.rs | 134 +++++++++------ src/app/victor_serial.rs | 137 +++++++++++++++ src/lib.rs | 2 + src/victor.rs | 15 +- src/victor_es519xx.rs | 359 +++++++++++++++++++++++++++++++++++++++ 8 files changed, 638 insertions(+), 65 deletions(-) create mode 100644 src/app/victor_serial.rs create mode 100644 src/victor_es519xx.rs diff --git a/src/app/hid.rs b/src/app/hid.rs index d6caa95..156deba 100644 --- a/src/app/hid.rs +++ b/src/app/hid.rs @@ -45,7 +45,7 @@ impl super::MyApp { pub fn spawn_hid_task(&mut self) { let (tx_data, rx_data) = mpsc::channel::>(100); - let (tx_mode, rx_mode) = mpsc::channel::(10); + let (tx_mode, rx_mode) = mpsc::channel::<(MeterMode, String)>(10); let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); self.serial_rx = Some(rx_data); @@ -129,7 +129,7 @@ impl super::MyApp { let _ = tx_data.blocking_send(Some(reading.value)); if last_mode != Some(reading.mode) { last_mode = Some(reading.mode); - let _ = tx_mode.blocking_send(reading.mode); + let _ = tx_mode.blocking_send((reading.mode, reading.unit)); } } } diff --git a/src/app/mod.rs b/src/app/mod.rs index 6cc23cf..5e9c0e3 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -16,18 +16,29 @@ use crate::multimeter::{MeterMode, RangeCmd, RateCmd, ScpiMode}; // Submodules for split impl blocks #[cfg(not(target_arch = "wasm32"))] mod hid; +#[cfg(not(target_arch = "wasm32"))] +mod victor_serial; mod graph; mod recording; mod serial; mod settings; mod ui; +/// How rusty_meter talks to the multimeter. +/// +/// - `Serial` — SCPI over UART (OWON XDM series, remote control) +/// - `VictorHid` — Victor 86B/C/D via USB HID + FS9922 cable protocol (read only) +/// - `VictorSerial` — Victor 86E via CP2102 UART + ES51932 ASCII frames (read only) #[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Default)] pub enum ConnectionType { #[default] Serial, + /// Victor 86B/C/D: USB HID, Fortune FS9922-DMM4. See `victor` module / sigrok wiki. #[cfg(not(target_arch = "wasm32"))] VictorHid, + /// Victor 86E: CP2102 serial 19200 7o1, Cyrustek ES51932. See `victor_es519xx` module. + #[cfg(not(target_arch = "wasm32"))] + VictorSerial, } const VERSION: &str = env!("CARGO_PKG_VERSION"); @@ -171,7 +182,7 @@ pub struct MyApp { #[serde(skip)] shutdown_tx: Option>, // Signal to shutdown serial task #[serde(skip)] - mode_rx: Option>, // Channel for mode updates + mode_rx: Option>, // Channel for mode + unit updates #[serde(skip)] value_debug_shared: Arc>, // Shared debug flag for live updates #[serde(skip)] @@ -427,7 +438,17 @@ impl MyApp { } pub fn is_read_only(&self) -> bool { - matches!(self.connection_type, ConnectionType::VictorHid) + #[cfg(not(target_arch = "wasm32"))] + { + matches!( + self.connection_type, + ConnectionType::VictorHid | ConnectionType::VictorSerial + ) + } + #[cfg(target_arch = "wasm32")] + { + false + } } /// Whether a mode button should appear in the control panel for the current connection. @@ -436,7 +457,10 @@ impl MyApp { MeterMode::Duty => { #[cfg(not(target_arch = "wasm32"))] { - matches!(self.connection_type, ConnectionType::VictorHid) + matches!( + self.connection_type, + ConnectionType::VictorHid | ConnectionType::VictorSerial + ) } #[cfg(target_arch = "wasm32")] { diff --git a/src/app/serial.rs b/src/app/serial.rs index b99220d..2286703 100644 --- a/src/app/serial.rs +++ b/src/app/serial.rs @@ -11,6 +11,23 @@ use crate::multimeter::{MeterMode, RateCmd, ScpiMode}; const SERIAL_TOKEN: Token = Token(0); +fn default_unit_for_mode(mode: MeterMode) -> String { + match mode { + MeterMode::Vdc => "VDC".to_owned(), + MeterMode::Vac => "VAC".to_owned(), + MeterMode::Adc => "ADC".to_owned(), + MeterMode::Aac => "AAC".to_owned(), + MeterMode::Res => "Ohm".to_owned(), + MeterMode::Cap => "F".to_owned(), + MeterMode::Freq => "Hz".to_owned(), + MeterMode::Per => "s".to_owned(), + MeterMode::Duty => "%".to_owned(), + MeterMode::Diod => "V".to_owned(), + MeterMode::Cont => "Ohm".to_owned(), + MeterMode::Temp => "°C".to_owned(), + } +} + impl super::MyApp { pub fn spawn_serial_task(&mut self) { if self.serial.is_none() { @@ -19,7 +36,7 @@ impl super::MyApp { let (tx_data, rx_data) = mpsc::channel::>(100); // Channel for measurements let (tx_cmd, mut rx_cmd) = mpsc::channel::(100); // Channel for commands - let (tx_mode, rx_mode) = mpsc::channel::(10); // Channel for mode updates + let (tx_mode, rx_mode) = mpsc::channel::<(MeterMode, String)>(10); let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); // Shutdown signal self.serial_rx = Some(rx_data); self.serial_tx = Some(tx_cmd.clone()); @@ -257,7 +274,8 @@ impl super::MyApp { }; if mode != last_mode { last_mode = mode; - let _ = tx_mode.send(mode).await; + let unit = default_unit_for_mode(mode); + let _ = tx_mode.send((mode, unit)).await; if mode == MeterMode::Cont { if beeper_enabled { command_queue.push_back("SYST:BEEP:STATe ON\n".to_string()); diff --git a/src/app/ui.rs b/src/app/ui.rs index 44d72f9..e8b1a7f 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -133,62 +133,28 @@ impl super::MyApp { } // Process all available mode updates + let read_only = self.is_read_only(); if let Some(ref mut rx) = self.mode_rx { - while let Ok(mode) = rx.try_recv() { + while let Ok((mode, unit)) = rx.try_recv() { if mode != self.metermode { self.metermode = mode; + self.curr_unit = unit; self.values = VecDeque::with_capacity(self.mem_depth); self.hist_values = VecDeque::with_capacity(self.hist_mem_depth); // Reset histogram buffer - match mode { - MeterMode::Vdc => { - self.curr_unit = "VDC".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "VDC"); + self.rangecmd = if read_only { + None + } else { + match mode { + MeterMode::Vdc => RangeCmd::new(&self.curr_meter, "VDC"), + MeterMode::Vac => RangeCmd::new(&self.curr_meter, "VAC"), + MeterMode::Adc => RangeCmd::new(&self.curr_meter, "ADC"), + MeterMode::Aac => RangeCmd::new(&self.curr_meter, "AAC"), + MeterMode::Res => RangeCmd::new(&self.curr_meter, "RES"), + MeterMode::Cap => RangeCmd::new(&self.curr_meter, "CAP"), + MeterMode::Temp => RangeCmd::new(&self.curr_meter, "TEMP"), + _ => None, } - MeterMode::Vac => { - self.curr_unit = "VAC".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "VAC"); - } - MeterMode::Adc => { - self.curr_unit = "ADC".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "ADC"); - } - MeterMode::Aac => { - self.curr_unit = "AAC".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "AAC"); - } - MeterMode::Res => { - self.curr_unit = "Ohm".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "RES"); - } - MeterMode::Cap => { - self.curr_unit = "F".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "CAP"); - } - MeterMode::Freq => { - self.curr_unit = "Hz".to_owned(); - self.rangecmd = None; - } - MeterMode::Per => { - self.curr_unit = "s".to_owned(); - self.rangecmd = None; - } - MeterMode::Duty => { - self.curr_unit = "%".to_owned(); - self.rangecmd = None; - } - MeterMode::Diod => { - self.curr_unit = "V".to_owned(); - self.rangecmd = None; - } - MeterMode::Cont => { - self.curr_unit = "Ohm".to_owned(); - self.rangecmd = None; - } - MeterMode::Temp => { - self.curr_unit = "°C".to_owned(); - self.rangecmd = RangeCmd::new(&self.curr_meter, "TEMP"); - } - } + }; self.curr_range = 0; if self.value_debug { println!("Updated metermode to: {:?}", mode); @@ -262,24 +228,31 @@ impl super::MyApp { ui.label("Connection:"); egui::ComboBox::from_id_salt("connection_type") .selected_text(match self.connection_type { - super::ConnectionType::Serial => "SCPI Serial", - super::ConnectionType::VictorHid => "Victor USB HID", + super::ConnectionType::Serial => "SCPI Serial (OWON)", + super::ConnectionType::VictorHid => "Victor USB HID (86B/C/D)", + super::ConnectionType::VictorSerial => "Victor Serial (86E)", }) .show_ui(ui, |ui| { ui.selectable_value( &mut self.connection_type, super::ConnectionType::Serial, - "SCPI Serial", + "SCPI Serial (OWON)", ); ui.selectable_value( &mut self.connection_type, super::ConnectionType::VictorHid, - "Victor USB HID", + "Victor USB HID (86B/C/D)", + ); + ui.selectable_value( + &mut self.connection_type, + super::ConnectionType::VictorSerial, + "Victor Serial (86E)", ); }); } match self.connection_type { + #[cfg(target_arch = "wasm32")] super::ConnectionType::Serial => { ui.label("Serial port:"); ui.add( @@ -295,6 +268,21 @@ impl super::MyApp { ); } #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::Serial | super::ConnectionType::VictorSerial => { + ui.label("Serial port:"); + ui.add( + DropDownBox::from_iter( + &self.portlist, + "portlistbox", + &mut self.serial_port, + |ui, text| ui.selectable_label(false, text), + ) + .desired_width(150.0) + .select_on_focus(true) + .filter_by_input(false), + ); + } + #[cfg(not(target_arch = "wasm32"))] super::ConnectionType::VictorHid => { ui.label("HID device:"); let mut selected_idx = self @@ -379,11 +367,47 @@ impl super::MyApp { } else { self.connection_state = super::ConnectionState::Connected; - self.curr_meter = "Victor 86 series".to_owned(); + self.curr_meter = "Victor 86B/C/D".to_owned(); self.rangecmd = None; self.spawn_hid_task(); } } + #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::VictorSerial => { + match mio_serial::new( + &self.serial_port, + crate::victor_es519xx::VICTOR_86E_BAUD, + ) + .open_native_async() + { + Ok(serial) => { + self.serial = Some(serial); + if let Some(ref mut serial) = self.serial { + let _ = serial + .set_data_bits(DataBits::Seven); + let _ = serial.set_stop_bits( + mio_serial::StopBits::One, + ); + let _ = serial.set_parity( + mio_serial::Parity::Odd, + ); + self.connection_state = + super::ConnectionState::Connected; + self.curr_meter = "Victor 86E".to_owned(); + self.rangecmd = None; + self.spawn_victor_serial_task(); + } + } + Err(e) => { + self.connection_state = + super::ConnectionState::Disconnected; + self.connection_error = Some(format!( + "Failed to connect: {}", + e + )); + } + } + } } } } diff --git a/src/app/victor_serial.rs b/src/app/victor_serial.rs new file mode 100644 index 0000000..72e32e4 --- /dev/null +++ b/src/app/victor_serial.rs @@ -0,0 +1,137 @@ +//! Read-only serial task for Victor 86E (ES51932 over CP2102). +//! +//! Unlike the SCPI `serial` task, this only listens for 14-byte frames and never +//! sends commands. Serial port must be opened at 19200 7o1 — see `victor_es519xx`. + +use std::{ + io::{self, Read}, + time::Duration, +}; + +use mio::{Events, Interest, Poll, Token}; +use tokio::sync::{mpsc, oneshot}; + +use crate::multimeter::MeterMode; +use crate::victor_es519xx; + +const SERIAL_TOKEN: Token = Token(1); + +impl super::MyApp { + pub fn spawn_victor_serial_task(&mut self) { + if self.serial.is_none() { + return; + } + + let (tx_data, rx_data) = mpsc::channel::>(100); + let (tx_mode, rx_mode) = mpsc::channel::<(MeterMode, String)>(10); + let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); + + self.serial_rx = Some(rx_data); + self.mode_rx = Some(rx_mode); + self.shutdown_tx = Some(shutdown_tx); + self.serial_tx = None; + + let mut serial = self.serial.take().unwrap(); + let value_debug_shared = self.value_debug_shared.clone(); + let poll_interval_shared = self.poll_interval_shared.clone(); + let device_shared = self.device.clone(); + + tokio::spawn(async move { + let mut poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1); + let mut readbuf = [0u8; 256]; + let mut packet_buf = Vec::with_capacity(512); + let mut shutting_down = false; + let mut last_mode = None::; + + poll.registry() + .register(&mut serial, SERIAL_TOKEN, Interest::READABLE) + .unwrap(); + + { + let mut dev = device_shared.lock().unwrap(); + *dev = "Victor 86E (read only)".to_owned(); + } + + if *value_debug_shared.lock().unwrap() { + println!("Victor 86E serial task started"); + } + + loop { + tokio::select! { + _ = &mut shutdown_rx, if !shutting_down => { + shutting_down = true; + } + _ = async { + let debug = *value_debug_shared.lock().unwrap(); + let interval = *poll_interval_shared.lock().unwrap(); + + match poll.poll(&mut events, Some(Duration::from_millis(interval))) { + Ok(()) => { + for event in events.iter() { + if !event.is_readable() { + continue; + } + loop { + match serial.read(&mut readbuf) { + Ok(0) => break, + Ok(count) => { + if debug { + println!("Victor 86E received {} bytes", count); + } + let readings = + victor_es519xx::feed_bytes( + &mut packet_buf, + &readbuf[..count], + ); + for reading in readings { + if debug { + println!( + "Victor 86E reading: {} {:?}", + reading.value, reading.mode + ); + } + let _ = tx_data.send(Some(reading.value)).await; + if last_mode != Some(reading.mode) { + last_mode = Some(reading.mode); + let _ = tx_mode + .send((reading.mode, reading.unit)) + .await; + } + } + } + Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, + Err(e) => { + if debug { + println!("Victor 86E read error: {}", e); + } + break; + } + } + } + } + } + Err(e) => { + if debug { + println!("Victor 86E poll error: {}", e); + } + } + } + + tokio::time::sleep(Duration::from_millis(interval)).await; + } => {} + } + + if shutting_down { + break; + } + } + + let _ = poll.registry().deregister(&mut serial); + drop(serial); + if *value_debug_shared.lock().unwrap() { + println!("Victor 86E serial task shutting down"); + } + }); + } +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index a8be4d2..1cdd5f2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,3 +7,5 @@ mod helpers; mod multimeter; #[cfg(not(target_arch = "wasm32"))] mod victor; +#[cfg(not(target_arch = "wasm32"))] +mod victor_es519xx; diff --git a/src/victor.rs b/src/victor.rs index dbc2dac..fa2a3ea 100644 --- a/src/victor.rs +++ b/src/victor.rs @@ -1,6 +1,15 @@ -//! Victor (RuoShui) 86-series USB HID protocol support. -//! Deobfuscation followed by Fortune Semiconductor FS9922-DMM4 -//! chip packet decode. +//! Victor (RuoShui) 86B/C/D USB HID protocol support. +//! +//! These meters use a USB HID interface (VID 0x1244, PID 0xd237) with obfuscated +//! 14-byte reports from the USB cable. After deobfuscation the payload follows the +//! Fortune Semiconductor FS9922-DMM4 chip format. Read only — modes are set on the meter. +//! +//! For the Victor 86E (CP2102 serial / ES51932) see `victor_es519xx` instead. +//! +//! ## Sources +//! +//! - +//! - libsigrok `serial_hid_victor.c` and `fs9922.c` use crate::multimeter::MeterMode; diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs new file mode 100644 index 0000000..10853ba --- /dev/null +++ b/src/victor_es519xx.rs @@ -0,0 +1,359 @@ +//! Cyrustek ES51932 (Victor / RuoShui 86E) serial protocol parser. +//! +//! The 86E uses a CP2102 USB-UART bridge (not USB HID like the 86B/C/D). +//! It streams read-only measurement frames; modes cannot be changed remotely. +//! +//! ## Serial settings +//! +//! - 19200 baud, 7 data bits, odd parity, 1 stop bit (7o1) +//! - Linux example: `stty -F /dev/ttyUSB0 19200 cs7 parenb parodd -cstopb raw -echo` +//! +//! ## Frame layout (14 bytes, CR/LF terminated) +//! +//! `[range][digit×5][function][status][opt1][opt2][opt3][opt4][CR][LF]` +//! +//! A line like `103560;000:3` is not human-padded text — the semicolon and colon +//! are literal protocol bytes. For example `;` (0x3b) encodes DC voltage mode. +//! +//! ## Sources +//! +//! - [rusty_meter#16](https://github.com/markusdd/rusty_meter/issues/16) — 86E +//! captures and serial parameters (Markus Krause / MFJoyBoy) +//! - [EEVblog teardown / ES51932_log](https://www.eevblog.com/forum/testgear/teardown-ruoshui-86e-22000-count-dmm-50-eur/) +//! — original 14-byte packet description and Perl decoder +//! - [libsigrok `es519xx.c`](https://github.com/sigrokproject/libsigrok/blob/master/src/dmm/es519xx.c) +//! — range exponents and function-byte mapping (ES51931/ES51932, 19200/14b) + +use crate::multimeter::MeterMode; +use crate::victor::VictorReading; + +pub const VICTOR_86E_BAUD: u32 = 19200; +pub const PACKET_LEN: usize = 14; + +/// Exponents for 19200 baud / 14-byte / ES51931/32 packets (from libsigrok). +const EXPONENTS_VOLTAGE: [i32; 8] = [-4, -3, -2, -1, -5, 0, 0, 0]; +const EXPONENTS_UA: [i32; 8] = [-8, -7, 0, 0, 0, 0, 0, 0]; +const EXPONENTS_MA: [i32; 8] = [-6, -5, 0, 0, 0, 0, 0, 0]; +const EXPONENTS_A: [i32; 8] = [-3, 0, 0, 0, 0, 0, 0, 0]; +const EXPONENTS_MANUAL_A: [i32; 8] = [-4, -3, -2, -1, 0, 0, 0, 0]; +const EXPONENTS_RES: [i32; 8] = [-2, -1, 0, 1, 2, 3, 4, 0]; +const EXPONENTS_FREQ: [i32; 8] = [-2, -1, 0, 0, 1, 2, 3, 4]; +const EXPONENTS_CAP: [i32; 8] = [-12, -11, -10, -9, -8, -7, -6, -5]; +const EXPONENTS_DIODE: [i32; 8] = [-4, 0, 0, 0, 0, 0, 0, 0]; + +#[derive(Debug, Clone, Default)] +struct Es519xxFlags { + is_sign: bool, + is_ol: bool, + is_ul: bool, + is_judge: bool, + is_dc: bool, + is_ac: bool, + is_auto: bool, + is_vahz: bool, + is_voltage: bool, + is_current: bool, + is_micro: bool, + is_milli: bool, + is_resistance: bool, + is_continuity: bool, + is_diode: bool, + is_frequency: bool, + is_duty_cycle: bool, + is_capacitance: bool, + is_temperature: bool, + is_celsius: bool, + is_fahrenheit: bool, +} + +fn parse_flags(buf: &[u8; PACKET_LEN], flags: &mut Es519xxFlags) { + flags.is_judge = buf[7] & (1 << 3) != 0; + flags.is_sign = buf[7] & (1 << 2) != 0; + flags.is_ol = buf[7] & (1 << 0) != 0; + + flags.is_ul = buf[9] & (1 << 3) != 0; + + flags.is_dc = buf[10] & (1 << 3) != 0; + flags.is_ac = buf[10] & (1 << 2) != 0; + flags.is_auto = buf[10] & (1 << 1) != 0; + flags.is_vahz = buf[10] & (1 << 0) != 0; + + match buf[6] { + 0x3b => flags.is_voltage = true, // ';' + 0x3d => { + flags.is_current = true; + flags.is_micro = true; + flags.is_auto = true; + } + 0x3f => { + flags.is_current = true; + flags.is_milli = true; + flags.is_auto = true; + } + 0x30 => { + flags.is_current = true; + flags.is_auto = true; + } + 0x39 => { + flags.is_current = true; + flags.is_auto = false; + } + 0x33 => flags.is_resistance = true, + 0x35 => flags.is_continuity = true, + 0x31 => flags.is_diode = true, + 0x32 => { + if flags.is_judge { + flags.is_duty_cycle = true; + } else { + flags.is_frequency = true; + } + } + 0x36 => flags.is_capacitance = true, + 0x34 => { + flags.is_temperature = true; + if flags.is_judge { + flags.is_celsius = true; + } else { + flags.is_fahrenheit = true; + } + } + _ => {} + } + + if flags.is_vahz && (flags.is_voltage || flags.is_current) { + flags.is_voltage = false; + flags.is_current = false; + flags.is_micro = false; + flags.is_milli = false; + if flags.is_judge { + flags.is_duty_cycle = true; + flags.is_frequency = false; + } else { + flags.is_frequency = true; + flags.is_duty_cycle = false; + } + } +} + +fn flags_valid(flags: &Es519xxFlags) -> bool { + let mult = [flags.is_micro, flags.is_milli] + .into_iter() + .filter(|&b| b) + .count(); + if mult > 1 { + return false; + } + + let modes = [ + flags.is_voltage, + flags.is_current, + flags.is_resistance, + flags.is_frequency, + flags.is_duty_cycle, + flags.is_capacitance, + flags.is_temperature, + flags.is_continuity, + flags.is_diode, + ] + .into_iter() + .filter(|&b| b) + .count(); + if modes > 1 { + return false; + } + + !(flags.is_ac && flags.is_dc) +} + +fn parse_value(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags) -> Option { + if flags.is_ol || flags.is_ul { + return Some(f64::INFINITY); + } + + if !buf[1].is_ascii_digit() + || !buf[2].is_ascii_digit() + || !buf[3].is_ascii_digit() + || !buf[4].is_ascii_digit() + || !buf[5].is_ascii_digit() + { + return None; + } + + let mut intval = 0i64; + for &digit in &buf[1..=5] { + intval = intval * 10 + (digit - b'0') as i64; + } + if flags.is_sign { + intval = -intval; + } + Some(intval as f64) +} + +fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Option { + let idx = (buf[0] as i32).saturating_sub(b'0' as i32); + if !(0..=7).contains(&idx) { + return None; + } + let idx = idx as usize; + + let exponent = if flags.is_duty_cycle { + -1 + } else if flags.is_voltage { + EXPONENTS_VOLTAGE[idx] + } else if flags.is_current && flags.is_micro { + EXPONENTS_UA[idx] + } else if flags.is_current && flags.is_milli { + EXPONENTS_MA[idx] + } else if flags.is_current && flags.is_auto { + EXPONENTS_A[idx] + } else if flags.is_current { + EXPONENTS_MANUAL_A[idx] + } else if flags.is_resistance || flags.is_continuity { + EXPONENTS_RES[idx] + } else if flags.is_frequency { + EXPONENTS_FREQ[idx] + } else if flags.is_capacitance { + EXPONENTS_CAP[idx] + } else if flags.is_diode { + EXPONENTS_DIODE[idx] + } else if flags.is_temperature { + EXPONENTS_RES[idx] + } else { + return None; + }; + + Some(value * 10f64.powi(exponent)) +} + +fn mode_from_flags(flags: &Es519xxFlags) -> Option<(MeterMode, &'static str)> { + if flags.is_continuity { + return Some((MeterMode::Cont, "Ohm")); + } + if flags.is_diode { + return Some((MeterMode::Diod, "V")); + } + if flags.is_duty_cycle { + return Some((MeterMode::Duty, "%")); + } + if flags.is_voltage { + if flags.is_ac { + return Some((MeterMode::Vac, "VAC")); + } + return Some((MeterMode::Vdc, "VDC")); + } + if flags.is_current { + if flags.is_ac { + return Some((MeterMode::Aac, "AAC")); + } + return Some((MeterMode::Adc, "ADC")); + } + if flags.is_resistance { + return Some((MeterMode::Res, "Ohm")); + } + if flags.is_capacitance { + return Some((MeterMode::Cap, "F")); + } + if flags.is_frequency { + return Some((MeterMode::Freq, "Hz")); + } + if flags.is_temperature { + if flags.is_fahrenheit { + return Some((MeterMode::Temp, "°F")); + } + return Some((MeterMode::Temp, "°C")); + } + None +} + +/// Parse a 14-byte Victor 86E / ES51932 serial frame. +pub fn parse_packet(buf: &[u8; PACKET_LEN]) -> Option { + if buf[12] != b'\r' || buf[13] != b'\n' { + return None; + } + + let mut flags = Es519xxFlags::default(); + parse_flags(buf, &mut flags); + if !flags_valid(&flags) { + return None; + } + + let mut value = parse_value(buf, &flags)?; + value = apply_range(buf, &flags, value)?; + + if flags.is_continuity { + value = if value.is_infinite() || !(0.0..=25.0).contains(&value) { + 0.0 + } else { + 1.0 + }; + } + + let (mode, unit) = mode_from_flags(&flags)?; + + Some(VictorReading { + value, + mode, + unit: unit.to_owned(), + }) +} + +/// Append incoming serial bytes and return any complete parsed frames. +pub fn feed_bytes(buffer: &mut Vec, chunk: &[u8]) -> Vec { + buffer.extend_from_slice(chunk); + let mut readings = Vec::new(); + + loop { + let Some(pos) = buffer.windows(2).position(|w| w == b"\r\n") else { + break; + }; + if pos + 2 < PACKET_LEN { + buffer.drain(..pos + 2); + continue; + } + let start = pos + 2 - PACKET_LEN; + if start > pos { + buffer.drain(..pos + 2); + continue; + } + let frame: [u8; PACKET_LEN] = buffer[start..=pos + 1].try_into().ok().unwrap(); + buffer.drain(..pos + 2); + if let Some(reading) = parse_packet(&frame) { + readings.push(reading); + } + } + + if buffer.len() > PACKET_LEN * 4 { + let keep = PACKET_LEN * 2; + let drain_to = buffer.len().saturating_sub(keep); + buffer.drain(..drain_to); + } + + readings +} + +#[cfg(test)] +mod tests { + use super::*; + + fn frame(s: &str) -> [u8; PACKET_LEN] { + let bytes = s.as_bytes(); + assert_eq!(bytes.len(), PACKET_LEN); + bytes.try_into().unwrap() + } + + #[test] + fn parses_86e_dc_voltage_sample() { + // From issue #16: ~3.6 V battery in DC mode. + let reading = parse_packet(&frame("103560;000:3\r\n")).unwrap(); + assert!((reading.value - 3.56).abs() < 1e-6, "got {}", reading.value); + assert_eq!(reading.mode, MeterMode::Vdc); + assert_eq!(reading.unit, "VDC"); + } + + #[test] + fn rejects_incomplete_footer() { + let mut buf = frame("103560;000:3\r\n"); + buf[13] = b'X'; + assert!(parse_packet(&buf).is_none()); + } +} \ No newline at end of file From 712f191207224bfb062a9fe32ccba4bc38fe84f6 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Sun, 12 Jul 2026 22:54:47 +0200 Subject: [PATCH 05/13] Fix CI: install libudev-dev and apply rustfmt hidapi requires libudev on Linux; add it (and existing X11 deps) to check, test, and clippy jobs. Run cargo fmt on Victor support changes. --- .github/workflows/rust.yml | 4 +- src/app/hid.rs | 11 +- src/app/mod.rs | 6 +- src/app/ui.rs | 329 ++++++++++++++++++------------------- src/app/victor_serial.rs | 2 +- src/victor.rs | 2 +- src/victor_es519xx.rs | 2 +- 7 files changed, 172 insertions(+), 184 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 8e251e8..cebd98d 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -19,6 +19,7 @@ jobs: profile: minimal toolchain: stable override: true + - run: sudo apt-get install libudev-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev - uses: actions-rs/cargo@v1 with: command: check @@ -50,7 +51,7 @@ jobs: profile: minimal toolchain: stable override: true - - run: sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev + - run: sudo apt-get install libudev-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev - uses: actions-rs/cargo@v1 with: command: test @@ -78,6 +79,7 @@ jobs: steps: - uses: actions/checkout@v4 - uses: actions-rust-lang/setup-rust-toolchain@v1 + - run: sudo apt-get install libudev-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev - run: cargo clippy -- -D warnings # trunk: diff --git a/src/app/hid.rs b/src/app/hid.rs index 156deba..99aa9f0 100644 --- a/src/app/hid.rs +++ b/src/app/hid.rs @@ -19,9 +19,7 @@ impl super::MyApp { let path = device.path().to_string_lossy().into_owned(); let label = format!( "{} {} ({:04x}:{:04x})", - device - .manufacturer_string() - .unwrap_or("Victor"), + device.manufacturer_string().unwrap_or("Victor"), device.product_string().unwrap_or("Multimeter"), device.vendor_id(), device.product_id(), @@ -121,10 +119,7 @@ impl super::MyApp { } if let Some(reading) = victor::parse_hid_buffer(&readbuf[..len]) { if *value_debug_shared.lock().unwrap() { - println!( - "Victor reading: {} {:?}", - reading.value, reading.mode - ); + println!("Victor reading: {} {:?}", reading.value, reading.mode); } let _ = tx_data.blocking_send(Some(reading.value)); if last_mode != Some(reading.mode) { @@ -147,4 +142,4 @@ impl super::MyApp { } }); } -} \ No newline at end of file +} diff --git a/src/app/mod.rs b/src/app/mod.rs index 5e9c0e3..0a6b994 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -14,15 +14,15 @@ use tokio::sync::{mpsc, oneshot}; use crate::multimeter::{MeterMode, RangeCmd, RateCmd, ScpiMode}; // Submodules for split impl blocks +mod graph; #[cfg(not(target_arch = "wasm32"))] mod hid; -#[cfg(not(target_arch = "wasm32"))] -mod victor_serial; -mod graph; mod recording; mod serial; mod settings; mod ui; +#[cfg(not(target_arch = "wasm32"))] +mod victor_serial; /// How rusty_meter talks to the multimeter. /// diff --git a/src/app/ui.rs b/src/app/ui.rs index e8b1a7f..4236c66 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -333,11 +333,9 @@ impl super::MyApp { Ok(serial) => { self.serial = Some(serial); if let Some(ref mut serial) = self.serial { - let _ = - serial.set_data_bits(DataBits::Eight); - let _ = serial.set_stop_bits( - mio_serial::StopBits::One, - ); + let _ = serial.set_data_bits(DataBits::Eight); + let _ = serial + .set_stop_bits(mio_serial::StopBits::One); let _ = serial.set_parity(mio_serial::Parity::None); self.connection_state = @@ -349,10 +347,8 @@ impl super::MyApp { Err(e) => { self.connection_state = super::ConnectionState::Disconnected; - self.connection_error = Some(format!( - "Failed to connect: {}", - e - )); + self.connection_error = + Some(format!("Failed to connect: {}", e)); } } } @@ -361,9 +357,8 @@ impl super::MyApp { if self.hid_device_path.is_empty() { self.connection_state = super::ConnectionState::Disconnected; - self.connection_error = Some( - "No Victor HID device selected".to_owned(), - ); + self.connection_error = + Some("No Victor HID device selected".to_owned()); } else { self.connection_state = super::ConnectionState::Connected; @@ -383,14 +378,11 @@ impl super::MyApp { Ok(serial) => { self.serial = Some(serial); if let Some(ref mut serial) = self.serial { + let _ = serial.set_data_bits(DataBits::Seven); let _ = serial - .set_data_bits(DataBits::Seven); - let _ = serial.set_stop_bits( - mio_serial::StopBits::One, - ); - let _ = serial.set_parity( - mio_serial::Parity::Odd, - ); + .set_stop_bits(mio_serial::StopBits::One); + let _ = + serial.set_parity(mio_serial::Parity::Odd); self.connection_state = super::ConnectionState::Connected; self.curr_meter = "Victor 86E".to_owned(); @@ -401,10 +393,8 @@ impl super::MyApp { Err(e) => { self.connection_state = super::ConnectionState::Disconnected; - self.connection_error = Some(format!( - "Failed to connect: {}", - e - )); + self.connection_error = + Some(format!("Failed to connect: {}", e)); } } } @@ -543,155 +533,159 @@ impl super::MyApp { ui.vertical(|ui| { if self.is_read_only() { ui.label( - egui::RichText::new( - "Read only — change mode on the meter", - ) - .italics(), + egui::RichText::new("Read only — change mode on the meter") + .italics(), ); } let btn_size = Vec2 { x: 70.0, y: 20.0 }; let read_only = self.is_read_only(); ui.add_enabled_ui(!read_only, |ui| { - ui.horizontal(|ui| { - let vdc_btn = egui::Button::new("VDC") - .selected(self.metermode == MeterMode::Vdc) - .min_size(btn_size); - if ui.add(vdc_btn).clicked() { - self.set_mode( - MeterMode::Vdc, - "VDC", - "CONF:VOLT:DC AUTO\n", - Some("VDC"), - None, - ); - } - let vac_btn = egui::Button::new("VAC") - .selected(self.metermode == MeterMode::Vac) - .min_size(btn_size); - if ui.add(vac_btn).clicked() { - self.set_mode( - MeterMode::Vac, - "VAC", - "CONF:VOLT:AC AUTO\n", - Some("VAC"), - None, - ); - } - let adc_btn = egui::Button::new("ADC") - .selected(self.metermode == MeterMode::Adc) - .min_size(btn_size); - if ui.add(adc_btn).clicked() { - self.set_mode( - MeterMode::Adc, - "ADC", - "CONF:CURR:DC AUTO\n", - Some("ADC"), - None, - ); - } - let aac_btn = egui::Button::new("AAC") - .selected(self.metermode == MeterMode::Aac) - .min_size(btn_size); - if ui.add(aac_btn).clicked() { - self.set_mode( - MeterMode::Aac, - "AAC", - "CONF:CURR:AC AUTO\n", - Some("AAC"), - None, - ); - } - }); - ui.horizontal(|ui| { - let res_btn = egui::Button::new("Ohm") - .selected(self.metermode == MeterMode::Res) - .min_size(btn_size); - if ui.add(res_btn).clicked() { - self.set_mode( - MeterMode::Res, - "Ohm", - "CONF:RES AUTO\n", - Some("RES"), - None, - ); - } - let cap_btn = egui::Button::new("C") - .selected(self.metermode == MeterMode::Cap) - .min_size(btn_size); - if ui.add(cap_btn).clicked() { - self.set_mode( - MeterMode::Cap, - "F", - "CONF:CAP AUTO\n", - Some("CAP"), - None, - ); - } - let freq_btn = egui::Button::new("Freq") - .selected(self.metermode == MeterMode::Freq) - .min_size(btn_size); - if ui.add(freq_btn).clicked() { - self.set_mode( - MeterMode::Freq, - "Hz", - "CONF:FREQ\n", - Some("FREQ"), - None, - ); - } - let per_btn = egui::Button::new("Period") - .selected(self.metermode == MeterMode::Per) - .min_size(btn_size); - if ui.add(per_btn).clicked() { - self.set_mode(MeterMode::Per, "s", "CONF:PER\n", Some("PER"), None); - } - if self.mode_visible_in_ui(MeterMode::Duty) { - let duty_btn = egui::Button::new("Duty") - .selected(self.metermode == MeterMode::Duty) + ui.horizontal(|ui| { + let vdc_btn = egui::Button::new("VDC") + .selected(self.metermode == MeterMode::Vdc) .min_size(btn_size); - if ui.add(duty_btn).clicked() { - self.set_mode(MeterMode::Duty, "%", "", None, None); + if ui.add(vdc_btn).clicked() { + self.set_mode( + MeterMode::Vdc, + "VDC", + "CONF:VOLT:DC AUTO\n", + Some("VDC"), + None, + ); } - } - }); - ui.horizontal(|ui| { - let diod_btn = egui::Button::new("Diode") - .selected(self.metermode == MeterMode::Diod) - .min_size(btn_size); - if ui.add(diod_btn).clicked() { - self.set_mode( - MeterMode::Diod, - "V", - "CONF:DIOD\n", - Some("DIOD"), - Some(self.beeper_enabled), - ); - } - let cont_btn = egui::Button::new("Cont") - .selected(self.metermode == MeterMode::Cont) - .min_size(btn_size); - if ui.add(cont_btn).clicked() { - self.set_mode( - MeterMode::Cont, - "Ohm", - "CONF:CONT\n", - Some("CONT"), - Some(self.beeper_enabled), - ); - } - let temp_btn = egui::Button::new("Temp") - .selected(self.metermode == MeterMode::Temp) - .min_size(btn_size); - if ui.add(temp_btn).clicked() { - self.set_mode( - MeterMode::Temp, - "°C", - "CONF:TEMP:RTD PT100\n", - Some("TEMP"), - None, - ); - } - }); + let vac_btn = egui::Button::new("VAC") + .selected(self.metermode == MeterMode::Vac) + .min_size(btn_size); + if ui.add(vac_btn).clicked() { + self.set_mode( + MeterMode::Vac, + "VAC", + "CONF:VOLT:AC AUTO\n", + Some("VAC"), + None, + ); + } + let adc_btn = egui::Button::new("ADC") + .selected(self.metermode == MeterMode::Adc) + .min_size(btn_size); + if ui.add(adc_btn).clicked() { + self.set_mode( + MeterMode::Adc, + "ADC", + "CONF:CURR:DC AUTO\n", + Some("ADC"), + None, + ); + } + let aac_btn = egui::Button::new("AAC") + .selected(self.metermode == MeterMode::Aac) + .min_size(btn_size); + if ui.add(aac_btn).clicked() { + self.set_mode( + MeterMode::Aac, + "AAC", + "CONF:CURR:AC AUTO\n", + Some("AAC"), + None, + ); + } + }); + ui.horizontal(|ui| { + let res_btn = egui::Button::new("Ohm") + .selected(self.metermode == MeterMode::Res) + .min_size(btn_size); + if ui.add(res_btn).clicked() { + self.set_mode( + MeterMode::Res, + "Ohm", + "CONF:RES AUTO\n", + Some("RES"), + None, + ); + } + let cap_btn = egui::Button::new("C") + .selected(self.metermode == MeterMode::Cap) + .min_size(btn_size); + if ui.add(cap_btn).clicked() { + self.set_mode( + MeterMode::Cap, + "F", + "CONF:CAP AUTO\n", + Some("CAP"), + None, + ); + } + let freq_btn = egui::Button::new("Freq") + .selected(self.metermode == MeterMode::Freq) + .min_size(btn_size); + if ui.add(freq_btn).clicked() { + self.set_mode( + MeterMode::Freq, + "Hz", + "CONF:FREQ\n", + Some("FREQ"), + None, + ); + } + let per_btn = egui::Button::new("Period") + .selected(self.metermode == MeterMode::Per) + .min_size(btn_size); + if ui.add(per_btn).clicked() { + self.set_mode( + MeterMode::Per, + "s", + "CONF:PER\n", + Some("PER"), + None, + ); + } + if self.mode_visible_in_ui(MeterMode::Duty) { + let duty_btn = egui::Button::new("Duty") + .selected(self.metermode == MeterMode::Duty) + .min_size(btn_size); + if ui.add(duty_btn).clicked() { + self.set_mode(MeterMode::Duty, "%", "", None, None); + } + } + }); + ui.horizontal(|ui| { + let diod_btn = egui::Button::new("Diode") + .selected(self.metermode == MeterMode::Diod) + .min_size(btn_size); + if ui.add(diod_btn).clicked() { + self.set_mode( + MeterMode::Diod, + "V", + "CONF:DIOD\n", + Some("DIOD"), + Some(self.beeper_enabled), + ); + } + let cont_btn = egui::Button::new("Cont") + .selected(self.metermode == MeterMode::Cont) + .min_size(btn_size); + if ui.add(cont_btn).clicked() { + self.set_mode( + MeterMode::Cont, + "Ohm", + "CONF:CONT\n", + Some("CONT"), + Some(self.beeper_enabled), + ); + } + let temp_btn = egui::Button::new("Temp") + .selected(self.metermode == MeterMode::Temp) + .min_size(btn_size); + if ui.add(temp_btn).clicked() { + self.set_mode( + MeterMode::Temp, + "°C", + "CONF:TEMP:RTD PT100\n", + Some("TEMP"), + None, + ); + } + }); }); // add_enabled_ui }); }); @@ -714,10 +708,7 @@ impl super::MyApp { if self.is_read_only() { ui.label("Mode/range controlled on device"); let mut auto_scale = self.auto_scale_units(&self.metermode); - if ui - .checkbox(&mut auto_scale, "Auto-scale units") - .changed() - { + if ui.checkbox(&mut auto_scale, "Auto-scale units").changed() { self.set_auto_scale_units(self.metermode, auto_scale); } return; diff --git a/src/app/victor_serial.rs b/src/app/victor_serial.rs index 72e32e4..1244e01 100644 --- a/src/app/victor_serial.rs +++ b/src/app/victor_serial.rs @@ -134,4 +134,4 @@ impl super::MyApp { } }); } -} \ No newline at end of file +} diff --git a/src/victor.rs b/src/victor.rs index fa2a3ea..503eafe 100644 --- a/src/victor.rs +++ b/src/victor.rs @@ -337,4 +337,4 @@ mod tests { assert_eq!(reading.mode, MeterMode::Vdc); assert_eq!(reading.unit, "VDC"); } -} \ No newline at end of file +} diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 10853ba..9624a26 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -356,4 +356,4 @@ mod tests { buf[13] = b'X'; assert!(parse_packet(&buf).is_none()); } -} \ No newline at end of file +} From cf573ef42989c2f5f65ad366f4ab7bbdfb07bff1 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Wed, 15 Jul 2026 23:59:18 +0200 Subject: [PATCH 06/13] implement serial Victor86B/C/D (new gen) support --- Cargo.lock | 11 - Cargo.toml | 5 +- data/victor_serial/Victor86D.png | Bin 0 -> 350230 bytes data/victor_serial/ht1621b.PDF | Bin 0 -> 187489 bytes data/victor_serial/raw_tx_data.vcd | 1407 +++++++++++++++++ data/victor_serial/victor_serial_samples.csv | 18 + src/app/graph.rs | 5 +- src/app/hid.rs | 6 +- src/app/mod.rs | 138 +- src/app/settings.rs | 1 + src/app/ui.rs | 313 ++-- src/app/victor_86bcd_capture_ui.rs | 180 +++ src/app/victor_86bcd_serial.rs | 331 ++++ ...{victor_serial.rs => victor_86e_serial.rs} | 4 +- src/bin/victor_86bcd_explore.rs | 120 ++ src/helpers.rs | 16 +- src/lib.rs | 6 +- src/victor_86bcd_capture.rs | 698 ++++++++ src/victor_dm1107.rs | 910 +++++++++++ src/victor_es519xx.rs | 5 +- src/{victor.rs => victor_fs9922.rs} | 8 +- 21 files changed, 4041 insertions(+), 141 deletions(-) create mode 100644 data/victor_serial/Victor86D.png create mode 100644 data/victor_serial/ht1621b.PDF create mode 100644 data/victor_serial/raw_tx_data.vcd create mode 100644 data/victor_serial/victor_serial_samples.csv create mode 100644 src/app/victor_86bcd_capture_ui.rs create mode 100644 src/app/victor_86bcd_serial.rs rename src/app/{victor_serial.rs => victor_86e_serial.rs} (99%) create mode 100644 src/bin/victor_86bcd_explore.rs create mode 100644 src/victor_86bcd_capture.rs create mode 100644 src/victor_dm1107.rs rename src/{victor.rs => victor_fs9922.rs} (95%) diff --git a/Cargo.lock b/Cargo.lock index 11cdbb9..37ceda6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4141,7 +4141,6 @@ dependencies = [ "rfd", "serde", "serde_json", - "subprocess", "tempfile", "tokio", "urlencoding", @@ -4476,16 +4475,6 @@ dependencies = [ "float-cmp", ] -[[package]] -name = "subprocess" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3713691ac66e56ba6bafb8a62158859653b3127ae5cacae98d437bbb0c9ccb06" -dependencies = [ - "libc", - "winapi", -] - [[package]] name = "subtle" version = "2.5.0" diff --git a/Cargo.toml b/Cargo.toml index 1e57d56..23bbb80 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,7 +25,6 @@ egui_plot = "0.35.0" log = "0.4.30" reqwest = { version = "0.13.4", features = ["blocking"] } urlencoding = "2.1.3" -subprocess = "1.1.0" serde_json = "1.0.150" regex = "1.12.3" indexmap = "2.14.0" @@ -54,6 +53,10 @@ hidapi = "2.6.3" [target.'cfg(target_arch = "wasm32")'.dependencies] wasm-bindgen-futures = "0.4.72" +[[bin]] +name = "victor-86bcd-explore" +path = "src/bin/victor_86bcd_explore.rs" + [build-dependencies] # for windows icon embedding winres = "0.1" diff --git a/data/victor_serial/Victor86D.png b/data/victor_serial/Victor86D.png new file mode 100644 index 0000000000000000000000000000000000000000..87ef2e47da1ed405b34e0afc5a3562e93f0e2dfc GIT binary patch literal 350230 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%0Ap2inj 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 Y+fBgOL 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

N|S}_5(vgy=$hqj3(wqP~|!X{d7r#N{e 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%0A*W$DM-kCiwdUQ$_?CT9BtYO@CqBX&Gx+`H*N zzYgBsk~tOOa3Jc*4^9fhI((nANuxb4-`jVq$zdIl-90>b`D$t+9y}ifAF<=a63LMR zMYbKEPh5a}$Ip}I&xw~I{52dFXGh216%>+RoT;Rs#?iOcx&q2)>A(GC34_)RcxJx3 z58TieFP%35Qf36QW=%s8D=ak9P+1BR>>D zLpLA=bV&tm@Z)4VX&no;K~KYn{*YybVWW*C${&gvWcF*#b!%Vxw6B?^)|PTemU4d|CEh;3WE@FGr$mE+^Y~ktzm5w6#bxNv?d) ziD}CEWw&}Qj$sn4&4CttB}$-tt#)ioXz6UuXvQKd?0YrADn#ZID-JZLm>wKS86LFt zRnYI)=z3oG`+9IA6G4Y_f(q|(j1dflgfz*Hn4KJSA=qc*n+87PQ@ZkjK=O8p%*yIi zS8Y!v2DplbF2X|UBok6AKgZyj-*&&tEne^{*h2d}#YCaie?ZJDyOvlh^MV%Wv1KG{ zmI*3{b%jx5Fw#Dq%d<`gVzd{-+iEr!Z8q9mr5AYpHMT!lLV}tUU&!G~hLrBhq6;E3 z#vCXm>E3*4MH#lDrQ<#|_at*|Bx1rXLBH5SLGv8IRE`&izAK^GLCke;>RYx8Ijj^3 z)hWxRs1C&YJiVdh-QEq8fbsAPS_t4@zdr(?Zv029{>FM%mKk8+?mYiw9A{f{_V-sZ zMg#`eFEA35(4xjGYa2&zZ`rhwJS5Q(G#FFUuczx8x(5Q$o!*n(Y1-v~R44-f-v4J{ zIJ>$^P}t7cyIBXTmh-VgH!fAASE%0Ch9$mL<`)m`cb+1@+v^uAHgXlMWtcgcqzr~w z6wsRc{m63niQQa>&&pbEaq=TyHb9x?;rW{{Oc-xzQ(Y6;oLP@Ps9YY9gu?eoKX2D? zCpsC``RtvmwaGTdxk`eze!9Q~yPv8>Q9xUE-rR|NU!j)QSCNv1j4tBa(Fi{7%Ta_j zmd>e36j=ggzNxeB`fC1FJ;=Sh=^^}9q#}pgHKbz0H}{lFeR}$I+dHd|pUPKXH7ABn zaM;`OZAeABfm=;QtTHZEEaz?UR-5cgA*lF^^zd(NhsL5@sS+6x4IDY6T-jIG-9OEw zTKP#9&Lo{#=tATQA``8WUkfGd8Kt<3EF7VZTXNuwzhs|ebxfD|V_>}+dYRmN=Q=l? z(l5?t1;O^bSiu-l{t}A%a^quc%6yKe_#S8L{L);xu#K5BBvQGtvs*k~Rb4%A+t?#& zyqdkD{@{+BF@Vum*So$>IAbg@rmee5InJ&$J#Ec37&8H^wGHV~@3A?dyPVu8;v+dN z@Ztd&w8w&Ef-n>*ZUtmhIOHXqSQngxT-mXupDNEBB^KB*{{i>4yotc17}C5#$LfI> zkzv=;jm~h&<6pnmPC#4pO_3_>Jz!X?s;Qm3Xkeu_wtGdFO}x505&w8A{Zz^xGM5_{ zQmAD)72O+$%Y=zd5X7dTdA=vkF_^=oGRs52$ItHImkPB8^MZn{T z>t?uIbX9h4jyFL+KaH<`Zl#Y~94W)!3^9=$TEAqP@5+!I*CF;h%Xn@vY>-2 zM@IpgFiOAEJ7=)iV)Yyur~J1W}~h^ByeQp2VP-*v)evwAhQBM zZ%1dzjNb33v-5HiDd}n~f2!UuJ))?HszVzvr}Zu6!Bo`C`qCw1F?00kd|-Ifi5gZ) ztDN=hP1FWPZ~xh_ce-E2@_$}odD`x8pSVA?Zpv&}RZLCA(b>|c$yEp+HWT_Z>*){M zst>3$Ldq&viAtug^eog8--b$fXdM}ySEy-KvdH$dJbN`@S(y(-MC0AV(5BcU**A{AW4HAxd9bt>Q780&?}2Nj}=lm6nx{hd%Uk%A^6)7y*%I-~#qCRHSA^ zf}K7+sRqwC%JK9i_aiT*ZP(XrCImn~ViT!c`8{icF=V2c$9NbPDDo+NuH{0&AUz<* z{Cl8=zA6zldW&RELyh*xj~oF3Af@w$8DfJk9VhX3g)} za9reRHqnW7v7pN3=I~51n&B}04&N|R#=je0N{N&}`pd?&I<=8|w|8z}_&itIRhE*m z>kXMFYKvz&zeV~`_^Iquz5O6}I`(xos zNFJt3n4VG}tbBCzCXjPfb~jlHB)aL$Ss+szlJ=kx_}wzas5AiP7n{V;3>;&pl#Dpd z*T1NNb?!@b4_X0@>On&|g73Q>ymr+f$^19@XMlv$6{a!2pMI3=bLbqR!_TQJS^s=W`T9iV3I-p?HH?fx3l%c8jE?&c zR~Ay+2C|Eb0q{dPo}325o5JGELOMM3!IX?eV${LL2qBY2+Z*}2wzhZOPx7>VF@5~7 zT2)hB2YQX1_54;&cy7GARPealU?P_iTz zqd2SNu7Jg>Sq(kI_!2rB^5yDM8?Hw7jGV1$HMLHMkF0Sb-U9eLjO>CD8woU|&M4`j zKVb!0XlKM!@Tf%h*wUD|x(Vr^AfpV=bggtRCd`o2pZ8! zDkV@+Cb5|`OJhocpx(p6Jfxp^79|UZAS88(=&>p?l=OGIE&bGRnAwNtT>0R~(A4>l zFmM&NVHsV)t##CEA}vP5YY_2{&f?>gm}Vn8NM+H70Oiz)(FeB}S$i(uL9K+)(rv*q z$bwJ#4_1(KYd=;wa!ugKXybbE7xp>nuslVr;^aKEA(h7b7hRYv2CJ%h+u;@Vv*`&| zB)Xc@TTa8fM)R7*)lz*t*-C+6&ZM{G^T*kF$uw-Y&Q0=4JG>>%aC|hKgeX*au|5$* z-g@$Wtk~jWjnIBFK#D5Tk!xNnT+S+8OgCen;1yb>$fX1X11KZEYbw>hC2QxiCvMhd zJCLx*j&r4aKeKNMx47G040l@;&UdIQw@z4ICNHrTFXY&zWHyhZVC3DVlj5!|U*j$D ztlr5c3xPe*>F}g`#d9OSUzzgI!moJNV|@SBn4>TKgT8$qSEKLi!u{it=YeBHhpv>&yG zR-mg-*AOu{Vt&K^souLcc?nv)A^6089N;~5-HRs6Zfar^v3QR#;G`fx?9}p^-Tw|@*y$^oSoGasom^H;sy}^{vUuh0 z^xG#lQvXUWEWT^tZ{#Jv)0-uIDyz>@S%#e|Cqq`PtD7e+MVbHd5%OjF(Kt&eR;3)P}*@s zN1Z{*E}Er?_>)ZJV(ApOKd_PUn4X-8@Q)K>j#;$Xu7krBgXm|pRjFg|cVdRqDe2e96=J(k4C2~d#YL<|E37U_lQwPPo z!jY@ZbR9l@!z}y;HI?}9;#-w&fzIZi71|GGDp8eV)qX5+zgJ}%mS&Kd6wd}48nZ*> zh4MQiVG%SMsUox*%NrBX&2pZ#i4DY`jq0PYa<%PeTil_vBC6;h2DJu4!QLxx{1B1lMu6#=@F&s)h4-9PE%w3jq z%N(WUuXOt>92s7-Brc?vF%>b^SH9^R;1K4}^%nU4F232F1Zt@tTRh_iBz5#fHC&aJ zY$=c|VH{k4cU!LZ4%Z zV79&axOKDL3!$W}H0mNaPCYW`U3uf{qfnkRC$!^es~t}bXLC~N$oIs??f}8{qeqgU zF4h8RoSgk1$6h!c4+7!vFOy|H_qpUf0W)nE_|s_Ec1GEVY9_(xV9^)@C9o>pPMv|{ zvL8q$n8$b|ckE;M_lnhlwg=l@YB@*A-pCQRgFKzhgRlyX#!TYyxy32KbJXh_rkgQn ztV{KjY^Wq#f+@Tl>Mr}~m^mF6+V>iH`<#O+i7RFdcc&ZTPAZaOijWNw&-1M zC`fRqFrh}FC~eLID>0Y3(eHP6V?=E!-J5M|lWoo8LYmg@pz=r~;%IS&E{UAPac#h& z=>e!E2!EIjMmlW0`;*9NwRFUV`0eT^0AQthxoqL@Rqd=Os|{TB$5Uj&Z*4M;%l9T( z@FlSXQGC(G)eQPcAUZH?lBC>Eo#ryGW;jE)a2w`kzK;mr?@zI90&CQQw#7f}qBY|I zRZjth{0B2?4{{HsSeKW-xH^rC;jN>%0!(*k79LSkOK7SrbCb7qyV^0{XQ!b1ATPNl zrYwKvmNf1e-(QaWDkjad_nd$l+dWe5DI&}=MlJA4%Gi*0pgDh9m_09WJxxfg zkD81hFz#9>&9g%Ns_}I`l3_)xdlO6@mhk<7@Ug9S(H{M4N)4eXs`YgGhw%XmrW$G` z*K?L3O_@kd9L(onP{~loX=Sc0)UjKl8&wzyrI1_al&(s3P-AG%n3R3_Se8YF8y2}* z_JTUsw}6Va=wAgRfNFGb#v*LxC}iy6k@w*^5cDc+EZ*Yt2!V}_4d@XEn;u(e&}7T@ zo5o%?A;1TfUzjY`?C=l=U{CW$h=7&Kfh007wt|fl0Dyk}ScB+#e$g{Lzu<^XS`BS| zOO4hIqWeq=E5|B^sV+fVR5{4#D@Dr-`*?Sl^%1nzb9Et-p8P(uhq=-df}7PZRC%{R`HuZv+7?m9zqW7diB#h^gxhAjiL79z>Fl9hdR za(m3sd(P4vD+whQZv;2DynfSM5H^m!5)%m)+7|v33-f`z+5@eOt!uUwo)e;pu}v@; zbrtUkr_307ja00@_O`ajtk6ci~mW3_T5JhaDTzR1nqp2`cP@KJ`Yii_eBL z{m}biJPn_{YStP-uO`04@4vp7?ogdw->KyEjk&BuBONy`NjGOTjhy8;FX#50dkYAv z3A#>aWC7fS-FAoWgSUU_O3mZetowtvY1@P>9)|U8^i8KA%!YXQ}Au@;!i@4nosO}kn!`sB8CEtVv2tAcg1H;CQ`qwl)BSbNjE~THs%w( zIiJEwZ;i#^{4V+gm6~p=tfMoQJhE{YsY13S*@-{?41&&2^$n=cd`JNudKLB5g2RPJ z>vIZKtG>*IfmXfR7ZOPRM4@kmpmo<+!<`Ywf6_C;{iM!%ATs)(0AbF-);uihub())dhPO2(mawuBTkYW%milN-XM*!P$UK)O`PKoA;shsqa@_P5t%PEi}{+O|oa6 zQ32$#zo|j(O3qc1$;=PYfq~pS7%V{!~o{q&S6O6y$S-W$Tcfr)5VU$nQ8P%JEHxj4?O)hb7$ZK?^sC7)GaR_Tx21?1R zgbnzVeud$~Yvayonwk1tDL-l*E`zqXwnV5^Ap%MF?VPqj;>on5U>8{MFQA++L4DqC1L(Jc5md{sjdM$ljpuPsae7Z^S-fs5;Qr?9K$>%F56g;Wf@tP6Ga7q-eQc?36a9x8t8_WP8i5NOo4YktceXu zJm|jj46uDijh|KN%&O#H8VWaaL0uhswb-{+^1PeEr_S(Ablw;6#zvm3&)g=XOx`=)3f=fnUZ%kol(?Woj57MREK5fOJ>z_KZ@ z$!@d`G}n zQGc{ zlqxJ#p!Mx!PC5eG1~0JWdJs+N#7ASEi-+nehqNJ7?Z6cR?iL|SMZz&6aQ+(^kFW%x zWj+e%Mj`D;uD3XgQ}!n*=V`{cKf*W&*H&ot8qD|FH1i>wh2s~t!S^QRB`JxLVo^A< zv>?fHqFhYqJ*^fcj2xkXUKr5zXMC*Dt4?Mn1PZ$fQU0MOd{hlM9Xyh}08+u`3SA*p zL^z#uww(X?@Qw+elH2RM5XZEs^$Ze>8V@*~mAG0yzcdCdv!s+tHyZ$Hq zA%wXMDC74o)Ev_}N0t}lnfjtC8K79Vtz-CvfZI44PF6iX1dhM71B$gCgQDP|Kc*AP zeIZR_F;PIH5z+3pX!d$Mh(aDt#9kK3Q>w8TLutxnR5p8}uVVzSF4C2P@pb6zT~sqZpTMYOa7G|zbhT)$c<^=( z*%zn_fJ%InnSEQe)T+s~c;9BJsiLQnJ=Wk;XRy;ytAap8ztw!$38UG9Dm9EP z_1e{-O_B)*d$0KM$piKdb{UVy;-Y^_@YGPJeX743-@iJ;e{FJFTPgV1*$%x1fa&08 z_H|&+7EuolVgA({WhEjM6t-$|j)ORvaIm)nMZ)gRD@LOcS(-8!ob&vr$Bc&q`saPJ zEMqtt@M`A;jizC5_Z3-|=?X|^=qlWu7eER*-+y_kU{b;A^)P$UTL~;Fv>sF9rF>Mw z9On;|*1k0`Y!R?o7y@!q>o~CRh@4XbniwJz(2AO@uB~%<`vR|acj4dwOiXJWGs%ot zGLFZ*3PbkW4OSz|f-C4{85>RxbHDIf6V-g>x*`+xtM8A(!^pVrGy+Gxln8 z&(BhPHhnOD>ZwIrJ?|3)U{X33=JlYd+`r?n*3UBiX8E+*%ZDC@bqq^5n!v!oo`oH2 zICYNABB#h4N$w~xG+J%u=H}`3=4m$~Y@RYYKZ7*E1ePNka9|CSz%uV((ZM!`o-WwD zsfDWvAZjZ$SMw}PsmhY)O8GJ!1eCRbfefhW)RkJyGc{kHPv@MhY8p|4APjNNQDky0 z@OU)h@xvd8lXD(Ee8l&Wmqo%SL0xNBmtEmI&Yf+F)Vt#ydpPiQt zUhV8~);}XoQjU)f`TncFk|YWJ{t#;dhJyhQAKc?`?>T$B`(#;46pFWVKs>AGxwv35 z)&5WrL|7YOtR*ipSpld)k3(psVx-zH&o661hG7LO<5$6TSmDP?WrptIZ`6~)hO?|9 z4U7XgwXlz)pBDsqfi;#+v(1GIo80-}J=*OCMV6A}$20;a1n^EjeB zW7)x?5m!ChJn+X8bexoZ(}r8*iiTDrpcw^%Z>!d^<*Gyli5hrJb=nu^YQIibG$`*8 zy>mr-0>s%u1iq@0eOtr3C45lAMwgva*mc!yrRA)lwoEO9S6BGF!bD2aH-0ItL|~kF z(vBibkkXDUi;>kEO+9m}R91da`DXc&QQ@-&bSN+wQsB_QnSoJOa59*1KFOG*Ip;~v zN81;HOrt_odx|CPbD>wsm#ZFyq4Qd9U?G4xH6}>HLVdLvavauLqA;Y>jA#YW4hpVq zuMy@k)@AGs#tf1as|F^MBI7uV8R00b92lR&(e;xFZA2*tv|oZxHEwZ^5JSrtx=~0o z(iKk->H$*~&aM#ko2$)K$`0zvNB~#G*Bg*)qXSLjodY{6o+sc0(ADe=(BG2qZV4Zw z|2h9_>yBlrV09^5l5{PU(M}80nF_U0C0cYT+geNzLKxw!p&eKjB1_9Ug1p+BkfNv0 zs7w{9$Y_>G5i`%&I5~4rI8KK#{Uj&O3r1N+oTZo|#gbuc2tiH}I1&nyJjWPAZVh8~ zz8UGPG0=JWEJ;eYtBcFrEO@3ec=(_WFRLU|5H&KZug}7&y#(FMDJTB2-(!uT)oQW6 zxy8>u`Gh-nK4jQG=Zio8f#FwY42J{G&quiPVQIAJ{cn{*P#fXbKu%Y3vSt&NRjb+N z#?4#&@>l=B++2@)_r4}h#_S*NGD#9lAq_57XWGANy;cS3_iMc`ziCNRAawrYOcu}B zz+r7jtJP+E>k_wa-Qm*ZYpkxV(dl-`)0CrweV#sj#G^;|*xTD7O$%C$4i~mAbL-ao zT)K3H)wOjxoeo)=aCo@SPd`23$0rYY_39;I;J9_`Hn-pZkcEXMc6Xlh{dZsT;NcGx zae=V`b8~Zi@Zm??zI~T=r_G~>-*WH!lyN*H&ohCsnbCR91mEvj0St9yDUEo6RSw4K zU{nZ+!I?PMwbsgH!HDoOVZhSz0?W$_G}}$u-4>(qnD)-D(gK8mz<82p4AYbpCtm6S zi^J+!Jy&bLmmlco&;1_iD0wSIg&VO@GOV>()xOJ{v@R76bu75Q@oa zE_W4KYvt-4;|8Dp{U`k5(@&X{P^TPHGYb|F_K-fB6$fN5?ELZ}90af6Z@y_d70ZuhVEY%2i>KWbE$j@cHk5 z&!0a31B0_O?%ch@Z+`b%R@c{g{`3iHHsaayr=)2@7)2~Cukh*L|B}!C(?1Y|hE^x# z;P4r*c3x?p#UI}3>gwD}4hK99J z6vTxiwubKV0`sd&1l=x0o-(n9vpi>z%GKLp7|KEG%#nqKxXB7cAw8@A5R53Dt2*8L zpbL!9Ue7p|BS)uU2tvKm-rr!Fd#`cYGgG6hS~S#&s77ezyFP2y@}(q3&--M>BQW&& z->&dZ2_I*Ja+zBVVhwfpJB_HDK$b*MBZiXvXTsD{Rs~roGn^({ya;fL(+?=Tn+$gMbmG}ctE0HuW|eCdqfS3F^=!P z`Hr7|`WgTDPyfW_tJ|EN?C|u-QwGBUz1{-b7q4^U<~8Q#dRPNr{pHWhFU+yDyuikV zbvmskj~_my*PCN99@Fl0*|@ODja%2bdi^q^(SUBZOCxHO*A0LO9-*Ncp=c1W2waSG zvHX>vX?m)w@L-BaL1}p8VC)=*oK_LA5`=6;meV+9n5O)Aaz^LrPYm)2OHY4fI2!Zx z)js!s+U0mKmYrSah>T?+ir8p0=!p>$B9QK6OV8#Y>oZYRXF z!s-m5!Uj~u7@$^aeh~P6?l^ za1^;CLJ;Gbf&^1hd-<#c!8CDKNcUj|`8b_fSn-$;T4=~&vcMWz0W4TY$2d}yfOQ5a z=L0;^2!Z)ljDbFo00o8!!zuwQ#?f+)fu0@@wdrS*l;UJ4PDL|ElINtVhiV(>I>SO? zSjYoHXBbg%iYX7yP4&!(wUhtV*s6_F3_&Dl4JvO82626}u&}_5o9}b?!;d*S*yGE; zrW_pZv9YniojZTW=H@m}9^dD$e>r718q#XFSy@@((v{0Jn+;Bm515}{WNm$&tJkmd zYUd?cUa-2p$tRzD#>(mj4w#=`Ah4GH`8fysdo-IZHa0eBG#VW4@A2rtJ?`EAj+3)v zy4@bvZrosPeT^iZP~;iiUYF~)Zt=}GU$L{hOIGA+ndm_=MI@!L@j>{6z^oEM@-DPk z!OefI!Zf{EV`(-Ttgfu`!G|BPeQ}f1lRdur;*b1r?^_1v=XB@i`S@p_@^?S`B}*#{ zY;9lQ_~?W?cRyf#eVM&iPxqw z!4hwb(eqq-0iDV;hwNqUJI9eJ$ep24z#5htk!3H>c@f8)4M*I6w!`7+8J%WG9H$)j z$D9l%xB?o1(D{YAF1OlkE)g=96_}_XHZcdL;8;ygO3c(;Ihj&`icvynpc7b@8kS~c z<$$TtKj$F#-VL;iUg-E)O|6buIxB;(RAD|vGQKX1dPa$@up^UU@b%eG$R#0j#l7Uu;OiZU<{d|WW<3L zH#XBN2`RphV;{#kh73!~!j-7OMU(T`B@8jd&XG7rBeWRj=ucA8!jbAFU6F;RHDWoJ z!I}%{xd2PX362*y1~aQ4-wL^6p>}|?Y@H4k4FXQTd!p~JQMfP@YYodQ%Y1P64!`~9 z-}2!uk0L7q++f^w+=Q*3DZqn}++}f5~JrqBl3k#)S)PZf=q$V|I6*a_P!- z7FU+Ie(M(Z?%g9vGcH}e%y0kYcig&tnlTw>di8XL)Iv%U7<^>veHXJq=9lmFsv=-)mk#=$F}Em;BRF9bheVIMs6s?dW7k z249&r2A-Roml#qP(#~>LbIW@sL8XB;aH(IP641UNFNK}L%Lzj2Mo`v@1+F*1c}v6p@WQ7aGQAbF<%GDVM?r0- z;EHMAZ)H$qI??667D|Lu?JpI%_;(9sZ^0Qy!xStB1@l3`p%FEKHHOd{!cfd)1MlIv zHsty^UgCI;;Rc2kW7%x9xE7}Tn5V?XaEN1+J9082YYD9(u!g`us%G3KH!KtKYun(i zjc6LkD0oiBx8$6tdmXRWwnkjWM`1`{gK}0|24y%UNJ=$ZC4eNEKKX&98^NtsgSo{y zmR6RS-|x|kLbYaVvalfWy*UvQp$)jOae?>W|A6I{RbD=O!q;E^g~>SO>h)V(zkQpF z7cVg$kLdpY?7iocWw({!`2%px^Xap^Ct1a!mDJLxwI*i2Y;5eGJR38y)7$DEIf@cR zkt~+Y$}*W%X`j6Yz(!)_d<-;NW;1oHOXLzP`q2)Mx+Ib9SCS zU~O}YJ0ENRUX-0a{@+tR{+q2Ge3dvNWVgjfDBiqG@<-(CFUc_?ntq7=|eF+HuXp zC)VJU!)r|=S1=%B{k(DA0-+0;3ISl5yeUCGNcc0mIRVUVp^K z`b9cfk8Zci*47r+Z{6hR_z0s7&RLEQ-tyhof8)z9e#ebF@3FRVnO?WclZW5)=P!Q8 zmFqY7*)RT)yxXPU@3OVM#f_V{*xcMC&ojFHA?S=wr%!*-=hl1gaqXMyJbm(*#iEd% z@v*uMJB8H@RhBr)8)eVfbQ ze#hq4MK-tAnVcTuUCm%P4C9wb&SoX&zXpIaEoM8^6jh+LTq#zJ;kHTm5XG(2f~~2gQzh8i z@uFDpCs(tBKU0KJDM%B;pqta}WK?Cquh|CT3qp| zk&&HutwkQ=Tl3#Wq6Rpvg911?=R$%z!LGpD!W?TI*1c0y2FN zcWOtccAWT{Z@lFj9D6v5W@LiUsY&Q|@*sSq>_a1K+Y}MaAGIurAW!%qayMFhvyK#) zaAd?GSDOmyagwHG2IngTas_Nw|II4sYM=hv+!Z z>G3g7zJJVj-#kJmeU1;0sQL?@?>y(*zdvA6dT!mh&xP$CCQI1d-saYO?=f6iq2KFc zKFFx8WwbJ)*XwZo=1s0$zd^6pXEK@LT@9fwO$#s(q0<6UyG5aMrnQ4JREue=Fdq@! zL~6?|;Zwlhy2nGBGt};%8PcpG^OM}A)6?a&f><|b;ISlNfY_k zR#>zFpHUVibyZW_<-HCl@I3XFfAJODDr4Xj!-eM)ZRnymG6!S8*=OI%ZeULnCBojhaM?UH2)by)`GHoD|JxiJj8 zl4(SR2w0iW^E@Q{P%YnkX~ULz<@eP7hu6V3x{>=vR%Fj@%XetWn5BJD`OWA#4-h=sw{ym@vAn7KLM(2%ywh z))GhGfU7*#OF=gkTyMQR#oJsGCzfZ0&lvbSj(@?j={3K!HR}#;D9=!7u3F8b%JWh? zj*X+hV-$=WY&pdZt9TE%>T7yVTx{QX%YUHaPdJW)f!-cUzu#eFZHQ8eGGqvjfNdbA zlrTOeDR|m+5ZifP+bpetEGP$76a|q|x;chdq*;fHqjj!ayT;1e2x}L3=HxwxV@6dO zvaG{MD2d zf5>3a17DMOAax3*N}M-rY;AJ==1neLy3AxcVLX}2?0CXt%b>guT5quK&I3fz5+H#A zH7=xcz>0T!JTAD3%CcZKolsRJgTaVPm#;G%e$Bpl)6@vMa^)t!`t?6@@BV%2YQbVY z1@9ORSGaKT3jO|L4i8TRrIltlTIbT`>+}aBiek?3;agVLwy@T*Sj^aY@|cyib?$!j z8Nd3?Z%{budcpH&Pgz;p;L7#e4Z~G&j4|LKj^l@*_>p!N4hpdzPzr-WX@kiXRh3cI zmfDrgJ6)iaSKjeoe9c;FNL9keK4n-c?pBs{rT9gfuy0_WikWky7S@3arRSom*!DGp z(nBo)48Qdy|G`&$i{rG#5tLH&Iyo0NS6E%?H#NANm#}?>#&}OB(Tut|SsJ3;(p*04 zR%sU(N@J@$7Z%5&1r&r|h{}|5F+mZ|dZ?^Rl4a<3G~(^wyzq%l z0ZE!dw~H=1;`2l;!x_(COh9}U5F(yXJ~)LUVubt8b5@pw(|k`8Fq%}sN&-CvI;05k zdKp-qCkd+CVNq7pR*I0t9#p^y@HZSQ)F?ckdc~&qTu_=0u;o3kmFGl5tsqq}@`??o z*z&OAJsQhf;IDZ88OtAWyuwqp+-)XUVWUBp(V)w$C~;LC=pfidA$8put^7yYkAY{| zghML@{lSQfm##A}92YNMVRdzlEbp+nb%A^LKVfxkoom;wvzX6$^5`3$?>wO>=YZz& zmFwKN^*+Pl8ka9$VKHBjG#s)2>IJ*cA9L_# zALlHCkudBVx9+la@dCGQ-)3+BHPh+zhvR9Og*-nVZ-XJiBr-6MWKC$gS+?m_|wlB4Ej8O_KKIgyO>l$)r&>Ji``x3i<0}F{haGJ zZ*qEaz~1X!-t6y_WZj10MyQ_cy|lAX_=aF`kGl2{>SsrwV~k`zQ3O#LG!=xle$WJ@XYlIGxk!vG6`JNc z?^^*4;7x)v2`Wj+vK(XnyYTt{wkaiUhBQYd9f^gHt(nUugKFGs?WPd)_d)Pzz(qmS ziZY2lToth*q`b%sBnqP)BLhS2$-?GC=R`ob%FC)euX25kR2Ay3>-W3iF7tj#dszvA(&@haZ2=>c&NG-oDA^))w7f zkDIq|qqSi)T4DRrHivKD@PGZM|HPla_#?B~9F*dtPd?>;{P#7V|NK{6xO9QKD(Uxo zOiqtcF>5$M*th-&J@A1=G(u0$-n&5f9A>K$9QMi+}`HiC!f(9tg^no z!FwNkz<1w$!~Wi$2#@v}VjP>7Xd`uoDV+Hl_=O0pILpz^)V?sHT@X{u=W`C;?(=f@ z8P{%H=hp38*vhiGc7cO8M|65U?tglpTeojg6l0$6Jm%rU2VA{*gN^NNKK$eplC;Bx z?Q0wy9MS9dxcAXL?tgL@qdhO4@38ai8S7gY@!nCE1$%pYRJEmCELd4v=lJk7&!0Wv z@aTxGi&r76&q*%{7Ec@-5XL9)TH;b1=y|w=?QvKKE+nLlP%=u>>veI?v6vSWzQVRP zM_J(5dHzyW%$;R!68_O9eBcZl9un&qD#tLo0X-pWfo!~<|MYv?4J72_Bw$BCCR)=u~o0BM@AHtbW^HDy&( z2CXil-WYg<=M={-o}c0P9L@Wo>_UbjYZ0>xM00@W0iLh$e2L?4A-uW>*TkljqT9*2 zyuHD&-(|KasOnmt7ZBWN&*l(*cFSPA=jndM&Vk~z5MmP01_JP$VJ&eSN`o;8X_{iR z;mWnE42A=ylT)lMux<*haN+Vr2BSV%o-sK+;mO1A`0l$0JbkiDQI&wgBq?i~8{EG0 zJ{w!>WSM3-?D6`A#agL&Daj}u&f6d?L@+1?-EN1Q@88B~!*p`WH(!6v*I)gO*ZXgA z*0J~Yh#JHF&wj?;yZ5<$=Qi8hn>>4xQP#5OCyw*XdX5r!N)_0)MX+pMYK%4rpc}y$ zn0SC#12>?qYu>zl!|(pfZyAmT{JVerpZMhSPq_Wwdz6b3lNdVvoW<;fKmG2X`NQx2 zg%`UoF{#F+ieLQlANl+jpYi^^yOd=W*3=S;V$2_Z_j~^EufJt){|!|o_HbEOoSdFe zRwXZ9Jg3v`aCrEZ2jBdiUvbRw`=vf@B;0Vb`(0V?vp#*rJ?8YotKn!T~- zXclVYcv;U>csi+JIOtMUB`2p-=4Az5pzM)N+_m$3?LCLi@i$*{AI)c4bKNU8Jd98z zXq?s*N^#(7UUYS$=aS}9h$o;%x)U){6x63^CC zPgQ%015MdPsS9l4VzLhm$2-xAy$6#RlEhFJbB+!cyxD)n(a|AChi|Csnk!eYV@%3) zIz<78Z{PCWH{Y?r&3?Zc_z~ZuU@|5%P;=G zbbQSC_>{@`6yIce5JsD%DgE9MrJyM0R8>Wiqznf`Mx#~oyo>ixRRz{Mj7}sFz-Y>9 z!T98e)6-)~6BPaSs8%vj!7b-KlgW$+-+fQN-^W?Y#miUd^?H~jp`O?5?jG^%$zy*1 zyMN{JqbE!zQ@;88-$}ECVln6P<*W4i19XxwsR~YZj(Gm`34i(17kvNS_f!^kU+mET zdyn~i&f7Qp7_Io?cfaLe{{>HCakRvWrOQ@#-fr!jIntX zQxDIq=TKQ*;CSX0S3>6NA+nC-@GO8M950pSF^=bWj=a!MOn?*EJ9(P2IvlXIzCw~{ zULPJYp2?iKP&iJ94W?_UW+hXoBxbn}LLmwn!V*9`$~M9$zO>zI$7uGaT}rncfzQC^W~&&3tb$Jc7^ zT`yVdX$G0*^${FSJx6nq)ik4OQ;@(bYRXBPl4lw7*@PF*AMvN(|1-~bUT}PJiq@Jd zS1*BwljBpIbIfLQ4i8RvdvHuqhJs>Bae6xD`v(u1O(*m^Io{Reoi0Zw6JEY}&3HWF z$>WC<^Ha1^yxBkC^z;tD2o>FIki&-uqB$LQA60Yu8AO;ppHkh&vZY^{;y zImNu-^{ZDrefpgJy|+vzbL!esmKA^e{U3Po{3%zjUS(r*gEY&S&8NJ6^_tzC7aY7j zW;$7rqzT`C^A-DhyOc%Ai`^H1qpIfo?XN2wAD!^**-NZ*=)Ziyo4x0}e*K2mulJ~H z8|GZ*TU5QsEJMU(pq-`g_M{5dx}Hz2Sbp=N&YNCl*^bXVmZG zEmBeRbV_NL?{)#lEl_)y;@P#H97hMpmAIs>7n-QNM9VFHghu4eA-`a+%jW7Ty*BaFU@cXwW(s3G${4(fnXH4gtdKWE!4rPsX$2BQK*bx{J&K<#YsfoE zu^Qmj>^)Qor4vglYc78G+D}UO09fxB&kFL=F$}TpxLPLM*|QOBI+0CUwFjq`K2;ad zIYzt%B!~zUkswYuh&#m?NE1||QQ9*yux%8bfMhN#4b{$Ls|q)VQMb$G?G4ZxcXZ6G zC>wmGMO0-FC~tuTPa3jROVF&GF9IR8HMrPg=_6!m!ura9t+f?;-JJ1k!FV=rHZ1}e z?HJ^qkFI-u`2i%g#Z{gwTZ*6GQ5;U-ue+Ygwh;S_hhTYJDHx4LY+t-Uzu#y7^&7tY z<5#?Vy+;{>8+LbJAUpM1n%*k?K!b8>V-e=uTedz-~#LRl<0JsB~Zy=L!q z2V-QPlI+`QyRMesto1DBC41!o$H%8Ud$vp7%`rw}Ys+*tXF8cuS=%f{*3MGCIpXAa z%+9lybh`4cx~`bc7R;wJ>e}JGLRB?SpFC%G_Z8lH%2L)J$K#3Y|EV3tqQV1D9zW;# z?kmcoq9|njMMZB>>~Vu^@+G2zM1{%vWIyxV*s%QSL(eC-D^gSOtM?4kh3ECDqM914 z_p-iId+N$Uns9MzjZU6ntz$f!Q(D1~_8Tjp3Ryf9NaUO#5aRlzSzG-vwyc2EXokHW z7dF<|SQ{~2NV=ZcqQE+dEE8*3k)X(xXQN|S?HIw4R2KUoxbuB{a+_Y%av6Y@yN&Zo zNH~UAgUucX6+JI)!jm;0rxQvCs)?$5H``B6_;~LrYl{hHJ1Vf}#?)q}Fx+qDLlwK!iW!R&rYfuyBg+#%{ zH?}_=o-zmLL&NmTK67mqI%!QH>9;j=FwN=m|T*G^zsZG5 zTkOBCSj;EXbxl>(pfugQPd6WgY~O9$(NonGRb66h5y;kg7K@6aIBocopzCrB?HWJ= z*P5c7piU;}P=_d@z7K15-ig4~ixRCgHn^0^$~7w>F?e7$FY)sb9Mgtfc&4;7KN^fs zfKi@Ac`mIuKE7tTxaL?aEQd44s0Z&~w%pvYl(pt$A$x|L_mox5e4)salwLPyYh#5Z zF^p$(=A{V1AHx-hcodA92COoJr@2BTSZy?zYx%Xjp(?Soj*74+x?H3hP*@&rmE?X;DyCwuvCp3Nj5_1IN#9d2Vbts?u>fR?Oz&0=aqxKDexS{6aCS;bb8S z87vv0Xt~0$taBV5z2VWrZ`kYg+1-7{Y_XuSRzMzZUQW-FjYQBZC9Xh4*bCxiUK+s@ zD#OO65a!xUbzn|yxQXT}S1To(8atgHqrob}l?{5`J~~OkOOnrMHBBZ*q`8)i*_&(J zc<(xS+U5B0n3LmUyoK4k;PA}}uV25WHyGlqV==d!92XoN%s4%sljw{~7p~Cl4aw3R zf;(1gVH&gfgwxYQPR57K=QAna?8GEq?k#GeV}Ls`>MsZpAFLA(>RZ0X(+(?Dcw9}b8SSL7_?Ei@l@7;To4K^Txy0HjA?U84OrH`lz==!ok8P}_oys|PKr0sPZS%OVYq+{Pff@kpj3lFm37!fL0MZ8 zZCD+OCVVoTGMg7vwJ>Rd2Im4XwR?Sbule$Lq7{RoljG zp~HIS_Q3PWRmVSk;OLo}qXW;C%PCc*nN1zV!f|=s^6L*Z<4UpE(-bJ`0FLGR1;%w< z^XS1NP7aUIMssv<%xpFntE8c?xaI+osYQkg;JsKgt`t~Ewbj7-8hDCAsFgu$$)Be~ zRtYp{Lex(bR$hdXQXXv*y4^na?|;g#{@wq;?f335S{a4fE@7QlX}otldia26PaZKE zjo5qjik+QD+`9E1oxIC%*rPYdNK?mXE#=_Aqm)A%MUr_sUFh}|Ch^?5eT&b2{wuED zxJkb+aLwl6`vV z&QU=CC=|-5GjNKq6lFjJibr7Nl+=(CnZKNvGg#LMLpd2STm+sdU;Wha!FJ7OH!E&j zw2Y5xG7Z-+Y3jn#F%`eMr#PH?#`BcDsitxY=RBpCFzX=b@s9Y2pc)B^o|X{n zVb73tVg!QZdXxZz;BSwu{g6N-4J0Fw?L{exLRPgzqY75^+0rG)J1tqFDQl!Sx%M=No(-TLx=lS4T z!p>Vbp24eAC7ZY-Xj@}+&U1Wp!sKL(R~{QS)e08~H+Y)8GFl6h_g+#D+1lc4Em;fd z8gE?_{nmyfOE=Rf1)&+gOhrPOwg zZJ1853OrQR6kC@7oSq!B|M~@k{(y@YE@QM}KAp1vdY7kcjj~N(wpuBa(Ig>xr_lyuL}<&p){+iH*%yJWf~zTAHglckQ8p=LC6?C;4M)b@(y{#C`BQ_ab)p)LixQ9 z3QpTzyzodbd>4PnryChfS;$trXUQwIXb)vZAgks<^}5hbXG^?~zAH_Ha{U zjKOCqc!x5Q&n!(+(e{-S(G!HyXf)#E&pzYshaaGH!C$`o1G~?kvM3gKd-ffNZ;!FH zV*AoXG@hy~sfv=iuBgkBqr(Hf{PQ3A>d$}18^fimw9ub9oJSSuL@JPv2YdabI8s;a2# zI^=7U6)@it9s;tk`8T*@wN?@aZxWIuAx+ZoI|w0yIfF2Mp%MA;5ruy+mFEyUkjSXx zxVdTh=%!_3P;+`*v%RTVUvnts=ypA2p;6ZJ{zb?B*zxGlQPfa7Vf#@4Ro+p#Qo7?6 zS(cHQgu2dHlqE%7V{5VeTF3%13fgG2F(hFVW|}0VX@XZuT-`Bab%Uo%3&n?IqR|-X z8O3^P=%hx14AOMD!QF-crx2uowXM`TZQj%3A4EaZIv%W1Sy+uOhH$PCW=eQZmZS16 zS+|Q1dH&wj_LCAmfqv0Oqmm4g&e@dW?Rkh38gGh1M1=~25pmyNThUuQ{t+!t@V`1LX?t);I+QzA8tABUoGk9HLu>*tgLu8HXM_Q#ahL1 zWVm8sGP6vMOYUCHIGDhTLrYZ~7L6-g7K= z?ho6zedOLalC}U+!39q09&G>sAOJ~3K~(9i$0&=dYs#`h8;!|QZ06`>;hg~|vNU6D zZHtp)8I4xi+j~J`;P7CNy;mzZH)m1I zdAt9XXV0GUa{mpTPLHFbHyoet(;p>VPPdp%dz_xWW^ZqYhYxqCt&}=Yis*18%~ICa zzGe2m6#V)(|1&r4+~CpEE451F3qHS7 zv(c{^pVsucp0zbczvt+86nPHao}-g1c3*f7PduZM;pVpH-X+hx^6XD^$cZIdY8cv5 zI}7iP@D%M^h}3#ZUDcFDMOlD$C&$c-g2B^1WmPhr zOeJeT?eL2Q4<9}x?`Gt=1IR+`h}DH|JKF&Ok2kEfL7 zB3Lz+s;*fq7L;YQcBJHhFwcM*E!1o`PfKwQmc-J{8P>zS1D}(Ix=T@clmFw*OSp%b zZJi4*R?tacdtmwCQpx*QDyS?LSQ){50jH-5qZHd+M>qE*iO1Hk(Sy%#DvstbFHG`IF~o8ZM4JA6~J% zf7PNY&(Sg5xT@IRly{7JiY$jt?$8PJjuj_kDCRX=L(R`_Y4%P%Ckv0OWHVm?k3ew0 zLp#eC$0PDH3ZJl(-y2kB|Jl!P&QixpHDJe5I##T@NTxBmhcITHAxf5I+9>i zMdqyo`wA*i6ej9R&U=qw|6t!H)B zu)0>!?KrIUY_2;@bZ2YW+Em~SFZV3{f#t(n2``R3CsW7HiNV%F?8`Sdl+yf+Ox-$1 zRhG==a~AVLf(oMgey;bCBxOcJh-^6L!|b}iKH_hMWSSRivBcXNZ!O;Ckmn>?adLFb zpZ@qIbzL(aPnvb9Xbt$#9bsOI+FB-)iMTnHV&SCVoD3;qbkA~LjQ zlA1AiFL+g3&+FH3IXM~Qy<<9CFq_SpE#?%3tbxTl<9H(jZNDji`3G=}%^@efm&iQP z93KY7smaSFU8C{nG zz1{#+>N%ML-mx{T`NeI;cy2g(Xj+vCT777ZS%o!E-wuulg0S7gIF~=(;{3?3SZ@mu zWynd*9it#qo6YZxZeB%5lh1ZFgp{f<_c1G)Hd<^Z|gUjJOCbX_?&c*N1_u2}% zj+;%5CQ&dj&^Mk;+``xp7A9mNSSafX;mO|PP@z&}=xcMX`6`;73ZD%UHV+Q1{UZ{V z2#0>|xV7oHchz!X-EwkhNfOV6ZB4J|P}<>ZaKXRsL##%xr&wF_936`#kta3xt|h!W zHoToXDyy2cAK(n>%lpNmb6!&AFN%VqC>y~OX)X3TI!RKXk75bujYgv>9v&Dj<5LX-LW;TLbAtmIE))+1BSjRHRM8&=}!ewbuT1QZz zf<@&^6e@&chv&6Xs{zCENW@~JJevd0-OH9+7d*YpGa19$wr8{giS`US3OjTZRp8kf zWC~VSJ<|ykbI4d)QejQVq|_M7 z+LE@TS>Mt2lM_DDWC6~bOfXuv7T#J+12|hOt`R(8qT_cT1x@@-u$-dx6c8akTWg7U zOASVQ1}O}Ur`t-0Bd-*p)8J}kdM)H@y%m4PRT6p`kg|Q3bV=MKqOC3oN`+9<%y>5X zo=lNr$SR{N221C@^reM?M=nOv12l+xPC!%_gL|0 z9~O1OLW1Rf&{S}>DFv=}lx0b|kZP6ANzpx^5m*|@oz+FLf#M398zkJoZ~;RokZ-Njif}6<`l+MZmRj7I!_Wx)dEFHOU2`~9v@{%woUgq6 zaa|{*7V@^nI@w?>s2#$ooiH=49JTjoZK!RHt`#atWKA*jRr(lvAWa3q(@8v6Hyoeb z@Qk_w(@qAxo+r;d-h#q2=)+15-JZZYO<;2aYz=SrVSU?k=aS>@1f&e3K(8;DZh|v{sa7C4nRpmz$5l2Hu4Y>k*6MBYyZ~ zKpyB@LiJofApqLBWtC-AIh1>j(U%CmdaX+Ak?f2DULjnkz9$}P^o1t zqb!m7FtPh*7`~G6cM`|-70YKgEg#L?r=#B|!*- zkzzd6%x9j}uH`o$)r?EUtV%d8lAtFBE3S>)Ejl5j5E36;1Fmpgn2*>3-pO3Z+$maK z`S1v%!~)C`%|;4qnZ~3VQYF@pF`}_qw~S2lEg^A+pR`**8bUu^99KY?=4-^EAh1v& zrB2%XY4dJxE{*LcDSUj$98g(H7YVCuCf~(L3BL)NO4C~Eln)5h2&Cq}fGYtriO*>v zcp`N@Fj5z1s6FcnI*O1gCLm!9Ac)V52-vcE&LgYPTkvhSj{i5&E$}m~q-)o<;j=q% z#bTdM*`3=_zYjRS`Py7!BPFQdM(hUGe#QhSw*W)4Aff zfI1`}jijXm0oHX*QI?b;H&?tS(wPQ&DDIhzUz&`c*Kp5yE`_A36;eWc7Vc}i_XSaE0gpms8Z3w9@ODPTBp6>{;%osYIj%gjSc$OL(@{WLmM7C#-Z5bQ*}t#NdDy&j|O)M^J8CV{T6Sc>c^NLjQv~ zsseD@0!&FdF|-65=q$%%d6S*vU2Z=q;nSY7+R9G;T(whDgsZ$iOX^K90?Y3|SmO!z z#?R((u)|d=mz+|;2W!FxN6SEa*0rLm4caXkj7N~kLsRW@+2YzkB=_jP5hnEiTDu9C zDXlO-mcrGGntQh#gMLNV)TB)JT7F&l9XqE)2m7)h+Rhr*qIsbdo;kqx$T}h4Q z1kbU8Qw{U52GjG3k@u`S&k)ZA6nzYv$}rF#?-es!hSC-R?#^SwCe1WSNK6vwJN^r3 z5aAaGbFQhlSE>h}-_Q&**gdd3*w?(Bfpt+_FRfE)%k>C(&XR$8FTogPRZ&(I*2ats z;m#0omFGDt!#>?C!#c}sK9l`mVSP(5r={!=_Ol?Hk+VcHVVF=mr>MlOx5RXD{nge= z=(~4KlGV`b_yrY0t1qs2KEG3Qd%J|P#(0IQVR{Hf65!!wElL7G#1mj+(47Zs6=f~! z_F8#1RxBUiaO@pBc27JrS+)~+#LlW^e?;WV_h_BP)6MS&`0)Wmd*=*u7tnd}Q78!w z&$VJbH>~7F_7$dy_@*OO`|vUqpD$}^OMVgsNjTpeU-m_gN2S>dUy55nqA3=EU}RsT z$-88oceiwQyZxku&kveTP)SU&v&4Zjh(*v;&QE%5XShR1nL&6)AZAq9HxxI15dsfV zsqdqF!7851CZ%U3&3jzia7b{0;NbGTLKtdk83l&#k=j8DDdF6pa?{P=VpFp5v`uW@ zd6bc~Ki(^jCJMhR5q-j}mJ8X@b?w8$wN@A-ghz0l8Ni1ipVBK-DFwYp!<1n^L7gnM zXvH$Dx~yu7vXWd}!56R9GO!>AuBe3nE$Q&TI>Wu9B(*iqsrkEhe4{-FnZf6h$WbAo ztx4&)QNhQ~amOlFyyCt$^lXB|bAsh5mU+kwq3}@G)Rm^rGE(nDhH3Dwl`qHxG5DjI zn`KkVv)*&uzij#UpOjo&g@-RR_AiS03&o@iyrYduXMe~?m{;(4D=B%(5OyA0?1NT{ zPA8Xqa=i{^Az2QLhfbQ{ouhK%CNoMR^qdz9!FgEJ@_f7_O%gg;iuXO3%_yo0-%`%K z_gGs~)fKi*We*wAf;vksTO-A1Hw_=$Qfy!F_zJp1kMfEXTFS~RC9W}7&9Da>DcJ_Sd^6_H+A zQ|4nO;t*w-c+YB{GRkEmIB5o1CO5dy8Q02gAjEsNox`Ia05cwny=eGWJQstUjAS;* zx|pm>o_GGc<@5h{TOtaWBqhx{sI&`7er`u_ONhi9P{G*~R9(fA`7}>HhacVttPj^m zM2YW76G>_{g}#Q36uPx&a?xQIGg8Oiv=P2JaQ~uzjL|GA!_(JVvRwxYFZKt-rB&Cm zcg4DxG<7*P1#BzLXC~p-7;agM^)+u3_)@{|6+F)pTqmWQr{syaJH1lmNzUV0$?RlG z>EQhuRx8U5ulO9z4hdr%FOhI|9~4MuEp=T}JBtqMc)?Z(?JPrRuX7j$nf6@UaD0BN z=IUn6){4UDgcol;N0Wpn2a397?S`i;@$3gpgmhg?o;KG+ODwN2iJ{xgNz$~*xID^J zRyzqrU879GaL{Me>rgJ{92_4@l1vXpEv2VzZ6(hhV6-92Qqn4=3Q0=C?BYX)ia2k^ zi2F@?8paenL(VD2bIrHUHE&K5@RFGt&(iwy3K!hp9*uJvg~wV=Rf|y5CL})%0Wuy% z?KDr`XlB)tUYh13JmWiB@I4Fo^FIZJ<36VIbKL^FLe}OCG0a-i&vnRTokFbPL(7tB z3!V7l^FrH)lZ`NnZw(j3(Cm0kL)h{Ba)YT#Gqg!0s3$z_U2Q)p;nQwOl0c`6&iX<4 zgrEcMMWt7&C2ZOl7V54ORlgPz_!d&do7(t7%lgquOz}Jet?4C>l~mC!JSM(5Ad-$& zHId0IH^|9zLm7rvi*BLwM`MSCVT57EM};yDlZEHO3)tCHC{j=+-X+8p`XyZm&s1Uj zN`4DXxj+ZvK9c<&ih1do7LqXaECqPH6Zee`dB~*6cwGpFxULPq(h2WdN5@$Xwc}AY z;m<1JuUPVa&Q`C(C{4+YMtLxK#@glt56|*Z;6GveB^5Y@1TdPAnLwWHoaT6@IGiZz5O5R8v+d4| zz47Nxh&>c%F5ojudOJ^1Q2`NIp-@g>pDE~R&oEbXaxLX3l2kUdyH*%uz#9mB!G{SZ zyt^%!poJ9YKU+xC#+&ATjW;R2$!^dVWbbbKNeUmO6edYfSuU9lqT5X=5iUMrMGPot zV{8ySt@)Po@!E*(@of=_!?U##b=YZHT**@~nvU_Tq?&<}($@wqF zLToDh86(L*y$4%cQmwhNF=S(qQqHH0iv_h(%qK@2+d0a^wF{T1oa5l+g!0XSWH%4b zj~NVV?m|`>8^z>Ii)JDng&*xpec=D`eRAxqCt-Pg7?>BGHIjBmD^`r6 zmnS57f-+hH4wRBew?XvUmd|X?#X~K^JnOiN&kg~B4YU2f z*?Y4lNs=Tn?^82BA|f*@Gpnkr&*|x&V|(Yo40dHnAw($r-Q)}T0uhixfq(==2x51z zJF|=FnZByKjyxjV-INciYHkr#v!LLqt9z^@D&5WPR8vzmRZ~;5pserF&9)6zsu$1( zHI-Os4#MlQ-9G7MdD0%tT1^vg705;TqJ!Ub!tXP@Sd7W!Bs_X_&Bs6an6vE$R9Kdo z+q;+aPeHTrO@dE5;j=Muxfd=bk=9fQ6JlhxUz7Y<==#Prjx`!enEX7^Ml$Bt$a7tp1 zG)qx(7ItH1Gh`MmJips>x1Uk&xw*UJoktJ3ytqIllXB*dUwqE}Vb9(4jJy3z0?vjG zO_`fR@x!Tp_9-g&#;O}ZEbj3+_UIyL_|Ke$y_njzqPAKut;m=&E^$;?N8(ilX4YoL zfRd}m0)J0Nh^EEX{?jq^u%>CI`YWYbX!{qctWAPPov;}*GBj5xsC%wfKe-#Uq%@1% z2x@o-Sl$X7k8j(qzB)D3@i<@X`cG40cFB4?!PReT_|7sPFi}^#5y=}g4~Xp7D-wc| zSLV@5Jb{sc9R6Pl1bIc{d^{C`0S&#W-G&~?dq$agC>`fMF^l?LD}DmL;vRNhLL)9F z?iy3qb0&3!)l{T;J@zT?NV2}45)UJSM=*$Qv4U;$=&Fl4ia)8|lGsdNFFAWPO^@)H z#3NNUx=?`61^!NyFU!o$ys)3ma_!>s0dIfs4pLP{Lixij^R(x7e?Us%X%hY^!8<8& zk(6C2yoc}@;qThY{mhHjn`~FY6#cTkTceX7D1W#s{PfApFFq=qkII){!IOtVPQv}I zu)i-{?-qXj^f7NgddU9nmSN~Q+ho3a`XygHyCunv66|iI1%6cZ;**6YXdf1uMKOw<8d&nkl3R%2dK5(qHG~$ z10KsFr(wnIYtWL9pWRx7R@2?Po$s8;NMj`|SsuR_8a+B_47O~u}m zTl1z&iACO@fX}xrd}o`;zITr_U$1n#Mq?x~k2Cu&UO?F;q|Ta5Agf_av6T zxXIYi**zaQG04K>1eY1Iir*EpmRt9M^b`?e659Xj)k%G^Z^`{yttp#!MR#in7NRVB zsSjR#+lD3_Q4}jXR5OIRaMONSt2b~rj4Zz6o($e2@fOgrFjIIc%I{gY)x>=%+|3JL z-%tGZ_kZMK%v@{-w!0Cs@Q%9l5{oafBfIrCpAe1e@18c^N?9=pX-+dK7> z|D_a%W81bBc!HhV+9c(ZcV_<8Umm#J6y`&sOTxUL*`5jgS;rSoXU@*yCm$^Q%~uOA zZ#({fVi&-H(j^$OaC3XhGEdy^C#I#)mBRgD&&|tc zESIBs6_{_B_b;GK2#Z-2Y%G#0b zSki1IA#vo1>a;0ePV@N~siWd)s8KGp+e6cOzoaqXY!$cTZa&@4JK>#8$62q?VSBr& zkprXAh0vw96?;eA>1Z&K8rHtoU|g_?cIFmwDWlzJhfGsz2LJ62-&y7Zw%R_Z`S0pn z+E@oSC}0e#*qXN0ON$)82NuRmh;jm{U=^Wp>8Ep}gD%sjg@;+W6s2=9ei3hj=QrP5 z-mHkj+Gi`ysHbhitCOutF&@_BO{Ul7JN^u?t_nRwnrPxl5wC zumuD)Gj!+Wvsao0UK}R=;j=H$>7I+TkbRT#p~bo@cx6sC+{tM^!CF2ovm&kT?x-#6uK^P{UEdH#r)!x zg-_lSKKn-b1!ndmzbLnUgT~i890eyl_96x%|8ozIgVW z|M;K(o@dXVGLAj6%zXaESA72L1vmQxi<+7Zu`xdXatwcHj&q1@wM3z(eTUoe)72?K%t{}RU!&?TI4a9 zzZxoN8VKtODR5|azMo>fP&$E863^VaY0Qbkyzs@#J0qS?4SrK8d~4qdli}aUQSr7sB<} zC&)c_hXd1M2O+1W@W-dmV43;d@Bctb!r73y*&q1y>l>ck9hl}qx5?zLLrEl=5jDmZ zDkf{0(@3>Zsd3?BE+mPHe}N&6!NE+U?T$0YcoI@UXdD{GhT(RbUh59yQKDK-ZAoPE zOXw{2^bF83vkK;GLvL4mh+msM3S4xF>s`+{xFb=&s=eM)8ovnbo{#uys@Cb(y0pw* z>wk@8~Qs#J$N#XCWUAD%% zBcJ%Hs4^e89^iTp+r4|Z26xBbAYT(iOmZ_~WEB)lLh=MQiCSbokyNCyI@O{hB01c(Fh5 zd_S3~uzRBxfwMky)+gptm=+ic3@T*1C5Jt5XrOc2kD{yeY2Tdj0LkyC`QgKv|KVo~ z?_3wYeyUua!P{>syPdKdm7#;P?ZV}SuwRsCp9vRdg^!;U{?$(kw{zm|i)1&;R#m4l zwo7$K_}x!4-`w1iQTCHL3U!3we!uXKUp@D8WlEN0=X@q*THHzs7>Ays z3Dv!!xtA@nwm~E!>}SK^M+%PG)sC}0s23(`1qJM*Pxe=jiL&F57g|d*i7!mGW9QRr zYF_Ge@Ue?mi#nNakvRIDd@KMop*o{}Hg8a6m*H$T*wx!zX9rBt^hz}q0=45evPYm86|FuM)9m*WmaW!#a+tkpo@aO3_TdW5s0 zoG*n=gp!2C??PJKL^{Y%N-$D$p1)2A8p3S(!^4p&wdha!6L7C zf|&5)%%_KbL+VGQ>t2D^w>5mHnGcSTlI*Svn=uw!845m&Vuc~GT8Z^ih|sM#9q+X0 z>$5TJ@BJ8Ka^^GiNS7HqwflWU>BToC0daeMD<+UPRKsx-qq)aN{oIWwDj~HWF)Qn8 ztGizxz0FP2`2}!-=54Zess95ICX_EJe1mz^9)X98^6m_O z%C>oYzIIf$Y_ZqRq?cd7nDK zKH0UoX|cA+S4ZNOZSf&FIBXb)78J%JgwTISt-^&#_OvsU&GPl^cHHHIdV4XJWg0Aw_@;9ACsKTiOu5qqQnF6 zN0dLJ+>z`$1(f zQuvgGxNSwjOn@bk!ph5wuLKLblj)~#6@K;M%=>RmeE#`D-zgvc03JLr)S4H#zcofR zZVhC^2$z@2^`&rsutTB0_z0ff37@{mJiX1#B<5yIAZI(rlartPukA5dF3Zf}Ftgd% z0pYn6v`_Svfhx;vP*o>rMyyRzOkx}5yJ6sBx3L>pNo>Y}dv{_Q=I}wQ1ygy2Yn>dM zLMIZBBy+`7rKjc_tT-jjUZ;QX_Z4T?FaEzr)iV9T;AS6#Db?mR>DLnD%W(+iTGLfr zH?}<_;c?&daMP1VGqcuMWt7Dohla|{8A=J-aw6&n<2edP9kPdLL!=d4q7t`|@q2vy z>g=|c-}dk)6gF>u5J$)^ccfv9^gGDm4<_M!R=VPn;!@22 z*;LS_&=+$i`X0hZMeM@4)H4b^(}jOv=C>?7b>D6gBnf@r(f2*Mt{kmTg1P5=d{Ow- zM+@&>FWlS~<_WeVTwEw!r)Y6n5ZN1zOV`1}ho-0h@@wUMTlkCj7Cw10akVRCv9Stf zEv^pBjpb6nNY$=dnB6^*h)MQ}Nl_|-id~>!-U2LNX{3de65FBYd^@ro?FfQ>FHDp9 zZ>w!-rbtAP$?JHn!4+Xxs?^{scT~IGR{A%x44H?pk_N!gpHo5fQqs zCkKP_Mc46Ub21;x$$ots5TJzhQl1N6Wp6vPLl-Q0Vm z+|hL%DJRmh)Z-!wEXAFUE(=57k+SXC*a2QELqzrqMU zrvtb91Go40O!MsHWx=L|F!UX}&1mW!Y1C(J2%J^NOUKz$yg5>Nc^d=2{Bh0XmTE1I z3FaZYX7I$~63?3MG_-2M=E)xo`ka{8o2A>3;3}9;wmW>i&-hhsV(b ztNFa6?YDTY{cFF)U$b=6uBY^aF`uf^{`QCOF7xq0==u)E9gKcuB5t0@vSM1bKnYph zXKNr#%mQ(wu-ny4nICs_6nyr0+GUBIU1L5&2b%$z3cG&ddVt-ePfvFuL^`9Id#18az^nBBH!Cb)EQ)sqkrernc!B`pNEyDW-fY z!0cCE|1E|8jhTnQ83PX`^E0t)$bYE9e<}-qUkab2ObVkYk84!7@GLa9k z+X>sgaJVrmyk&u9GQyTJ%(EB+!aO)H6P&yE>jxujE|tIjnec}fGhg2(?w)rn3Y|hu znX~PPmcrpMxeCh;oSO7wzUcP%dvX%Gyg_48Btl9ZDJ$Y`aH>U}?;9eCxhQv2VUZb? zg_n1CJb!V+{r=#NM%S^%4GYe9JDxnc;xNtJAEqNRzA_!#Q&N239ZhU;6cG*HMu^Py ztFxN=pU0l8j!qSO#|-KO`A$_mF0{}jb13@WmCcnbLNCIY;A+=#u?yzohD@!bbJQGP zgsS)Xlv$So(_-IZ|E9LUX%M06U#zYg4h_2{U5!zZw-?@SVksC8P_{I5RLw>oFr6&NSDzeZWm)j;Aj)G`ISE;IClt9TX` zYdC6#q&!9We<}QHW_D!$io~VDN5BIW-Xrm2;BzfZ2%`vBMR>d@AELZpV5iEQCjKZB z|F<6aH_OCt+|tdbI{?Gb@!)*N_2mVN7H;VF02o3P4d z@osT~85xMHDwF#iJQsK{X0~HC^;T#1byf9yNIdG&%#rjHcN?P;2sd&?b!! zsS=iM1G9A8PYd0m43X^(2;XVu12#xS5`~UVI!LasZU@|n#QNSyK*dKJe+Oqc&5C7i z^t+Kfg}JperJT*xj+k$#>uek914yYr|Lrk7vD@_mT+lsepadkh*yBL$* zGoRKH4+`sqY1;Y9yjcrAiWhv&xxv9O_Du7@VV=>&h-FA4cPO6%|C+*viJihvNt~m+ zP2nNRUjX+`NVCGA&=(j{ItmM!&&tAoVBvq}!2ik2*TCeL_uKxjsx>Fn?ujpq(pUN4V@Qcf2gL9lj zRz;_omp6C3xVdA0n2x+?TMp=R$JK*#t{$8-3|6N4q0ytnEe_VJ$z(t=J`$WpI=aZYmrLKBg z;u1Ok#UkK{F*@S(Zl+zod8dMdOG8VdoY3B+9=ZWdT~)HYN#Q%sd;kvf!Zgin$@F5x zz)Yci^-ur_UrX&3o{kF|gWg)PID*s};K-vMUlGP-`?%XD3qvZLr^KbJlAdFPr>NcA z6Y7;HwO!50ik?1!;+r#;c17irSFt{*_?}Rej3S+d)4K3Eq0Un)NIbtpCZZ~5YA$J= z%4mWS$s~z943wp?%ropKre&@Y$qc*%{sHBGVdf7ge?#W45q<)k0~_!8QM(Xk;7ba> zVd4K^;eV&_A9dkN;Jz9fn0jIyI^KQjF+cjj``qqr8}3#}Fi*__^CEn6lllBP92VcV!#qbzF^ja#W@8lyl-oPz zvJ(BGcFsr3J@Y)X8G8DDFqbcq5eYVHNMO=jMg&SJyu6(_>?iK_d-l_0#w-<<28War z=Vu!}{=wUvZ#R7P&2#SV4;3el3984vRyto%CEg4#k5eWGg4S_8Ey)*8!H`-6Xqe6` z-(GF1#kG4!76G``oO{&}gtG*1W#Md0O6iu8L!I_; z+rTBTL+G4QA6#Pk8s+!E-%boNY(uW#Prm9S8Rx=S^K70(M8}V9Wx?qt>ItX)yGS?+!U%yeTU&msmVmhRC?) zsfDefWjr-ayqxl$Sa5|mYwQl6hl8-`6?3~0%uSE?erribCHl8ep{NR^~ z;#WK3hv&P2G>r7)Xjf;yj>CRS!}o&ufSI3?Oznoa8IyVSw4eBDX7SZX#i77Vr|#;Q zEKcK;ASXJ%;m!2*j$<_CHDy=#sAB(BqUQf4SuKa! z2HCuAMHuVD>lnvTXg@XWsKtpD9?9(0-eMJ6zd0z2Dw2))Tx>>TZpB=~sH=TK`YR}Z z0G_e%_bfa?cn^5ruSVFor1S##3iuS|QwmRk=W5n-vzHa^$T_pyZF%>}Tb%Eg-+~zv7}HzE19JlfBDa zUYzmh>XO4@=H=}jhsn+WRn@hRwe>BYSG=>Q=G`BI$(uB`785P8;_d8}wueeRPYr7{ zF)|VFplrUj!Rn3pC`Ryc_WDevDQvRvaI{4uS*v4L%3^Bws;&(Baio-V039`U4Q=IZ zkN{W7IXI;%6GYa0lF?mEoLDb-}I+cyPAkoyQM( zbbY~Ln)&SOZ+LlgM=4>dzIIG8HQBM`7f|-^WreM(-Ki3xu3bEx3dU?=G26h!GC15Y zS3;@o{fxZz@CuO^Jb!u1ewr&mj`A19RGG!^19iV^f=TsOXIQ}1>Rt&+U>rKGA6)S8 z`T;|qc=qy!7dLmt6rCWS;!b!3I1M6>kSk_Xcu8dfuNou7NQm#tgtD`Sn!y)Ryhf;K zUnRar-7$r&rl>0gV+>}jg>6ne+H`FCWXCBwcP6U3LQ(xPxnM+AcoV!q>i=mY$u#Y% z@5wuLq*C+MPG@d)q~DUp9sRg5$>$9U-wWoGa;EDCq>no#~$;)k?YyX{ybUCxzj6Ax!;PPV2VVZbxd&kS0JEqwnSo_t4BeK^NdMxin zSYz#NeK4ukVpgWK554N@_SrR_2kT_>*&+Wbq^QGwxdN%r6zzTTWN>9W#4S# zv`x4D7V|+BD?VvfmG!!V(2@IZMbh~Dy2Gh9*)4sf@-L@JPbO9nmI#$VMM`H*^RloP z0A(0@9$sEhR497G+t@!)Jr zPL@vY_8g{}X|cVsHbmQ6xSR%Ux|=W$21D0zzTNWR{G4&0@c8XzX~6I}IW6i1uC04?F-%^jQbi?cevw8Lx|G0Q%?`$3)E7L5B^DTj)n5qotUX{WrJt0y$m84|J6C+W%vp= z%JU|=155`~iSjLTtvlM;7VKr0f?Wf!6o%ez=e#`MkyGO4_Ky3*fyvcK0aA_n{kiF~ zmD|*v5ciYTbH3Yhd49%rJ2GqGtLHDd-%reo8$e6A-F$V;9-;R8q+Ww%z~{K1>Ur=! zuehtP_uSs?x!WI@Cc9qZWVr(Ny7Xv6KA`;{P`&ZIt*qswA@f5v>^Lg3+$I6v#jn;so{82tjdGP|nH&qsM5YJC## z(W<5$fe&rNeaubO)-axMU>e@}bB2CH>38U`q3g{%$E%CTZ*Ta{GarB?3CTV5JLtB) zN8@LBBsMqNDd~tov++^!>F8w*%JD{{_(~=AmZTWcY)13*mJ*vRTzA6btUN6+xwI2| znHpAR>nwBpT=nD@=NW3#{VtMdhsRk77V66V6j$51LFn;~u*N4_eKs*o8-<3x`gieW zoDv5xi?G?-(ur+kkK=%%V`h65HXiCL?KT8)Ok%3goDxIdF^&UgyDj6` zqXPH)1BZF8Rax;^sdWn zHyeaRlEgkIrg?U0(O`wEt7!KAtniQq%_yNunQ`dZj^=WwPucwDEq1lIh-I$hSlhTR zDWYsoisBMP3rc4Om4SKZqu;NC`s+X)bqJREb@}Q(slQ7jB?nBbj5SRX+b6YlnObg0 z%99QrZxa1k4?{8so?Y*Izr`$Mmym$Guo~LdHXozYZNmtd_{6U|Wp9%<-*b=l8|FNK zbYyw67!ThU=7X4+y5y0R2aa(1 zl3icXcZ|cpI1cn($5PB8=c4Wdt#%?{V~w%?vhH5%aUa_t(P8iNN=RENhopzN(Z%|K3xe8?OQ6Z1SX7lRYdd{%Xznl)ZB81*^PcO6~dn>U5d zPVPtg3Lo!c5b6e6uLK(gXG#@rQUMjx4Nd;Go`|;?16a!-BBc+vJv(zv4kv^0sjAD< zd#1phwhz`cVjS9j(1r(O*BSb>>}t% zgBQ9o!fNzXisu>7;fyKuh?@JKH!XZGn2(5AP2J5(uZc0PoLy#9ht;z^&AtyfLd1&Z zba%ls1cInH&we^$%3SG|V zU{+hp(zBF>vJ|u|^&0VjO%gFDoGFpqBXrkgI*(g4Op8yePkzgcZR~O_gY=(|5Ck}nbG@Hw! z;ueF6grY3P_O+4(d=g#G^x019hlzd=a;x4LU$ohVsll-Zbj^RBcYO_MwKDS~_%v}I z-Inc%s>Pl?uO%F{;pp$0J8-)#Gs-whufaqXI$#T2CFRGL8$P_=(rtR={2aDhOLw@3 z!`?j_xY>1x(?Jsiryot9YeT#>$Lft0H<~DDU?mB<5jN*A?$Ew}HSHS^z8}m78?Yjo z(ruvM!v2MOA;^X>5`%lPBGm?CWAI}#sjo<4pGccsS1rDxaYB>be0xa9*#^!w=zPcZ zsC=}6k8hQ)MEOGCe({@bQt}1UG2!Q!?^u*0Y*`nX5Cp5mV<+?x+O8(nIr67?h4_NL ztv{Y$mu01~ZA;cR1hEa`TBRbVdO0Pe?et_7&?@7P+$q#&dtrA*(s z@x3QkHT9WR=3~DscKMtIyNbLJys?oC9KQD4jMY)wP9gJOj|W%lYLs>i`-E8lM!oSz zXbL^fQbUv$pM3@$p@03RYUAK$(pjMwc$kDAZxSC~Z@9c1$(sQ#ADQ-IdI5*Y7!N-F z#T|^&NWCEqt$?*}VYwErd9VeA0oYp}eGJ+nV#h?f0frs2IVW$<{2K2+0f=vL_+Bs{ zz;xTgNZOpia1Qd74|H=4u42rnN;|$93SF+^Mh2c(9l2VMw(9nGkD3ZL|aFAi|8!lVoHq6nQGj%{Xz_42D<^1ER@=5hD6zDqrW5`8j;61igdf?3wHFp4|cT+<%GH{yI; zqI{FWtS`oZtUhrEpytQTHVbOK28gNxOJaC09$V|LumTk&y9L!M`8iY?Al3GZUs%|x zLOq8WyR7x3ri?0u)0=d6qskE6b2D? zB7D#%{>6iVcOP!pJlG)H4O~7ne{5fU<1V^9lw z#m@>x=Tm}ygKjU7-6eUmgU+r}c+{iRGJ5 zOnZ)>$F;wuL9AR1^V->3iuriEJV##MlW*^MI4=D4h46eXJe_9lmck8Cbn)xI6_v)0 z|A;ZzL)cE$so%^$UC|k77E}?m5asQ``S)+S=|5MXa<8BYGxQcZAAhPl1FS?+mNKjY^oC z{yD&#mPW}(#h%JMt;W`vntzCav=?VL&dhwTESPX*+5yjytpcyT9j2B6>o640TiXy{ zO%hsFz0u~jmoY97?OhRaWu^p>YP#BmCf<|-tLaE(t`#;8y#^m*yu8QWKKsvF?=gXQ zO`9rwJujsoWkKc{mO@6^W#L0f{Q7d>uReOnlP7272Rr0^XUCVP1I&}tjkr9n_$gnn zNCQSeQzAZ8aAk#qb<7v7wQ=4De_Z^wLXv52wwLJH72RfMhfUi$-jMLUVLphEyB@|1 z*j$;<8Cf=Q4g?^VtypDWUsXd4K4PPN8f!zpK=Wu_=FipHul%G$D zucrl_3;$(NZkNKWpjsdmcNl318TcA?YFN9(EQ}UJQ*d1Oh?YnkXVLm1I8!*;3prH> zaZ-lV@|%1?2;$j8J7t17*yoiYqAPo}as`o9_a9$FrBIB$fP(xE)wB3q0hEpUhT2|>)Ei%wUMNnN$%%xFZ z8t;)>*(nT8-&^8-%y?cG!Y|?4R-8%JSFhoD{B#y{>FkoV+rnq6yjTt_#XZ<2^OS9e zN^P3Px-W_P9qv*6=?ZaGGg*TApEp@z)`H(*qW)Yz9cQ+@(V-IpYga_9--n3@ub$-4R&U zkN&*2@EE_2Gg`T8L?n&er_VIBNm4>xI@DH;hyOj%(XvapvtRRJs9wHKtn%;*3X1 zA(dkH^`yiPhRk1GZu##%c)-UWJYak7h7b$hGijt@to^2^YfIs$ilnd z9Qb!P6aQ%{e7&fhVizdl=k|k$`{dS?L6#~ViHH+m@jWLa5Y=&JEUcm*HZ^VYHF>`1 zluw?z##SKMP6%5~cSRt(UpAX+C+k_Es>zzz=3x!dPgN^L?rea!yUfpa8-D%PIluhDCGWhmV|%?JU2Nd` z$}QXuaDNMXw{V+hILxs3b3Q>gyw46)???<*(2i)l$CZ$H-0^V>bJMH3)N_try^UNw zA&*;|?{8@MelVXVNJ=p5(DNs-{XM+++&zXx0&&Nq#cwKYZYwP(sx}-k8r)tH&i`th zRxU<1#N)&cLUO)^`Pv;I+;AZWeuU6T$AeCI=f3dUec|bBR}4Ha3pYM-6=N{gZug+z z>Nkyj4H2)`(gi*ney;>ul0SqKKUX#r&1_U#HLq9F9Hv}}=wZ>Tgg_U`<=_2JS z!FXTP2y>*f{ITyEOedu2wJKGYWJ0CpX=@w>v8(k+qI3cqNu1}*gTCYOrsszjBY$yq z#>Y?2dH3COh6e+jk8p7gn~gQ*{?^Q^=h-}2Pm3|1DbDyftZR>BuGE#D4?+WcS`oDw zfk;!~EM{nM@tAV)7~MS}4Mg!)T+=0S8l?xvKMIOLJB2dR_-cWqRuWRi+g4#Pd1>F-Bnq z6;jRXqkLmPR^D1xMyr2BafhIti9vJ-oxqq97g@NRsmZM=6=w?T&ZUK~SISH@FK zFP##q&%WZ{7C-OPyStr&NkwCZ$CuD$WYZx}pEKqg#%|(rRG#dFUrmYoCGq71UmTQ| zv+{CLZWp+j;6;I#TDZ}|ZGk&2+!woKZ6>l|z#DQ8L41N4t|hJcnv#M9 zM;@~hGu2hx>>0$lmJ@`xsYj02xqjbETemR`b=buEL!79utvl(ZWvK1L8Dn<$L5rG7 zmZ-PMEcL&&jnM9ot)|Ilz!A*X#=C?R;u&JeVrhI_eO#jb7S|j{@SMTO)Ky`*mE631 zdoCpRuH8Ans)0bX&6!YgX{JNjxOw!M2)mRy&%#xox#$yTgRtupyD@XN8Q6^-yG`bN z+i|w-INOcv&Ie>Sz}O?((HPITwdUX57~`2H+uxaHxSvejHaF@vwe}lQI7C`FNVCdF z4#oOCAn0j|MN?~7=gBA`2rUD0rdo3JL zTf6}U<)F$O&MAw*3BO-2dMi$xV~!{*l~-5q+4pr)MEaE-MV3~H6)Lio-$xk+#+CpZ zp{zMi2zXR29IJg`o$pfHum)qAwt0{DIZ_(~^42!x*Szk2-z3fTn*a&h)GzMGF3{nX z26#9v_q4yZBygsnTJN8+l$O?Z1})y&y-FG(C5d?V*38yhmu5t5)WyFU^RYxq9T?AQ z&=LonU`)i~)_$17PGcHYmbWb=J%{5)gl$TU0(}y?lo*mQ_;bp3uy)KaW?`Fz^DeRL zI<`4+-ib4w#BNAzhQv5zwqr*>bmSqCdO?QHv=3ts<7mIl2t#k0kNw_$ldIb1;*7`D zZF5;w>bUVi70VpH0jCrn8YB!5#&f)Dlw;~PE}u{yzfZY*LfV`oZ`j3guM2N}5B?j1 zB%vP%g#L+&t4$Up2N*8943+~XQQ%Jp-7@gZ$H26tY8{}X%VJ5ahM9X^TO@4 zaJwisvvM;jFAF>?g=b~v<*Xc3I3T=S3iqW{bzbq!{iVRHcFv}*Jd0iRT;ldsCwoSG zV~y<6Bfhch2OFupJXMvAF|j6Xyob8TC#$K3{F7F4SQE4a)rxV(5tBN!q;4T*B(Sm- zShpBV=BpnwHvc6#u5{TL&1P$+)Z=KDr6m}T`)^x(<+eXGQcpu40@!uY8T-2qmVk|| zlawtE`( zTNPpAOsRsdrf-#H?YCHKS3ZVdj5(Nt#bB&bs4G@!m|iUpXLin5%`hq27P5#DZ(((G z8Xl#i^pu1?^`xTAecCn$;d+VIGnq&d>*-$2Rr{5zdlumf$=I+ngD@%(lzya$?(OHhpHy z(D%YH^o+S<=!9`d41J>S6J3{_PbB&-le>;C3pqg+yO!NJUh-Ron@(i+L@jAgLO`5o{&3sEO`fwzEK~_(Txcm*MQ9B>x#5DNnQkfY} z1_P)*1T@|N#QqDqsxASDOHIKT*MVtNf`4y_JNbGpdm0 z+2bQ~^w)9HrH|MXGREf5CsI;vkDjChl*A&58SDV17P@-y(rQmm^OCwvjKe57W9~@w zB8*w+{is^P_NzL9J|%KC@7P1Ks~x&*>4yYe7WyP?Gwc$aWnt49^V!s&sl)mVT_^Ot zIfP9)kvi-`ozC}4#rM*(tZr(2kTjV^WQ@Oc)YFBFs}%W~tFWUSRcADdc`pcywtbjW z``>By`Q6~pswZyHN=(YE>#PopkDdcNeeLZV#peVz?my^X&23HsI#kh3eg{>}7e z@VfB5WNOoP9u*{_wQptGyoW@VWR%OcE+a+qN*%6^);pC;}X<$hT>%!S*PapKS&B=6e%4Gv{K7k& z?Vxq#&Pkesn9f|{NAt}9XJu5?7{*|VtJPv&EQ>Lj!vXI0aC`81b4z0P2SMeE8={9WQclA3Onpo|(i!%V?cP4qWrrcjI| z8l!@;DD$GmKwQe18#Q@Zltl|uF$rf0mEGbJjv7;&XJuImhh;J5v=~vJOW_dU_Nx-+ zQkY!&TGZ+;MbX7BS6dJ!XJ$pApvM2P;jnIma>_kHmrx+$E@|9CPb`(~Zvmp_Wdi6W z(@AE(6sBb%i!$bn0*7KAxluC<&SFGY{5j0XlRwo3yV!aJpR|1vvJ>xK+(WhCm%~K{ zLAt~s%2t(4woUs!CHgLr`%KP47NO6XuItP>X=sA7&}A{9JgK!$5?%7WnrsXvCo3a& zW(Z(f1(z;TLzk;gFho&trs;Sbe)OFw!JZ)*yAb18BJtt=AUGr&t6~5znZjBsl^;t&+FNa%FR8TKSV$JCFSE^Gd+Bl zZhJ<`-J1V95Wd&U2iMW3+@ZTm%JuumlW&mwTU+()_ePPHmdG~5Jcu)~-x3roh<1Zq z>WDsje%95mA>jgDfhn7aKV)Y>PVjT`Rb0ckViE@OimwtYQ%WX6Ik7VY_j;rKl_9N6 zr!q*5K6;%JV#YdwRh@dPbwotSD7h%TH&g3>%_NL>iIu3mSJ0?Z=3-2$C`+;Xc;;dk z!7XmPvDELzaOR@Svt7MyYXCLpo4PW%SVJrrLt56|5HmZ+_DRaTR5$x=x7DRHahSw6 zakW;TGMU6-fkg{RSeehVxZ2GamC;jM5Q^0NDV zjDd(Tk4}tPp>)a2m%C(F%O__R+3)m`u0wL?xD=KFv7Yh4Y-p)TC_#|@rd|ZGa^mBh_NLX9~Y6)|3tWl4P)fIv04f03Y%D|eu zfq-F6Gx@>R-kFan*Ig~=3`CE1dsn8AfVB7|mCy}&Ju5+|6TFMb?d=Ygp6Bs3z4xP$ zoT_B!ju}h5dr^zuX|LYKXoI8`4!G2rQ+1DG!3m7ojio5QF)r?@+Ck@iS04)%^LeMP zZdBKwDS$4h8pVvA5tW3=KGttLSnKUV(AiZlzV~O+imk4XH~h7Zp}GVEb_iFA)v=%J ziQ$M=s1YOaF*Mq0uoe@E073E!6MOeO!NjTr5#S4Tm8;@#w=`aSl3*I*sxE&{J|^OI zRgkojMl531zBx!&wNk{VZq%in=Yr_n!Fxwz|w2HfNNSkstgEavnkdEqwM5eyZ7#Jy!Xx zWDu(-8is?Xs|epPt%$Fb)S1t$#(WS+vm>xuz;z9?5Z@h+jn|m;rVm+}NDwW2HI{YV z1kFA~%| zgMHpb94&(jc&@`;`z7Ai*c7Z|fNLottxNa>v-iH> zjhTrzVEV3vKQkW>l9K7v`w_0+ww3TaA@c(BZ(T3!L^V`Lv5Hb0aYG95Le&wsuD03< z=!je=l;kRk8`j6KQ?&)Rm~Cb!wPT5W65mG4Wyw zh<_u>@yQo(IAUrM7ZE1}hXzh~xiQIMWf=DHxXlq_ArLE0)y6vUlo_57goq0ZLZYvp zrPPMhA}o88NYe557}Le2*zANmVA%FI23`VgP5m{r@NXEOL}kr5;Y2v%;%`U-5^Zl7 zRFubBoWVKjZpJTgmxd@ux%FGK2vc2gxTy749p58;z@oSYp^inA6^tq7QxJULyIf)s z=+bsDl+Z|2iAh{n>+p$1Rxqu)aA=r(ZAa6d7^6s2^EjLw9juR@F5tJQF{Qxc)WNWY zhi{`F|AO+9zhe2|Cvf$cJZ?zeQO3icna>(*o|y$)ku&uA9V5nv1MKf%DaicNC$=Mh zVO{m8Uz1%YSu^>HBV7=(I_csUggf4wNg0z#eI*tNLj@3seM%^jTg?Tt$okhe6ha!iW&_j=o_w;=>|ZfRj^|D<3M|PDd%{VO$!wDp4 zVQvj*R{u@i6>crV^KxqWAw5S~O&ejARI0S;-$o>KP{+QJ9PoZ=l;>%q z?wZ#_nAbw_M2}v|m)lRr8Q;GP7`78}Ainl3(vNAYm z+TASX>VuC@^civ2;S_{c8b)5> z;fyDkK-3qw7hS735)mPxu(mUBvAFaRd7{g~7=mGxQx#VeSNC3mIl1&#=Z(WdqpZ{V z+VP8Vj@Jg?ov0s;3l1xy-w_$(?~9Qr!#}ML?YQ|bsY^*-SMddhir+@sFdAqy8*WCu zyMRaUz33Nkks}x3EH?YM4%CG+S0AZYL2sJOc6zd|!k4Ydl-;jLT0)PE4#Q*qDw8t+XyZ0fZaYsB}{y#88mD(Gy3He{{ zF`~Kpfad%SaQ+6>>wls=`5HKR1zes(X7(sroRxn#!ENYC<#VJ!G-0A5pg7y8>;0m z`!)BH|5kTomr09Lhru>Z6rC{>OItZ*NF(Nm*2_-Wm{017IuhGS=%4#|m}XTay)-Ke z-!m*q-MMi2nX5w?{f-2$o&V^blPuWrpWF} zhgy$-y#wIMS7@LA4b97cARK=MIXFbv-h~vUWx>V$C%`cB`4Na!R26}2e*r0L=-wf8 z?*Zce5oG@{^{Amtk?potugfF;cws+h55;C+coZNKp4~;47a;aq$3=0 z#1)JX_&Sv}17or)1#Wd=!wEVw|MzW_>l^UDeKRH@n>0_OiEq2^uTy>3e zBW3AGaMQW2yu|Ve8-3@xVr~MUwRnK;t<&hq*H=nk9`7KWrt`4;u|7tthh;kQ8hZ!O z2S?DSUqPR~fF8d@c={Evy#pz$w406f@=u0g{-C;8q_^Yx_o}HiP&TZHZlshA7aM`Gkg~DR-8Gi%*S^$xuGuPfUb8`h zTcD-k%tqBbM;d+_Si9Dof#fe6QWqA|jlw9CI09q-T{P*Mew<+lyjM59VxtAI#dPr_ zCzCZ;&({+QI1(etij%_`eDl)fiTO7-jtqjuCq^87f66V^==9*zQ7eBME%TN@gYC+l z9;grMEBkkPi>wZ>Rpb7|7>mBC1vVc7^uCd#v8SMf3h0>dQ0K zm*>X~|zL*>16PHfDq-Tqlh5+c&6njRa&V0Zca&F8UsvC_1_}KhxGFpU4*F(-m!HEi! z12jsouMMQh@M><-Gv*A>k%U-z1^2KoKjZl*Z%#ixOTut#4n0_%lfG^kr@3pBp&U0`mXKe5l>z~c8k)mkyo@g1gLA!U>doFcfV@})#4F! zMj^{?4>+~72@JPpG&~rNd1HDmP8uG91}9yZBX#F`(;NZ9O?#?^RqaMJgfgsK?;*s# z*2;}W)BLEDpZCl&^Z$_wdJZ}N932__XcoP?lh-kj^r+eyUa!YB*;pS)#(v~ZKR#pL zot-A1AM@LClxWjs=;?upP+q2)M>kw|VLjv&EW`9VP~xXqDYL)lZ?CLj&$8~)h)cz$ zcIz?XcpIyoFRNX9^s0(j%%f};$3t1Q@Kdb zBJ3?8X;WA(H}$f+_*}6jy_+ucrW0G#r;H-qNR7lMR{vnroZ!9J8};GkrAUeJw5*_I z4XsA$)YC5x&>TF%^ynBj&t5=|zr^JD8FrsMK^RYUSM^8iknwoWA)wtV(0t~wokuDdHxnMy|wdr8b=0Z#AtWS23R89Z?pyn z*N{11&Ohy`om*mSRvZ!W#hhKcb5`x6n$c@Ov`esb{k`+Db|vVhgE);NW+c#S|G8)E z2sOLA#CWN8Q}mvL^7VuR<95B}wcfZ(o8UY@xc-AKt(*r2=#iOEUTw6J-AGbaKIZfh zgkRcCae|{Dj#3_bE-TW)NKY?b&pkH|8YCypG@M+_7c6fIHx=6rU~?EI%`|=5 z{y8}MF+LEIjoZD*auNC^(O4vk^v*sW^RCS7`bQ=GNm!*sEJkRn8qMxL7Dvx8J$ecp ze~HQS7Z^W!4B6X9`^7zAX9v~R1odc?MIH#}hcS@P=YS^$LyQqk(_pojhU1?+06}$2orcQrF;(RI;CFuPf2s9}taj z$Zt?m}ak>OlwnU7H>B6$x#@bd3H$8(u1rD-^@+?wR^(5 z!;^_U^5oM?*Joi3YVzlF&7)9G^Omm?c!W7%LEOjd8)BP30y>3oOMMPxFu@b~bn!Tkcs*7vVaes~9+T?4Bn5F1Er z(}8boI#fDUYiF>d+jPLu43OUVtkK9P`O$2PQX^DIcSHfw38s05DgqFmnvP2sHtT~9e7iEBy2tAd^tv(9%}9?rMQWZxWxPrEYowVw1c~s{ zaT5GZ3QI?07?+w~a1>(5`H2d#HUm{2QHY=l(FjqiV@7HsRz9p2HuA}mTiVoRM1Y18 zu_&NLg|@7)3G(b9o4B+i}2BTxA!yG6}q zy?JNO-a-2hI^(nvo7{!roZCli;)tjZpEkkxyj#wk^Rq!7HC_0yB-g}2iL_b78Frn5 zCDY9+!ND%F-jb14q`#@;!Lxo!$V`Tgdztn9oowW(cb#uxg-oT4t02O*Kl5 ze`_n9h&Y)*#uMmd8*#D?j3y{1+bG8qXjMT%2@L@nLNaurNxoLhFbxZOa_Z)l@yIxsF7D+TfxE+bFL zIAWk%%0!-86of9kjVuZY&>)CnJFqN_KvLOpZAy?9%#q?xBiyuUBA7q1O%xiKW_tCJ z1Utssrm$23Vo{|3sFW2@RFEP-iUP4LAY}zqH9}QGLXpWQj7ErMZEsR95$YPD9zm)a zQr9Tz5eg$8)d+1{#N`5EHV5W2gxM|R_6FtcHOkvd;Q9iq*$v|K7W3O1=yV31O(C;e z6w76*m#T@(iV{s(B96w8@ffc__zKYD_l!w1;eyN|L= z+oIRYYQQgvVdV20LOvnWwr^{@LR>YF)e2ZG(adI;eK^O>=_%%Cr)baKLf)T2F3wS3 zen5454a{eVt0kf;nsS8s?maB-KfvnXA*x45*gAZK$%BWO+~3D|X9wkIj8IkSH6YGN z(Of2(Xt0xPX;cysjWD!r5!;9uTf{aIjK<`a2t=W6i`8<8cDY1s8nmr_Rt;j?Cbw0C zs7*S)x@pn24Pu*~BgPbW+alWbaBU-^O*3W!18izWAuV6e-`d(%Oyq||N{O7(CmJa# z?7vts8nGpR;)ss=;IvbPbbNMl&m{>FGwkLMoO-fpBDEouZo)<;o(nzG12(9}AW!jo-8D_@aC+R0m`AX7qDj%ChX89tf z&J5ZW+QkCP*$lJGOWd5l!|dz~%Xg=c)3>Ovu29X=-x#E<(2PcyZH*DXxQDQRfcnuR zOb#Dn=im_A2L~v|lQe}^ja8puz2IBc#7|7>0icQ550j!owtmbnx^VHkJVh&l% z5ta)StF&8=hBJl&Z9PIe8Y7Ok5GE6pTN6~{EtI1Xs&wsSd!2_X@Jgn%Fcp(qfFL@xdlY}!do74b|-Ibz(#fUi-v}}7s*F)G9GndHefw>%s-#4 zqZj3;(N|bM!ajli6l_$^zl*-|`}gL?pN+{mM=#Ub^*}y%g@Jtj2>6jA?2O;C{0zhX@A>|HK#|INQ{EIEX>NKx;Mc)GJ_7~}7%}?0|pEjFkrxE z!$3X*1`HT5;Lb6S&wv2~1`N1!4CFIlz<>b*?i>U83>YwAz<@i)Kt2No3>Yxr&M}bB qfB^#r47hU) literal 0 HcmV?d00001 diff --git a/data/victor_serial/ht1621b.PDF b/data/victor_serial/ht1621b.PDF new file mode 100644 index 0000000000000000000000000000000000000000..795c52afe629d88c63757099183831a112855ada GIT binary patch literal 187489 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

R|bHFsWeuBA`iwGtV(IoQs zGO*1SC5#?_s=p6yKTwrIll|p=i_E+rD-BKd_Qz4;>ev-o*4I(jTC(Aowb}2Qv@T7R z3te+^zz&o1s$MOeZKMB$|8Eeow>Mt=%#UAerKatrS>j6gVe>$cJNQ8{d+Um`468AR zM=nuI5jD|c$R2v-n7&@8=DJr))EEH~;lLTlO;=_yAS~47d!i0`Nz~5Cl-~Go&F&sD zk~98e9t)@`f(sJ2LWsIjB9b5#BePV@W1sF}W~pqK5I?6|eJ`UWS?{NDsA6wsd0J#O z3O+d?jI~d5m6RDad&yu~y8YpQOzeVpH@BrX9SK>U3HRi<1n9+b)#1gq2z`(7H6z)* z%lon$XZB?053NWKH*Q?VzERNGW#0#9?u2{Tg_9|)rW`l

  • &0mbix5Tk3qZhTH18 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 z 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 = hist_values.iter().copied().collect(); @@ -171,6 +171,7 @@ pub fn show_histogram( 0.0001, &metermode, false, + None, ); let chart_name = format!( " Samples: {}\nBin Width: {} {}\n Min: {}\n Max: {}", @@ -218,6 +219,7 @@ pub fn show_histogram( 0.0001, &metermode, false, + None, ); let (formatted_end, _) = crate::helpers::format_measurement( bin_end, @@ -226,6 +228,7 @@ pub fn show_histogram( 0.0001, &metermode, false, + None, ); // Sample count is the bar's value (height) let sample_count = bar.value as usize; diff --git a/src/app/hid.rs b/src/app/hid.rs index 99aa9f0..8a19a22 100644 --- a/src/app/hid.rs +++ b/src/app/hid.rs @@ -5,7 +5,7 @@ use hidapi::HidApi; use tokio::sync::{mpsc, oneshot}; use crate::multimeter::MeterMode; -use crate::victor::{self, VICTOR_PRODUCT_ID, VICTOR_VENDOR_ID}; +use crate::victor_fs9922::{self, VICTOR_PRODUCT_ID, VICTOR_VENDOR_ID}; impl super::MyApp { pub fn refresh_hid_devices(&mut self) { @@ -117,7 +117,9 @@ impl super::MyApp { if *value_debug_shared.lock().unwrap() { println!("Victor HID received {} bytes", len); } - if let Some(reading) = victor::parse_hid_buffer(&readbuf[..len]) { + if let Some(reading) = + victor_fs9922::parse_hid_buffer(&readbuf[..len]) + { if *value_debug_shared.lock().unwrap() { println!("Victor reading: {} {:?}", reading.value, reading.mode); } diff --git a/src/app/mod.rs b/src/app/mod.rs index 0a6b994..26c0abf 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -22,23 +22,61 @@ mod serial; mod settings; mod ui; #[cfg(not(target_arch = "wasm32"))] -mod victor_serial; +mod victor_86bcd_serial; +#[cfg(not(target_arch = "wasm32"))] +mod victor_86bcd_capture_ui; +mod victor_86e_serial; /// How rusty_meter talks to the multimeter. /// -/// - `Serial` — SCPI over UART (OWON XDM series, remote control) -/// - `VictorHid` — Victor 86B/C/D via USB HID + FS9922 cable protocol (read only) -/// - `VictorSerial` — Victor 86E via CP2102 UART + ES51932 ASCII frames (read only) +/// - `ScpiSerial` — SCPI over UART (OWON XDM series, remote control) +/// - `VictorHid` — **legacy** Victor 86B/C/D via USB HID + FS9922 cable (discontinued) +/// - `Victor86bcdSerial` — **newer** Victor (e.g. 86D): DM1107, opto-isolated CP2102 serial +/// - `Victor86eSerial` — Victor 86E via CP2102 UART + ES51932 ASCII frames (read only) #[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Default)] pub enum ConnectionType { #[default] - Serial, - /// Victor 86B/C/D: USB HID, Fortune FS9922-DMM4. See `victor` module / sigrok wiki. + ScpiSerial, + /// Legacy Victor 86B/C/D: USB HID, Fortune FS9922-DMM4. See `victor_fs9922` / sigrok wiki. #[cfg(not(target_arch = "wasm32"))] VictorHid, + /// Newer Victor (e.g. 86D): DM1107, 9600 8N1 serial over opto-isolated USB. See `victor_dm1107`. + #[cfg(not(target_arch = "wasm32"))] + Victor86bcdSerial, /// Victor 86E: CP2102 serial 19200 7o1, Cyrustek ES51932. See `victor_es519xx` module. #[cfg(not(target_arch = "wasm32"))] - VictorSerial, + Victor86eSerial, +} + +/// Victor 86D / DM1107: 9600 baud, 8 data bits, no parity, 1 stop (8N1). +/// Line settings must be set on the builder before open — post-open `set_*` is unreliable. +#[cfg(not(target_arch = "wasm32"))] +pub(crate) fn open_victor_8n1_serial( + path: &str, + baud: u32, +) -> Result { + use mio_serial::{DataBits, Parity, SerialPortBuilderExt, StopBits}; + + mio_serial::new(path, baud) + .data_bits(DataBits::Eight) + .parity(Parity::None) + .stop_bits(StopBits::One) + .open_native_async() +} + +/// Victor 86E / ES51932: 19200 baud, 7 data bits, odd parity, 1 stop (7o1). +#[cfg(not(target_arch = "wasm32"))] +pub(crate) fn open_victor_7o1_serial( + path: &str, + baud: u32, +) -> Result { + use mio_serial::{DataBits, Parity, SerialPortBuilderExt, StopBits}; + + mio_serial::new(path, baud) + .data_bits(DataBits::Seven) + .parity(Parity::Odd) + .stop_bits(StopBits::One) + .open_native_async() } const VERSION: &str = env!("CARGO_PKG_VERSION"); @@ -183,10 +221,37 @@ pub struct MyApp { shutdown_tx: Option>, // Signal to shutdown serial task #[serde(skip)] mode_rx: Option>, // Channel for mode + unit updates + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + victor_86bcd_rx: Option>, + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + victor_lcd_display: String, #[serde(skip)] value_debug_shared: Arc>, // Shared debug flag for live updates #[serde(skip)] poll_interval_shared: Arc>, // Shared poll interval for live updates + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + victor_86bcd_capture_function: crate::victor_86bcd_capture::Victor86bcdCaptureFunction, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_unit: crate::victor_86bcd_capture::Victor86bcdCaptureUnit, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_dp_mode: crate::victor_86bcd_capture::Victor86bcdCaptureDpMode, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_digits: [crate::victor_86bcd_capture::LcdDigit; 4], + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_dp_after: Option, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_notes: String, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_duration_ms: u64, + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + victor_86bcd_capture_tx: Option>, + #[cfg(not(target_arch = "wasm32"))] + #[serde(skip)] + victor_86bcd_capture_status_shared: Arc>, #[serde(skip)] last_graph_update: f64, // Track last graph update time #[serde(skip)] @@ -274,6 +339,10 @@ impl Default for MyApp { serial_tx: None, shutdown_tx: None, // Initially no shutdown signal mode_rx: None, // Initially no mode update channel + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_rx: None, + #[cfg(not(target_arch = "wasm32"))] + victor_lcd_display: String::new(), poll_interval_ms: 20, graph_update_interval_ms: 20, // Default to 20ms for ~50 FPS graph_update_interval_max: 1000, // Default maximum of 1000ms @@ -284,6 +353,26 @@ impl Default for MyApp { lock_remote: true, // Default to locking remote mode value_debug_shared: Arc::new(Mutex::new(false)), poll_interval_shared: Arc::new(Mutex::new(20)), + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_function: crate::victor_86bcd_capture::Victor86bcdCaptureFunction::default(), + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_unit: crate::victor_86bcd_capture::Victor86bcdCaptureUnit::default(), + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_dp_mode: crate::victor_86bcd_capture::Victor86bcdCaptureDpMode::default(), + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_digits: [crate::victor_86bcd_capture::LcdDigit::Off; 4], + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_dp_after: None, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_notes: String::new(), + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_duration_ms: 1000, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_tx: None, + #[cfg(not(target_arch = "wasm32"))] + victor_86bcd_capture_status_shared: Arc::new(Mutex::new( + crate::victor_86bcd_capture::Victor86bcdCaptureStatus::default(), + )), last_graph_update: 0.0, // Initialize to 0 last_hist_collect_time: 0.0, // Initialize to 0 connection_state: ConnectionState::Disconnected, // Initially disconnected @@ -412,6 +501,12 @@ impl MyApp { self.serial_tx = None; // Drop sender to stop sending commands self.serial_rx = None; // Drop receiver to stop receiving measurements self.mode_rx = None; // Drop mode receiver + #[cfg(not(target_arch = "wasm32"))] + { + self.victor_86bcd_rx = None; + self.victor_lcd_display.clear(); + self.victor_86bcd_capture_tx = None; + } self.serial = None; // Clear serial port self.connection_state = ConnectionState::Disconnected; self.connection_error = None; // Clear any previous error @@ -442,7 +537,9 @@ impl MyApp { { matches!( self.connection_type, - ConnectionType::VictorHid | ConnectionType::VictorSerial + ConnectionType::VictorHid + | ConnectionType::Victor86bcdSerial + | ConnectionType::Victor86eSerial ) } #[cfg(target_arch = "wasm32")] @@ -451,22 +548,39 @@ impl MyApp { } } + #[cfg(not(target_arch = "wasm32"))] + fn is_victor_connection(&self) -> bool { + matches!( + self.connection_type, + ConnectionType::VictorHid + | ConnectionType::Victor86bcdSerial + | ConnectionType::Victor86eSerial + ) + } + /// Whether a mode button should appear in the control panel for the current connection. pub fn mode_visible_in_ui(&self, mode: MeterMode) -> bool { match mode { MeterMode::Duty => { #[cfg(not(target_arch = "wasm32"))] { - matches!( - self.connection_type, - ConnectionType::VictorHid | ConnectionType::VictorSerial - ) + self.is_victor_connection() } #[cfg(target_arch = "wasm32")] { false } } + MeterMode::Per => { + #[cfg(not(target_arch = "wasm32"))] + { + self.connection_type == ConnectionType::ScpiSerial + } + #[cfg(target_arch = "wasm32")] + { + true + } + } _ => true, } } diff --git a/src/app/settings.rs b/src/app/settings.rs index 73a8150..619c9dd 100644 --- a/src/app/settings.rs +++ b/src/app/settings.rs @@ -27,6 +27,7 @@ impl super::MyApp { self.value_debug = value_debug; *self.value_debug_shared.lock().unwrap() = value_debug; } + ui.label("Baud rate:"); ui.add( TextEdit::singleline(&mut self.baud_rate.to_string()) diff --git a/src/app/ui.rs b/src/app/ui.rs index 4236c66..5c2d929 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -76,6 +76,53 @@ impl TabViewer for PlotTabViewer<'_> { } impl super::MyApp { + /// Local CONT/DIOD threshold sliders. When `send_to_meter` is true, changes are sent via SCPI. + fn show_cont_diod_threshold_sliders(&mut self, ui: &mut egui::Ui, send_to_meter: bool) { + if self.metermode == MeterMode::Cont { + let threshold_slider = ui.add( + egui::Slider::new(&mut self.cont_threshold, 0..=1000) + .text("Threshold (Ω)") + .step_by(1.0) + .clamping(SliderClamping::Always), + ); + if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) + { + if let Some(tx) = self.serial_tx.clone() { + let cmd = format!("CONT:THREshold {}\n", self.cont_threshold); + let value_debug = self.value_debug; + tokio::spawn(async move { + if let Err(e) = tx.send(cmd).await { + if value_debug { + println!("Failed to queue threshold command: {}", e); + } + } + }); + } + } + } else if self.metermode == MeterMode::Diod { + let threshold_slider = ui.add( + egui::Slider::new(&mut self.diod_threshold, 0.0..=3.0) + .text("Threshold (V)") + .step_by(0.1) + .clamping(SliderClamping::Always), + ); + if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) + { + if let Some(tx) = self.serial_tx.clone() { + let cmd = format!("DIOD:THREshold {}\n", self.diod_threshold); + let value_debug = self.value_debug; + tokio::spawn(async move { + if let Err(e) = tx.send(cmd).await { + if value_debug { + println!("Failed to queue threshold command: {}", e); + } + } + }); + } + } + } + } + /// Called by the framework to save state before shutdown. pub fn save(&mut self, storage: &mut dyn eframe::Storage) { // Save recording data if recording is active @@ -123,16 +170,49 @@ impl super::MyApp { self.is_init = true; } - // Process all available measurements - if let Some(ref mut rx) = self.serial_rx { - while let Ok(meas_opt) = rx.try_recv() { - if let Some(meas) = meas_opt { - self.curr_meas = meas; // Update curr_meas with new data + // Victor 86B/C/D serial: LCD text + mode from DM1107 frames (read-only, no SCPI ranges) + #[cfg(not(target_arch = "wasm32"))] + if self.connection_type == super::ConnectionType::Victor86bcdSerial { + if let Some(rx) = &mut self.victor_86bcd_rx { + while let Ok(update) = rx.try_recv() { + self.victor_lcd_display = update.display; + if let Some(v) = update.value { + self.curr_meas = v; + } + if update.mode != self.metermode { + self.metermode = update.mode; + self.curr_unit = update.unit; + self.values = VecDeque::with_capacity(self.mem_depth); + self.hist_values = VecDeque::with_capacity(self.hist_mem_depth); + self.rangecmd = None; + self.curr_range = 0; + if self.value_debug { + println!("Updated metermode to: {:?}", update.mode); + } + } else if self.curr_unit != update.unit { + self.curr_unit = update.unit; + } } } } - // Process all available mode updates + // SCPI / Victor 86E / HID — all use serial_rx for the live value + #[cfg(not(target_arch = "wasm32"))] + let poll_serial_rx = self.connection_type != super::ConnectionType::Victor86bcdSerial; + #[cfg(target_arch = "wasm32")] + let poll_serial_rx = true; + + if poll_serial_rx { + if let Some(ref mut rx) = self.serial_rx { + while let Ok(meas_opt) = rx.try_recv() { + if let Some(meas) = meas_opt { + self.curr_meas = meas; + } + } + } + } + + // Process mode updates (SCPI / Victor 86E / HID) let read_only = self.is_read_only(); if let Some(ref mut rx) = self.mode_rx { while let Ok((mode, unit)) = rx.try_recv() { @@ -228,14 +308,17 @@ impl super::MyApp { ui.label("Connection:"); egui::ComboBox::from_id_salt("connection_type") .selected_text(match self.connection_type { - super::ConnectionType::Serial => "SCPI Serial (OWON)", + super::ConnectionType::ScpiSerial => "SCPI Serial (OWON)", super::ConnectionType::VictorHid => "Victor USB HID (86B/C/D)", - super::ConnectionType::VictorSerial => "Victor Serial (86E)", + super::ConnectionType::Victor86bcdSerial => { + "Victor Serial (86B/C/D)" + } + super::ConnectionType::Victor86eSerial => "Victor Serial (86E)", }) .show_ui(ui, |ui| { ui.selectable_value( &mut self.connection_type, - super::ConnectionType::Serial, + super::ConnectionType::ScpiSerial, "SCPI Serial (OWON)", ); ui.selectable_value( @@ -245,7 +328,12 @@ impl super::MyApp { ); ui.selectable_value( &mut self.connection_type, - super::ConnectionType::VictorSerial, + super::ConnectionType::Victor86bcdSerial, + "Victor Serial (86B/C/D)", + ); + ui.selectable_value( + &mut self.connection_type, + super::ConnectionType::Victor86eSerial, "Victor Serial (86E)", ); }); @@ -253,7 +341,7 @@ impl super::MyApp { match self.connection_type { #[cfg(target_arch = "wasm32")] - super::ConnectionType::Serial => { + super::ConnectionType::ScpiSerial => { ui.label("Serial port:"); ui.add( DropDownBox::from_iter( @@ -268,7 +356,9 @@ impl super::MyApp { ); } #[cfg(not(target_arch = "wasm32"))] - super::ConnectionType::Serial | super::ConnectionType::VictorSerial => { + super::ConnectionType::ScpiSerial + | super::ConnectionType::Victor86bcdSerial + | super::ConnectionType::Victor86eSerial => { ui.label("Serial port:"); ui.add( DropDownBox::from_iter( @@ -326,7 +416,7 @@ impl super::MyApp { self.connection_error = None; match self.connection_type { - super::ConnectionType::Serial => { + super::ConnectionType::ScpiSerial => { match mio_serial::new(&self.serial_port, self.baud_rate) .open_native_async() { @@ -368,27 +458,41 @@ impl super::MyApp { } } #[cfg(not(target_arch = "wasm32"))] - super::ConnectionType::VictorSerial => { - match mio_serial::new( + super::ConnectionType::Victor86bcdSerial => { + match super::open_victor_8n1_serial( + &self.serial_port, + crate::victor_dm1107::VICTOR_86BCD_BAUD, + ) { + Ok(serial) => { + self.serial = Some(serial); + self.connection_state = + super::ConnectionState::Connected; + self.curr_meter = + "Victor 86B/C/D (DM1107)".to_owned(); + self.rangecmd = None; + self.spawn_victor_86bcd_serial_task(); + } + Err(e) => { + self.connection_state = + super::ConnectionState::Disconnected; + self.connection_error = + Some(format!("Failed to connect: {}", e)); + } + } + } + #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::Victor86eSerial => { + match super::open_victor_7o1_serial( &self.serial_port, crate::victor_es519xx::VICTOR_86E_BAUD, - ) - .open_native_async() - { + ) { Ok(serial) => { self.serial = Some(serial); - if let Some(ref mut serial) = self.serial { - let _ = serial.set_data_bits(DataBits::Seven); - let _ = serial - .set_stop_bits(mio_serial::StopBits::One); - let _ = - serial.set_parity(mio_serial::Parity::Odd); - self.connection_state = - super::ConnectionState::Connected; - self.curr_meter = "Victor 86E".to_owned(); - self.rangecmd = None; - self.spawn_victor_serial_task(); - } + self.connection_state = + super::ConnectionState::Connected; + self.curr_meter = "Victor 86E".to_owned(); + self.rangecmd = None; + self.spawn_victor_86e_serial_task(); } Err(e) => { self.connection_state = @@ -444,17 +548,35 @@ impl super::MyApp { ui.separator(); + #[cfg(not(target_arch = "wasm32"))] + if self.value_debug + && self.connection_type == super::ConnectionType::Victor86bcdSerial + && self.connection_state == super::ConnectionState::Connected + { + let capture_frame = egui::Frame { + inner_margin: 12.0.into(), + outer_margin: egui::Margin::symmetric(24, 8), + corner_radius: 5.0.into(), + shadow: epaint::Shadow::NONE, + fill: self.box_background_color, + stroke: egui::Stroke::new(1.0, egui::Color32::DARK_GRAY), + }; + capture_frame.show(ui, |ui| { + self.show_victor_86bcd_capture_panel(ui); + }); + } + ui.horizontal(|ui| { // Determine if the background and shadow should be dark red based on mode and threshold let is_below_threshold = match self.metermode { - MeterMode::Cont => self - .values - .back() - .is_some_and(|&val| val <= self.cont_threshold as f64), - MeterMode::Diod => self - .values - .back() - .is_some_and(|&val| val <= self.diod_threshold as f64), + MeterMode::Cont => { + self.curr_meas.is_finite() + && self.curr_meas <= self.cont_threshold as f64 + } + MeterMode::Diod => { + self.curr_meas.is_finite() + && self.curr_meas <= self.diod_threshold as f64 + } _ => false, }; let background_color = if is_below_threshold { @@ -488,6 +610,35 @@ impl super::MyApp { Vec2 { x: 400.0, y: 300.0 }, egui::Layout::top_down(egui::Align::RIGHT).with_cross_justify(false), |ui| { + #[cfg(not(target_arch = "wasm32"))] + let (formatted_value, display_unit) = { + let lcd_override = + if self.connection_type + == super::ConnectionType::Victor86bcdSerial + && self.curr_meas + != crate::helpers::METER_OVERLOAD_VALUE + && !self.victor_lcd_display.is_empty() + { + Some(( + self.victor_lcd_display.as_str(), + self.curr_unit.as_str(), + )) + } else { + None + }; + let auto_scale = + !self.is_read_only() && self.auto_scale_units(&self.metermode); + format_measurement( + self.curr_meas, + 10, + 1_000_000.0, + 0.000001, + &self.metermode, + auto_scale, + lcd_override, + ) + }; + #[cfg(target_arch = "wasm32")] let (formatted_value, display_unit) = format_measurement( self.curr_meas, 10, @@ -495,6 +646,7 @@ impl super::MyApp { 0.000001, &self.metermode, self.auto_scale_units(&self.metermode), + None, ); ui.label( egui::RichText::new(formatted_value) @@ -627,17 +779,19 @@ impl super::MyApp { None, ); } - let per_btn = egui::Button::new("Period") - .selected(self.metermode == MeterMode::Per) - .min_size(btn_size); - if ui.add(per_btn).clicked() { - self.set_mode( - MeterMode::Per, - "s", - "CONF:PER\n", - Some("PER"), - None, - ); + if self.mode_visible_in_ui(MeterMode::Per) { + let per_btn = egui::Button::new("Period") + .selected(self.metermode == MeterMode::Per) + .min_size(btn_size); + if ui.add(per_btn).clicked() { + self.set_mode( + MeterMode::Per, + "s", + "CONF:PER\n", + Some("PER"), + None, + ); + } } if self.mode_visible_in_ui(MeterMode::Duty) { let duty_btn = egui::Button::new("Duty") @@ -706,11 +860,10 @@ impl super::MyApp { options_frame.show(ui, |ui| { ui.vertical(|ui| { if self.is_read_only() { - ui.label("Mode/range controlled on device"); - let mut auto_scale = self.auto_scale_units(&self.metermode); - if ui.checkbox(&mut auto_scale, "Auto-scale units").changed() { - self.set_auto_scale_units(self.metermode, auto_scale); - } + ui.label( + egui::RichText::new("Range controlled on device").italics(), + ); + self.show_cont_diod_threshold_sliders(ui, false); return; } let ratebox = egui::ComboBox::from_label("Sampling Rate").show_index( @@ -780,57 +933,7 @@ impl super::MyApp { } } - if self.metermode == MeterMode::Cont { - let threshold_slider = ui.add( - egui::Slider::new(&mut self.cont_threshold, 0..=1000) - .text("Threshold (Ω)") - .step_by(1.0) - .clamping(SliderClamping::Always), - ); - if threshold_slider.drag_stopped() || threshold_slider.lost_focus() - { - if let Some(tx) = self.serial_tx.clone() { - let cmd = - format!("CONT:THREshold {}\n", self.cont_threshold); - let value_debug = self.value_debug; - tokio::spawn(async move { - if let Err(e) = tx.send(cmd).await { - if value_debug { - println!( - "Failed to queue threshold command: {}", - e - ); - } - } - }); - } - } - } else if self.metermode == MeterMode::Diod { - let threshold_slider = ui.add( - egui::Slider::new(&mut self.diod_threshold, 0.0..=3.0) - .text("Threshold (V)") - .step_by(0.1) - .clamping(SliderClamping::Always), - ); - if threshold_slider.drag_stopped() || threshold_slider.lost_focus() - { - if let Some(tx) = self.serial_tx.clone() { - let cmd = - format!("DIOD:THREshold {}\n", self.diod_threshold); - let value_debug = self.value_debug; - tokio::spawn(async move { - if let Err(e) = tx.send(cmd).await { - if value_debug { - println!( - "Failed to queue threshold command: {}", - e - ); - } - } - }); - } - } - } + self.show_cont_diod_threshold_sliders(ui, true); } // scale control per mode diff --git a/src/app/victor_86bcd_capture_ui.rs b/src/app/victor_86bcd_capture_ui.rs new file mode 100644 index 0000000..29b286d --- /dev/null +++ b/src/app/victor_86bcd_capture_ui.rs @@ -0,0 +1,180 @@ +//! Victor 86B/C/D serial labeled capture panel (DM1107). + +use egui::{DragValue, RichText}; + +use crate::victor_86bcd_capture::{ + LcdDigit, LcdDisplay, Victor86bcdCaptureContext, Victor86bcdCaptureDpMode, + Victor86bcdCaptureFunction, Victor86bcdCaptureJob, Victor86bcdCaptureUnit, +}; + +use super::MyApp; + +impl MyApp { + pub fn show_victor_86bcd_capture_panel(&mut self, ui: &mut egui::Ui) { + ui.heading("Victor 86B/C/D serial capture"); + ui.label( + "DM1107 USB-serial meters only (not 86E ES51932 or legacy HID). \ + Describe what the meter shows, then record a raw byte window (9600 8N1). \ + Set each LCD digit: off (_), 0–9, or L. Decimal-after picks where the point sits \ + between digits (manual range = fixed position).", + ); + + ui.horizontal(|ui| { + ui.label("Function:"); + let prev_function = self.victor_86bcd_capture_function; + egui::ComboBox::from_id_salt("victor_86bcd_capture_function") + .selected_text(self.victor_86bcd_capture_function.label()) + .show_ui(ui, |ui| { + for function in Victor86bcdCaptureFunction::all() { + ui.selectable_value( + &mut self.victor_86bcd_capture_function, + *function, + function.label(), + ); + } + }); + if self.victor_86bcd_capture_function != prev_function { + self.victor_86bcd_capture_unit = self + .victor_86bcd_capture_function + .default_unit(); + } + + ui.label("Unit:"); + egui::ComboBox::from_id_salt("victor_86bcd_capture_unit") + .selected_text(self.victor_86bcd_capture_unit.label()) + .show_ui(ui, |ui| { + for unit in Victor86bcdCaptureUnit::all() { + ui.selectable_value( + &mut self.victor_86bcd_capture_unit, + *unit, + unit.label(), + ); + } + }); + + ui.label("Decimal:"); + egui::ComboBox::from_id_salt("victor_86bcd_capture_dp_mode") + .selected_text(self.victor_86bcd_capture_dp_mode.label()) + .show_ui(ui, |ui| { + for mode in Victor86bcdCaptureDpMode::all() { + ui.selectable_value( + &mut self.victor_86bcd_capture_dp_mode, + *mode, + mode.label(), + ); + } + }); + }); + + ui.horizontal(|ui| { + ui.label("LCD:"); + for (i, digit) in self.victor_86bcd_capture_digits.iter_mut().enumerate() { + ui.label(format!("d{i}")); + egui::ComboBox::from_id_salt(format!("victor_86bcd_capture_d{i}")) + .selected_text(digit.ui_label()) + .width(52.0) + .show_ui(ui, |ui| { + for option in LcdDigit::all() { + ui.selectable_value(digit, *option, option.ui_label()); + } + }); + } + + ui.label("DP after:"); + let mut dp_choice = self + .victor_86bcd_capture_dp_after + .map(|n| n + 1) + .unwrap_or(0); + egui::ComboBox::from_id_salt("victor_86bcd_capture_dp_after") + .selected_text(match self.victor_86bcd_capture_dp_after { + None => "none", + Some(0) => "d0", + Some(1) => "d1", + Some(2) => "d2", + Some(_) => "?", + }) + .width(64.0) + .show_ui(ui, |ui| { + ui.selectable_value(&mut dp_choice, 0, "none"); + ui.selectable_value(&mut dp_choice, 1, "d0"); + ui.selectable_value(&mut dp_choice, 2, "d1"); + ui.selectable_value(&mut dp_choice, 3, "d2"); + }); + self.victor_86bcd_capture_dp_after = match dp_choice { + 0 => None, + n => Some((n - 1) as u8), + }; + + let preview = LcdDisplay { + digits: self.victor_86bcd_capture_digits, + dp_after: self.victor_86bcd_capture_dp_after, + }; + ui.label(RichText::new(format!("→ {}", preview.format())).monospace()); + }); + + ui.horizontal(|ui| { + ui.label("Notes:"); + ui.add( + egui::TextEdit::singleline(&mut self.victor_86bcd_capture_notes) + .desired_width(280.0) + .hint_text("REL, MAX/MIN — optional"), + ); + }); + + ui.horizontal(|ui| { + ui.label("Record duration:"); + ui.add( + DragValue::new(&mut self.victor_86bcd_capture_duration_ms) + .range(50..=10_000) + .speed(50) + .suffix(" ms"), + ); + ui.label("of raw serial (click to type)"); + }); + + let display = LcdDisplay { + digits: self.victor_86bcd_capture_digits, + dp_after: self.victor_86bcd_capture_dp_after, + }; + let can_capture = self.connection_state == super::ConnectionState::Connected + && self.victor_86bcd_capture_tx.is_some() + && !display.is_empty(); + + if ui + .add_enabled(can_capture, egui::Button::new("Capture sample")) + .on_hover_text("Append one CSV row: d0–d3, dp_after, and raw bytes in the window") + .clicked() + { + if let Some(tx) = &self.victor_86bcd_capture_tx { + let job = Victor86bcdCaptureJob { + context: Victor86bcdCaptureContext { + function: self.victor_86bcd_capture_function, + unit: self.victor_86bcd_capture_unit, + dp_mode: self.victor_86bcd_capture_dp_mode, + display, + notes: self.victor_86bcd_capture_notes.clone(), + }, + duration_ms: self.victor_86bcd_capture_duration_ms, + }; + if tx.try_send(job).is_err() { + let mut st = self.victor_86bcd_capture_status_shared.lock().unwrap(); + st.message = "Capture busy — wait for current recording".to_owned(); + } + } + } + + let status = self.victor_86bcd_capture_status_shared.lock().unwrap(); + if !status.message.is_empty() { + ui.add_space(4.0); + ui.label(RichText::new(&status.message).small()); + } + ui.label( + RichText::new(format!( + "CSV: {} | explore: cargo run --bin victor-86bcd-explore", + crate::victor_86bcd_capture::default_samples_path().display() + )) + .small() + .weak(), + ); + } +} \ No newline at end of file diff --git a/src/app/victor_86bcd_serial.rs b/src/app/victor_86bcd_serial.rs new file mode 100644 index 0000000..1cb2618 --- /dev/null +++ b/src/app/victor_86bcd_serial.rs @@ -0,0 +1,331 @@ +//! Victor DM1107 serial task (mio-serial, 9600 8N1). +//! +//! Newer Victor meters (e.g. 86D): binary stream from opto-isolated USB link. +//! Live display values use [`victor_dm1107::feed_bytes`] (20-byte `a5 12` frame decode). +//! +//! Serial I/O uses [`mio::Poll`] on a blocking thread (same integration `mio-serial` +//! expects). The poll wakes as soon as the port is readable; the timeout is only +//! checked when idle so shutdown can be observed. + +use std::{ + io::{self, Read}, + path::PathBuf, + sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }, + time::Duration, +}; + +use mio::{Events, Interest, Poll, Token}; +use mio_serial::{ClearBuffer, SerialPort}; +use tokio::sync::{mpsc, oneshot}; +use tokio::time::{sleep_until, Instant}; + +use crate::victor_86bcd_capture::{self, Victor86bcdCaptureJob}; +use crate::victor_dm1107::{self, Dm1107LiveUpdate}; + +const SERIAL_TOKEN: Token = Token(2); +/// Max wait when no bytes are arriving; lets the reader thread observe `stop`. +const IDLE_POLL_MS: u64 = 250; + +struct ActiveCapture { + job: Victor86bcdCaptureJob, + buf: Vec, + ends_at: Instant, +} + +fn drain_readable_serial( + serial: &mut mio_serial::SerialStream, + readbuf: &mut [u8], +) -> io::Result> { + let mut chunk = Vec::new(); + loop { + match serial.read(readbuf) { + Ok(0) => break, + Ok(count) => chunk.extend_from_slice(&readbuf[..count]), + Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, + Err(e) => return Err(e), + } + } + Ok(chunk) +} + +fn process_chunk( + chunk: &[u8], + stream: &mut victor_dm1107::Dm1107Stream, + active_capture: &mut Option, + debug: bool, +) -> Vec { + if debug { + println!( + "Victor serial +{} bytes: {}", + chunk.len(), + victor_dm1107::hex_encode(&chunk[..chunk.len().min(32)]), + ); + } + if let Some(cap) = active_capture { + cap.buf.extend_from_slice(chunk); + } + victor_dm1107::feed_bytes(stream, chunk) +} + +async fn push_live_updates( + tx_live: &mpsc::Sender, + updates: Vec, + debug: bool, +) { + for update in updates { + if debug { + println!( + "Victor 86B/C/D: {} {} {:?}", + update.display, update.unit, update.mode + ); + } + let _ = tx_live.send(update).await; + } +} + +/// Background reader: `mio::Poll` blocks until the OS reports readability. +struct SerialReader { + bytes_rx: mpsc::Receiver>, + reader_handle: tokio::task::JoinHandle<()>, + stop: Arc, +} + +impl SerialReader { + fn spawn(mut serial: mio_serial::SerialStream) -> Self { + let (bytes_tx, bytes_rx) = mpsc::channel::>(32); + let stop = Arc::new(AtomicBool::new(false)); + let stop_bg = stop.clone(); + + let reader_handle = tokio::task::spawn_blocking(move || { + let mut poll = match Poll::new() { + Ok(p) => p, + Err(e) => { + eprintln!("Victor serial Poll::new failed: {e}"); + return; + } + }; + let mut events = Events::with_capacity(1); + if let Err(e) = poll + .registry() + .register(&mut serial, SERIAL_TOKEN, Interest::READABLE) + { + eprintln!("Victor serial register failed: {e}"); + return; + } + + let mut readbuf = [0u8; 256]; + loop { + if stop_bg.load(Ordering::Acquire) { + break; + } + + match poll.poll(&mut events, Some(Duration::from_millis(IDLE_POLL_MS))) { + Ok(()) => { + for event in events.iter() { + if !event.is_readable() { + continue; + } + match drain_readable_serial(&mut serial, &mut readbuf) { + Ok(chunk) if chunk.is_empty() => {} + Ok(chunk) => { + if bytes_tx.blocking_send(chunk).is_err() { + let _ = poll.registry().deregister(&mut serial); + return; + } + } + Err(e) => { + eprintln!("Victor serial read error: {e}"); + let _ = poll.registry().deregister(&mut serial); + return; + } + } + } + } + Err(e) => { + eprintln!("Victor serial poll error: {e}"); + break; + } + } + } + + let _ = poll.registry().deregister(&mut serial); + }); + + Self { + bytes_rx, + reader_handle, + stop, + } + } + + async fn next_chunk(&mut self) -> Option> { + self.bytes_rx.recv().await + } + + async fn shutdown(self) { + self.stop.store(true, Ordering::Release); + let _ = self.reader_handle.await; + } +} + +async fn run_serial_loop( + mut serial: mio_serial::SerialStream, + mut shutdown_rx: oneshot::Receiver<()>, + mut capture_rx: mpsc::Receiver, + tx_live: mpsc::Sender, + value_debug_shared: Arc>, + capture_status_shared: Arc>, + device_shared: Arc>, +) { + let _ = serial.clear(ClearBuffer::Input); + let _ = serial.write_data_terminal_ready(true); + + if *value_debug_shared.lock().unwrap() { + println!("Victor 86B/C/D serial task started (DM1107 decode, 9600 8N1)"); + if let Some(name) = serial.name() { + println!("Victor 86B/C/D port: {name}"); + } + } + + { + let mut dev = device_shared.lock().unwrap(); + *dev = "Victor 86B/C/D serial (DM1107)".to_owned(); + } + + let mut reader = SerialReader::spawn(serial); + let mut stream = victor_dm1107::Dm1107Stream::new(); + let mut active_capture: Option = None; + let mut shutting_down = false; + + let write_status = |msg: String, bytes: usize| { + let mut st = capture_status_shared.lock().unwrap(); + st.message = msg; + st.bytes_written = bytes; + }; + + let finish_capture = |cap: ActiveCapture, debug: bool, write_status: &dyn Fn(String, usize)| { + let path: PathBuf = victor_86bcd_capture::default_samples_path(); + let job = cap.job; + match victor_86bcd_capture::append_labeled_capture( + &path, + &job.context, + job.duration_ms, + &cap.buf, + ) { + Ok(written) => { + let msg = format!( + "Saved {written} bytes ({} ms) → {}", + job.duration_ms, + path.display() + ); + if debug { + println!("{msg}"); + if written > 0 { + let preview = victor_dm1107::hex_encode(&cap.buf[..written.min(48)]); + println!(" start: {preview}…"); + } + } + write_status(msg, written); + } + Err(e) => { + let msg = format!("Capture write failed: {e}"); + eprintln!("{msg}"); + write_status(msg, 0); + } + } + }; + + loop { + let capture_deadline = active_capture.as_ref().map(|c| c.ends_at); + + tokio::select! { + _ = &mut shutdown_rx, if !shutting_down => { + shutting_down = true; + } + job = capture_rx.recv(), if active_capture.is_none() => { + if let Some(job) = job { + let duration = Duration::from_millis(job.duration_ms); + write_status( + format!( + "Recording {} ms for {}…", + job.duration_ms, + job.context.summary(), + ), + 0, + ); + active_capture = Some(ActiveCapture { + job, + buf: Vec::new(), + ends_at: Instant::now() + duration, + }); + } + } + _ = async { + if let Some(deadline) = capture_deadline { + sleep_until(deadline).await; + } + }, if capture_deadline.is_some() => { + if let Some(cap) = active_capture.take() { + let debug = *value_debug_shared.lock().unwrap(); + finish_capture(cap, debug, &write_status); + } + } + chunk = reader.next_chunk(), if !shutting_down => { + let Some(chunk) = chunk else { break; }; + let debug = *value_debug_shared.lock().unwrap(); + let updates = process_chunk(&chunk, &mut stream, &mut active_capture, debug); + push_live_updates(&tx_live, updates, debug).await; + } + } + + if shutting_down { + break; + } + } + + reader.shutdown().await; + + if *value_debug_shared.lock().unwrap() { + println!("Victor 86B/C/D serial task shutting down"); + } +} + +impl super::MyApp { + pub fn spawn_victor_86bcd_serial_task(&mut self) { + if self.serial.is_none() { + return; + } + + let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>(); + let (capture_tx, capture_rx) = mpsc::channel::(8); + let (tx_live, rx_live) = mpsc::channel::(100); + + self.shutdown_tx = Some(shutdown_tx); + self.victor_86bcd_capture_tx = Some(capture_tx); + self.victor_86bcd_rx = Some(rx_live); + self.serial_rx = None; + self.serial_tx = None; + self.mode_rx = None; + + let serial = self.serial.take().unwrap(); + let value_debug_shared = self.value_debug_shared.clone(); + let capture_status_shared = self.victor_86bcd_capture_status_shared.clone(); + let device_shared = self.device.clone(); + + tokio::spawn(async move { + run_serial_loop( + serial, + shutdown_rx, + capture_rx, + tx_live, + value_debug_shared, + capture_status_shared, + device_shared, + ) + .await; + }); + } +} \ No newline at end of file diff --git a/src/app/victor_serial.rs b/src/app/victor_86e_serial.rs similarity index 99% rename from src/app/victor_serial.rs rename to src/app/victor_86e_serial.rs index 1244e01..28f41c0 100644 --- a/src/app/victor_serial.rs +++ b/src/app/victor_86e_serial.rs @@ -17,7 +17,7 @@ use crate::victor_es519xx; const SERIAL_TOKEN: Token = Token(1); impl super::MyApp { - pub fn spawn_victor_serial_task(&mut self) { + pub fn spawn_victor_86e_serial_task(&mut self) { if self.serial.is_none() { return; } @@ -134,4 +134,4 @@ impl super::MyApp { } }); } -} +} \ No newline at end of file diff --git a/src/bin/victor_86bcd_explore.rs b/src/bin/victor_86bcd_explore.rs new file mode 100644 index 0000000..c5dfe39 --- /dev/null +++ b/src/bin/victor_86bcd_explore.rs @@ -0,0 +1,120 @@ +//! Offline analysis of Victor 86B/C/D DM1107 serial captures. +//! +//! ```text +//! cargo run --bin victor-86bcd-explore +//! ``` + +use std::env; + +use rusty_meter::victor_86bcd_capture; +use rusty_meter::victor_dm1107::{self, MeterFunction, VictorFrame}; + +struct Sample { + label: String, + display: rusty_meter::victor_86bcd_capture::LcdDisplay, + raw: Vec, +} + +fn load_latest(path: &str) -> Vec { + let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path}: {e}")); + victor_86bcd_capture::latest_samples_by_key(&text) + .into_iter() + .map(|row| Sample { + label: row.context.summary(), + display: row.context.display, + raw: row.raw, + }) + .collect() +} + +fn function_label(f: MeterFunction) -> &'static str { + match f { + MeterFunction::Vdc => "VDC", + MeterFunction::Vac => "VAC", + MeterFunction::Adc => "ADC", + MeterFunction::Aac => "AAC", + MeterFunction::Res => "RES", + MeterFunction::Cap => "CAP", + MeterFunction::Freq => "FREQ", + MeterFunction::Duty => "DUTY", + MeterFunction::Diod => "DIOD", + MeterFunction::Cont => "CONT", + MeterFunction::Temp => "TEMP", + MeterFunction::Unknown => "?", + } +} + +fn digit_hex(frame: &VictorFrame) -> String { + frame + .digits + .iter() + .map(|d| format!("{:02x}", d.raw)) + .collect::>() + .join(" ") +} + +fn main() { + let path = env::args() + .nth(1) + .unwrap_or_else(|| "data/victor_serial/victor_serial_samples.csv".to_owned()); + + let samples = load_latest(&path); + + println!("=== Victor 86B/C/D DM1107 serial, 20-byte `a5 12` frames ==="); + println!("File: {path} ({} unique captures)\n", samples.len()); + + println!("--- Frame decode ---"); + println!( + "{:<32} {:>6} mode decode (labeled)", + "context", "labeled" + ); + + let mut framed = 0usize; + let mut decoded_ok = 0usize; + for sample in &samples { + let Some(frame) = victor_dm1107::find_frame(&sample.raw) else { + println!("{:<32} (no a5 12 frame)", sample.label); + continue; + }; + framed += 1; + let reading = victor_dm1107::decode_frame(&frame); + let mode = format!( + "{} {:?} {:?}", + function_label(frame.decoded_mode.function), + frame.decoded_mode.unit, + frame.decoded_mode.dp_mode, + ); + let labeled = sample.display.format(); + let mark = if reading.text == labeled + || (reading.text.replace('_', "") == labeled.replace('_', "")) + { + decoded_ok += 1; + "ok" + } else if reading.text.is_empty() { + "??" + } else { + "~~" + }; + println!( + "{:<32} {:>6} {:<12} {} ({mark}, conf={}) wire={}", + sample.label, + labeled, + mode, + reading.text, + reading.confidence, + digit_hex(&frame), + ); + } + println!( + "({framed}/{} framed, {decoded_ok}/{} exact text match)\n", + samples.len(), + samples.len() + ); + + println!("--- Protocol ---"); + println!(" • DM1107 meter IC → opto isolation → CP2102 USB serial (9600 8N1)."); + println!(" • 20-byte repeating frames: `a5 12` sync, 3-byte mode header, 4 digit bytes, tail `.. 04 ..`."); + println!(" • Digit bytes: low 7 bits = segment map, bit 7 = decimal point (positions 0–2)."); + println!(" • `0x5f` = lit zero; `0x00` = off; `0x80` = DP only; `0xdf` = zero + DP."); + println!(" • Mode annunciators are single bits across bytes 2–4 and 9 (V/m/DC/−/AUTO/…)."); +} \ No newline at end of file diff --git a/src/helpers.rs b/src/helpers.rs index e345a67..9e0b453 100644 --- a/src/helpers.rs +++ b/src/helpers.rs @@ -1,5 +1,8 @@ use crate::multimeter::MeterMode; +/// Sentinel value for open-line / overload on SCPI and Victor DM1107 meters. +pub const METER_OVERLOAD_VALUE: f64 = 1e9; + pub fn format_measurement( value: f64, max_digits: usize, @@ -7,13 +10,14 @@ pub fn format_measurement( sci_threshold_low: f64, meter_mode: &MeterMode, auto_scale_units: bool, + lcd_override: Option<(&str, &str)>, ) -> (String, String) { if value.is_nan() { return (" NaN".to_string(), "".to_string()); } // Check for overload/open condition (1e9) in specific modes - if value == 1e9 + if value == METER_OVERLOAD_VALUE && matches!( meter_mode, MeterMode::Diod | MeterMode::Cont | MeterMode::Res @@ -22,6 +26,16 @@ pub fn format_measurement( return ("OVERLOAD".to_string(), "".to_string()); } + // Victor 6000-count meters: show wire-decoded LCD text (4 digits), unit from annunciator. + if let Some((lcd, unit)) = lcd_override { + if !lcd.is_empty() { + return ( + format!("{:>width$}", lcd, width = max_digits), + unit.to_string(), + ); + } + } + let abs_value = value.abs(); let mut display_value = value; let mut display_unit = match meter_mode { diff --git a/src/lib.rs b/src/lib.rs index 1cdd5f2..e6ac27a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,6 +6,10 @@ pub use app::MyApp; mod helpers; mod multimeter; #[cfg(not(target_arch = "wasm32"))] -mod victor; +mod victor_fs9922; +#[cfg(not(target_arch = "wasm32"))] +pub mod victor_dm1107; +#[cfg(not(target_arch = "wasm32"))] +pub mod victor_86bcd_capture; #[cfg(not(target_arch = "wasm32"))] mod victor_es519xx; diff --git a/src/victor_86bcd_capture.rs b/src/victor_86bcd_capture.rs new file mode 100644 index 0000000..763a40e --- /dev/null +++ b/src/victor_86bcd_capture.rs @@ -0,0 +1,698 @@ +//! Labeled serial capture for Victor 86B/C/D meters (DM1107 USB-serial). +//! +//! On these meters, **manual range** means a fixed decimal-point position +//! (not a traditional 20 V / 200 mV knob). **Unit** (V, mV, µA, …) is a separate +//! LCD annunciator — reflected in the wire stream. +//! +//! Captures store the LCD as four explicit digit slots (`d0`–`d3`) plus `dp_after` +//! (decimal after digit 0, 1, or 2). Use `_` for a digit that is completely off; +//! `0`–`9` for a lit digit. This avoids spreadsheet coercion (`00.00` → `0`) and +//! keeps off-vs-zero distinct for protocol correlation. +//! +//! Not used for Victor 86E (ES51932 serial) or legacy HID (FS9922) meters. + +use std::fs::OpenOptions; +use std::io::{self, Write}; +use std::path::{Path, PathBuf}; + +use chrono::Local; +use serde::{Deserialize, Serialize}; + +use crate::victor_dm1107; + +/// Measurement function selected on the meter (user-declared). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +pub enum Victor86bcdCaptureFunction { + #[default] + Vdc, + Vac, + Adc, + Aac, + Res, + Cap, + Freq, + Per, + Duty, + Diod, + Cont, + Temp, + Other, +} + +impl Victor86bcdCaptureFunction { + pub fn label(self) -> &'static str { + match self { + Self::Vdc => "VDC", + Self::Vac => "VAC", + Self::Adc => "ADC", + Self::Aac => "AAC", + Self::Res => "RES", + Self::Cap => "CAP", + Self::Freq => "FREQ", + Self::Per => "PER", + Self::Duty => "DUTY", + Self::Diod => "DIOD", + Self::Cont => "CONT", + Self::Temp => "TEMP", + Self::Other => "OTHER", + } + } + + pub fn default_unit(self) -> Victor86bcdCaptureUnit { + match self { + Self::Vdc | Self::Vac | Self::Diod => Victor86bcdCaptureUnit::V, + Self::Adc => Victor86bcdCaptureUnit::A, + Self::Aac => Victor86bcdCaptureUnit::A, + Self::Res | Self::Cont => Victor86bcdCaptureUnit::Ohm, + Self::Cap => Victor86bcdCaptureUnit::Nf, + Self::Freq => Victor86bcdCaptureUnit::Hz, + Self::Per | Self::Duty => Victor86bcdCaptureUnit::Percent, + Self::Temp => Victor86bcdCaptureUnit::Celsius, + Self::Other => Victor86bcdCaptureUnit::Unknown, + } + } + + pub fn all() -> &'static [Self] { + &[ + Self::Vdc, + Self::Vac, + Self::Adc, + Self::Aac, + Self::Res, + Self::Cap, + Self::Freq, + Self::Per, + Self::Duty, + Self::Diod, + Self::Cont, + Self::Temp, + Self::Other, + ] + } +} + +/// Unit annunciator lit on the LCD (separate from function dial). +#[allow(non_camel_case_types)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +pub enum Victor86bcdCaptureUnit { + #[default] + V, + mV, + A, + mA, + uA, + Ohm, + kOhm, + MOhm, + Nf, + Uf, + Hz, + Percent, + Celsius, + Fahrenheit, + Unknown, +} + +impl Victor86bcdCaptureUnit { + pub fn label(self) -> &'static str { + match self { + Self::V => "V", + Self::mV => "mV", + Self::A => "A", + Self::mA => "mA", + Self::uA => "uA", + Self::Ohm => "Ω", + Self::kOhm => "kΩ", + Self::MOhm => "MΩ", + Self::Nf => "nF", + Self::Uf => "µF", + Self::Hz => "Hz", + Self::Percent => "%", + Self::Celsius => "°C", + Self::Fahrenheit => "°F", + Self::Unknown => "?", + } + } + + pub fn all() -> &'static [Self] { + &[ + Self::V, + Self::mV, + Self::A, + Self::mA, + Self::uA, + Self::Ohm, + Self::kOhm, + Self::MOhm, + Self::Nf, + Self::Uf, + Self::Hz, + Self::Percent, + Self::Celsius, + Self::Fahrenheit, + Self::Unknown, + ] + } +} + +/// Fixed decimal-point position (manual) vs autorange moving the decimal (auto). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +pub enum Victor86bcdCaptureDpMode { + /// Decimal point locked by the range dial. + #[default] + Manual, + /// Meter chose decimal placement. + Auto, +} + +impl Victor86bcdCaptureDpMode { + pub fn label(self) -> &'static str { + match self { + Self::Manual => "manual DP", + Self::Auto => "auto DP", + } + } + + pub fn csv_value(self) -> &'static str { + match self { + Self::Manual => "manual", + Self::Auto => "auto", + } + } + + pub fn all() -> &'static [Self] { + &[Self::Manual, Self::Auto] + } +} + +/// One LCD digit position: completely off, a lit numeral, or overload `L`. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +pub enum LcdDigit { + /// Digit position blank on the LCD (`_` in CSV). + #[default] + Off, + D0, + D1, + D2, + D3, + D4, + D5, + D6, + D7, + D8, + D9, + /// Overload / open-line `L` (usually last digit). + L, +} + +impl LcdDigit { + pub fn csv_value(self) -> &'static str { + match self { + Self::Off => "_", + Self::D0 => "0", + Self::D1 => "1", + Self::D2 => "2", + Self::D3 => "3", + Self::D4 => "4", + Self::D5 => "5", + Self::D6 => "6", + Self::D7 => "7", + Self::D8 => "8", + Self::D9 => "9", + Self::L => "L", + } + } + + pub fn ui_label(self) -> &'static str { + match self { + Self::Off => "off", + Self::L => "L", + d => d.csv_value(), + } + } + + pub fn all() -> &'static [Self] { + &[ + Self::Off, + Self::D0, + Self::D1, + Self::D2, + Self::D3, + Self::D4, + Self::D5, + Self::D6, + Self::D7, + Self::D8, + Self::D9, + Self::L, + ] + } + + pub fn is_configured(self) -> bool { + !matches!(self, Self::Off) + } +} + +/// Four-digit LCD layout with explicit decimal placement. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +pub struct LcdDisplay { + pub digits: [LcdDigit; 4], + /// Decimal point after digit index 0, 1, or 2. `None` = no decimal shown. + pub dp_after: Option, +} + +impl LcdDisplay { + pub fn is_empty(self) -> bool { + self.digits.iter().all(|d| !d.is_configured()) && self.dp_after.is_none() + } + + /// Human-readable preview: `00.00`, `__.1L`, `_1.23`, etc. + pub fn format(&self) -> String { + let mut out = String::new(); + for (i, digit) in self.digits.iter().enumerate() { + out.push(match digit { + LcdDigit::Off => '_', + LcdDigit::L => 'L', + d => d.csv_value().chars().next().unwrap_or('_'), + }); + if self.dp_after == Some(i as u8) { + out.push('.'); + } + } + out + } + + pub fn sort_key(&self) -> String { + format!( + "{},{},{},{},{}", + self.digits[0].csv_value(), + self.digits[1].csv_value(), + self.digits[2].csv_value(), + self.digits[3].csv_value(), + self.dp_after + .map(|n| n.to_string()) + .unwrap_or_else(|| "_".to_owned()) + ) + } +} + +fn parse_lcd_digit_field(field: &str) -> Option { + match field.trim() { + "_" | "-" | "" => Some(LcdDigit::Off), + "0" => Some(LcdDigit::D0), + "1" => Some(LcdDigit::D1), + "2" => Some(LcdDigit::D2), + "3" => Some(LcdDigit::D3), + "4" => Some(LcdDigit::D4), + "5" => Some(LcdDigit::D5), + "6" => Some(LcdDigit::D6), + "7" => Some(LcdDigit::D7), + "8" => Some(LcdDigit::D8), + "9" => Some(LcdDigit::D9), + "L" | "l" => Some(LcdDigit::L), + _ => None, + } +} + +fn parse_dp_after_field(field: &str) -> Option> { + match field.trim() { + "_" | "-" | "" => Some(None), + "0" => Some(Some(0)), + "1" => Some(Some(1)), + "2" => Some(Some(2)), + _ => None, + } +} + +/// Full user-declared meter state for one labeled capture. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Victor86bcdCaptureContext { + pub function: Victor86bcdCaptureFunction, + /// LCD unit annunciator (V, mV, µA, …). + pub unit: Victor86bcdCaptureUnit, + /// Manual fixed decimal vs autorange. + pub dp_mode: Victor86bcdCaptureDpMode, + /// Four LCD digit slots + decimal placement. + pub display: LcdDisplay, + /// Optional extras: REL, MAX/MIN, hold, probe notes, etc. + pub notes: String, +} + +impl Default for Victor86bcdCaptureContext { + fn default() -> Self { + Self { + function: Victor86bcdCaptureFunction::default(), + unit: Victor86bcdCaptureFunction::default().default_unit(), + dp_mode: Victor86bcdCaptureDpMode::default(), + display: LcdDisplay::default(), + notes: String::new(), + } + } +} + +impl Victor86bcdCaptureContext { + /// Short label for status messages and explore output. + pub fn summary(&self) -> String { + let mut parts = vec![format!( + "{} {} {}", + self.function.label(), + self.unit.label(), + self.dp_mode.label() + )]; + parts.push(self.display.format()); + if !self.notes.trim().is_empty() { + parts.push(format!("({})", self.notes.trim())); + } + parts.join(" ") + } + + /// Unique key for offline tools (same digits in different unit/DP mode stay distinct). + pub fn sample_key(&self) -> String { + let notes = self.notes.trim(); + if notes.is_empty() { + format!( + "{}|{}|{}|{}", + self.function.label(), + self.unit.label(), + self.dp_mode.csv_value(), + self.display.sort_key() + ) + } else { + format!( + "{}|{}|{}|{}|{}", + self.function.label(), + self.unit.label(), + self.dp_mode.csv_value(), + self.display.sort_key(), + notes + ) + } + } +} + +/// Capture request: record every byte received for `duration_ms`. +#[derive(Debug, Clone)] +pub struct Victor86bcdCaptureJob { + pub context: Victor86bcdCaptureContext, + pub duration_ms: u64, +} + +#[derive(Debug, Clone, Default)] +pub struct Victor86bcdCaptureStatus { + pub message: String, + pub bytes_written: usize, +} + +pub const SAMPLES_CSV_HEADER: &str = + "timestamp,function,unit,dp_mode,d0,d1,d2,d3,dp_after,notes,duration_ms,byte_count,raw_hex"; + +pub fn default_samples_path() -> PathBuf { + PathBuf::from("data/victor_serial/victor_serial_samples.csv") +} + +fn csv_field(value: &str) -> String { + if value.contains(['"', ',', '\n', '\r']) { + format!("\"{}\"", value.replace('"', "\"\"")) + } else { + value.to_owned() + } +} + +fn write_csv_row( + file: &mut impl Write, + timestamp: &str, + context: &Victor86bcdCaptureContext, + duration_ms: u64, + raw: &[u8], +) -> io::Result<()> { + let ts = timestamp; + let hex = victor_dm1107::hex_encode(raw); + let dp_after = context + .display + .dp_after + .map(|n| n.to_string()) + .unwrap_or_else(|| "_".to_owned()); + writeln!( + file, + "{ts},{},{},{},{},{},{},{},{},{},{duration_ms},{},{}", + context.function.label(), + context.unit.label(), + context.dp_mode.csv_value(), + context.display.digits[0].csv_value(), + context.display.digits[1].csv_value(), + context.display.digits[2].csv_value(), + context.display.digits[3].csv_value(), + dp_after, + csv_field(context.notes.trim()), + raw.len(), + csv_hex_field(&hex), + ) +} + +fn csv_hex_field(hex: &str) -> String { + format!("\"{}\"", hex.replace('"', "\"\"")) +} + +pub fn append_labeled_capture( + path: &Path, + context: &Victor86bcdCaptureContext, + duration_ms: u64, + raw: &[u8], +) -> io::Result { + if let Some(parent) = path.parent() { + if !parent.as_os_str().is_empty() { + std::fs::create_dir_all(parent)?; + } + } + let needs_header = !path.exists() || path.metadata()?.len() == 0; + let mut file = OpenOptions::new().create(true).append(true).open(path)?; + if needs_header { + writeln!(file, "{SAMPLES_CSV_HEADER}")?; + } + let ts = Local::now().format("%Y-%m-%dT%H:%M:%S%.3f").to_string(); + write_csv_row(&mut file, &ts, context, duration_ms, raw)?; + Ok(raw.len()) +} + +/// One parsed CSV row (current structured LCD format only). +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Victor86bcdCaptureRow { + pub timestamp: String, + pub context: Victor86bcdCaptureContext, + pub duration_ms: u64, + pub raw: Vec, +} + +fn parse_data_line(line: &str) -> Option { + let (prefix, tail) = split_tail_fields(line, 3)?; + let duration_ms: u64 = tail[0].parse().ok()?; + let _byte_count: usize = tail[1].parse().ok()?; + let raw = parse_hex_field(tail[2]); + let mut parts: Vec<&str> = prefix.split(',').collect(); + while parts.last().is_some_and(|s| s.is_empty()) { + parts.pop(); + } + if parts.len() < 10 { + return None; + } + let function = parse_function_label(parts[1]); + let notes = if parts.len() >= 10 { + parts[9].to_owned() + } else { + String::new() + }; + let context = Victor86bcdCaptureContext { + function, + unit: parse_unit_label(parts[2]).unwrap_or_else(|| function.default_unit()), + dp_mode: parse_dp_mode_label(parts[3]), + display: LcdDisplay { + digits: [ + parse_lcd_digit_field(parts[4])?, + parse_lcd_digit_field(parts[5])?, + parse_lcd_digit_field(parts[6])?, + parse_lcd_digit_field(parts[7])?, + ], + dp_after: parse_dp_after_field(parts[8])?, + }, + notes, + }; + Some(Victor86bcdCaptureRow { + timestamp: parts[0].to_owned(), + context, + duration_ms, + raw, + }) +} + +fn split_tail_fields(line: &str, n: usize) -> Option<(&str, Vec<&str>)> { + let mut rest = line; + let mut tail = Vec::with_capacity(n); + for _ in 0..n { + let (left, right) = rest.rsplit_once(',')?; + tail.push(right); + rest = left; + } + tail.reverse(); + Some((rest, tail)) +} + +pub fn parse_samples_csv(text: &str) -> Vec { + let mut lines = text.lines(); + let header = lines.next().unwrap_or(""); + if header.trim().is_empty() { + return Vec::new(); + } + + let mut rows = Vec::new(); + for line in lines { + if line.trim().is_empty() { + continue; + } + if let Some(row) = parse_data_line(line) { + rows.push(row); + } + } + rows +} + +/// Latest row per [`Victor86bcdCaptureContext::sample_key`]. +pub fn latest_samples_by_key(text: &str) -> Vec { + let mut latest = std::collections::HashMap::new(); + for row in parse_samples_csv(text) { + latest.insert(row.context.sample_key(), row); + } + let mut out: Vec<_> = latest.into_values().collect(); + out.sort_by(|a, b| a.context.display.sort_key().cmp(&b.context.display.sort_key())); + out +} + +fn parse_hex_field(field: &str) -> Vec { + let trimmed = field.trim().trim_matches('"'); + trimmed + .split_whitespace() + .filter_map(|t| u8::from_str_radix(t, 16).ok()) + .collect() +} + +fn parse_function_label(label: &str) -> Victor86bcdCaptureFunction { + match label.trim().to_ascii_uppercase().as_str() { + "VDC" => Victor86bcdCaptureFunction::Vdc, + "VAC" => Victor86bcdCaptureFunction::Vac, + "ADC" => Victor86bcdCaptureFunction::Adc, + "AAC" => Victor86bcdCaptureFunction::Aac, + "RES" => Victor86bcdCaptureFunction::Res, + "CAP" => Victor86bcdCaptureFunction::Cap, + "FREQ" => Victor86bcdCaptureFunction::Freq, + "PER" => Victor86bcdCaptureFunction::Per, + "DUTY" => Victor86bcdCaptureFunction::Duty, + "DIOD" => Victor86bcdCaptureFunction::Diod, + "CONT" => Victor86bcdCaptureFunction::Cont, + "TEMP" => Victor86bcdCaptureFunction::Temp, + _ => Victor86bcdCaptureFunction::Other, + } +} + +fn parse_dp_mode_label(label: &str) -> Victor86bcdCaptureDpMode { + match label.trim().to_ascii_lowercase().as_str() { + "auto" | "auto dp" => Victor86bcdCaptureDpMode::Auto, + _ => Victor86bcdCaptureDpMode::Manual, + } +} + +fn parse_unit_label(label: &str) -> Option { + match label.trim() { + "V" => Some(Victor86bcdCaptureUnit::V), + "mV" => Some(Victor86bcdCaptureUnit::mV), + "A" => Some(Victor86bcdCaptureUnit::A), + "mA" => Some(Victor86bcdCaptureUnit::mA), + "uA" | "µA" => Some(Victor86bcdCaptureUnit::uA), + "Ω" | "Ohm" => Some(Victor86bcdCaptureUnit::Ohm), + "kΩ" | "kOhm" => Some(Victor86bcdCaptureUnit::kOhm), + "MΩ" | "MOhm" => Some(Victor86bcdCaptureUnit::MOhm), + "nF" => Some(Victor86bcdCaptureUnit::Nf), + "µF" | "uF" => Some(Victor86bcdCaptureUnit::Uf), + "Hz" => Some(Victor86bcdCaptureUnit::Hz), + "%" => Some(Victor86bcdCaptureUnit::Percent), + "°C" | "C" => Some(Victor86bcdCaptureUnit::Celsius), + "°F" | "F" => Some(Victor86bcdCaptureUnit::Fahrenheit), + "" => None, + _ => Some(Victor86bcdCaptureUnit::Unknown), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn writes_and_parses_structured_lcd_csv() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("samples.csv"); + let context = Victor86bcdCaptureContext { + function: Victor86bcdCaptureFunction::Vdc, + unit: Victor86bcdCaptureUnit::mV, + dp_mode: Victor86bcdCaptureDpMode::Manual, + display: LcdDisplay { + digits: [LcdDigit::D0, LcdDigit::D0, LcdDigit::D0, LcdDigit::D0], + dp_after: Some(1), + }, + notes: "REL on".to_owned(), + }; + append_labeled_capture(&path, &context, 500, &[0xa5, 0x12]).unwrap(); + let text = std::fs::read_to_string(&path).unwrap(); + assert!(text.contains(",0,0,0,0,1,REL on,")); + let rows = parse_samples_csv(&text); + assert_eq!(rows.len(), 1); + assert_eq!(rows[0].context, context); + assert_eq!(rows[0].duration_ms, 500); + assert_eq!(rows[0].raw, vec![0xa5, 0x12]); + } + + #[test] + fn structured_lcd_distinguishes_off_from_zero() { + let zero = LcdDisplay { + digits: [LcdDigit::D0, LcdDigit::D0, LcdDigit::D0, LcdDigit::D0], + dp_after: Some(1), + }; + let off = LcdDisplay { + digits: [LcdDigit::Off, LcdDigit::Off, LcdDigit::D0, LcdDigit::D0], + dp_after: Some(1), + }; + assert_eq!(zero.format(), "00.00"); + assert_eq!(off.format(), "__.00"); + assert_ne!(zero.sort_key(), off.sort_key()); + } + + #[test] + fn sample_key_distinguishes_unit_and_dp() { + let a = Victor86bcdCaptureContext { + function: Victor86bcdCaptureFunction::Vdc, + unit: Victor86bcdCaptureUnit::V, + dp_mode: Victor86bcdCaptureDpMode::Manual, + display: LcdDisplay { + digits: [LcdDigit::D0, LcdDigit::D0, LcdDigit::D0, LcdDigit::D0], + dp_after: Some(1), + }, + notes: String::new(), + }; + let b = Victor86bcdCaptureContext { + function: Victor86bcdCaptureFunction::Vdc, + unit: Victor86bcdCaptureUnit::mV, + dp_mode: Victor86bcdCaptureDpMode::Manual, + display: LcdDisplay { + digits: [LcdDigit::D0, LcdDigit::D0, LcdDigit::D0, LcdDigit::D0], + dp_after: Some(1), + }, + notes: String::new(), + }; + assert_ne!(a.sample_key(), b.sample_key()); + } + + #[test] + fn default_samples_path_uses_victor_serial_subdir() { + assert_eq!( + default_samples_path(), + PathBuf::from("data/victor_serial/victor_serial_samples.csv") + ); + } +} \ No newline at end of file diff --git a/src/victor_dm1107.rs b/src/victor_dm1107.rs new file mode 100644 index 0000000..73930d1 --- /dev/null +++ b/src/victor_dm1107.rs @@ -0,0 +1,910 @@ +//! Victor DM1107 meters (e.g. 86D) — CP2102 serial protocol (9600 8N1). +//! +//! Newer Victor handhelds use a **DM1107** system IC and expose **only** a serial +//! link (CP2102 USB-UART). Meter logic is galvanically isolated from USB via an +//! optocoupler path — not the legacy HID/FS9922 cable used on discontinued 86B/C/D units. +//! +//! Each burst is a fixed **20-byte** frame: +//! ```text +//! a5 12 b2 b3 b4 [d3 d2 d1 d0] b9 pad… flg0-2 t0 04 t2 +//! ``` +//! +//! The four digit bytes on the wire are **rightmost-first** (`slice[8]` = LCD d0 / MSD, +//! `slice[5]` = LCD d3 / LSD). [`VictorFrame::digits`] is stored left-to-right for display. +//! +//! Digit bytes use **7 segment bits (low) + decimal point (bit 7)** on d0–d2. +//! `0x5f` is a lit **zero**; `0x00` is the digit position **off**; `0x80` is +//! **decimal point only** (digit off, DP lit). Combined: `0xdf = 0x5f|0x80` is zero + DP. +//! +//! Mode/range/unit annunciators are individual bits across bytes 2–4 and 9 (not +//! independent byte values). See [`LcdAnnunciators`]. + +use crate::helpers::METER_OVERLOAD_VALUE; +use crate::multimeter::MeterMode; + +pub const VICTOR_86BCD_BAUD: u32 = 9600; + +pub const SYNC: [u8; 2] = [0xa5, 0x12]; +pub const FRAME_LEN: usize = 20; +pub const TAIL_MARKER: u8 = 0x04; + +/// Low 7 bits = segment bitmap; bit 7 = decimal point after this digit (positions 0–2). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DigitCell { + pub raw: u8, +} + +impl DigitCell { + /// Lit zero segment pattern (not “off”). + pub const ZERO_SEG: u8 = 0x5f; + /// Digit position completely off. + pub const HARD_OFF: u8 = 0x00; + /// Digit off with only the decimal point lit. + pub const DP_ONLY: u8 = 0x80; + + pub fn from_raw(raw: u8) -> Self { + Self { raw } + } + + pub fn segments(self) -> u8 { + self.raw & 0x7f + } + + pub fn decimal_point(self) -> bool { + self.raw & 0x80 != 0 + } + + pub fn is_zero(self) -> bool { + self.segments() == Self::ZERO_SEG + } + + /// Digit position off: `0x00`, or `0x80` when only the DP is lit. + pub fn is_off(self) -> bool { + matches!(self.raw, Self::HARD_OFF | Self::DP_ONLY) + } + + pub fn is_dp_only(self) -> bool { + self.raw == Self::DP_ONLY + } +} + +/// Three-byte mode/range header after `a5 12`. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ModeHeader { + pub b2: u8, + pub b3: u8, + pub b4: u8, +} + +/// LCD annunciator bits extracted from the mode header and delimiter byte. +/// +/// Each field maps to one on-screen symbol (V, m, DC, −, AUTO, …). Modes are +/// derived from which combination is lit, not from whole-byte templates. +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub struct LcdAnnunciators { + /// Byte 9 bit 1 — DC marker. + pub dc: bool, + /// Byte 9 bit 3 — AC marker. + pub ac: bool, + /// Byte 9 bit 2 — minus (−) annunciator (independent of measurement function). + pub minus: bool, + /// Byte 4 bit 4 — AUTO range. + pub auto_range: bool, + /// Byte 4 bit 6 — MANUAL range (fixed decimal point). + pub manual_range: bool, + /// Byte 4 bit 2 — diode test. + pub diode: bool, + /// Byte 4 bit 3 — continuity. + pub continuity: bool, + /// Byte 2 bit 2 — volt (V) unit. + pub volt: bool, + /// Byte 2 bit 3 — milli (m) prefix. + pub milli: bool, + /// Byte 2 bit 1 — ampere (A) unit. + pub amp: bool, + /// Byte 2 bit 5 — ohm (Ω) unit. + pub ohm: bool, + /// Byte 2 bit 6 — kilo (k) prefix. + pub kilo: bool, + /// Byte 2 bit 7 — mega (M) prefix. + pub mega: bool, + /// Byte 2 bit 4 — hertz (Hz). + pub hertz: bool, + /// Byte 2 bit 0 — farad (F) capacitance. + pub farad: bool, + /// Byte 3 bit 2 — duty cycle (%). + pub duty: bool, + /// Byte 3 bit 5 — Celsius (°C). + pub celsius: bool, + /// Byte 3 bit 4 — Fahrenheit (°F). + pub fahrenheit: bool, + /// Byte 3 bit 6 — nano (n) prefix. + pub nano: bool, + /// Byte 3 bit 7 — micro (µ) prefix. + pub micro: bool, +} + +impl LcdAnnunciators { + pub fn from_mode_header(mode: ModeHeader, delimiter: u8) -> Self { + Self { + dc: delimiter & 0x02 != 0, + minus: delimiter & 0x04 != 0, + ac: delimiter & 0x08 != 0, + auto_range: mode.b4 & 0x10 != 0, + manual_range: mode.b4 & 0x40 != 0, + diode: mode.b4 & 0x04 != 0, + continuity: mode.b4 & 0x08 != 0, + volt: mode.b2 & 0x04 != 0, + milli: mode.b2 & 0x08 != 0, + amp: mode.b2 & 0x02 != 0, + ohm: mode.b2 & 0x20 != 0, + kilo: mode.b2 & 0x40 != 0, + mega: mode.b2 & 0x80 != 0, + hertz: mode.b2 & 0x10 != 0, + farad: mode.b2 & 0x01 != 0, + duty: mode.b3 & 0x04 != 0, + celsius: mode.b3 & 0x20 != 0, + fahrenheit: mode.b3 & 0x10 != 0, + nano: mode.b3 & 0x40 != 0, + micro: mode.b3 & 0x80 != 0, + } + } + + pub fn function_and_unit(self) -> (MeterFunction, MeterUnit) { + if self.diode { + return (MeterFunction::Diod, MeterUnit::V); + } + if self.continuity { + return (MeterFunction::Cont, MeterUnit::Ohm); + } + if self.celsius { + return (MeterFunction::Temp, MeterUnit::Celsius); + } + if self.fahrenheit { + return (MeterFunction::Temp, MeterUnit::Fahrenheit); + } + if self.duty { + return (MeterFunction::Duty, MeterUnit::Percent); + } + if self.hertz { + return (MeterFunction::Freq, MeterUnit::Hz); + } + if self.farad { + let unit = if self.micro { + MeterUnit::uF + } else if self.nano { + MeterUnit::nF + } else { + MeterUnit::Unknown + }; + return (MeterFunction::Cap, unit); + } + if self.ohm { + let unit = if self.mega { + MeterUnit::MOhm + } else if self.kilo { + MeterUnit::kOhm + } else { + MeterUnit::Ohm + }; + return (MeterFunction::Res, unit); + } + if self.volt { + let unit = if self.milli { MeterUnit::mV } else { MeterUnit::V }; + return if self.ac { + (MeterFunction::Vac, unit) + } else { + (MeterFunction::Vdc, unit) + }; + } + if self.amp { + let unit = if self.micro { + MeterUnit::uA + } else if self.milli { + MeterUnit::mA + } else { + MeterUnit::A + }; + return if self.ac { + (MeterFunction::Aac, unit) + } else { + (MeterFunction::Adc, unit) + }; + } + (MeterFunction::Unknown, MeterUnit::Unknown) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MeterFunction { + Vdc, + Vac, + Adc, + Aac, + Res, + Cap, + Freq, + Duty, + Diod, + Cont, + Temp, + Unknown, +} + +#[allow(non_camel_case_types)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MeterUnit { + V, + mV, + A, + mA, + uA, + Ohm, + kOhm, + MOhm, + nF, + uF, + Hz, + Percent, + Celsius, + Fahrenheit, + Unknown, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DpMode { + Manual, + Auto, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum AcDc { + Dc, + Ac, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DisplayKind { + Normal, + /// `.0L`, `0.L`, bar graph full — first/last digit off, DP lit. + Overload, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DecodedMode { + pub function: MeterFunction, + pub unit: MeterUnit, + pub dp_mode: DpMode, + pub ac_dc: AcDc, + /// Minus (−) annunciator lit; digit bytes stay unsigned. + pub is_negative: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VictorFrame { + pub mode: ModeHeader, + pub decoded_mode: DecodedMode, + /// Four digit slots in LCD order: `[d0, d1, d2, d3]` (left to right). + pub digits: [DigitCell; 4], + pub delimiter: u8, + pub flags: [u8; 3], + pub tail: [u8; 3], + pub display_kind: DisplayKind, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DecodedReading { + pub text: String, + pub confidence: u8, +} + +/// One live decode from the serial stream (6000-count / 4-digit LCD meters). +#[derive(Debug, Clone, PartialEq)] +pub struct Dm1107LiveUpdate { + /// LCD text as shown on the meter (`21.40`, `00.00`, `.0L`, …). + pub display: String, + /// Parsed value for graph/recording when numeric. + pub value: Option, + pub mode: MeterMode, + /// Unit annunciator (`VDC`, `nF`, `Hz`, …) — not auto-scaled. + pub unit: String, +} + +/// Rolling buffer for live CP2102 stream decode. +#[derive(Debug, Default)] +pub struct Dm1107Stream { + buf: Vec, + last_text: Option, + last_mode_key: Option, +} + +impl Dm1107Stream { + pub fn new() -> Self { + Self::default() + } +} + +const STREAM_KEEP_MAX: usize = 64; + +/// Parse one aligned 20-byte frame starting at `offset`. +pub fn parse_frame_at(raw: &[u8], offset: usize) -> Option { + let slice = raw.get(offset..offset + FRAME_LEN)?; + if slice[0..2] != SYNC { + return None; + } + let mode = ModeHeader { + b2: slice[2], + b3: slice[3], + b4: slice[4], + }; + // Wire transmits d3..d0; store d0..d3 for LCD-left-to-right decode. + let digits = [ + DigitCell::from_raw(slice[8]), + DigitCell::from_raw(slice[7]), + DigitCell::from_raw(slice[6]), + DigitCell::from_raw(slice[5]), + ]; + let delimiter = slice[9]; + let flags = [slice[14], slice[15], slice[16]]; + let tail = [slice[17], slice[18], slice[19]]; + if tail[1] != TAIL_MARKER { + return None; + } + let decoded_mode = decode_mode_header(mode, delimiter); + let display_kind = classify_display(&digits, flags); + Some(VictorFrame { + mode, + decoded_mode, + digits, + delimiter, + flags, + tail, + display_kind, + }) +} + +/// Find the most recent valid `a5 12` frame in a buffer (live stream may retain older frames). +pub fn find_frame(raw: &[u8]) -> Option { + if raw.len() < FRAME_LEN { + return None; + } + let last_start = raw.len() - FRAME_LEN; + (0..=last_start).rev().find_map(|i| parse_frame_at(raw, i)) +} + +/// Decode the 3-byte mode header + delimiter into meter function/unit/DP mode. +pub fn decode_mode_header(mode: ModeHeader, delimiter: u8) -> DecodedMode { + let ann = LcdAnnunciators::from_mode_header(mode, delimiter); + let (function, unit) = ann.function_and_unit(); + let ac_dc = if ann.ac { AcDc::Ac } else { AcDc::Dc }; + let dp_mode = if ann.manual_range { + DpMode::Manual + } else { + DpMode::Auto + }; + + DecodedMode { + function, + unit, + dp_mode, + ac_dc, + is_negative: ann.minus, + } +} + +fn decoded_mode_key(dm: &DecodedMode) -> String { + format!( + "{:?}|{:?}|{:?}|{:?}|{}", + dm.function, dm.unit, dm.dp_mode, dm.ac_dc, dm.is_negative + ) +} + +fn apply_negative_sign(text: &str, is_negative: bool) -> String { + if is_negative + && !text.is_empty() + && !text.starts_with('-') + && !is_overload_display(text) + { + format!("-{text}") + } else { + text.to_owned() + } +} + +/// Map wire mode header to UI [`MeterMode`] and unit label. +pub fn meter_mode_and_unit(dm: &DecodedMode) -> (MeterMode, String) { + let mode = match dm.function { + MeterFunction::Vdc => MeterMode::Vdc, + MeterFunction::Vac => MeterMode::Vac, + MeterFunction::Adc => MeterMode::Adc, + MeterFunction::Aac => MeterMode::Aac, + MeterFunction::Res => MeterMode::Res, + MeterFunction::Cap => MeterMode::Cap, + MeterFunction::Freq => MeterMode::Freq, + MeterFunction::Duty => MeterMode::Duty, + MeterFunction::Diod => MeterMode::Diod, + MeterFunction::Cont => MeterMode::Cont, + MeterFunction::Temp => MeterMode::Temp, + MeterFunction::Unknown => MeterMode::Vdc, + }; + let unit = match (dm.function, dm.unit, dm.ac_dc) { + (MeterFunction::Vdc, MeterUnit::V, _) => "VDC".to_owned(), + (MeterFunction::Vdc, MeterUnit::mV, _) => "mVDC".to_owned(), + (MeterFunction::Vac, MeterUnit::V, _) => "VAC".to_owned(), + (MeterFunction::Vac, MeterUnit::mV, _) => "mVAC".to_owned(), + (MeterFunction::Adc, MeterUnit::A, _) => "ADC".to_owned(), + (MeterFunction::Adc, MeterUnit::mA, _) => "mADC".to_owned(), + (MeterFunction::Adc, MeterUnit::uA, _) => "µADC".to_owned(), + (MeterFunction::Aac, MeterUnit::A, _) => "AAC".to_owned(), + (MeterFunction::Aac, MeterUnit::mA, _) => "mAAC".to_owned(), + (MeterFunction::Aac, MeterUnit::uA, _) => "µAAC".to_owned(), + (MeterFunction::Res, MeterUnit::Ohm, _) => "Ω".to_owned(), + (MeterFunction::Res, MeterUnit::kOhm, _) => "kΩ".to_owned(), + (MeterFunction::Res, MeterUnit::MOhm, _) => "MΩ".to_owned(), + (MeterFunction::Cont, MeterUnit::Ohm, _) => "Ω".to_owned(), + (MeterFunction::Cap, MeterUnit::nF, _) => "nF".to_owned(), + (MeterFunction::Cap, MeterUnit::uF, _) => "µF".to_owned(), + (MeterFunction::Freq, MeterUnit::Hz, _) => "Hz".to_owned(), + (MeterFunction::Duty, MeterUnit::Percent, _) => "%".to_owned(), + (MeterFunction::Diod, MeterUnit::V, _) => "V".to_owned(), + (MeterFunction::Temp, MeterUnit::Celsius, _) => "°C".to_owned(), + (MeterFunction::Temp, MeterUnit::Fahrenheit, _) => "°F".to_owned(), + _ => "?".to_owned(), + }; + (mode, unit) +} + +/// Open-line / overload strings — no numeric value, must not trigger Cont/Diod thresholds. +pub fn is_overload_display(display: &str) -> bool { + matches!(display, "OL" | ".0L" | "0.L" | "OVERLOAD") || display.contains('L') +} + +fn parse_display_value(display: &str, mode: MeterMode) -> Option { + if is_overload_display(display) + && matches!(mode, MeterMode::Diod | MeterMode::Cont | MeterMode::Res) + { + return Some(METER_OVERLOAD_VALUE); + } + let stripped = display.trim(); + if stripped.is_empty() || stripped.ends_with('.') { + return None; + } + stripped.parse().ok() +} + +fn classify_display(digits: &[DigitCell; 4], flags: [u8; 3]) -> DisplayKind { + let overload_flags = flags == [0xff, 0xff, 0xff] || flags[0] == 0xff; + let ol_digits = digits[0].is_dp_only() + || digits[0].raw == DigitCell::HARD_OFF + || digits[3].raw == DigitCell::HARD_OFF; + if overload_flags || ol_digits { + DisplayKind::Overload + } else { + DisplayKind::Normal + } +} + +/// Empirical segment → digit/char (not standard GFEDCBA — DM1107 wire encoding). +fn glyph_for_segments(seg7: u8) -> Option { + match seg7 { + 0x5f => Some('0'), + 0x3d => Some('2'), + 0x50 => Some('1'), + 0x72 => Some('4'), + 0x79 => Some('3'), + 0x51 => Some('7'), + 0x7b => Some('9'), + 0x7f => Some('8'), + 0x6b => Some('5'), + 0x6f => Some('6'), + 0x0e | 0x0c => Some('0'), // overload / diode zero glyph + _ => None, + } +} + +/// Build display text from digit cells + decimal points. +pub fn format_digits(digits: &[DigitCell; 4]) -> DecodedReading { + // DIOD `.0L`: leading DP-only, `0` in the middle, LSD hard-off. + if digits[0].is_dp_only() + && digits[2].segments() == 0x0e + && digits[3].raw == DigitCell::HARD_OFF + { + return DecodedReading { + text: ".0L".to_owned(), + confidence: 90, + }; + } + // RES `0.L`: d1 = zero+DP (`0xdf`), d2 = overload glyph (`0x0e`). + if digits[1].is_zero() + && digits[1].decimal_point() + && digits[2].segments() == 0x0e + { + return DecodedReading { + text: "0.L".to_owned(), + confidence: 90, + }; + } + // CONT open (`_0L._`): d1 = 0, d2 = `0x8e` (0x0e + DP), outer digits hard-off. + if digits[0].raw == DigitCell::HARD_OFF + && digits[1].is_zero() + && digits[2].segments() == 0x0e + && digits[2].decimal_point() + && digits[3].raw == DigitCell::HARD_OFF + { + return DecodedReading { + text: "OL".to_owned(), + confidence: 90, + }; + } + + let mut chars: Vec = Vec::new(); + + let mut known = 0u8; + let mut total = 0u8; + + for (i, cell) in digits.iter().enumerate() { + if cell.is_dp_only() { + chars.push('.'); + continue; + } + if cell.raw == DigitCell::HARD_OFF { + continue; + } + total += 1; + if let Some(c) = glyph_for_segments(cell.segments()) { + chars.push(c); + known += 1; + } else { + chars.push('?'); + } + if i < 3 && cell.decimal_point() { + chars.push('.'); + } + } + + let text: String = chars.into_iter().collect(); + let confidence = if total == 0 { + 0 + } else { + ((known as u16) * 100 / total as u16).min(100) as u8 + }; + DecodedReading { text, confidence } +} + +/// Full frame → human reading string (best effort). +pub fn decode_frame(frame: &VictorFrame) -> DecodedReading { + let mut reading = format_digits(&frame.digits); + if reading.confidence >= 50 && !reading.text.is_empty() { + reading.text = apply_negative_sign(&reading.text, frame.decoded_mode.is_negative); + return reading; + } + if frame.display_kind == DisplayKind::Overload { + let text = match frame.decoded_mode.function { + MeterFunction::Cont => "OL".to_owned(), + MeterFunction::Res => "0.L".to_owned(), + MeterFunction::Diod => ".0L".to_owned(), + _ => ".0L".to_owned(), + }; + return DecodedReading { + text, + confidence: 85, + }; + } + reading.text = apply_negative_sign(&reading.text, frame.decoded_mode.is_negative); + reading +} + +/// Append serial bytes; return new live readings (display + mode + optional value). +pub fn feed_bytes(state: &mut Dm1107Stream, chunk: &[u8]) -> Vec { + state.buf.extend_from_slice(chunk); + let mut out = Vec::new(); + + if let Some(frame) = find_frame(&state.buf) { + let reading = decode_frame(&frame); + let mode_key = decoded_mode_key(&frame.decoded_mode); + let usable = !reading.text.is_empty() + && (reading.confidence >= 50 || frame.display_kind == DisplayKind::Overload); + let changed = state.last_text.as_deref() != Some(reading.text.as_str()) + || state.last_mode_key.as_deref() != Some(mode_key.as_str()); + if usable && changed { + let display = reading.text.clone(); + state.last_text = Some(display.clone()); + state.last_mode_key = Some(mode_key); + let (mode, unit) = meter_mode_and_unit(&frame.decoded_mode); + out.push(Dm1107LiveUpdate { + display, + value: parse_display_value(&reading.text, mode), + mode, + unit, + }); + } + } + + if state.buf.len() > STREAM_KEEP_MAX { + let keep = STREAM_KEEP_MAX / 2; + let drain = state.buf.len().saturating_sub(keep); + state.buf.drain(..drain); + } + out +} + +/// Format bytes as lowercase hex (debug logging, CSV). +pub fn hex_encode(bytes: &[u8]) -> String { + bytes + .iter() + .map(|b| format!("{b:02x}")) + .collect::>() + .join(" ") +} + +#[cfg(test)] +mod tests { + use super::*; + + fn parse_hex_line(hex: &str) -> Vec { + hex.split_whitespace() + .filter_map(|t| u8::from_str_radix(t, 16).ok()) + .collect() + } + + #[test] + fn hex_encodes_bytes() { + assert_eq!(hex_encode(&[0xa5, 0x12, 0x04]), "a5 12 04"); + } + + #[test] + fn parses_vdc_manual_zero_frame() { + let raw = parse_hex_line( + "a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49", + ); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(frame.mode.b2, 0x04); + assert_eq!(frame.mode.b4, 0x40); + assert_eq!(frame.decoded_mode.function, MeterFunction::Vdc); + assert_eq!(frame.decoded_mode.unit, MeterUnit::V); + assert_eq!(frame.decoded_mode.dp_mode, DpMode::Manual); + assert!(frame.digits[1].decimal_point()); + assert_eq!(frame.digits[1].segments(), 0x5f); + } + + #[test] + fn parses_vdc_21_34_payload() { + let raw = parse_hex_line( + "a5 12 04 00 40 72 79 d0 3d 42 00 00 00 00 01 ff ff fc 04 34", + ); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(frame.digits[0].segments(), 0x3d); + assert!(frame.digits[1].decimal_point()); + assert_eq!(frame.digits[1].segments(), 0x50); + assert_eq!(frame.digits[2].segments(), 0x79); + assert_eq!(frame.digits[3].segments(), 0x72); + assert_eq!(decode_frame(&frame).text, "21.34"); + assert_eq!(frame.tail[2], 0x34); + } + + #[test] + fn decodes_vdc_auto_21_40_capture() { + let raw = parse_hex_line( + "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", + ); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(frame.digits[0].segments(), 0x3d); + assert_eq!(frame.digits[1].segments(), 0x50); + assert!(frame.digits[1].decimal_point()); + assert_eq!(frame.digits[2].segments(), 0x72); + assert!(frame.digits[3].is_zero()); + assert_eq!(decode_frame(&frame).text, "21.40"); + } + + #[test] + fn decodes_manual_vdc_zero_layouts() { + let cases = [ + ("a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49", "00.00"), + ("a5 12 04 00 40 5f 5f 5f df 42 00 00 00 00 00 00 00 0c 04 49", "0.000"), + ("a5 12 04 00 40 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 49", "000.0"), + ]; + for (hex, want) in cases { + let raw = parse_hex_line(hex); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(decode_frame(&frame).text, want, "{hex}"); + } + } + + #[test] + fn decodes_mode_mv_and_res_ladder() { + let mv = parse_hex_line("a5 12 0c 00 10 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 21"); + assert_eq!(find_frame(&mv).unwrap().decoded_mode.unit, MeterUnit::mV); + + for (b2, unit) in [(0x20, MeterUnit::Ohm), (0x60, MeterUnit::kOhm), (0xa0, MeterUnit::MOhm)] { + let mut raw = parse_hex_line( + "a5 12 00 00 10 5f df 5f 5f 40 00 00 00 00 00 00 00 0c 04 33", + ); + raw[2] = b2; + assert_eq!(find_frame(&raw).unwrap().decoded_mode.unit, unit); + } + } + + #[test] + fn diode_ol_overload_pattern() { + let raw = parse_hex_line( + "a5 12 04 00 04 00 0e 5f 80 40 ff ff ff ff ff ff ff fc 04 e5", + ); + let frame = find_frame(&raw).unwrap(); + assert_eq!(frame.display_kind, DisplayKind::Overload); + assert!(frame.digits[0].is_dp_only()); + assert_eq!(frame.digits[2].segments(), 0x0e); + assert_eq!(frame.digits[3].raw, DigitCell::HARD_OFF); + assert_eq!(decode_frame(&frame).text, ".0L"); + } + + #[test] + fn decodes_negative_vdc_auto_21_19() { + let raw = parse_hex_line( + "a5 12 04 00 10 7b 50 d0 3d 46 00 00 00 00 01 ff ff fe 04 ea", + ); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(frame.delimiter, 0x46); + assert!(frame.decoded_mode.is_negative); + assert_eq!(frame.decoded_mode.function, MeterFunction::Vdc); + assert_eq!(frame.decoded_mode.unit, MeterUnit::V); + let reading = decode_frame(&frame); + assert_eq!(reading.text, "-21.19"); + let (mode, unit) = meter_mode_and_unit(&frame.decoded_mode); + assert_eq!(mode, MeterMode::Vdc); + assert_eq!(unit, "VDC"); + assert_eq!( + parse_display_value(&reading.text, mode), + Some(-21.19) + ); + } + + #[test] + fn annunciator_bits_from_captures() { + let vdc_auto = LcdAnnunciators::from_mode_header( + ModeHeader { + b2: 0x04, + b3: 0x00, + b4: 0x10, + }, + 0x42, + ); + assert!(vdc_auto.volt); + assert!(vdc_auto.dc); + assert!(vdc_auto.auto_range); + assert!(!vdc_auto.milli); + assert!(!vdc_auto.minus); + + let vdc_neg = LcdAnnunciators::from_mode_header( + ModeHeader { + b2: 0x04, + b3: 0x00, + b4: 0x10, + }, + 0x46, + ); + assert!(vdc_neg.minus); + assert_eq!( + vdc_neg.function_and_unit(), + (MeterFunction::Vdc, MeterUnit::V) + ); + + let mv_auto = LcdAnnunciators::from_mode_header( + ModeHeader { + b2: 0x0c, + b3: 0x00, + b4: 0x10, + }, + 0x42, + ); + assert!(mv_auto.volt); + assert!(mv_auto.milli); + assert_eq!( + mv_auto.function_and_unit(), + (MeterFunction::Vdc, MeterUnit::mV) + ); + + let mv_neg = LcdAnnunciators::from_mode_header( + ModeHeader { + b2: 0x0c, + b3: 0x00, + b4: 0x10, + }, + 0x46, + ); + assert!(mv_neg.minus); + assert_eq!( + mv_neg.function_and_unit(), + (MeterFunction::Vdc, MeterUnit::mV) + ); + } + + #[test] + fn decodes_negative_mv_without_breaking_unit() { + let mut raw = parse_hex_line("a5 12 0c 00 10 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 21"); + raw[9] = 0x46; + let frame = find_frame(&raw).unwrap(); + assert_eq!(frame.decoded_mode.function, MeterFunction::Vdc); + assert_eq!(frame.decoded_mode.unit, MeterUnit::mV); + assert!(frame.decoded_mode.is_negative); + let (mode, unit) = meter_mode_and_unit(&frame.decoded_mode); + assert_eq!(unit, "mVDC"); + assert_eq!(mode, MeterMode::Vdc); + } + + #[test] + fn decodes_digit_six() { + // CAP µF capture: segment 0x6f = digit 6 (distinct from 0x7d seen elsewhere). + let raw = parse_hex_line( + "a5 12 01 80 10 6f bd 6f 72 40 00 03 ff ff ff ff ff fc 04 93", + ); + let frame = parse_frame_at(&raw, 0).unwrap(); + assert_eq!(frame.decoded_mode.function, MeterFunction::Cap); + assert_eq!(frame.decoded_mode.unit, MeterUnit::uF); + assert_eq!(decode_frame(&frame).text, "462.6"); + } + + #[test] + fn temp_shows_trailing_digits() { + let raw = parse_hex_line( + "a5 12 00 20 00 5f 79 5f 5f 40 00 00 00 00 00 00 00 0c 04 bd", + ); + let frame = find_frame(&raw).unwrap(); + assert!(frame.digits[0].is_zero()); + assert!(frame.digits[1].is_zero()); + assert_eq!(frame.digits[2].segments(), 0x79); + assert!(frame.digits[3].is_zero()); + assert_eq!(decode_frame(&frame).text, "0030"); + } + + #[test] + fn digit_cell_dp_bit() { + let cell = DigitCell::from_raw(0xdf); + assert_eq!(cell.segments(), 0x5f); + assert!(cell.decimal_point()); + assert!(!cell.is_off()); + } + + #[test] + fn feed_bytes_emits_mode_and_display() { + let frame = parse_hex_line( + "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", + ); + let mut stream = Dm1107Stream::new(); + let updates = feed_bytes(&mut stream, &frame); + assert_eq!(updates.len(), 1); + assert_eq!(updates[0].display, "21.40"); + assert_eq!(updates[0].value, Some(21.40)); + assert_eq!(updates[0].mode, MeterMode::Vdc); + assert_eq!(updates[0].unit, "VDC"); + assert!(feed_bytes(&mut stream, &frame).is_empty()); + } + + #[test] + fn cont_open_line_decodes_as_ol() { + let raw = parse_hex_line( + "a5 12 20 00 08 00 8e 5f 00 40 ff ff ff ff ff ff ff fc 04 05", + ); + let frame = find_frame(&raw).unwrap(); + assert_eq!(frame.decoded_mode.function, MeterFunction::Cont); + let reading = decode_frame(&frame); + assert_eq!(reading.text, "OL"); + assert!(is_overload_display(&reading.text)); + assert_eq!(parse_display_value(&reading.text, MeterMode::Cont), Some(METER_OVERLOAD_VALUE)); + } + + #[test] + fn feed_bytes_emits_on_mode_change() { + let vdc = parse_hex_line( + "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", + ); + let cap = parse_hex_line( + "a5 12 01 40 10 5f 5f 5f 5f 42 00 00 00 00 00 00 00 0c 04 00", + ); + let mut stream = Dm1107Stream::new(); + assert_eq!(feed_bytes(&mut stream, &vdc).len(), 1); + let cap_updates = feed_bytes(&mut stream, &cap); + assert_eq!(cap_updates.len(), 1); + assert_eq!(cap_updates[0].mode, MeterMode::Cap); + assert_eq!(cap_updates[0].unit, "nF"); + } +} \ No newline at end of file diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 9624a26..3ef911c 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -1,6 +1,7 @@ //! Cyrustek ES51932 (Victor / RuoShui 86E) serial protocol parser. //! -//! The 86E uses a CP2102 USB-UART bridge (not USB HID like the 86B/C/D). +//! The 86E uses a CP2102 USB-UART bridge and ES51932 ASCII frames (distinct from +//! legacy 86B/C/D HID meters and from newer DM1107 serial meters such as the 86D). //! It streams read-only measurement frames; modes cannot be changed remotely. //! //! ## Serial settings @@ -25,7 +26,7 @@ //! — range exponents and function-byte mapping (ES51931/ES51932, 19200/14b) use crate::multimeter::MeterMode; -use crate::victor::VictorReading; +use crate::victor_fs9922::VictorReading; pub const VICTOR_86E_BAUD: u32 = 19200; pub const PACKET_LEN: usize = 14; diff --git a/src/victor.rs b/src/victor_fs9922.rs similarity index 95% rename from src/victor.rs rename to src/victor_fs9922.rs index 503eafe..03d6c87 100644 --- a/src/victor.rs +++ b/src/victor_fs9922.rs @@ -1,10 +1,12 @@ -//! Victor (RuoShui) 86B/C/D USB HID protocol support. +//! Fortune Semiconductor **FS9922-DMM4** — Victor (RuoShui) legacy 86B/C/D USB HID path. //! -//! These meters use a USB HID interface (VID 0x1244, PID 0xd237) with obfuscated +//! Those meters used a USB HID interface (VID 0x1244, PID 0xd237) with obfuscated //! 14-byte reports from the USB cable. After deobfuscation the payload follows the //! Fortune Semiconductor FS9922-DMM4 chip format. Read only — modes are set on the meter. //! -//! For the Victor 86E (CP2102 serial / ES51932) see `victor_es519xx` instead. +//! **Newer** Victor meters (e.g. 86D, DM1107) do not use this path — they stream a +//! binary serial protocol over an opto-isolated CP2102 link. See `victor_dm1107`. +//! Victor 86E (ES51932 ASCII serial) is a separate line: `victor_es519xx`. //! //! ## Sources //! From f627e8f7887a5818bfbf00ee18c35a8d3a90842c Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Thu, 16 Jul 2026 00:12:28 +0200 Subject: [PATCH 07/13] unify Victor serial processes --- src/app/mod.rs | 3 +- src/app/victor_86bcd_serial.rs | 331 -------------------- src/app/victor_86e_serial.rs | 137 --------- src/app/victor_readonly_serial.rs | 482 ++++++++++++++++++++++++++++++ 4 files changed, 483 insertions(+), 470 deletions(-) delete mode 100644 src/app/victor_86bcd_serial.rs delete mode 100644 src/app/victor_86e_serial.rs create mode 100644 src/app/victor_readonly_serial.rs diff --git a/src/app/mod.rs b/src/app/mod.rs index 26c0abf..10744c1 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -22,10 +22,9 @@ mod serial; mod settings; mod ui; #[cfg(not(target_arch = "wasm32"))] -mod victor_86bcd_serial; +mod victor_readonly_serial; #[cfg(not(target_arch = "wasm32"))] mod victor_86bcd_capture_ui; -mod victor_86e_serial; /// How rusty_meter talks to the multimeter. /// diff --git a/src/app/victor_86bcd_serial.rs b/src/app/victor_86bcd_serial.rs deleted file mode 100644 index 1cb2618..0000000 --- a/src/app/victor_86bcd_serial.rs +++ /dev/null @@ -1,331 +0,0 @@ -//! Victor DM1107 serial task (mio-serial, 9600 8N1). -//! -//! Newer Victor meters (e.g. 86D): binary stream from opto-isolated USB link. -//! Live display values use [`victor_dm1107::feed_bytes`] (20-byte `a5 12` frame decode). -//! -//! Serial I/O uses [`mio::Poll`] on a blocking thread (same integration `mio-serial` -//! expects). The poll wakes as soon as the port is readable; the timeout is only -//! checked when idle so shutdown can be observed. - -use std::{ - io::{self, Read}, - path::PathBuf, - sync::{ - atomic::{AtomicBool, Ordering}, - Arc, - }, - time::Duration, -}; - -use mio::{Events, Interest, Poll, Token}; -use mio_serial::{ClearBuffer, SerialPort}; -use tokio::sync::{mpsc, oneshot}; -use tokio::time::{sleep_until, Instant}; - -use crate::victor_86bcd_capture::{self, Victor86bcdCaptureJob}; -use crate::victor_dm1107::{self, Dm1107LiveUpdate}; - -const SERIAL_TOKEN: Token = Token(2); -/// Max wait when no bytes are arriving; lets the reader thread observe `stop`. -const IDLE_POLL_MS: u64 = 250; - -struct ActiveCapture { - job: Victor86bcdCaptureJob, - buf: Vec, - ends_at: Instant, -} - -fn drain_readable_serial( - serial: &mut mio_serial::SerialStream, - readbuf: &mut [u8], -) -> io::Result> { - let mut chunk = Vec::new(); - loop { - match serial.read(readbuf) { - Ok(0) => break, - Ok(count) => chunk.extend_from_slice(&readbuf[..count]), - Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, - Err(e) => return Err(e), - } - } - Ok(chunk) -} - -fn process_chunk( - chunk: &[u8], - stream: &mut victor_dm1107::Dm1107Stream, - active_capture: &mut Option, - debug: bool, -) -> Vec { - if debug { - println!( - "Victor serial +{} bytes: {}", - chunk.len(), - victor_dm1107::hex_encode(&chunk[..chunk.len().min(32)]), - ); - } - if let Some(cap) = active_capture { - cap.buf.extend_from_slice(chunk); - } - victor_dm1107::feed_bytes(stream, chunk) -} - -async fn push_live_updates( - tx_live: &mpsc::Sender, - updates: Vec, - debug: bool, -) { - for update in updates { - if debug { - println!( - "Victor 86B/C/D: {} {} {:?}", - update.display, update.unit, update.mode - ); - } - let _ = tx_live.send(update).await; - } -} - -/// Background reader: `mio::Poll` blocks until the OS reports readability. -struct SerialReader { - bytes_rx: mpsc::Receiver>, - reader_handle: tokio::task::JoinHandle<()>, - stop: Arc, -} - -impl SerialReader { - fn spawn(mut serial: mio_serial::SerialStream) -> Self { - let (bytes_tx, bytes_rx) = mpsc::channel::>(32); - let stop = Arc::new(AtomicBool::new(false)); - let stop_bg = stop.clone(); - - let reader_handle = tokio::task::spawn_blocking(move || { - let mut poll = match Poll::new() { - Ok(p) => p, - Err(e) => { - eprintln!("Victor serial Poll::new failed: {e}"); - return; - } - }; - let mut events = Events::with_capacity(1); - if let Err(e) = poll - .registry() - .register(&mut serial, SERIAL_TOKEN, Interest::READABLE) - { - eprintln!("Victor serial register failed: {e}"); - return; - } - - let mut readbuf = [0u8; 256]; - loop { - if stop_bg.load(Ordering::Acquire) { - break; - } - - match poll.poll(&mut events, Some(Duration::from_millis(IDLE_POLL_MS))) { - Ok(()) => { - for event in events.iter() { - if !event.is_readable() { - continue; - } - match drain_readable_serial(&mut serial, &mut readbuf) { - Ok(chunk) if chunk.is_empty() => {} - Ok(chunk) => { - if bytes_tx.blocking_send(chunk).is_err() { - let _ = poll.registry().deregister(&mut serial); - return; - } - } - Err(e) => { - eprintln!("Victor serial read error: {e}"); - let _ = poll.registry().deregister(&mut serial); - return; - } - } - } - } - Err(e) => { - eprintln!("Victor serial poll error: {e}"); - break; - } - } - } - - let _ = poll.registry().deregister(&mut serial); - }); - - Self { - bytes_rx, - reader_handle, - stop, - } - } - - async fn next_chunk(&mut self) -> Option> { - self.bytes_rx.recv().await - } - - async fn shutdown(self) { - self.stop.store(true, Ordering::Release); - let _ = self.reader_handle.await; - } -} - -async fn run_serial_loop( - mut serial: mio_serial::SerialStream, - mut shutdown_rx: oneshot::Receiver<()>, - mut capture_rx: mpsc::Receiver, - tx_live: mpsc::Sender, - value_debug_shared: Arc>, - capture_status_shared: Arc>, - device_shared: Arc>, -) { - let _ = serial.clear(ClearBuffer::Input); - let _ = serial.write_data_terminal_ready(true); - - if *value_debug_shared.lock().unwrap() { - println!("Victor 86B/C/D serial task started (DM1107 decode, 9600 8N1)"); - if let Some(name) = serial.name() { - println!("Victor 86B/C/D port: {name}"); - } - } - - { - let mut dev = device_shared.lock().unwrap(); - *dev = "Victor 86B/C/D serial (DM1107)".to_owned(); - } - - let mut reader = SerialReader::spawn(serial); - let mut stream = victor_dm1107::Dm1107Stream::new(); - let mut active_capture: Option = None; - let mut shutting_down = false; - - let write_status = |msg: String, bytes: usize| { - let mut st = capture_status_shared.lock().unwrap(); - st.message = msg; - st.bytes_written = bytes; - }; - - let finish_capture = |cap: ActiveCapture, debug: bool, write_status: &dyn Fn(String, usize)| { - let path: PathBuf = victor_86bcd_capture::default_samples_path(); - let job = cap.job; - match victor_86bcd_capture::append_labeled_capture( - &path, - &job.context, - job.duration_ms, - &cap.buf, - ) { - Ok(written) => { - let msg = format!( - "Saved {written} bytes ({} ms) → {}", - job.duration_ms, - path.display() - ); - if debug { - println!("{msg}"); - if written > 0 { - let preview = victor_dm1107::hex_encode(&cap.buf[..written.min(48)]); - println!(" start: {preview}…"); - } - } - write_status(msg, written); - } - Err(e) => { - let msg = format!("Capture write failed: {e}"); - eprintln!("{msg}"); - write_status(msg, 0); - } - } - }; - - loop { - let capture_deadline = active_capture.as_ref().map(|c| c.ends_at); - - tokio::select! { - _ = &mut shutdown_rx, if !shutting_down => { - shutting_down = true; - } - job = capture_rx.recv(), if active_capture.is_none() => { - if let Some(job) = job { - let duration = Duration::from_millis(job.duration_ms); - write_status( - format!( - "Recording {} ms for {}…", - job.duration_ms, - job.context.summary(), - ), - 0, - ); - active_capture = Some(ActiveCapture { - job, - buf: Vec::new(), - ends_at: Instant::now() + duration, - }); - } - } - _ = async { - if let Some(deadline) = capture_deadline { - sleep_until(deadline).await; - } - }, if capture_deadline.is_some() => { - if let Some(cap) = active_capture.take() { - let debug = *value_debug_shared.lock().unwrap(); - finish_capture(cap, debug, &write_status); - } - } - chunk = reader.next_chunk(), if !shutting_down => { - let Some(chunk) = chunk else { break; }; - let debug = *value_debug_shared.lock().unwrap(); - let updates = process_chunk(&chunk, &mut stream, &mut active_capture, debug); - push_live_updates(&tx_live, updates, debug).await; - } - } - - if shutting_down { - break; - } - } - - reader.shutdown().await; - - if *value_debug_shared.lock().unwrap() { - println!("Victor 86B/C/D serial task shutting down"); - } -} - -impl super::MyApp { - pub fn spawn_victor_86bcd_serial_task(&mut self) { - if self.serial.is_none() { - return; - } - - let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>(); - let (capture_tx, capture_rx) = mpsc::channel::(8); - let (tx_live, rx_live) = mpsc::channel::(100); - - self.shutdown_tx = Some(shutdown_tx); - self.victor_86bcd_capture_tx = Some(capture_tx); - self.victor_86bcd_rx = Some(rx_live); - self.serial_rx = None; - self.serial_tx = None; - self.mode_rx = None; - - let serial = self.serial.take().unwrap(); - let value_debug_shared = self.value_debug_shared.clone(); - let capture_status_shared = self.victor_86bcd_capture_status_shared.clone(); - let device_shared = self.device.clone(); - - tokio::spawn(async move { - run_serial_loop( - serial, - shutdown_rx, - capture_rx, - tx_live, - value_debug_shared, - capture_status_shared, - device_shared, - ) - .await; - }); - } -} \ No newline at end of file diff --git a/src/app/victor_86e_serial.rs b/src/app/victor_86e_serial.rs deleted file mode 100644 index 28f41c0..0000000 --- a/src/app/victor_86e_serial.rs +++ /dev/null @@ -1,137 +0,0 @@ -//! Read-only serial task for Victor 86E (ES51932 over CP2102). -//! -//! Unlike the SCPI `serial` task, this only listens for 14-byte frames and never -//! sends commands. Serial port must be opened at 19200 7o1 — see `victor_es519xx`. - -use std::{ - io::{self, Read}, - time::Duration, -}; - -use mio::{Events, Interest, Poll, Token}; -use tokio::sync::{mpsc, oneshot}; - -use crate::multimeter::MeterMode; -use crate::victor_es519xx; - -const SERIAL_TOKEN: Token = Token(1); - -impl super::MyApp { - pub fn spawn_victor_86e_serial_task(&mut self) { - if self.serial.is_none() { - return; - } - - let (tx_data, rx_data) = mpsc::channel::>(100); - let (tx_mode, rx_mode) = mpsc::channel::<(MeterMode, String)>(10); - let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); - - self.serial_rx = Some(rx_data); - self.mode_rx = Some(rx_mode); - self.shutdown_tx = Some(shutdown_tx); - self.serial_tx = None; - - let mut serial = self.serial.take().unwrap(); - let value_debug_shared = self.value_debug_shared.clone(); - let poll_interval_shared = self.poll_interval_shared.clone(); - let device_shared = self.device.clone(); - - tokio::spawn(async move { - let mut poll = Poll::new().unwrap(); - let mut events = Events::with_capacity(1); - let mut readbuf = [0u8; 256]; - let mut packet_buf = Vec::with_capacity(512); - let mut shutting_down = false; - let mut last_mode = None::; - - poll.registry() - .register(&mut serial, SERIAL_TOKEN, Interest::READABLE) - .unwrap(); - - { - let mut dev = device_shared.lock().unwrap(); - *dev = "Victor 86E (read only)".to_owned(); - } - - if *value_debug_shared.lock().unwrap() { - println!("Victor 86E serial task started"); - } - - loop { - tokio::select! { - _ = &mut shutdown_rx, if !shutting_down => { - shutting_down = true; - } - _ = async { - let debug = *value_debug_shared.lock().unwrap(); - let interval = *poll_interval_shared.lock().unwrap(); - - match poll.poll(&mut events, Some(Duration::from_millis(interval))) { - Ok(()) => { - for event in events.iter() { - if !event.is_readable() { - continue; - } - loop { - match serial.read(&mut readbuf) { - Ok(0) => break, - Ok(count) => { - if debug { - println!("Victor 86E received {} bytes", count); - } - let readings = - victor_es519xx::feed_bytes( - &mut packet_buf, - &readbuf[..count], - ); - for reading in readings { - if debug { - println!( - "Victor 86E reading: {} {:?}", - reading.value, reading.mode - ); - } - let _ = tx_data.send(Some(reading.value)).await; - if last_mode != Some(reading.mode) { - last_mode = Some(reading.mode); - let _ = tx_mode - .send((reading.mode, reading.unit)) - .await; - } - } - } - Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, - Err(e) => { - if debug { - println!("Victor 86E read error: {}", e); - } - break; - } - } - } - } - } - Err(e) => { - if debug { - println!("Victor 86E poll error: {}", e); - } - } - } - - tokio::time::sleep(Duration::from_millis(interval)).await; - } => {} - } - - if shutting_down { - break; - } - } - - let _ = poll.registry().deregister(&mut serial); - drop(serial); - if *value_debug_shared.lock().unwrap() { - println!("Victor 86E serial task shutting down"); - } - }); - } -} \ No newline at end of file diff --git a/src/app/victor_readonly_serial.rs b/src/app/victor_readonly_serial.rs new file mode 100644 index 0000000..5262451 --- /dev/null +++ b/src/app/victor_readonly_serial.rs @@ -0,0 +1,482 @@ +//! Read-only Victor serial task (86E ES51932 and 86B/C/D DM1107). +//! +//! Both meters stream measurement frames over CP2102 USB-UART; neither accepts +//! remote commands. Serial line settings are applied before spawn (see +//! [`super::open_victor_8n1_serial`] / [`super::open_victor_7o1_serial`]). +//! +//! I/O uses [`mio::Poll`] on a blocking thread. The poll wakes when the port is +//! readable; the idle timeout exists only so shutdown can be observed. + +use std::{ + io::{self, Read}, + path::PathBuf, + sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }, + time::Duration, +}; + +use mio::{Events, Interest, Poll, Token}; +use mio_serial::{ClearBuffer, SerialPort}; +use tokio::sync::{mpsc, oneshot}; +use tokio::time::{sleep_until, Instant}; + +use crate::multimeter::MeterMode; +use crate::victor_86bcd_capture::{self, Victor86bcdCaptureJob}; +use crate::victor_dm1107::{self, Dm1107LiveUpdate}; +use crate::victor_es519xx; + +const SERIAL_TOKEN: Token = Token(2); +const IDLE_POLL_MS: u64 = 250; + +/// Which Victor read-only wire protocol to decode. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum VictorReadonlyProtocol { + /// Victor 86E — Cyrustek ES51932, 19200 7o1, 14-byte ASCII frames. + Es519xx, + /// Victor 86B/C/D — DM1107, 9600 8N1, 20-byte `a5 12` binary frames. + Dm1107, +} + +impl VictorReadonlyProtocol { + fn device_label(self) -> &'static str { + match self { + Self::Es519xx => "Victor 86E (read only)", + Self::Dm1107 => "Victor 86B/C/D serial (DM1107)", + } + } + + fn startup_log(self) -> &'static str { + match self { + Self::Es519xx => "Victor 86E serial task started (ES51932, 19200 7o1)", + Self::Dm1107 => "Victor 86B/C/D serial task started (DM1107, 9600 8N1)", + } + } + + fn assert_dtr(self) -> bool { + matches!(self, Self::Dm1107) + } +} + +struct ActiveCapture { + job: Victor86bcdCaptureJob, + buf: Vec, + ends_at: Instant, +} + +struct CaptureSide { + rx: mpsc::Receiver, + status: Arc>, +} + +enum TaskDispatch { + Es519xx { + tx_value: mpsc::Sender>, + tx_mode: mpsc::Sender<(MeterMode, String)>, + }, + Dm1107 { + tx_live: mpsc::Sender, + }, +} + +enum Decoder { + Es519xx { + packet_buf: Vec, + last_mode: Option, + }, + Dm1107 { + stream: victor_dm1107::Dm1107Stream, + }, +} + +impl Decoder { + fn new(protocol: VictorReadonlyProtocol) -> Self { + match protocol { + VictorReadonlyProtocol::Es519xx => Self::Es519xx { + packet_buf: Vec::with_capacity(512), + last_mode: None, + }, + VictorReadonlyProtocol::Dm1107 => Self::Dm1107 { + stream: victor_dm1107::Dm1107Stream::new(), + }, + } + } + + async fn feed_and_dispatch( + &mut self, + protocol: VictorReadonlyProtocol, + chunk: &[u8], + capture: &mut Option, + dispatch: &TaskDispatch, + debug: bool, + ) { + if debug { + match protocol { + VictorReadonlyProtocol::Es519xx => { + println!("Victor 86E +{} bytes", chunk.len()); + } + VictorReadonlyProtocol::Dm1107 => { + println!( + "Victor serial +{} bytes: {}", + chunk.len(), + victor_dm1107::hex_encode(&chunk[..chunk.len().min(32)]), + ); + } + } + } + + if let Some(cap) = capture { + cap.buf.extend_from_slice(chunk); + } + + match (self, dispatch) { + (Self::Es519xx { packet_buf, last_mode }, TaskDispatch::Es519xx { tx_value, tx_mode }) => { + for reading in victor_es519xx::feed_bytes(packet_buf, chunk) { + if debug { + println!( + "Victor 86E reading: {} {:?}", + reading.value, reading.mode + ); + } + let _ = tx_value.send(Some(reading.value)).await; + if *last_mode != Some(reading.mode) { + *last_mode = Some(reading.mode); + let _ = tx_mode.send((reading.mode, reading.unit)).await; + } + } + } + (Self::Dm1107 { stream }, TaskDispatch::Dm1107 { tx_live }) => { + for update in victor_dm1107::feed_bytes(stream, chunk) { + if debug { + println!( + "Victor 86B/C/D: {} {} {:?}", + update.display, update.unit, update.mode + ); + } + let _ = tx_live.send(update).await; + } + } + _ => {} + } + } +} + +fn write_capture_status( + status: &Arc>, + msg: String, + bytes: usize, +) { + let mut st = status.lock().unwrap(); + st.message = msg; + st.bytes_written = bytes; +} + +fn finish_labeled_capture(cap: ActiveCapture, debug: bool, status: &CaptureSide) { + let path: PathBuf = victor_86bcd_capture::default_samples_path(); + let job = cap.job; + match victor_86bcd_capture::append_labeled_capture( + &path, + &job.context, + job.duration_ms, + &cap.buf, + ) { + Ok(written) => { + let msg = format!( + "Saved {written} bytes ({} ms) → {}", + job.duration_ms, + path.display() + ); + if debug { + println!("{msg}"); + if written > 0 { + let preview = victor_dm1107::hex_encode(&cap.buf[..written.min(48)]); + println!(" start: {preview}…"); + } + } + write_capture_status(&status.status, msg, written); + } + Err(e) => { + let msg = format!("Capture write failed: {e}"); + eprintln!("{msg}"); + write_capture_status(&status.status, msg, 0); + } + } +} + +fn drain_readable_serial( + serial: &mut mio_serial::SerialStream, + readbuf: &mut [u8], +) -> io::Result> { + let mut chunk = Vec::new(); + loop { + match serial.read(readbuf) { + Ok(0) => break, + Ok(count) => chunk.extend_from_slice(&readbuf[..count]), + Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, + Err(e) => return Err(e), + } + } + Ok(chunk) +} + +struct SerialReader { + bytes_rx: mpsc::Receiver>, + reader_handle: tokio::task::JoinHandle<()>, + stop: Arc, +} + +impl SerialReader { + fn spawn(mut serial: mio_serial::SerialStream) -> Self { + let (bytes_tx, bytes_rx) = mpsc::channel::>(32); + let stop = Arc::new(AtomicBool::new(false)); + let stop_bg = stop.clone(); + + let reader_handle = tokio::task::spawn_blocking(move || { + let mut poll = match Poll::new() { + Ok(p) => p, + Err(e) => { + eprintln!("Victor serial Poll::new failed: {e}"); + return; + } + }; + let mut events = Events::with_capacity(1); + if let Err(e) = poll + .registry() + .register(&mut serial, SERIAL_TOKEN, Interest::READABLE) + { + eprintln!("Victor serial register failed: {e}"); + return; + } + + let mut readbuf = [0u8; 256]; + loop { + if stop_bg.load(Ordering::Acquire) { + break; + } + + match poll.poll(&mut events, Some(Duration::from_millis(IDLE_POLL_MS))) { + Ok(()) => { + for event in events.iter() { + if !event.is_readable() { + continue; + } + match drain_readable_serial(&mut serial, &mut readbuf) { + Ok(chunk) if chunk.is_empty() => {} + Ok(chunk) => { + if bytes_tx.blocking_send(chunk).is_err() { + let _ = poll.registry().deregister(&mut serial); + return; + } + } + Err(e) => { + eprintln!("Victor serial read error: {e}"); + let _ = poll.registry().deregister(&mut serial); + return; + } + } + } + } + Err(e) => { + eprintln!("Victor serial poll error: {e}"); + break; + } + } + } + + let _ = poll.registry().deregister(&mut serial); + }); + + Self { + bytes_rx, + reader_handle, + stop, + } + } + + async fn next_chunk(&mut self) -> Option> { + self.bytes_rx.recv().await + } + + async fn shutdown(self) { + self.stop.store(true, Ordering::Release); + let _ = self.reader_handle.await; + } +} + +async fn run_serial_loop( + mut serial: mio_serial::SerialStream, + protocol: VictorReadonlyProtocol, + mut shutdown_rx: oneshot::Receiver<()>, + dispatch: TaskDispatch, + mut capture: Option, + value_debug_shared: Arc>, + device_shared: Arc>, +) { + let _ = serial.clear(ClearBuffer::Input); + if protocol.assert_dtr() { + let _ = serial.write_data_terminal_ready(true); + } + + if *value_debug_shared.lock().unwrap() { + println!("{}", protocol.startup_log()); + if let Some(name) = serial.name() { + println!("Victor serial port: {name}"); + } + } + + { + let mut dev = device_shared.lock().unwrap(); + *dev = protocol.device_label().to_owned(); + } + + let mut reader = SerialReader::spawn(serial); + let mut decoder = Decoder::new(protocol); + let mut active_capture: Option = None; + let mut shutting_down = false; + + loop { + let capture_deadline = active_capture.as_ref().map(|c| c.ends_at); + + tokio::select! { + _ = &mut shutdown_rx, if !shutting_down => { + shutting_down = true; + } + job = async { + match capture.as_mut() { + Some(side) => side.rx.recv().await, + None => std::future::pending().await, + } + }, if active_capture.is_none() && capture.is_some() => { + if let Some(job) = job { + if let Some(side) = &capture { + write_capture_status( + &side.status, + format!( + "Recording {} ms for {}…", + job.duration_ms, + job.context.summary(), + ), + 0, + ); + } + let duration = Duration::from_millis(job.duration_ms); + active_capture = Some(ActiveCapture { + job, + buf: Vec::new(), + ends_at: Instant::now() + duration, + }); + } + } + _ = async { + if let Some(deadline) = capture_deadline { + sleep_until(deadline).await; + } + }, if capture_deadline.is_some() => { + if let (Some(cap), Some(side)) = (active_capture.take(), &capture) { + let debug = *value_debug_shared.lock().unwrap(); + finish_labeled_capture(cap, debug, side); + } + } + chunk = reader.next_chunk(), if !shutting_down => { + let Some(chunk) = chunk else { break; }; + let debug = *value_debug_shared.lock().unwrap(); + decoder + .feed_and_dispatch(protocol, &chunk, &mut active_capture, &dispatch, debug) + .await; + } + } + + if shutting_down { + break; + } + } + + reader.shutdown().await; + + if *value_debug_shared.lock().unwrap() { + println!("Victor serial task shutting down ({protocol:?})"); + } +} + +impl super::MyApp { + pub fn spawn_victor_readonly_serial_task(&mut self, protocol: VictorReadonlyProtocol) { + if self.serial.is_none() { + return; + } + + let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>(); + self.shutdown_tx = Some(shutdown_tx); + self.serial_tx = None; + + let serial = self.serial.take().unwrap(); + let value_debug_shared = self.value_debug_shared.clone(); + let device_shared = self.device.clone(); + + let (dispatch, capture) = match protocol { + VictorReadonlyProtocol::Es519xx => { + let (tx_value, rx_value) = mpsc::channel::>(100); + let (tx_mode, rx_mode) = mpsc::channel::<(MeterMode, String)>(10); + self.serial_rx = Some(rx_value); + self.mode_rx = Some(rx_mode); + self.victor_86bcd_rx = None; + ( + TaskDispatch::Es519xx { + tx_value, + tx_mode, + }, + None, + ) + } + VictorReadonlyProtocol::Dm1107 => { + let (capture_tx, capture_rx) = mpsc::channel::(8); + let (tx_live, rx_live) = mpsc::channel::(100); + self.victor_86bcd_capture_tx = Some(capture_tx); + self.victor_86bcd_rx = Some(rx_live); + self.serial_rx = None; + self.mode_rx = None; + ( + TaskDispatch::Dm1107 { tx_live }, + Some(CaptureSide { + rx: capture_rx, + status: self.victor_86bcd_capture_status_shared.clone(), + }), + ) + } + }; + + tokio::spawn(async move { + run_serial_loop( + serial, + protocol, + shutdown_rx, + dispatch, + capture, + value_debug_shared, + device_shared, + ) + .await; + }); + } + + pub fn spawn_victor_86e_serial_task(&mut self) { + self.spawn_victor_readonly_serial_task(VictorReadonlyProtocol::Es519xx); + } + + pub fn spawn_victor_86bcd_serial_task(&mut self) { + self.spawn_victor_readonly_serial_task(VictorReadonlyProtocol::Dm1107); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn protocol_labels_differ() { + assert_ne!( + VictorReadonlyProtocol::Es519xx.device_label(), + VictorReadonlyProtocol::Dm1107.device_label(), + ); + } +} \ No newline at end of file From 58a762291e65f09bf77fb75dbd9c104148f8f70c Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Thu, 16 Jul 2026 00:16:05 +0200 Subject: [PATCH 08/13] format and clippy fixes --- src/app/graph.rs | 11 +++- src/app/hid.rs | 4 +- src/app/mod.rs | 19 +++--- src/app/ui.rs | 42 +++++-------- src/app/victor_86bcd_capture_ui.rs | 8 +-- src/app/victor_readonly_serial.rs | 27 ++++---- src/bin/victor_86bcd_explore.rs | 6 +- src/lib.rs | 6 +- src/victor_86bcd_capture.rs | 9 ++- src/victor_dm1107.rs | 99 +++++++++++++----------------- 10 files changed, 111 insertions(+), 120 deletions(-) diff --git a/src/app/graph.rs b/src/app/graph.rs index d01b006..a39ff10 100644 --- a/src/app/graph.rs +++ b/src/app/graph.rs @@ -99,8 +99,15 @@ pub fn show_histogram( hist_mem_depth_max: usize, ) { // Format the latest measurement for display - let (_formatted_value, display_unit) = - crate::helpers::format_measurement(curr_meas, 10, 1_000_000.0, 0.0001, &metermode, false, None); + let (_formatted_value, display_unit) = crate::helpers::format_measurement( + curr_meas, + 10, + 1_000_000.0, + 0.0001, + &metermode, + false, + None, + ); // Create bar chart data let hist_values_vec: Vec = hist_values.iter().copied().collect(); diff --git a/src/app/hid.rs b/src/app/hid.rs index 8a19a22..b9c7e2e 100644 --- a/src/app/hid.rs +++ b/src/app/hid.rs @@ -117,9 +117,7 @@ impl super::MyApp { if *value_debug_shared.lock().unwrap() { println!("Victor HID received {} bytes", len); } - if let Some(reading) = - victor_fs9922::parse_hid_buffer(&readbuf[..len]) - { + if let Some(reading) = victor_fs9922::parse_hid_buffer(&readbuf[..len]) { if *value_debug_shared.lock().unwrap() { println!("Victor reading: {} {:?}", reading.value, reading.mode); } diff --git a/src/app/mod.rs b/src/app/mod.rs index 10744c1..a66c468 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -22,9 +22,9 @@ mod serial; mod settings; mod ui; #[cfg(not(target_arch = "wasm32"))] -mod victor_readonly_serial; -#[cfg(not(target_arch = "wasm32"))] mod victor_86bcd_capture_ui; +#[cfg(not(target_arch = "wasm32"))] +mod victor_readonly_serial; /// How rusty_meter talks to the multimeter. /// @@ -247,10 +247,12 @@ pub struct MyApp { victor_86bcd_capture_duration_ms: u64, #[cfg(not(target_arch = "wasm32"))] #[serde(skip)] - victor_86bcd_capture_tx: Option>, + victor_86bcd_capture_tx: + Option>, #[cfg(not(target_arch = "wasm32"))] #[serde(skip)] - victor_86bcd_capture_status_shared: Arc>, + victor_86bcd_capture_status_shared: + Arc>, #[serde(skip)] last_graph_update: f64, // Track last graph update time #[serde(skip)] @@ -353,11 +355,14 @@ impl Default for MyApp { value_debug_shared: Arc::new(Mutex::new(false)), poll_interval_shared: Arc::new(Mutex::new(20)), #[cfg(not(target_arch = "wasm32"))] - victor_86bcd_capture_function: crate::victor_86bcd_capture::Victor86bcdCaptureFunction::default(), + victor_86bcd_capture_function: + crate::victor_86bcd_capture::Victor86bcdCaptureFunction::default(), #[cfg(not(target_arch = "wasm32"))] - victor_86bcd_capture_unit: crate::victor_86bcd_capture::Victor86bcdCaptureUnit::default(), + victor_86bcd_capture_unit: crate::victor_86bcd_capture::Victor86bcdCaptureUnit::default( + ), #[cfg(not(target_arch = "wasm32"))] - victor_86bcd_capture_dp_mode: crate::victor_86bcd_capture::Victor86bcdCaptureDpMode::default(), + victor_86bcd_capture_dp_mode: + crate::victor_86bcd_capture::Victor86bcdCaptureDpMode::default(), #[cfg(not(target_arch = "wasm32"))] victor_86bcd_capture_digits: [crate::victor_86bcd_capture::LcdDigit::Off; 4], #[cfg(not(target_arch = "wasm32"))] diff --git a/src/app/ui.rs b/src/app/ui.rs index 5c2d929..961b64d 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -85,8 +85,7 @@ impl super::MyApp { .step_by(1.0) .clamping(SliderClamping::Always), ); - if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) - { + if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) { if let Some(tx) = self.serial_tx.clone() { let cmd = format!("CONT:THREshold {}\n", self.cont_threshold); let value_debug = self.value_debug; @@ -106,8 +105,7 @@ impl super::MyApp { .step_by(0.1) .clamping(SliderClamping::Always), ); - if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) - { + if send_to_meter && (threshold_slider.drag_stopped() || threshold_slider.lost_focus()) { if let Some(tx) = self.serial_tx.clone() { let cmd = format!("DIOD:THREshold {}\n", self.diod_threshold); let value_debug = self.value_debug; @@ -570,12 +568,10 @@ impl super::MyApp { // Determine if the background and shadow should be dark red based on mode and threshold let is_below_threshold = match self.metermode { MeterMode::Cont => { - self.curr_meas.is_finite() - && self.curr_meas <= self.cont_threshold as f64 + self.curr_meas.is_finite() && self.curr_meas <= self.cont_threshold as f64 } MeterMode::Diod => { - self.curr_meas.is_finite() - && self.curr_meas <= self.diod_threshold as f64 + self.curr_meas.is_finite() && self.curr_meas <= self.diod_threshold as f64 } _ => false, }; @@ -612,20 +608,18 @@ impl super::MyApp { |ui| { #[cfg(not(target_arch = "wasm32"))] let (formatted_value, display_unit) = { - let lcd_override = - if self.connection_type - == super::ConnectionType::Victor86bcdSerial - && self.curr_meas - != crate::helpers::METER_OVERLOAD_VALUE - && !self.victor_lcd_display.is_empty() - { - Some(( - self.victor_lcd_display.as_str(), - self.curr_unit.as_str(), - )) - } else { - None - }; + let lcd_override = if self.connection_type + == super::ConnectionType::Victor86bcdSerial + && self.curr_meas != crate::helpers::METER_OVERLOAD_VALUE + && !self.victor_lcd_display.is_empty() + { + Some(( + self.victor_lcd_display.as_str(), + self.curr_unit.as_str(), + )) + } else { + None + }; let auto_scale = !self.is_read_only() && self.auto_scale_units(&self.metermode); format_measurement( @@ -860,9 +854,7 @@ impl super::MyApp { options_frame.show(ui, |ui| { ui.vertical(|ui| { if self.is_read_only() { - ui.label( - egui::RichText::new("Range controlled on device").italics(), - ); + ui.label(egui::RichText::new("Range controlled on device").italics()); self.show_cont_diod_threshold_sliders(ui, false); return; } diff --git a/src/app/victor_86bcd_capture_ui.rs b/src/app/victor_86bcd_capture_ui.rs index 29b286d..ab5157e 100644 --- a/src/app/victor_86bcd_capture_ui.rs +++ b/src/app/victor_86bcd_capture_ui.rs @@ -34,9 +34,7 @@ impl MyApp { } }); if self.victor_86bcd_capture_function != prev_function { - self.victor_86bcd_capture_unit = self - .victor_86bcd_capture_function - .default_unit(); + self.victor_86bcd_capture_unit = self.victor_86bcd_capture_function.default_unit(); } ui.label("Unit:"); @@ -102,7 +100,7 @@ impl MyApp { }); self.victor_86bcd_capture_dp_after = match dp_choice { 0 => None, - n => Some((n - 1) as u8), + n => Some(n - 1), }; let preview = LcdDisplay { @@ -177,4 +175,4 @@ impl MyApp { .weak(), ); } -} \ No newline at end of file +} diff --git a/src/app/victor_readonly_serial.rs b/src/app/victor_readonly_serial.rs index 5262451..b2694cf 100644 --- a/src/app/victor_readonly_serial.rs +++ b/src/app/victor_readonly_serial.rs @@ -11,8 +11,8 @@ use std::{ io::{self, Read}, path::PathBuf, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::Duration, }; @@ -20,7 +20,7 @@ use std::{ use mio::{Events, Interest, Poll, Token}; use mio_serial::{ClearBuffer, SerialPort}; use tokio::sync::{mpsc, oneshot}; -use tokio::time::{sleep_until, Instant}; +use tokio::time::{Instant, sleep_until}; use crate::multimeter::MeterMode; use crate::victor_86bcd_capture::{self, Victor86bcdCaptureJob}; @@ -131,13 +131,16 @@ impl Decoder { } match (self, dispatch) { - (Self::Es519xx { packet_buf, last_mode }, TaskDispatch::Es519xx { tx_value, tx_mode }) => { + ( + Self::Es519xx { + packet_buf, + last_mode, + }, + TaskDispatch::Es519xx { tx_value, tx_mode }, + ) => { for reading in victor_es519xx::feed_bytes(packet_buf, chunk) { if debug { - println!( - "Victor 86E reading: {} {:?}", - reading.value, reading.mode - ); + println!("Victor 86E reading: {} {:?}", reading.value, reading.mode); } let _ = tx_value.send(Some(reading.value)).await; if *last_mode != Some(reading.mode) { @@ -420,13 +423,7 @@ impl super::MyApp { self.serial_rx = Some(rx_value); self.mode_rx = Some(rx_mode); self.victor_86bcd_rx = None; - ( - TaskDispatch::Es519xx { - tx_value, - tx_mode, - }, - None, - ) + (TaskDispatch::Es519xx { tx_value, tx_mode }, None) } VictorReadonlyProtocol::Dm1107 => { let (capture_tx, capture_rx) = mpsc::channel::(8); @@ -479,4 +476,4 @@ mod tests { VictorReadonlyProtocol::Dm1107.device_label(), ); } -} \ No newline at end of file +} diff --git a/src/bin/victor_86bcd_explore.rs b/src/bin/victor_86bcd_explore.rs index c5dfe39..a22b26d 100644 --- a/src/bin/victor_86bcd_explore.rs +++ b/src/bin/victor_86bcd_explore.rs @@ -113,8 +113,10 @@ fn main() { println!("--- Protocol ---"); println!(" • DM1107 meter IC → opto isolation → CP2102 USB serial (9600 8N1)."); - println!(" • 20-byte repeating frames: `a5 12` sync, 3-byte mode header, 4 digit bytes, tail `.. 04 ..`."); + println!( + " • 20-byte repeating frames: `a5 12` sync, 3-byte mode header, 4 digit bytes, tail `.. 04 ..`." + ); println!(" • Digit bytes: low 7 bits = segment map, bit 7 = decimal point (positions 0–2)."); println!(" • `0x5f` = lit zero; `0x00` = off; `0x80` = DP only; `0xdf` = zero + DP."); println!(" • Mode annunciators are single bits across bytes 2–4 and 9 (V/m/DC/−/AUTO/…)."); -} \ No newline at end of file +} diff --git a/src/lib.rs b/src/lib.rs index e6ac27a..f3a2870 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,10 +6,10 @@ pub use app::MyApp; mod helpers; mod multimeter; #[cfg(not(target_arch = "wasm32"))] -mod victor_fs9922; +pub mod victor_86bcd_capture; #[cfg(not(target_arch = "wasm32"))] pub mod victor_dm1107; #[cfg(not(target_arch = "wasm32"))] -pub mod victor_86bcd_capture; -#[cfg(not(target_arch = "wasm32"))] mod victor_es519xx; +#[cfg(not(target_arch = "wasm32"))] +mod victor_fs9922; diff --git a/src/victor_86bcd_capture.rs b/src/victor_86bcd_capture.rs index 763a40e..3ed6e06 100644 --- a/src/victor_86bcd_capture.rs +++ b/src/victor_86bcd_capture.rs @@ -562,7 +562,12 @@ pub fn latest_samples_by_key(text: &str) -> Vec { latest.insert(row.context.sample_key(), row); } let mut out: Vec<_> = latest.into_values().collect(); - out.sort_by(|a, b| a.context.display.sort_key().cmp(&b.context.display.sort_key())); + out.sort_by(|a, b| { + a.context + .display + .sort_key() + .cmp(&b.context.display.sort_key()) + }); out } @@ -695,4 +700,4 @@ mod tests { PathBuf::from("data/victor_serial/victor_serial_samples.csv") ); } -} \ No newline at end of file +} diff --git a/src/victor_dm1107.rs b/src/victor_dm1107.rs index 73930d1..9d23687 100644 --- a/src/victor_dm1107.rs +++ b/src/victor_dm1107.rs @@ -190,7 +190,11 @@ impl LcdAnnunciators { return (MeterFunction::Res, unit); } if self.volt { - let unit = if self.milli { MeterUnit::mV } else { MeterUnit::V }; + let unit = if self.milli { + MeterUnit::mV + } else { + MeterUnit::V + }; return if self.ac { (MeterFunction::Vac, unit) } else { @@ -400,11 +404,7 @@ fn decoded_mode_key(dm: &DecodedMode) -> String { } fn apply_negative_sign(text: &str, is_negative: bool) -> String { - if is_negative - && !text.is_empty() - && !text.starts_with('-') - && !is_overload_display(text) - { + if is_negative && !text.is_empty() && !text.starts_with('-') && !is_overload_display(text) { format!("-{text}") } else { text.to_owned() @@ -515,10 +515,7 @@ pub fn format_digits(digits: &[DigitCell; 4]) -> DecodedReading { }; } // RES `0.L`: d1 = zero+DP (`0xdf`), d2 = overload glyph (`0x0e`). - if digits[1].is_zero() - && digits[1].decimal_point() - && digits[2].segments() == 0x0e - { + if digits[1].is_zero() && digits[1].decimal_point() && digits[2].segments() == 0x0e { return DecodedReading { text: "0.L".to_owned(), confidence: 90, @@ -654,9 +651,7 @@ mod tests { #[test] fn parses_vdc_manual_zero_frame() { - let raw = parse_hex_line( - "a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49", - ); + let raw = parse_hex_line("a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49"); let frame = parse_frame_at(&raw, 0).unwrap(); assert_eq!(frame.mode.b2, 0x04); assert_eq!(frame.mode.b4, 0x40); @@ -669,9 +664,7 @@ mod tests { #[test] fn parses_vdc_21_34_payload() { - let raw = parse_hex_line( - "a5 12 04 00 40 72 79 d0 3d 42 00 00 00 00 01 ff ff fc 04 34", - ); + let raw = parse_hex_line("a5 12 04 00 40 72 79 d0 3d 42 00 00 00 00 01 ff ff fc 04 34"); let frame = parse_frame_at(&raw, 0).unwrap(); assert_eq!(frame.digits[0].segments(), 0x3d); assert!(frame.digits[1].decimal_point()); @@ -684,9 +677,7 @@ mod tests { #[test] fn decodes_vdc_auto_21_40_capture() { - let raw = parse_hex_line( - "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", - ); + let raw = parse_hex_line("a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea"); let frame = parse_frame_at(&raw, 0).unwrap(); assert_eq!(frame.digits[0].segments(), 0x3d); assert_eq!(frame.digits[1].segments(), 0x50); @@ -699,9 +690,18 @@ mod tests { #[test] fn decodes_manual_vdc_zero_layouts() { let cases = [ - ("a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49", "00.00"), - ("a5 12 04 00 40 5f 5f 5f df 42 00 00 00 00 00 00 00 0c 04 49", "0.000"), - ("a5 12 04 00 40 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 49", "000.0"), + ( + "a5 12 04 00 40 5f 5f df 5f 42 00 00 00 00 00 00 00 0c 04 49", + "00.00", + ), + ( + "a5 12 04 00 40 5f 5f 5f df 42 00 00 00 00 00 00 00 0c 04 49", + "0.000", + ), + ( + "a5 12 04 00 40 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 49", + "000.0", + ), ]; for (hex, want) in cases { let raw = parse_hex_line(hex); @@ -715,10 +715,13 @@ mod tests { let mv = parse_hex_line("a5 12 0c 00 10 5f df 5f 5f 42 00 00 00 00 00 00 00 0c 04 21"); assert_eq!(find_frame(&mv).unwrap().decoded_mode.unit, MeterUnit::mV); - for (b2, unit) in [(0x20, MeterUnit::Ohm), (0x60, MeterUnit::kOhm), (0xa0, MeterUnit::MOhm)] { - let mut raw = parse_hex_line( - "a5 12 00 00 10 5f df 5f 5f 40 00 00 00 00 00 00 00 0c 04 33", - ); + for (b2, unit) in [ + (0x20, MeterUnit::Ohm), + (0x60, MeterUnit::kOhm), + (0xa0, MeterUnit::MOhm), + ] { + let mut raw = + parse_hex_line("a5 12 00 00 10 5f df 5f 5f 40 00 00 00 00 00 00 00 0c 04 33"); raw[2] = b2; assert_eq!(find_frame(&raw).unwrap().decoded_mode.unit, unit); } @@ -726,9 +729,7 @@ mod tests { #[test] fn diode_ol_overload_pattern() { - let raw = parse_hex_line( - "a5 12 04 00 04 00 0e 5f 80 40 ff ff ff ff ff ff ff fc 04 e5", - ); + let raw = parse_hex_line("a5 12 04 00 04 00 0e 5f 80 40 ff ff ff ff ff ff ff fc 04 e5"); let frame = find_frame(&raw).unwrap(); assert_eq!(frame.display_kind, DisplayKind::Overload); assert!(frame.digits[0].is_dp_only()); @@ -739,9 +740,7 @@ mod tests { #[test] fn decodes_negative_vdc_auto_21_19() { - let raw = parse_hex_line( - "a5 12 04 00 10 7b 50 d0 3d 46 00 00 00 00 01 ff ff fe 04 ea", - ); + let raw = parse_hex_line("a5 12 04 00 10 7b 50 d0 3d 46 00 00 00 00 01 ff ff fe 04 ea"); let frame = parse_frame_at(&raw, 0).unwrap(); assert_eq!(frame.delimiter, 0x46); assert!(frame.decoded_mode.is_negative); @@ -752,10 +751,7 @@ mod tests { let (mode, unit) = meter_mode_and_unit(&frame.decoded_mode); assert_eq!(mode, MeterMode::Vdc); assert_eq!(unit, "VDC"); - assert_eq!( - parse_display_value(&reading.text, mode), - Some(-21.19) - ); + assert_eq!(parse_display_value(&reading.text, mode), Some(-21.19)); } #[test] @@ -834,9 +830,7 @@ mod tests { #[test] fn decodes_digit_six() { // CAP µF capture: segment 0x6f = digit 6 (distinct from 0x7d seen elsewhere). - let raw = parse_hex_line( - "a5 12 01 80 10 6f bd 6f 72 40 00 03 ff ff ff ff ff fc 04 93", - ); + let raw = parse_hex_line("a5 12 01 80 10 6f bd 6f 72 40 00 03 ff ff ff ff ff fc 04 93"); let frame = parse_frame_at(&raw, 0).unwrap(); assert_eq!(frame.decoded_mode.function, MeterFunction::Cap); assert_eq!(frame.decoded_mode.unit, MeterUnit::uF); @@ -845,9 +839,7 @@ mod tests { #[test] fn temp_shows_trailing_digits() { - let raw = parse_hex_line( - "a5 12 00 20 00 5f 79 5f 5f 40 00 00 00 00 00 00 00 0c 04 bd", - ); + let raw = parse_hex_line("a5 12 00 20 00 5f 79 5f 5f 40 00 00 00 00 00 00 00 0c 04 bd"); let frame = find_frame(&raw).unwrap(); assert!(frame.digits[0].is_zero()); assert!(frame.digits[1].is_zero()); @@ -866,9 +858,7 @@ mod tests { #[test] fn feed_bytes_emits_mode_and_display() { - let frame = parse_hex_line( - "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", - ); + let frame = parse_hex_line("a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea"); let mut stream = Dm1107Stream::new(); let updates = feed_bytes(&mut stream, &frame); assert_eq!(updates.len(), 1); @@ -881,25 +871,22 @@ mod tests { #[test] fn cont_open_line_decodes_as_ol() { - let raw = parse_hex_line( - "a5 12 20 00 08 00 8e 5f 00 40 ff ff ff ff ff ff ff fc 04 05", - ); + let raw = parse_hex_line("a5 12 20 00 08 00 8e 5f 00 40 ff ff ff ff ff ff ff fc 04 05"); let frame = find_frame(&raw).unwrap(); assert_eq!(frame.decoded_mode.function, MeterFunction::Cont); let reading = decode_frame(&frame); assert_eq!(reading.text, "OL"); assert!(is_overload_display(&reading.text)); - assert_eq!(parse_display_value(&reading.text, MeterMode::Cont), Some(METER_OVERLOAD_VALUE)); + assert_eq!( + parse_display_value(&reading.text, MeterMode::Cont), + Some(METER_OVERLOAD_VALUE) + ); } #[test] fn feed_bytes_emits_on_mode_change() { - let vdc = parse_hex_line( - "a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea", - ); - let cap = parse_hex_line( - "a5 12 01 40 10 5f 5f 5f 5f 42 00 00 00 00 00 00 00 0c 04 00", - ); + let vdc = parse_hex_line("a5 12 04 00 10 5f 72 d0 3d 42 00 00 00 00 01 ff ff fc 04 ea"); + let cap = parse_hex_line("a5 12 01 40 10 5f 5f 5f 5f 42 00 00 00 00 00 00 00 0c 04 00"); let mut stream = Dm1107Stream::new(); assert_eq!(feed_bytes(&mut stream, &vdc).len(), 1); let cap_updates = feed_bytes(&mut stream, &cap); @@ -907,4 +894,4 @@ mod tests { assert_eq!(cap_updates[0].mode, MeterMode::Cap); assert_eq!(cap_updates[0].unit, "nF"); } -} \ No newline at end of file +} From bd9e095b3a56bbeeb60f6ece1ca18ef79b55f11e Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Thu, 16 Jul 2026 00:47:40 +0200 Subject: [PATCH 09/13] assert dtr for all victor serial meters --- src/app/victor_readonly_serial.rs | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/app/victor_readonly_serial.rs b/src/app/victor_readonly_serial.rs index b2694cf..b0dac9b 100644 --- a/src/app/victor_readonly_serial.rs +++ b/src/app/victor_readonly_serial.rs @@ -53,10 +53,6 @@ impl VictorReadonlyProtocol { Self::Dm1107 => "Victor 86B/C/D serial task started (DM1107, 9600 8N1)", } } - - fn assert_dtr(self) -> bool { - matches!(self, Self::Dm1107) - } } struct ActiveCapture { @@ -317,9 +313,8 @@ async fn run_serial_loop( device_shared: Arc>, ) { let _ = serial.clear(ClearBuffer::Input); - if protocol.assert_dtr() { - let _ = serial.write_data_terminal_ready(true); - } + // Harmless on 86E if ignored; required on some 86B/C/D CP2102 links. + let _ = serial.write_data_terminal_ready(true); if *value_debug_shared.lock().unwrap() { println!("{}", protocol.startup_log()); From 44d5b22c5d488a41f3a07f617117ff29eb1cc007 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Thu, 16 Jul 2026 21:48:05 +0200 Subject: [PATCH 10/13] fix some 86e decoding problems --- src/app/ui.rs | 27 ++++++-- src/app/victor_readonly_serial.rs | 14 +++- src/victor_es519xx.rs | 110 ++++++++++++++++++++++++++---- 3 files changed, 129 insertions(+), 22 deletions(-) diff --git a/src/app/ui.rs b/src/app/ui.rs index 961b64d..ad60e1e 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -237,6 +237,9 @@ impl super::MyApp { if self.value_debug { println!("Updated metermode to: {:?}", mode); } + } else if unit != self.curr_unit { + // Same mode, unit only (e.g. Victor 86E °C ↔ °F) + self.curr_unit = unit; } } } @@ -245,7 +248,8 @@ impl super::MyApp { let current_time = ui.ctx().input(|i| i.time); // Get current time in seconds let graph_interval = self.graph_update_interval_ms as f64 / 1000.0; // Convert ms to seconds if current_time - self.last_graph_update >= graph_interval { - if !self.curr_meas.is_nan() { + // Skip non-finite samples — histogram binning panics on Inf/NaN. + if self.curr_meas.is_finite() { self.values.push_back(self.curr_meas); self.update_histogram(self.curr_meas); // Update histogram with new measurement while self.values.len() > self.mem_depth { @@ -608,6 +612,7 @@ impl super::MyApp { |ui| { #[cfg(not(target_arch = "wasm32"))] let (formatted_value, display_unit) = { + // 86B/C/D only: glass text from segment decode. let lcd_override = if self.connection_type == super::ConnectionType::Victor86bcdSerial && self.curr_meas != crate::helpers::METER_OVERLOAD_VALUE @@ -620,9 +625,16 @@ impl super::MyApp { } else { None }; - let auto_scale = - !self.is_read_only() && self.auto_scale_units(&self.metermode); - format_measurement( + // 86E: SI values like SCPI → always auto-format prefixes. + // 86B/C/D: lcd_override; HID: no auto-scale (legacy). + // SCPI: respect the checkbox. + let auto_scale = match self.connection_type { + super::ConnectionType::Victor86eSerial => true, + super::ConnectionType::Victor86bcdSerial + | super::ConnectionType::VictorHid => false, + _ => self.auto_scale_units(&self.metermode), + }; + let (formatted_value, mut display_unit) = format_measurement( self.curr_meas, 10, 1_000_000.0, @@ -630,7 +642,12 @@ impl super::MyApp { &self.metermode, auto_scale, lcd_override, - ) + ); + // ES51932 unit flags (°C / °F); formatter defaults Temp to °C. + if self.metermode == MeterMode::Temp && !self.curr_unit.is_empty() { + display_unit = self.curr_unit.clone(); + } + (formatted_value, display_unit) }; #[cfg(target_arch = "wasm32")] let (formatted_value, display_unit) = format_measurement( diff --git a/src/app/victor_readonly_serial.rs b/src/app/victor_readonly_serial.rs index b0dac9b..373d250 100644 --- a/src/app/victor_readonly_serial.rs +++ b/src/app/victor_readonly_serial.rs @@ -80,6 +80,7 @@ enum Decoder { Es519xx { packet_buf: Vec, last_mode: Option, + last_unit: Option, }, Dm1107 { stream: victor_dm1107::Dm1107Stream, @@ -92,6 +93,7 @@ impl Decoder { VictorReadonlyProtocol::Es519xx => Self::Es519xx { packet_buf: Vec::with_capacity(512), last_mode: None, + last_unit: None, }, VictorReadonlyProtocol::Dm1107 => Self::Dm1107 { stream: victor_dm1107::Dm1107Stream::new(), @@ -131,16 +133,24 @@ impl Decoder { Self::Es519xx { packet_buf, last_mode, + last_unit, }, TaskDispatch::Es519xx { tx_value, tx_mode }, ) => { for reading in victor_es519xx::feed_bytes(packet_buf, chunk) { if debug { - println!("Victor 86E reading: {} {:?}", reading.value, reading.mode); + println!( + "Victor 86E reading: {} {:?} {}", + reading.value, reading.mode, reading.unit + ); } let _ = tx_value.send(Some(reading.value)).await; - if *last_mode != Some(reading.mode) { + // Notify UI on mode *or* unit change (°C ↔ °F stay MeterMode::Temp). + let mode_changed = *last_mode != Some(reading.mode); + let unit_changed = last_unit.as_deref() != Some(reading.unit.as_str()); + if mode_changed || unit_changed { *last_mode = Some(reading.mode); + *last_unit = Some(reading.unit.clone()); let _ = tx_mode.send((reading.mode, reading.unit)).await; } } diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 3ef911c..5a8d891 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -25,6 +25,7 @@ //! - [libsigrok `es519xx.c`](https://github.com/sigrokproject/libsigrok/blob/master/src/dmm/es519xx.c) //! — range exponents and function-byte mapping (ES51931/ES51932, 19200/14b) +use crate::helpers::METER_OVERLOAD_VALUE; use crate::multimeter::MeterMode; use crate::victor_fs9922::VictorReading; @@ -167,8 +168,9 @@ fn flags_valid(flags: &Es519xxFlags) -> bool { } fn parse_value(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags) -> Option { + // Never return Infinity — graph/histogram binning panics on non-finite samples. if flags.is_ol || flags.is_ul { - return Some(f64::INFINITY); + return Some(METER_OVERLOAD_VALUE); } if !buf[1].is_ascii_digit() @@ -191,13 +193,22 @@ fn parse_value(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags) -> Option { } fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Option { + // Overload sentinel is already in display units. + if value == METER_OVERLOAD_VALUE { + return Some(value); + } + let idx = (buf[0] as i32).saturating_sub(b'0' as i32); if !(0..=7).contains(&idx) { return None; } let idx = idx as usize; - let exponent = if flags.is_duty_cycle { + // Temperature: protocol digits are always °C with one fixed decimal place + // (libsigrok: "The digits always represent Celsius!"). Range byte is not used. + // Using RES exponents here made 31.6 °C display as 3.16. + // Duty and temperature both use a fixed one-decimal scale (not the range tables). + let exponent = if flags.is_duty_cycle || flags.is_temperature { -1 } else if flags.is_voltage { EXPONENTS_VOLTAGE[idx] @@ -217,13 +228,18 @@ fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Opti EXPONENTS_CAP[idx] } else if flags.is_diode { EXPONENTS_DIODE[idx] - } else if flags.is_temperature { - EXPONENTS_RES[idx] } else { return None; }; - Some(value * 10f64.powi(exponent)) + let mut scaled = value * 10f64.powi(exponent); + + // Wire value is always Celsius; convert when meter is in °F mode. + if flags.is_temperature && flags.is_fahrenheit { + scaled = scaled * 9.0 / 5.0 + 32.0; + } + + Some(scaled) } fn mode_from_flags(flags: &Es519xxFlags) -> Option<(MeterMode, &'static str)> { @@ -281,16 +297,13 @@ pub fn parse_packet(buf: &[u8; PACKET_LEN]) -> Option { let mut value = parse_value(buf, &flags)?; value = apply_range(buf, &flags, value)?; - if flags.is_continuity { - value = if value.is_infinite() || !(0.0..=25.0).contains(&value) { - 0.0 - } else { - 1.0 - }; - } - let (mode, unit) = mode_from_flags(&flags)?; + // Contract: never emit non-finite values to the UI / graph path. + if !value.is_finite() { + value = METER_OVERLOAD_VALUE; + } + Some(VictorReading { value, mode, @@ -316,8 +329,16 @@ pub fn feed_bytes(buffer: &mut Vec, chunk: &[u8]) -> Vec { buffer.drain(..pos + 2); continue; } - let frame: [u8; PACKET_LEN] = buffer[start..=pos + 1].try_into().ok().unwrap(); - buffer.drain(..pos + 2); + let end = pos + 2; + let Some(frame_slice) = buffer.get(start..end) else { + buffer.drain(..end); + continue; + }; + let Ok(frame) = <[u8; PACKET_LEN]>::try_from(frame_slice) else { + buffer.drain(..end); + continue; + }; + buffer.drain(..end); if let Some(reading) = parse_packet(&frame) { readings.push(reading); } @@ -357,4 +378,63 @@ mod tests { buf[13] = b'X'; assert!(parse_packet(&buf).is_none()); } + + #[test] + fn temperature_celsius_one_decimal() { + // Digits 00316 + fixed exp -1 → 31.6 °C (not RES exp -2 → 3.16). + // Function 0x34 ('4'), status judge bit (0x08) → Celsius. + let mut raw = frame("0003164000:3\r\n"); + raw[7] = 0x08; + let reading = parse_packet(&raw).unwrap(); + assert!((reading.value - 31.6).abs() < 1e-6, "got {}", reading.value); + assert_eq!(reading.mode, MeterMode::Temp); + assert_eq!(reading.unit, "°C"); + } + + #[test] + fn temperature_fahrenheit_converts_from_celsius_digits() { + // Same 31.6 °C digits, judge clear → °F: 31.6 * 9/5 + 32 = 88.88. + let mut raw = frame("0003164000:3\r\n"); + raw[7] = 0x00; + let reading = parse_packet(&raw).unwrap(); + assert!( + (reading.value - 88.88).abs() < 1e-3, + "got {}", + reading.value + ); + assert_eq!(reading.mode, MeterMode::Temp); + assert_eq!(reading.unit, "°F"); + } + + #[test] + fn capacitance_microfarad_range() { + // 4.885 µF → SI 4.885e-6 F: digits 04885, CAP '6', range '3' (exp -9). + let reading = parse_packet(&frame("3048856000:3\r\n")).unwrap(); + assert!( + (reading.value - 4.885e-6).abs() < 1e-12, + "got {}", + reading.value + ); + assert_eq!(reading.mode, MeterMode::Cap); + assert_eq!(reading.unit, "F"); + } + + #[test] + fn overload_is_finite_sentinel_not_infinity() { + // RES function '3', OL status bit 0 — must stay finite (histogram crash). + let mut raw = frame("0000003000:3\r\n"); + raw[7] = 0x01; + let reading = parse_packet(&raw).unwrap(); + assert!(reading.value.is_finite()); + assert_eq!(reading.value, METER_OVERLOAD_VALUE); + assert_eq!(reading.mode, MeterMode::Res); + } + + #[test] + fn feed_bytes_does_not_panic_on_short_crlf() { + let mut buf = Vec::new(); + let readings = feed_bytes(&mut buf, b"\r\n103560;000:3\r\n"); + assert_eq!(readings.len(), 1); + assert!((readings[0].value - 3.56).abs() < 1e-6); + } } From 2e9fa7828240b2f76944389c181b1586823ee764 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Fri, 17 Jul 2026 09:46:29 +0200 Subject: [PATCH 11/13] fix temp unit and scaling controls for 86e --- src/app/ui.rs | 191 +++++++++++++++++++++++++----------------- src/victor_es519xx.rs | 135 ++++++++++++++++++++++------- 2 files changed, 216 insertions(+), 110 deletions(-) diff --git a/src/app/ui.rs b/src/app/ui.rs index ad60e1e..74e0520 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -625,25 +625,47 @@ impl super::MyApp { } else { None }; - // 86E: SI values like SCPI → always auto-format prefixes. - // 86B/C/D: lcd_override; HID: no auto-scale (legacy). - // SCPI: respect the checkbox. + // 86B/C/D: lcd_override. HID: no auto-scale. + // 86E / SCPI: respect auto-scale checkbox. + // 86E + auto-scale off: SI → meter range unit (matches manual range). let auto_scale = match self.connection_type { - super::ConnectionType::Victor86eSerial => true, super::ConnectionType::Victor86bcdSerial | super::ConnectionType::VictorHid => false, _ => self.auto_scale_units(&self.metermode), }; - let (formatted_value, mut display_unit) = format_measurement( - self.curr_meas, - 10, - 1_000_000.0, - 0.000001, - &self.metermode, - auto_scale, - lcd_override, - ); - // ES51932 unit flags (°C / °F); formatter defaults Temp to °C. + let (formatted_value, mut display_unit) = if self.connection_type + == super::ConnectionType::Victor86eSerial + && !auto_scale + && !self.curr_unit.is_empty() + && self.curr_meas.is_finite() + && self.curr_meas != crate::helpers::METER_OVERLOAD_VALUE + { + let scaled = crate::victor_es519xx::si_to_meter_unit( + self.curr_meas, + &self.curr_unit, + ); + let (num, _) = format_measurement( + scaled, + 10, + 1_000_000.0, + 0.000001, + &self.metermode, + false, + None, + ); + (num, self.curr_unit.clone()) + } else { + format_measurement( + self.curr_meas, + 10, + 1_000_000.0, + 0.000001, + &self.metermode, + auto_scale, + lcd_override, + ) + }; + // Temp unit from decoder (°C / °F). if self.metermode == MeterMode::Temp && !self.curr_unit.is_empty() { display_unit = self.curr_unit.clone(); } @@ -873,40 +895,17 @@ impl super::MyApp { if self.is_read_only() { ui.label(egui::RichText::new("Range controlled on device").italics()); self.show_cont_diod_threshold_sliders(ui, false); - return; - } - let ratebox = egui::ComboBox::from_label("Sampling Rate").show_index( - ui, - &mut self.curr_rate, - self.ratecmd.len(), - |i| self.ratecmd.get_opt(i).0, - ); - if ratebox.changed() { - self.confstring = self - .ratecmd - .gen_scpi(self.ratecmd.get_opt(self.curr_rate).0); - if let Some(tx) = self.serial_tx.clone() { - let cmd = self.confstring.clone(); - tokio::spawn(async move { - if let Err(e) = tx.send(cmd).await { - println!("Failed to queue command: {}", e); - } - }); - } - if self.value_debug { - println!("Selected Rate changed: {}", self.confstring); - } - } - if let Some(rangecmd) = &self.rangecmd { - let rangebox = egui::ComboBox::from_label("Range").show_index( + } else { + let ratebox = egui::ComboBox::from_label("Sampling Rate").show_index( ui, - &mut self.curr_range, - rangecmd.len(), - |i| rangecmd.get_opt(i).0, + &mut self.curr_rate, + self.ratecmd.len(), + |i| self.ratecmd.get_opt(i).0, ); - if rangebox.changed() { - self.confstring = - rangecmd.gen_scpi(rangecmd.get_opt(self.curr_range).0); + if ratebox.changed() { + self.confstring = self + .ratecmd + .gen_scpi(self.ratecmd.get_opt(self.curr_rate).0); if let Some(tx) = self.serial_tx.clone() { let cmd = self.confstring.clone(); tokio::spawn(async move { @@ -916,45 +915,81 @@ impl super::MyApp { }); } if self.value_debug { - println!("Selected Range changed: {}", self.confstring); + println!("Selected Rate changed: {}", self.confstring); } } - } - // Add beeper and threshold controls for CONT and DIOD modes - if self.metermode == MeterMode::Cont || self.metermode == MeterMode::Diod { - let mut beeper = self.beeper_enabled; - if ui.checkbox(&mut beeper, "Beeper").changed() { - self.beeper_enabled = beeper; - if let Some(tx) = self.serial_tx.clone() { - let cmd = if beeper { - "SYST:BEEP:STATe ON\n".to_string() - } else { - "SYST:BEEP:STATe OFF\n".to_string() - }; - let value_debug = self.value_debug; - tokio::spawn(async move { - if let Err(e) = tx.send(cmd).await { - if value_debug { - println!("Failed to queue beeper command: {}", e); + if let Some(rangecmd) = &self.rangecmd { + let rangebox = egui::ComboBox::from_label("Range").show_index( + ui, + &mut self.curr_range, + rangecmd.len(), + |i| rangecmd.get_opt(i).0, + ); + if rangebox.changed() { + self.confstring = + rangecmd.gen_scpi(rangecmd.get_opt(self.curr_range).0); + if let Some(tx) = self.serial_tx.clone() { + let cmd = self.confstring.clone(); + tokio::spawn(async move { + if let Err(e) = tx.send(cmd).await { + println!("Failed to queue command: {}", e); } - } - }); + }); + } + if self.value_debug { + println!("Selected Range changed: {}", self.confstring); + } } } - - self.show_cont_diod_threshold_sliders(ui, true); + // Beeper + thresholds for SCPI CONT/DIOD + if self.metermode == MeterMode::Cont + || self.metermode == MeterMode::Diod + { + let mut beeper = self.beeper_enabled; + if ui.checkbox(&mut beeper, "Beeper").changed() { + self.beeper_enabled = beeper; + if let Some(tx) = self.serial_tx.clone() { + let cmd = if beeper { + "SYST:BEEP:STATe ON\n".to_string() + } else { + "SYST:BEEP:STATe OFF\n".to_string() + }; + let value_debug = self.value_debug; + tokio::spawn(async move { + if let Err(e) = tx.send(cmd).await { + if value_debug { + println!( + "Failed to queue beeper command: {}", + e + ); + } + } + }); + } + } + self.show_cont_diod_threshold_sliders(ui, true); + } } - // scale control per mode - let mut auto_scale = self.auto_scale_units(&self.metermode); - if ui - .checkbox(&mut auto_scale, "Auto-scale units") - .on_hover_text( - "Auto scale values and show prefixed units like mV/mΩ/kΩ", - ) - .changed() - { - self.set_auto_scale_units(self.metermode, auto_scale); + // SI-based meters (SCPI, 86E): same auto-scale control. + // LCD/HID Victors use fixed glass text / no magnitude auto-scale. + let show_auto_scale = match self.connection_type { + #[cfg(not(target_arch = "wasm32"))] + super::ConnectionType::Victor86bcdSerial + | super::ConnectionType::VictorHid => false, + _ => true, + }; + if show_auto_scale { + let mut auto_scale = self.auto_scale_units(&self.metermode); + if ui + .checkbox(&mut auto_scale, "Auto-scale units") + .on_hover_text( + "Auto scale values and show prefixed units like mV/mΩ/kΩ", + ) + .changed() + { + self.set_auto_scale_units(self.metermode, auto_scale); + } } }); }); diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 5a8d891..7a45df4 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -113,10 +113,12 @@ fn parse_flags(buf: &[u8; PACKET_LEN], flags: &mut Es519xxFlags) { 0x36 => flags.is_capacitance = true, 0x34 => { flags.is_temperature = true; + // Victor 86E (user report #16): judge set → °F, clear → °C + // (opposite of some ES519xx / libsigrok notes). if flags.is_judge { - flags.is_celsius = true; - } else { flags.is_fahrenheit = true; + } else { + flags.is_celsius = true; } } _ => {} @@ -192,23 +194,16 @@ fn parse_value(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags) -> Option { Some(intval as f64) } -fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Option { - // Overload sentinel is already in display units. - if value == METER_OVERLOAD_VALUE { - return Some(value); - } - +fn range_exponent(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags) -> Option { let idx = (buf[0] as i32).saturating_sub(b'0' as i32); if !(0..=7).contains(&idx) { return None; } let idx = idx as usize; - // Temperature: protocol digits are always °C with one fixed decimal place - // (libsigrok: "The digits always represent Celsius!"). Range byte is not used. - // Using RES exponents here made 31.6 °C display as 3.16. - // Duty and temperature both use a fixed one-decimal scale (not the range tables). - let exponent = if flags.is_duty_cycle || flags.is_temperature { + // Duty / temperature: fixed one-decimal scale (not range tables). + // Temperature digits are always °C on the wire (libsigrok). + Some(if flags.is_duty_cycle || flags.is_temperature { -1 } else if flags.is_voltage { EXPONENTS_VOLTAGE[idx] @@ -230,11 +225,18 @@ fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Opti EXPONENTS_DIODE[idx] } else { return None; - }; + }) +} +fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Option { + if value == METER_OVERLOAD_VALUE { + return Some(value); + } + + let exponent = range_exponent(buf, flags)?; let mut scaled = value * 10f64.powi(exponent); - // Wire value is always Celsius; convert when meter is in °F mode. + // Wire digits are always °C; convert only when unit is Fahrenheit. if flags.is_temperature && flags.is_fahrenheit { scaled = scaled * 9.0 / 5.0 + 32.0; } @@ -242,7 +244,8 @@ fn apply_range(buf: &[u8; PACKET_LEN], flags: &Es519xxFlags, value: f64) -> Opti Some(scaled) } -fn mode_from_flags(flags: &Es519xxFlags) -> Option<(MeterMode, &'static str)> { +/// Mode + unit as on the meter for this range (not SI magnitude auto-pick). +fn mode_and_unit(flags: &Es519xxFlags, exp: i32) -> Option<(MeterMode, &'static str)> { if flags.is_continuity { return Some((MeterMode::Cont, "Ohm")); } @@ -253,22 +256,63 @@ fn mode_from_flags(flags: &Es519xxFlags) -> Option<(MeterMode, &'static str)> { return Some((MeterMode::Duty, "%")); } if flags.is_voltage { - if flags.is_ac { - return Some((MeterMode::Vac, "VAC")); + // Only the finest voltage ranges are mV (exp -4 / -5); exp -3 is still volts. + if exp <= -4 { + return Some(if flags.is_ac { + (MeterMode::Vac, "mVAC") + } else { + (MeterMode::Vdc, "mVDC") + }); } - return Some((MeterMode::Vdc, "VDC")); + return Some(if flags.is_ac { + (MeterMode::Vac, "VAC") + } else { + (MeterMode::Vdc, "VDC") + }); } if flags.is_current { - if flags.is_ac { - return Some((MeterMode::Aac, "AAC")); + if flags.is_micro || exp <= -6 { + return Some(if flags.is_ac { + (MeterMode::Aac, "uAAC") + } else { + (MeterMode::Adc, "uADC") + }); + } + if flags.is_milli || exp <= -3 { + return Some(if flags.is_ac { + (MeterMode::Aac, "mAAC") + } else { + (MeterMode::Adc, "mADC") + }); } - return Some((MeterMode::Adc, "ADC")); + return Some(if flags.is_ac { + (MeterMode::Aac, "AAC") + } else { + (MeterMode::Adc, "ADC") + }); } if flags.is_resistance { - return Some((MeterMode::Res, "Ohm")); + // Range exponent selects the meter’s unit ladder (e.g. manual kΩ). + let unit = if exp >= 6 { + "MOhm" + } else if exp >= 3 { + "kOhm" + } else if exp <= -3 { + "mOhm" + } else { + "Ohm" + }; + return Some((MeterMode::Res, unit)); } if flags.is_capacitance { - return Some((MeterMode::Cap, "F")); + let unit = match exp { + -12 | -11 => "pF", + -10 => "nF", + -9..=-7 => "uF", + -6 | -5 => "mF", + _ => "F", + }; + return Some((MeterMode::Cap, unit)); } if flags.is_frequency { return Some((MeterMode::Freq, "Hz")); @@ -282,6 +326,22 @@ fn mode_from_flags(flags: &Es519xxFlags) -> Option<(MeterMode, &'static str)> { None } +/// Scale SI `value` into the unit string produced by [`mode_and_unit`]. +pub fn si_to_meter_unit(value_si: f64, unit: &str) -> f64 { + match unit { + "kOhm" => value_si / 1_000.0, + "MOhm" => value_si / 1_000_000.0, + "mOhm" => value_si * 1_000.0, + "mVDC" | "mVAC" | "mADC" | "mAAC" => value_si * 1_000.0, + "uADC" | "uAAC" | "µADC" | "µAAC" => value_si * 1_000_000.0, + "uF" | "µF" | "μF" => value_si * 1_000_000.0, + "nF" => value_si * 1_000_000_000.0, + "pF" => value_si * 1_000_000_000_000.0, + "mF" => value_si * 1_000.0, + _ => value_si, + } +} + /// Parse a 14-byte Victor 86E / ES51932 serial frame. pub fn parse_packet(buf: &[u8; PACKET_LEN]) -> Option { if buf[12] != b'\r' || buf[13] != b'\n' { @@ -295,9 +355,10 @@ pub fn parse_packet(buf: &[u8; PACKET_LEN]) -> Option { } let mut value = parse_value(buf, &flags)?; + let exp = range_exponent(buf, &flags)?; value = apply_range(buf, &flags, value)?; - let (mode, unit) = mode_from_flags(&flags)?; + let (mode, unit) = mode_and_unit(&flags, exp)?; // Contract: never emit non-finite values to the UI / graph path. if !value.is_finite() { @@ -381,10 +442,9 @@ mod tests { #[test] fn temperature_celsius_one_decimal() { - // Digits 00316 + fixed exp -1 → 31.6 °C (not RES exp -2 → 3.16). - // Function 0x34 ('4'), status judge bit (0x08) → Celsius. + // Digits 00316 + exp -1 → 31.6 °C. Judge clear → °C on Victor 86E. let mut raw = frame("0003164000:3\r\n"); - raw[7] = 0x08; + raw[7] = 0x00; let reading = parse_packet(&raw).unwrap(); assert!((reading.value - 31.6).abs() < 1e-6, "got {}", reading.value); assert_eq!(reading.mode, MeterMode::Temp); @@ -393,9 +453,9 @@ mod tests { #[test] fn temperature_fahrenheit_converts_from_celsius_digits() { - // Same 31.6 °C digits, judge clear → °F: 31.6 * 9/5 + 32 = 88.88. + // Judge set → °F on 86E; wire digits still °C → 31.6 * 9/5 + 32 = 88.88. let mut raw = frame("0003164000:3\r\n"); - raw[7] = 0x00; + raw[7] = 0x08; let reading = parse_packet(&raw).unwrap(); assert!( (reading.value - 88.88).abs() < 1e-3, @@ -408,7 +468,7 @@ mod tests { #[test] fn capacitance_microfarad_range() { - // 4.885 µF → SI 4.885e-6 F: digits 04885, CAP '6', range '3' (exp -9). + // 4.885 µF → SI 4.885e-6 F; unit reflects meter range (uF). let reading = parse_packet(&frame("3048856000:3\r\n")).unwrap(); assert!( (reading.value - 4.885e-6).abs() < 1e-12, @@ -416,7 +476,18 @@ mod tests { reading.value ); assert_eq!(reading.mode, MeterMode::Cap); - assert_eq!(reading.unit, "F"); + assert_eq!(reading.unit, "uF"); + assert!((si_to_meter_unit(reading.value, "uF") - 4.885).abs() < 1e-9); + } + + #[test] + fn resistance_range_selects_kohm_unit() { + // RES range index 5 → exp +3; digits 00047 → 47_000 Ω SI, unit kOhm. + let reading = parse_packet(&frame("5000473000:3\r\n")).unwrap(); + assert!((reading.value - 47_000.0).abs() < 1e-6, "got {}", reading.value); + assert_eq!(reading.mode, MeterMode::Res); + assert_eq!(reading.unit, "kOhm"); + assert!((si_to_meter_unit(reading.value, "kOhm") - 47.0).abs() < 1e-9); } #[test] From 00d0a96e12ddf6a6d6dc112618177749ab301f51 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Fri, 17 Jul 2026 09:48:14 +0200 Subject: [PATCH 12/13] rustfmt fix --- src/victor_es519xx.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 7a45df4..164a4e3 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -484,7 +484,11 @@ mod tests { fn resistance_range_selects_kohm_unit() { // RES range index 5 → exp +3; digits 00047 → 47_000 Ω SI, unit kOhm. let reading = parse_packet(&frame("5000473000:3\r\n")).unwrap(); - assert!((reading.value - 47_000.0).abs() < 1e-6, "got {}", reading.value); + assert!( + (reading.value - 47_000.0).abs() < 1e-6, + "got {}", + reading.value + ); assert_eq!(reading.mode, MeterMode::Res); assert_eq!(reading.unit, "kOhm"); assert!((si_to_meter_unit(reading.value, "kOhm") - 47.0).abs() < 1e-9); From 2df6b1a3884144620dc40dff2228bc5d3fe904c5 Mon Sep 17 00:00:00 2001 From: Markus Krause Date: Fri, 17 Jul 2026 11:14:26 +0200 Subject: [PATCH 13/13] try to improvee auto scale vs non auto scale --- src/app/mod.rs | 13 +++++- src/app/ui.rs | 74 ++++++++++++++++--------------- src/app/victor_readonly_serial.rs | 5 ++- src/victor_es519xx.rs | 19 ++++++-- 4 files changed, 69 insertions(+), 42 deletions(-) diff --git a/src/app/mod.rs b/src/app/mod.rs index a66c468..154fa53 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -113,9 +113,18 @@ pub struct Record { pub value: f64, } -#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)] +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] struct ModeDisplaySettings { - pub auto_scale_units: bool, // true = use mV / mΩ / kΩ etc. (current default behavior) + /// Prefer mV / kΩ / µF etc. from magnitude (default on, same as SCPI). + pub auto_scale_units: bool, +} + +impl Default for ModeDisplaySettings { + fn default() -> Self { + Self { + auto_scale_units: true, + } + } } /// We derive Deserialize/Serialize so we can persist app state on shutdown. diff --git a/src/app/ui.rs b/src/app/ui.rs index 74e0520..9bce588 100644 --- a/src/app/ui.rs +++ b/src/app/ui.rs @@ -238,7 +238,7 @@ impl super::MyApp { println!("Updated metermode to: {:?}", mode); } } else if unit != self.curr_unit { - // Same mode, unit only (e.g. Victor 86E °C ↔ °F) + // Same mode, unit only (°C↔°F, or Ω↔kΩ on range change) self.curr_unit = unit; } } @@ -626,46 +626,50 @@ impl super::MyApp { None }; // 86B/C/D: lcd_override. HID: no auto-scale. - // 86E / SCPI: respect auto-scale checkbox. - // 86E + auto-scale off: SI → meter range unit (matches manual range). + // SCPI: format_measurement(auto_scale). + // 86E: ON → SI + magnitude auto; OFF → decoder unit (meter range). let auto_scale = match self.connection_type { super::ConnectionType::Victor86bcdSerial | super::ConnectionType::VictorHid => false, _ => self.auto_scale_units(&self.metermode), }; - let (formatted_value, mut display_unit) = if self.connection_type - == super::ConnectionType::Victor86eSerial - && !auto_scale - && !self.curr_unit.is_empty() - && self.curr_meas.is_finite() - && self.curr_meas != crate::helpers::METER_OVERLOAD_VALUE - { - let scaled = crate::victor_es519xx::si_to_meter_unit( - self.curr_meas, - &self.curr_unit, - ); - let (num, _) = format_measurement( - scaled, - 10, - 1_000_000.0, - 0.000001, - &self.metermode, - false, - None, - ); - (num, self.curr_unit.clone()) - } else { - format_measurement( - self.curr_meas, - 10, - 1_000_000.0, - 0.000001, - &self.metermode, - auto_scale, - lcd_override, - ) + let (formatted_value, mut display_unit) = { + let use_meter_unit = self.connection_type + == super::ConnectionType::Victor86eSerial + && !auto_scale + && !self.curr_unit.is_empty() + && self.curr_meas.is_finite() + && self.curr_meas != crate::helpers::METER_OVERLOAD_VALUE; + + if use_meter_unit { + // What the meter “sends” as unit for this range. + let scaled = crate::victor_es519xx::si_to_meter_unit( + self.curr_meas, + &self.curr_unit, + ); + let (num, _) = format_measurement( + scaled, + 10, + 1_000_000.0, + 0.000001, + &self.metermode, + false, + None, + ); + (num, self.curr_unit.clone()) + } else { + format_measurement( + self.curr_meas, + 10, + 1_000_000.0, + 0.000001, + &self.metermode, + auto_scale, + lcd_override, + ) + } }; - // Temp unit from decoder (°C / °F). + // Temp unit from decoder (°C / °F); formatter defaults to °C. if self.metermode == MeterMode::Temp && !self.curr_unit.is_empty() { display_unit = self.curr_unit.clone(); } diff --git a/src/app/victor_readonly_serial.rs b/src/app/victor_readonly_serial.rs index 373d250..58de458 100644 --- a/src/app/victor_readonly_serial.rs +++ b/src/app/victor_readonly_serial.rs @@ -145,14 +145,15 @@ impl Decoder { ); } let _ = tx_value.send(Some(reading.value)).await; - // Notify UI on mode *or* unit change (°C ↔ °F stay MeterMode::Temp). + // Always push mode/unit so range-unit changes (Ω↔kΩ) update the UI. let mode_changed = *last_mode != Some(reading.mode); let unit_changed = last_unit.as_deref() != Some(reading.unit.as_str()); if mode_changed || unit_changed { *last_mode = Some(reading.mode); *last_unit = Some(reading.unit.clone()); - let _ = tx_mode.send((reading.mode, reading.unit)).await; } + // Send every sample: cheap, keeps curr_unit in sync with the wire range. + let _ = tx_mode.send((reading.mode, reading.unit)).await; } } (Self::Dm1107 { stream }, TaskDispatch::Dm1107 { tx_live }) => { diff --git a/src/victor_es519xx.rs b/src/victor_es519xx.rs index 164a4e3..65dcf4c 100644 --- a/src/victor_es519xx.rs +++ b/src/victor_es519xx.rs @@ -292,10 +292,10 @@ fn mode_and_unit(flags: &Es519xxFlags, exp: i32) -> Option<(MeterMode, &'static }); } if flags.is_resistance { - // Range exponent selects the meter’s unit ladder (e.g. manual kΩ). + // Range exponent → unit annunciator on the meter (for auto-scale off display). let unit = if exp >= 6 { "MOhm" - } else if exp >= 3 { + } else if exp >= 1 { "kOhm" } else if exp <= -3 { "mOhm" @@ -326,7 +326,7 @@ fn mode_and_unit(flags: &Es519xxFlags, exp: i32) -> Option<(MeterMode, &'static None } -/// Scale SI `value` into the unit string produced by [`mode_and_unit`]. +/// Scale SI value into the unit string from the decoder (meter range unit). pub fn si_to_meter_unit(value_si: f64, unit: &str) -> f64 { match unit { "kOhm" => value_si / 1_000.0, @@ -494,6 +494,19 @@ mod tests { assert!((si_to_meter_unit(reading.value, "kOhm") - 47.0).abs() < 1e-9); } + #[test] + fn resistance_exp1_is_kohm_for_meter_unit() { + // exp +1 (range index 3): SI = 47 * 10 = 470 Ω → unit kOhm → 0.47 kΩ display. + let reading = parse_packet(&frame("3000473000:3\r\n")).unwrap(); + assert!( + (reading.value - 470.0).abs() < 1e-9, + "got {}", + reading.value + ); + assert_eq!(reading.unit, "kOhm"); + assert!((si_to_meter_unit(reading.value, "kOhm") - 0.47).abs() < 1e-9); + } + #[test] fn overload_is_finite_sentinel_not_infinity() { // RES function '3', OL status bit 0 — must stay finite (histogram crash).