vfo-sync

Bidirectional VFO synchronization for IC-7300 and SDR++
git clone https://git.bradleygannon.com/vfo-sync.git
Log | Files | Refs

rspduo.rs (2016B)


      1 use std::{
      2     io::{Read, Write},
      3     net::TcpStream,
      4     sync::mpsc::{Receiver, Sender},
      5     time::{Duration, Instant},
      6 };
      7 
      8 use log::{debug, trace};
      9 
     10 use crate::State;
     11 
     12 pub(crate) fn rspduo_handler(tx: Sender<State>, rx: Receiver<State>) {
     13     let mut stream = TcpStream::connect("127.0.0.1:4532").unwrap();
     14     stream
     15         .set_read_timeout(Some(Duration::from_millis(100)))
     16         .unwrap();
     17     debug!("Connected to rigctl server");
     18     let mut current_state = State::default();
     19     let mut read_buf = [0x00; 128];
     20     let mut last_freq_check = Instant::now();
     21     loop {
     22         if let Some(new_state) = rx.try_iter().last() {
     23             trace!("Got new state from main thread");
     24             if new_state.freq != current_state.freq {
     25                 let cmd = format!("F {}\n", new_state.freq);
     26                 let mut cmd_bytes = cmd.as_bytes();
     27                 stream.write_all(&mut cmd_bytes).unwrap();
     28                 stream.read(&mut read_buf).unwrap();
     29                 debug!("Set new frequency to {}", new_state.freq);
     30             }
     31             current_state = new_state;
     32         }
     33         if last_freq_check.elapsed() > Duration::from_millis(100) {
     34             let mut new_state = current_state;
     35             let _ = stream.read(&mut read_buf);
     36             let mut cmd_bytes = "f\n".as_bytes();
     37             stream.write_all(&mut cmd_bytes).unwrap();
     38             let n = stream.read(&mut read_buf).unwrap();
     39             let resp = String::from_utf8(read_buf[..n].to_vec()).unwrap();
     40             let resp = resp.trim();
     41             trace!("Received {:?} \"{}\"", read_buf[..n].to_vec(), resp);
     42             let freq = resp.parse().unwrap();
     43             new_state.freq = freq;
     44             trace!("Current frequency is {}", new_state.freq);
     45             if new_state != current_state {
     46                 tx.send(new_state).unwrap();
     47                 debug!("Sent new state to main thread");
     48             }
     49             current_state = new_state;
     50             last_freq_check = Instant::now();
     51         }
     52     }
     53 }