vfo-sync

ic7300.rs (6254B)

---

 use log::{debug, trace};
 use serialport::{DataBits::Eight, Parity::None, StopBits::One};
 use std::{
     sync::mpsc::{Receiver, Sender},
     time::{Duration, Instant},
 };
 
 use crate::{Freq, Ptt, State};
 
 enum CivCmd {
     SetFreq(Freq),
     SetPtt(Ptt),
     ReadPtt,
 }
 
 fn to_bcd(n: u8) -> u8 {
     ((n / 10) * 16) + (n % 10)
 }
 
 fn from_bcd(n: u8) -> u8 {
     ((n / 16) * 10) + (n % 16)
 }
 
 impl From<CivCmd> for Vec<u8> {
     fn from(value: CivCmd) -> Self {
         match value {
             CivCmd::SetFreq(f) => {
                 let tens_ones_hz = (f % 100) as u8;
                 let thousands_hundreds_hz = ((f / 100) % 100) as u8;
                 let hundreds_tens_khz = ((f / 10_000) % 100) as u8;
                 let tens_ones_mhz = ((f / 1_000_000) % 100) as u8;
                 let bytes = vec![
                     0xfe,
                     0xfe,
                     0x94,
                     0xe1,
                     0x00,
                     to_bcd(tens_ones_hz),
                     to_bcd(thousands_hundreds_hz),
                     to_bcd(hundreds_tens_khz),
                     to_bcd(tens_ones_mhz),
                     0x00,
                     0xfd,
                 ];
                 trace!("Frequency is {}, converted to {:x?}", f, bytes);
                 bytes
             }
             CivCmd::SetPtt(p) => {
                 let bytes = vec![
                     0xfe,
                     0xfe,
                     0x94,
                     0xe1,
                     0x1c,
                     0x00,
                     if p { 0x01 } else { 0x00 },
                     0xfd,
                 ];
                 trace!("PTT is {}, converted to {:x?}", p, bytes);
                 bytes
             }
             CivCmd::ReadPtt => vec![0xfe, 0xfe, 0x94, 0xe1, 0x1c, 0x00, 0xfd],
         }
     }
 }
 
 #[derive(Debug)]
 enum CivMsg {
     Freq(Freq),
     Ptt(Ptt),
 }
 
 #[derive(Debug)]
 enum CivMsgError {
     InputTooShort,
     InvalidStartOrEnd,
     WrongAddress,
     WrongCommand,
 }
 
 impl TryFrom<&[u8]> for CivMsg {
     type Error = CivMsgError;
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         if value.len() < 8 {
             trace!("Input too short: {} < 8", value.len());
             return Err(CivMsgError::InputTooShort);
         }
         if value[..2] != [0xfe, 0xfe] || *value.last().unwrap() != 0xfd {
             trace!(
                 "Invalid start or end: [0x{:x}, 0x{:x}, ... , 0x{:x}]",
                 value[0],
                 value[1],
                 value.last().unwrap()
             );
             return Err(CivMsgError::InvalidStartOrEnd);
         }
         if value[2..4] != [0xe1, 0x94] && value[2..4] != [0x00, 0x94] {
             trace!(
                 "Wrong address: [..., 0x{:x}, 0x{:x}, ...]",
                 value[2],
                 value[3]
             );
             return Err(CivMsgError::WrongAddress);
         }
         if value[4] == 0x00 && value.len() == 11 {
             let freq = from_bcd(value[5]) as u32
                 + from_bcd(value[6]) as u32 * 100
                 + from_bcd(value[7]) as u32 * 10_000
                 + from_bcd(value[8]) as u32 * 1_000_000;
             return Ok(CivMsg::Freq(freq));
         }
         if value[4..6] == [0x1c, 0x00] && value.len() == 8 {
             return Ok(CivMsg::Ptt(value[6] != 0x00));
         }
         trace!("Command doesn't apply to us");
         Err(CivMsgError::WrongCommand)
     }
 }
 
 pub(crate) fn ic7300_handler(tx: Sender<State>, rx: Receiver<State>) {
     let mut port = serialport::new("/dev/ttyUSB1", 115_200)
         .data_bits(Eight)
         .parity(None)
         .stop_bits(One)
         .open()
         .unwrap();
     debug!("Serial port set up");
     let mut current_state = State::default();
     let mut read_buf = [0u8; 1024];
     let mut last_ptt_check = Instant::now();
     loop {
         if let Some(new_state) = rx.try_iter().last() {
             trace!("Got new state from main thread");
             if new_state.freq != current_state.freq {
                 let mut freq_bytes: Vec<u8> = CivCmd::SetFreq(new_state.freq).into();
                 port.write_all(&mut freq_bytes).unwrap();
                 debug!("Set new frequency to {}", new_state.freq);
             }
             if new_state.ptt != current_state.ptt {
                 let mut ptt_bytes: Vec<u8> = CivCmd::SetPtt(new_state.ptt).into();
                 port.write_all(&mut ptt_bytes).unwrap();
                 debug!("Set PTT to {}", new_state.ptt);
             }
             current_state = new_state;
         }
         if last_ptt_check.elapsed() > Duration::from_millis(100) {
             let mut ptt_bytes: Vec<u8> = CivCmd::ReadPtt.into();
             port.write_all(&mut ptt_bytes).unwrap();
             last_ptt_check = Instant::now();
             trace!("Sent ReadPtt command");
         }
         let mut new_state = current_state;
         if port.bytes_to_read().unwrap() == 0 {
             // trace!("No bytes to read, continuing");
             continue;
         }
         let n = match port.read(&mut read_buf) {
             Ok(n) => n,
             Err(_) => return,
         };
         trace!("{:?}", read_buf[..n].to_vec());
         let mut idx = 0;
         let mut start = Option::None;
         let mut msgs: Vec<CivMsg> = vec![];
         while idx < n {
             // trace!("{}", idx);
             if read_buf[idx] == 0xfe && read_buf[idx + 1] == 0xfe {
                 start = Some(idx);
             } else if read_buf[idx] == 0xfd {
                 let end = idx + 1;
                 match read_buf[start.unwrap()..end].try_into() {
                     Ok(msg) => {
                         debug!("Got new CivMsg: {:?}", msg);
                         msgs.push(msg);
                     }
                     Err(e) => trace!("Got a message that we don't care about: {:?}", e),
                 }
                 start = Option::None;
             }
             idx += 1;
         }
         for msg in msgs {
             match msg {
                 CivMsg::Freq(f) => new_state.freq = f,
                 CivMsg::Ptt(p) => new_state.ptt = p,
             }
         }
         if new_state != current_state {
             tx.send(new_state).unwrap();
             debug!("Sent new state to main thread");
         }
     }
 }