use crate::error::{M17Error, SoundmodemError};
use crate::tnc::{Tnc, TncError};
-use log::debug;
use m17core::kiss::MAX_FRAME_LEN;
use m17core::modem::{Demodulator, Modulator, ModulatorAction, SoftDemodulator, SoftModulator};
use m17core::tnc::SoftTnc;
use std::collections::VecDeque;
+use std::fmt::Display;
use std::fs::File;
use std::io::{self, ErrorKind, Read, Write};
use std::path::PathBuf;
use std::sync::RwLock;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
+use thiserror::Error;
pub struct Soundmodem {
event_tx: SyncSender<SoundmodemEvent>,
}
impl Soundmodem {
- pub fn new<I: InputSource, O: OutputSink, P: Ptt>(input: I, output: O, ptt: P) -> Self {
- // must create TNC here
+ pub fn new<I: InputSource, O: OutputSink, P: Ptt, E: ErrorHandler>(
+ input: I,
+ output: O,
+ ptt: P,
+ error: E,
+ ) -> Self {
let (event_tx, event_rx) = sync_channel(128);
let (kiss_out_tx, kiss_out_rx) = sync_channel(128);
spawn_soundmodem_worker(
Box::new(input),
Box::new(output),
Box::new(ptt),
+ Box::new(error),
);
Self {
event_tx,
}
}
+#[derive(Debug, Clone, Copy)]
+pub enum ErrorSource {
+ Input,
+ Output,
+ Ptt,
+}
+
+impl Display for ErrorSource {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Input => write!(f, "Input"),
+ Self::Output => write!(f, "Output"),
+ Self::Ptt => write!(f, "PTT"),
+ }
+ }
+}
+
+pub trait ErrorHandler: Send + Sync + 'static {
+ fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError);
+}
+
+impl<F> ErrorHandler for F
+where
+ F: FnMut(ErrorSource, SoundmodemError) + Send + Sync + 'static,
+{
+ fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) {
+ self(source, err)
+ }
+}
+
+/// Soundmodem errors will be ignored.
+pub struct NullErrorHandler;
+
+impl NullErrorHandler {
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+impl Default for NullErrorHandler {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl ErrorHandler for NullErrorHandler {
+ fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) {
+ let _ = source;
+ let _ = err;
+ }
+}
+
+/// Soundmodem errors will be logged at DEBUG level via the `log` crate.
+pub struct LogErrorHandler;
+
+impl LogErrorHandler {
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+impl Default for LogErrorHandler {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl ErrorHandler for LogErrorHandler {
+ fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) {
+ log::debug!("Soundmodem error: {source} - {err}");
+ }
+}
+
+/// Soundmodem errors will be logged to stdout.
+pub struct StdoutErrorHandler;
+
+impl StdoutErrorHandler {
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+impl Default for StdoutErrorHandler {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl ErrorHandler for StdoutErrorHandler {
+ fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) {
+ println!("Soundmodem error: {source} - {err}");
+ }
+}
+
+#[derive(Clone)]
+pub struct SoundmodemErrorSender {
+ source: ErrorSource,
+ event_tx: SyncSender<SoundmodemEvent>,
+}
+
+impl SoundmodemErrorSender {
+ pub fn send_error<E: Into<SoundmodemError>>(&self, err: E) {
+ let _ = self
+ .event_tx
+ .send(SoundmodemEvent::RuntimeError(self.source, err.into()));
+ }
+}
+
struct PartialKissOut {
output: Arc<[u8]>,
idx: usize,
})
}
- fn start(&mut self) -> Result<(), TncError> {
+ fn start(&mut self) {
let _ = self.event_tx.send(SoundmodemEvent::Start);
- Ok(())
}
- fn close(&mut self) -> Result<(), TncError> {
+ fn close(&mut self) {
let _ = self.event_tx.send(SoundmodemEvent::Close);
- Ok(())
}
}
Close,
DidReadFromOutputBuffer { len: usize, timestamp: Instant },
OutputUnderrun,
+ RuntimeError(ErrorSource, SoundmodemError),
}
fn spawn_soundmodem_worker(
input: Box<dyn InputSource>,
output: Box<dyn OutputSink>,
mut ptt_driver: Box<dyn Ptt>,
+ mut error_handler: Box<dyn ErrorHandler>,
) {
std::thread::spawn(move || {
// TODO: should be able to provide a custom Demodulator for a soundmodem
tnc.set_data_carrier_detect(demodulator.data_carrier_detect());
}
SoundmodemEvent::Start => {
- // TODO: runtime event handling
- input.start(event_tx.clone()).unwrap();
- output.start(event_tx.clone(), out_buffer.clone()).unwrap();
+ let input_errors = SoundmodemErrorSender {
+ source: ErrorSource::Input,
+ event_tx: event_tx.clone(),
+ };
+ input.start(event_tx.clone(), input_errors);
+ let output_errors = SoundmodemErrorSender {
+ source: ErrorSource::Output,
+ event_tx: event_tx.clone(),
+ };
+ output.start(event_tx.clone(), out_buffer.clone(), output_errors);
}
SoundmodemEvent::Close => {
- ptt_driver.ptt_off().unwrap();
+ input.close();
+ output.close();
+ if let Err(e) = ptt_driver.ptt_off() {
+ error_handler.soundmodem_error(ErrorSource::Ptt, e);
+ }
break;
}
SoundmodemEvent::DidReadFromOutputBuffer { len, timestamp } => {
);
}
SoundmodemEvent::OutputUnderrun => {
+ log::debug!("output underrun");
// TODO: cancel transmission, send empty data frame to host
}
+ SoundmodemEvent::RuntimeError(source, err) => {
+ error_handler.soundmodem_error(source, err);
+ }
}
// Update PTT state
let new_ptt = tnc.ptt();
if new_ptt != ptt {
if new_ptt {
- ptt_driver.ptt_on().unwrap();
- } else {
- ptt_driver.ptt_off().unwrap();
+ if let Err(e) = ptt_driver.ptt_on() {
+ error_handler.soundmodem_error(ErrorSource::Ptt, e);
+ }
+ } else if let Err(e) = ptt_driver.ptt_off() {
+ error_handler.soundmodem_error(ErrorSource::Ptt, e);
}
}
ptt = new_ptt;
}
pub trait InputSource: Send + Sync + 'static {
- fn start(&self, samples: SyncSender<SoundmodemEvent>) -> Result<(), SoundmodemError>;
- fn close(&self) -> Result<(), SoundmodemError>;
+ fn start(&self, samples: SyncSender<SoundmodemEvent>, errors: SoundmodemErrorSender);
+ fn close(&self);
}
pub struct InputRrcFile {
}
impl InputSource for InputRrcFile {
- fn start(&self, samples: SyncSender<SoundmodemEvent>) -> Result<(), SoundmodemError> {
+ fn start(&self, samples: SyncSender<SoundmodemEvent>, errors: SoundmodemErrorSender) {
let (end_tx, end_rx) = channel();
let baseband = self.baseband.clone();
std::thread::spawn(move || {
buf[idx] = sample;
idx += 1;
if idx == SAMPLES_PER_TICK {
- if let Err(e) = samples.try_send(SoundmodemEvent::BasebandInput(buf.into())) {
- debug!("overflow feeding soundmodem: {e:?}");
+ if samples
+ .try_send(SoundmodemEvent::BasebandInput(buf.into()))
+ .is_err()
+ {
+ errors.send_error(InputRrcError::Overflow);
}
next_tick += TICK;
idx = 0;
}
});
*self.end_tx.lock().unwrap() = Some(end_tx);
- Ok(())
}
- fn close(&self) -> Result<(), SoundmodemError> {
+ fn close(&self) {
let _ = self.end_tx.lock().unwrap().take();
- Ok(())
}
}
+#[derive(Debug, Error)]
+pub enum InputRrcError {
+ #[error("overflow occurred feeding sample to soundmodem")]
+ Overflow,
+}
+
pub struct NullInputSource {
end_tx: Mutex<Option<Sender<()>>>,
}
}
impl InputSource for NullInputSource {
- fn start(&self, samples: SyncSender<SoundmodemEvent>) -> Result<(), SoundmodemError> {
+ fn start(&self, samples: SyncSender<SoundmodemEvent>, errors: SoundmodemErrorSender) {
let (end_tx, end_rx) = channel();
std::thread::spawn(move || {
// assuming 48 kHz for now
if end_rx.try_recv() != Err(TryRecvError::Empty) {
break;
}
- if let Err(e) = samples.try_send(SoundmodemEvent::BasebandInput(
- [0i16; SAMPLES_PER_TICK].into(),
- )) {
- debug!("overflow feeding soundmodem: {e:?}");
+ if samples
+ .try_send(SoundmodemEvent::BasebandInput(
+ [0i16; SAMPLES_PER_TICK].into(),
+ ))
+ .is_err()
+ {
+ errors.send_error(NullInputError::Overflow);
}
}
});
*self.end_tx.lock().unwrap() = Some(end_tx);
- Ok(())
}
- fn close(&self) -> Result<(), SoundmodemError> {
+ fn close(&self) {
let _ = self.end_tx.lock().unwrap().take();
- Ok(())
}
}
+#[derive(Debug, Error)]
+pub enum NullInputError {
+ #[error("overflow occurred feeding sample to soundmodem")]
+ Overflow,
+}
+
impl Default for NullInputSource {
fn default() -> Self {
Self::new()
&self,
event_tx: SyncSender<SoundmodemEvent>,
buffer: Arc<RwLock<OutputBuffer>>,
- ) -> Result<(), SoundmodemError>;
- fn close(&self) -> Result<(), SoundmodemError>;
+ errors: SoundmodemErrorSender,
+ );
+ fn close(&self);
}
pub struct OutputRrcFile {
&self,
event_tx: SyncSender<SoundmodemEvent>,
buffer: Arc<RwLock<OutputBuffer>>,
- ) -> Result<(), SoundmodemError> {
+ errors: SoundmodemErrorSender,
+ ) {
let (end_tx, end_rx) = channel();
- let mut file = File::create(self.path.clone())?;
+ let mut file = match File::create(self.path.clone()) {
+ Ok(f) => f,
+ Err(e) => {
+ errors.send_error(OutputRrcError::Open(e));
+ return;
+ }
+ };
std::thread::spawn(move || {
// assuming 48 kHz for now
const TICK: Duration = Duration::from_millis(25);
out.copy_from_slice(&[be[0], be[1]]);
buf_used += 2;
} else if !buffer.idling {
- debug!("output rrc file had underrun");
let _ = event_tx.send(SoundmodemEvent::OutputUnderrun);
break;
}
}
if let Err(e) = file.write_all(&buf[0..buf_used]) {
- debug!("failed to write to rrc file: {e:?}");
+ errors.send_error(OutputRrcError::WriteError(e));
break;
}
let _ = event_tx.send(SoundmodemEvent::DidReadFromOutputBuffer {
}
});
*self.end_tx.lock().unwrap() = Some(end_tx);
- Ok(())
}
- fn close(&self) -> Result<(), SoundmodemError> {
+ fn close(&self) {
let _ = self.end_tx.lock().unwrap().take();
- Ok(())
}
}
+#[derive(Debug, Error)]
+pub enum OutputRrcError {
+ #[error("unable to open rrc file for writing: {0}")]
+ Open(#[source] std::io::Error),
+
+ #[error("error writing to output file: {0}")]
+ WriteError(#[source] std::io::Error),
+}
+
pub struct NullOutputSink {
end_tx: Mutex<Option<Sender<()>>>,
}
&self,
event_tx: SyncSender<SoundmodemEvent>,
buffer: Arc<RwLock<OutputBuffer>>,
- ) -> Result<(), SoundmodemError> {
+ _errors: SoundmodemErrorSender,
+ ) {
let (end_tx, end_rx) = channel();
std::thread::spawn(move || {
// assuming 48 kHz for now
for _ in 0..SAMPLES_PER_TICK {
if buffer.samples.pop_front().is_none() {
if !buffer.idling {
- debug!("null output had underrun");
let _ = event_tx.send(SoundmodemEvent::OutputUnderrun);
break;
}
}
});
*self.end_tx.lock().unwrap() = Some(end_tx);
- Ok(())
}
- fn close(&self) -> Result<(), SoundmodemError> {
+ fn close(&self) {
let _ = self.end_tx.lock().unwrap().take();
- Ok(())
}
}
projects / m17rt / blobdiff