vfo-sync

lib.rs (6565B)

---

 #![allow(clippy::missing_safety_doc)]
 
 mod civ;
 mod sync;
 
 use std::ffi::{c_char, CStr};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, Once};
 use std::thread::JoinHandle;
 
 use log::{debug, trace, Level, Log, Metadata, Record};
 
 const DEFAULT_PORT: &str = "/dev/ttyUSB1";
 
 extern "C" {
     fn civ_bridge_tune(freq: f64);
     fn civ_bridge_get_vfo_freq() -> f64;
     fn civ_bridge_log(level: i32, msg: *const c_char);
     fn civ_bridge_get_mode() -> i32;
     fn civ_bridge_set_mode(mode: i32);
     fn civ_bridge_get_bandwidth() -> f64;
     fn civ_bridge_set_bandwidth(hz: f64);
 }
 
 struct FlogLogger;
 
 impl Log for FlogLogger {
     fn enabled(&self, _metadata: &Metadata) -> bool {
         true
     }
 
     fn log(&self, record: &Record) {
         let level = match record.level() {
             Level::Error => 3,
             Level::Warn => 2,
             Level::Info => 1,
             Level::Debug | Level::Trace => 0,
         };
         let msg = std::ffi::CString::new(format!("[civ_sync] {}", record.args()))
             .unwrap_or_else(|_| std::ffi::CString::new("[civ_sync] <invalid utf8>").unwrap());
         unsafe { civ_bridge_log(level, msg.as_ptr()) };
     }
 
     fn flush(&self) {}
 }
 
 static LOGGER: FlogLogger = FlogLogger;
 static INIT: Once = Once::new();
 
 fn init_logger() {
     INIT.call_once(|| {
         log::set_logger(&LOGGER).ok();
         log::set_max_level(log::LevelFilter::Info);
     });
 }
 
 pub struct CivCtx {
     name: String,
     port: String,
     baud: u32,
     sync_mode: Arc<AtomicBool>,
     enabled: bool,
     status: Arc<Mutex<String>>,
     stop: Arc<AtomicBool>,
     handle: Option<JoinHandle<()>>,
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_create(name: *const c_char) -> *mut CivCtx {
     init_logger();
     let name = if name.is_null() {
         "<unnamed>".to_string()
     } else {
         unsafe { CStr::from_ptr(name) }
             .to_string_lossy()
             .into_owned()
     };
     let ctx = CivCtx {
         name: name.clone(),
         port: DEFAULT_PORT.to_string(),
         baud: 0,
         sync_mode: Arc::new(AtomicBool::new(true)),
         enabled: false,
         status: Arc::new(Mutex::new("Disconnected".to_string())),
         stop: Arc::new(AtomicBool::new(false)),
         handle: None,
     };
     debug!("Rust core created (instance: {})", name);
     Box::into_raw(Box::new(ctx))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_destroy(ctx: *mut CivCtx) {
     if ctx.is_null() {
         return;
     }
     let mut ctx = Box::from_raw(ctx);
     if ctx.enabled {
         stop_thread(&mut ctx);
     }
     debug!("Rust core destroyed (instance: {})", ctx.name);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_post_init(ctx: *mut CivCtx) {
     if ctx.is_null() {
         return;
     }
     trace!("Rust core post-init (instance: {})", (*ctx).name);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_enable(ctx: *mut CivCtx) {
     if ctx.is_null() {
         return;
     }
     let ctx = &mut *ctx;
     if ctx.enabled {
         return;
     }
     ctx.enabled = true;
     ctx.stop.store(false, Ordering::Relaxed);
     let port = ctx.port.clone();
     let baud = ctx.baud;
     let sync_mode = Arc::clone(&ctx.sync_mode);
     let stop = Arc::clone(&ctx.stop);
     let status = Arc::clone(&ctx.status);
     debug!("starting sync thread (instance: {})", ctx.name);
     ctx.handle = Some(std::thread::spawn(move || {
         sync::run(port, baud, sync_mode, stop, status);
     }));
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_disable(ctx: *mut CivCtx) {
     if ctx.is_null() {
         return;
     }
     let ctx = &mut *ctx;
     if ctx.enabled {
         stop_thread(ctx);
     }
 }
 
 fn stop_thread(ctx: &mut CivCtx) {
     ctx.enabled = false;
     ctx.stop.store(true, Ordering::Relaxed);
     if let Some(handle) = ctx.handle.take() {
         let _ = handle.join();
     }
     if let Ok(mut s) = ctx.status.lock() {
         *s = "Disconnected".to_string();
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_is_enabled(ctx: *mut CivCtx) -> bool {
     if ctx.is_null() {
         return false;
     }
     (*ctx).enabled
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_status(ctx: *mut CivCtx, out: *mut c_char, out_len: usize) {
     if ctx.is_null() || out.is_null() || out_len == 0 {
         return;
     }
     let text = {
         let s = (*ctx).status.lock().unwrap();
         s.clone()
     };
     let bytes = text.as_bytes();
     let n = bytes.len().min(out_len - 1);
     std::ptr::copy_nonoverlapping(bytes.as_ptr(), out as *mut u8, n);
     *out.add(n) = 0;
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_set_serial_port(ctx: *mut CivCtx, port: *const c_char) {
     if ctx.is_null() {
         return;
     }
     let port = if port.is_null() {
         DEFAULT_PORT.to_string()
     } else {
         unsafe { CStr::from_ptr(port) }
             .to_string_lossy()
             .into_owned()
     };
     debug!("serial port set to {}", port);
     (*ctx).port = port;
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_set_serial_baud(ctx: *mut CivCtx, baud: u32) {
     if ctx.is_null() {
         return;
     }
     debug!(
         "serial baud set to {}",
         if baud == 0 {
             "auto".to_string()
         } else {
             baud.to_string()
         }
     );
     (*ctx).baud = baud;
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn civ_set_sync_mode(ctx: *mut CivCtx, sync_mode: bool) {
     if ctx.is_null() {
         return;
     }
     debug!("mode/filter sync set to {}", sync_mode);
     (*ctx).sync_mode.store(sync_mode, Ordering::Relaxed);
 }
 
 /// Fill `out` (up to `out_len` bytes) with NUL-separated serial port names
 /// (double-NUL terminated) from `serialport::available_ports()`, returning the
 /// number of names written. Used by the shim to build the device dropdown.
 #[no_mangle]
 pub unsafe extern "C" fn civ_list_serial_ports(out: *mut c_char, out_len: usize) -> usize {
     if out.is_null() || out_len < 2 {
         return 0;
     }
     let ports = serialport::available_ports().unwrap_or_default();
     let buf = std::slice::from_raw_parts_mut(out as *mut u8, out_len);
     let mut pos = 0usize;
     let mut count = 0usize;
     for p in &ports {
         if p.port_name.is_empty() {
             continue;
         }
         let name = p.port_name.as_bytes();
         // Need room for the name, its NUL, and the final double-NUL byte.
         if pos + name.len() + 2 > out_len {
             break;
         }
         buf[pos..pos + name.len()].copy_from_slice(name);
         pos += name.len();
         buf[pos] = 0;
         pos += 1;
         count += 1;
     }
     buf[pos] = 0; // double-NUL terminator
     count
 }