GFSK experiment: Works pretty damn well

Cargo.toml

@@ -8,7 +8,7 @@ cpal = { version = "0.16.0", features = ["jack"] }
 eframe = "0.32.3"
 egui_plot = "0.33.0"
 hound = "3.5.1"
+iter_tools = "0.39.0"
 plotters = "0.3.7"
 rand = "0.9.2"
 tokio = { version = "1.47.1", features = ["full", "macros", "net", "sync", "time"] }
-tun-tap = "0.1.4"

run_net.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-echo "running as $1"
-
-cargo b --release
-sudo setcap cap_net_admin+eip target/release/rdsp
-./target/release/rdsp 0 > /dev/ttyACM0 &
-sleep .5
-sudo ip a a $1/24 dev radio0
-sudo ip -6 addr flush radio0
-sudo ip link set radio0 up 
-sudo ip -6 addr flush radio0
-

src/filtering/impulse_response.rs

@@ -4,14 +4,10 @@ pub mod design {
     use crate::fft::FFT;
     use crate::windows::{self, Window};
 
-    // Completely stolen from sdrpp dsp code
-    pub fn estimate_fir_length(transition_width: f32, sample_rate: f32) -> f32 {
-        3.8 * sample_rate / transition_width
-    }
-
     ///Designs a impulse response from a desired transfer function using windowing technique
     pub fn ir_from_transfer_function(
         transfer_function: &[Complex32],
+        ir_length: usize,
         window: Window,
     ) -> Vec<Complex32> {
         let tf_len = transfer_function.len();
@@ -23,11 +19,11 @@ pub mod design {
         // Shorten and window
         let mut ir = vec![];
 
-        for i in 0..tf_len {
+        for i in 0..ir_length {
             // Get value within ifft result (centering/trimming)
-            let k = (tf_len - (tf_len / 2) + i) % tf_len;
+            let k = (tf_len - (ir_length / 2) + i) % tf_len;
             // Windowing
-            ir.push(ifft.get_output()[k] * window(i as f32 / tf_len as f32) / tf_len as f32);
+            ir.push(ifft.get_output()[k] * window(i as f32 / ir_length as f32) / tf_len as f32);
         }
 
         ir
@@ -46,4 +42,10 @@ pub mod design {
         fft.execute(&centered_ir);
         Vec::from(fft.get_output())
     }
+
+    pub fn pi_loop(loop_p: f32, loop_i: f32, length: u32) -> Vec<Complex32> {
+        let mut v = vec![Complex32::new(loop_i, 0.); length as usize];
+        v[(length - 1) as usize] = Complex32::new(loop_p * length as f32, 0.);
+        v
+    }
 }

src/iq.rs

@@ -11,7 +11,7 @@ impl IQSampler {
     pub fn new(center_freq: f32) -> Self {
         // Design a lowpass filter that cuts off at the center freq
         // Estimate FIR length :
-        let fir_length = 50;
+        let fir_length = 100;
 
         // Ideal transfer function :
         let mut transfer_function = vec![Complex32::zero(); fir_length];
@@ -24,6 +24,7 @@ impl IQSampler {
 
         let ir = crate::filtering::impulse_response::design::ir_from_transfer_function(
             &transfer_function,
+            fir_length,
             windows::blackmann,
         );
         let mut low_pass_i = FIRFilter::new(&ir);

src/main.rs

@@ -13,14 +13,15 @@ mod units;
 mod windows;
 
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use egui_plot::{Legend, Line, Plot};
+use egui_plot::{Legend, Line, Plot, PlotUi};
 use hound::WavWriter;
-use rand::{Rng, rand_core::le, seq::index::sample};
+use iter_tools::Itertools;
+use plotters::data;
+use rand::{Rng, SeedableRng, rand_core::le, seq::index::sample};
 use std::{
     cell::{Cell, RefCell},
     collections::VecDeque,
     env::{self, args},
-    f32::consts::PI,
     fmt::Display,
     fs::File,
     io::{BufWriter, Read, Sink, Write, stdout},
@@ -37,486 +38,35 @@ use tokio::{
     sync::mpsc::{UnboundedSender, error::TryRecvError, unbounded_channel},
     time::timeout,
 };
-use tun_tap::Iface;
 
 use crate::{
     bfsk::BFSKMod,
     complex::Complex32,
-    filtering::{
-        dc_block::DCBlocker,
-        fir::FIRFilter,
-        impulse_response::{
-            self,
-            design::{estimate_fir_length, frequency_response},
-        },
-    },
+    filtering::{dc_block::DCBlocker, fir::FIRFilter, impulse_response},
     iq::IQSampler,
-    math::map,
     nco::Nco,
     squelch::Squelch,
     ted::elg::ELGate,
     units::frequency::hz_to_rad_per_sample,
+    windows::gaussian,
+};
+use eframe::{
+    egui::{self, CentralPanel, Color32, RichText},
+    glow::NUM_SHADER_BINARY_FORMATS,
 };
-use eframe::egui::{self, CentralPanel, Color32, RichText};
 use tokio::sync::RwLock;
 use tokio::sync::mpsc::{Receiver, Sender, channel};
 
-const BAUD_RATE: u32 = 1200;
+const BAUD_RATE: u32 = 1000;
 const SAMPLE_RATE: u32 = 48000;
 
 // Modulation parameters
 const CENTER_FREQ: f32 = 1700.;
 const DEVIATION: f32 = 500.;
 
-static mut INSTANCE_ID: u32 = 0;
-
-pub enum SampleSenderCommand {
-    Open,
-    Close,
-    Sample(f32),
-}
-
-pub trait SampleSender {
-    async fn open_link(&mut self);
-    async fn send_sample(&mut self, sample: f32);
-    async fn close_link(&mut self);
-}
-
-struct WavSampleSender {
-    writer: Option<WavWriter<BufWriter<File>>>,
-}
-
-impl Default for WavSampleSender {
-    fn default() -> Self {
-        Self { writer: None }
-    }
-}
-
-impl SampleSender for WavSampleSender {
-    async fn open_link(&mut self) {
-        let spec = hound::WavSpec {
-            channels: 1,
-            sample_rate: SAMPLE_RATE,
-            bits_per_sample: 16,
-            sample_format: hound::SampleFormat::Int,
-        };
-        self.writer = Some(hound::WavWriter::create("audio/modulated.wav", spec).unwrap());
-    }
-
-    async fn send_sample(&mut self, sample: f32) {
-        let out_sample = (sample * i16::MAX as f32) as i16;
-        self.writer
-            .as_mut()
-            .unwrap()
-            .write_sample(out_sample)
-            .unwrap();
-    }
-
-    async fn close_link(&mut self) {
-        self.writer = None;
-    }
-}
-
-struct FSKReceiver {
-    eye_sender: Sender<Vec<f32>>,
-    phase_lowpass: FIRFilter,
-    baseband_filter: FIRFilter,
-    elg: ELGate,
-    last_byte: u8,
-    frame_constructor: FrameConstructor,
-    bit_count: Option<u32>,
-    last_sample: Complex32,
-}
-
-impl FSKReceiver {
-    fn new(eye_sender: Sender<Vec<f32>>) -> Self {
-        let samples_per_symbol = (SAMPLE_RATE as f32) / (BAUD_RATE as f32);
-
-        let mut phase_lowpass =
-            FIRFilter::new(&vec![Complex32::new(1., 0.); samples_per_symbol as usize]);
-        phase_lowpass.normalize_dc();
-        //let mut dc_block = DCBlocker::new(0.999);
-        //let mut dc_block = DCBlocker::new(1.);
-
-        let loop_i = 0.03;
-        let loop_p = 0.1;
-        let mut loop_ir = vec![Complex32::new(loop_i, 0.); samples_per_symbol as usize / 4];
-        loop_ir.push(Complex32::new(loop_p, 0.));
-        let elg = ELGate::new(samples_per_symbol, FIRFilter::new(&loop_ir));
-
-        // Baseband filter
-        let bbf_length = estimate_fir_length(100., SAMPLE_RATE as f32).floor() as usize;
-        let mut frequency_response = vec![Complex32::zero(); bbf_length].into_boxed_slice();
-        let cutoff_bin = map(
-            hz_to_rad_per_sample(DEVIATION + 300., SAMPLE_RATE as f32),
-            0.,
-            2. * PI,
-            0.,
-            bbf_length as f32,
-        )
-        .floor() as usize;
-
-        // Design transfer function
-        for i in 0..cutoff_bin {
-            frequency_response[i] = Complex32::new(1., 0.);
-            frequency_response[bbf_length - 1 - i] = Complex32::new(1., 0.);
-        }
-
-        Self {
-            //iq_sampler: IQSampler::new(hz_to_rad_per_sample(CENTER_FREQ, SAMPLE_RATE as f32)),
-            phase_lowpass,
-            baseband_filter: FIRFilter::new(&impulse_response::design::ir_from_transfer_function(
-                &frequency_response,
-                windows::blackmann,
-            )),
-            elg,
-            last_byte: 0x00u8,
-            frame_constructor: FrameConstructor::new(),
-            bit_count: None,
-            eye_sender,
-            last_sample: Complex32::new(1., 0.),
-        }
-    }
-
-    async fn receive(&mut self, iq: Complex32) -> Result<Option<Frame>, FrameConstructionError> {
-        // Frame reconstruction
-        let filtered_bb = self.baseband_filter.next(iq);
-        // let dphi = self
-        //     .phase_lowpass
-        //     .next_real((self.last_sample * filtered_bb.conj()).arg());
-        let dphi = (self.last_sample * filtered_bb.conj()).arg();
-        self.last_sample = filtered_bb;
-        if let Some((bit_sample, eye)) = self.elg.next_eye(dphi) {
-            let _ = self.eye_sender.send(eye).await;
-            self.last_byte >>= 1;
-            self.last_byte |= ((bit_sample > 0.) as u8) << 7;
-            //last_byte <<= 1;
-            //last_byte |= ((bit_sample < 0.) as u8);
-            self.bit_count = self.bit_count.map(|x| x + 1);
-
-            if let None = self.bit_count
-                && self.last_byte == 0xD8
-            {
-                // Potential frame starts
-                self.last_byte = 0;
-                self.frame_constructor = FrameConstructor::new();
-                self.bit_count = Some(0);
-            }
-
-            if let Some(8) = self.bit_count {
-                let frame_opt = self.frame_constructor.add_byte(self.last_byte);
-                self.bit_count = Some(0);
-                //print!("{}", last_byte as char);
-                eprint!(".{:x}.", self.last_byte);
-                let _ = std::io::stdout().flush();
-                return frame_opt;
-            }
-        }
-        return Ok(None);
-    }
-}
-
-#[derive(Debug)]
-enum TransceiverState {
-    Waiting,
-    Receiving,
-    EOT,
-    SendingAck,
-    Sending,
-    Listening,
-}
-
-struct Transceiver {
-    tx_stream: Sender<Vec<u8>>,
-    rx_stream: Receiver<Vec<u8>>,
-
-    eye_receiver: Receiver<Vec<f32>>,
-    state_receiver: Receiver<TransceiverState>,
-}
-
-impl Transceiver {
-    pub async fn send(&self, data: Vec<u8>) {
-        self.tx_stream.send(data).await;
-    }
-
-    pub fn get_sender(&self) -> Sender<Vec<u8>> {
-        self.tx_stream.clone()
-    }
-
-    pub fn try_recv(&mut self) -> Result<Vec<u8>, TryRecvError> {
-        self.rx_stream.try_recv()
-    }
-
-    pub fn try_recv_eye(&mut self) -> Result<Vec<f32>, TryRecvError> {
-        self.eye_receiver.try_recv()
-    }
-
-    pub fn try_recv_state(&mut self) -> Result<TransceiverState, TryRecvError> {
-        self.state_receiver.try_recv()
-    }
-
-    pub fn start(mut sample_stream: Receiver<f32>, mut sample_sender: Sender<Vec<f32>>) -> Self {
-        let mut resend: Option<Vec<u8>> = None;
-        let (mut eyes_tx, eyes_rx) = channel::<Vec<f32>>(1024);
-        let (mut state_tx, state_rx) = channel::<TransceiverState>(1024);
-        state_tx.try_send(TransceiverState::Waiting);
-
-        let (rx_stream_sender, mut rx_stream_receiver) = channel::<Vec<u8>>(1024);
-        let (tx_stream_sender, mut tx_stream_receiver) = channel::<Vec<u8>>(1024);
-
-        let receiving = Arc::new(RwLock::new(false));
-        tokio::spawn(async move {
-            let mut squelch = Squelch::new(200, 0.5);
-            let mut iq_sampler =
-                IQSampler::new(hz_to_rad_per_sample(CENTER_FREQ, SAMPLE_RATE as f32));
-
-            let mut current_message = None;
-            loop {
-                select! {
-                    _ = async {
-                            while squelch.next(iq_sampler.sample(sample_stream.recv().await.unwrap())).is_none() {}
-                    }
-                    =>
-                    {
-                        state_tx.try_send(TransceiverState::Receiving);
-                        // Wait for end of tranmission
-                        let mut recv = Some(FSKReceiver::new(eyes_tx.clone()));
-                        let mut send_ack = false;
-                        while let Some(iq) = squelch.next(iq_sampler.sample(sample_stream.recv().await.unwrap()))
-                        {
-                            if recv.as_ref().is_some()
-                            {
-                                match recv.as_mut().unwrap().receive(iq).await
-                                {
-                                    Ok(Some(Frame::Data(dat))) => {
-                                        eprintln!("GOT DATA");
-                                        let _ = rx_stream_sender.try_send(dat);
-                                        send_ack = false;
-                                        recv = None;
-                                        state_tx.try_send(TransceiverState::EOT);
-                                    },
-                                    //Ok(Some(Frame::Ack)) => {current_message = None; recv = None; state_tx.try_send(TransceiverState::EOT);},
-                                    Err(()) => {recv = None;},
-                                    _ => {}
-                                }
-                            }
-                        }
-                        if send_ack
-                        {
-                            state_tx.try_send(TransceiverState::SendingAck);
-                            Self::transmit(Frame::Ack, &mut sample_sender).await;
-                        }
-                        state_tx.try_send(TransceiverState::Waiting);
-                    },
-                    message = async
-                    {
-                        if current_message.is_none()
-                        {
-                            current_message = Some((tx_stream_receiver).recv().await.unwrap());
-                        }
-                        state_tx.try_send(TransceiverState::Listening);
-                        tokio::time::sleep(Duration::from_millis(50 * rand::random_range(1..10))).await;
-                        current_message.as_ref().unwrap()
-                    } =>
-                    {
-                        state_tx.try_send(TransceiverState::Sending);
-                        eprintln!("Sending message");
-                        Self::transmit(Frame::Data(message.clone()), &mut sample_sender).await;
-                        current_message = None;
-                        eprintln!("Sent message");
-                        state_tx.try_send(TransceiverState::Waiting);
-                    }
-                };
-            }
-        });
-
-        Self {
-            eye_receiver: eyes_rx,
-            state_receiver: state_rx,
-
-            tx_stream: tx_stream_sender,
-            rx_stream: rx_stream_receiver,
-        }
-    }
-
-    pub async fn transmit(frame: Frame, samples_sender: &mut Sender<Vec<f32>>) {
-        let bytes = frame.bytes();
-        let data = bytes
-            .iter()
-            .flat_map(|x| byte_to_bits(*x))
-            .collect::<Vec<_>>();
-
-        let sample_per_symbols = SAMPLE_RATE / BAUD_RATE;
-        let bitstream = (0..(bytes.len() * 8 * sample_per_symbols as usize)).map(|i| {
-            if data[i / sample_per_symbols as usize] {
-                1.
-            } else {
-                -1.
-            }
-        });
-
-        // Synthesise impulse response
-        let mut impulse_response =
-            vec![Complex32::zero(); sample_per_symbols as usize].into_boxed_slice();
-        for (i, x) in impulse_response.iter_mut().enumerate() {
-            *x = Complex32::new(
-                windows::gaussian(0.3, i as f32 / sample_per_symbols as f32),
-                0.,
-            );
-        }
-
-        let mut gaussian_filter = FIRFilter::new(&impulse_response);
-        gaussian_filter.normalize_dc();
-        let filtered_bitstream = bitstream.map(|x| gaussian_filter.next_real(x));
-
-        let mut nco = Nco::new(0.);
-        let mut lo = Nco::new(hz_to_rad_per_sample(CENTER_FREQ, SAMPLE_RATE as f32));
-
-        // Generate passband
-        let samples = filtered_bitstream
-            .map(|f| {
-                nco.set_frequency(hz_to_rad_per_sample(f * DEVIATION, SAMPLE_RATE as f32));
-                nco.step_n(1);
-                lo.step_n(1);
-                (nco.cexp() * lo.cexp()).re
-            })
-            .collect::<Vec<_>>();
-
-        let len = samples.len();
-        samples_sender.send(samples).await.unwrap();
-        tokio::time::sleep(Duration::from_secs_f32(len as f32 / SAMPLE_RATE as f32)).await;
-    }
-}
-
-enum Frame {
-    Data(Vec<u8>),
-    Ack,
-}
-
-type FrameConstructionError = ();
-pub struct FrameConstructor {
-    frame: Vec<u8>,
-    frame_countdown: Option<u16>,
-    checksum: u8,
-    started: bool,
-}
-
-impl FrameConstructor {
-    pub fn new() -> Self {
-        Self {
-            frame: Vec::new(),
-            frame_countdown: None,
-            checksum: 0u8,
-            started: false,
-        }
-    }
-
-    pub fn add_byte(&mut self, byte: u8) -> Result<Option<Frame>, FrameConstructionError> {
-        if self.frame.is_empty() && byte != 0xC4 && byte != 0x4C && !self.started {
-            eprintln!("Wrong type {:x}", byte);
-            self.started = true;
-            return Err(());
-        }
-
-        if self.frame.is_empty() && byte == 0xC4 && !self.started {
-            self.started = true;
-            return Ok(Some(Frame::Ack));
-        }
-
-        if self.frame.is_empty() && byte == 0x4C && !self.started {
-            self.started = true;
-            return Ok(None);
-        }
-
-        self.frame.push(byte);
-
-        // Retrieve length
-        if self.frame.len() == 1 {
-            self.frame_countdown = Some(self.frame[0] as u16);
-            return Ok(None);
-        }
-        if self.frame.len() == 2 {
-            *self.frame_countdown.as_mut().unwrap() |= (self.frame[1] as u16) << 8;
-            return Ok(None);
-        }
-
-        if self.frame_countdown.unwrap() == 0 {
-            // All data has been received
-            if self.checksum == byte {
-                return Ok(Some(Frame::Data(
-                    self.frame.iter().skip(2).copied().collect(),
-                )));
-            }
-
-            eprintln!("Checksum failed");
-            return Err(());
-        }
-
-        //self.frame.push(byte);
-        self.checksum ^= byte;
-        *self.frame_countdown.as_mut().unwrap() -= 1;
-
-        Ok(None)
-    }
-}
-
-impl Frame {
-    pub fn bytes(&self) -> Vec<u8> {
-        let mut output_bytes = vec![];
-
-        // Initial training sequence
-        output_bytes.append(&mut vec![0b01010101; 32]);
-
-        // Preamble byte
-        output_bytes.push(0xD8);
-
-        // Command
-        match self {
-            Frame::Data(x) => {
-                assert!(x.len() < 65536, "Data size over MTU");
-
-                output_bytes.push(0x4C); // DATA FRAME
-
-                let len_u16 = x.len() as u16;
-                output_bytes.push((len_u16 & 0xFF).try_into().unwrap());
-                output_bytes.push(((len_u16 >> 8) & 0xFF).try_into().unwrap());
-
-                let mut checksum = 0u8;
-                x.iter().for_each(|x| checksum ^= x);
-                output_bytes.extend(x.iter());
-
-                output_bytes.push(checksum);
-            }
-            Frame::Ack => {
-                output_bytes.push(0xC4); // ACK FRAME
-            }
-        }
-
-        // SEND EOT
-        output_bytes.extend(std::iter::repeat_n(4, 16));
-        output_bytes
-    }
-}
-
 #[tokio::main]
 async fn main() {
     // Read instance
-    eprintln!(
-        "fir length: {}",
-        impulse_response::design::estimate_fir_length(1000., 48000.)
-    );
-    let id = std::env::args().collect::<Vec<_>>()[1]
-        .parse::<u32>()
-        .expect("NO INPUT ID");
-    assert!(id == 0 || id == 1);
-
-    unsafe {
-        INSTANCE_ID = id;
-    };
-
-    //Transceiver::transmit(Frame::Data("Skibditoilet".repeat(100).bytes().collect::<Vec<_>>()), &mut WavSampleSender{}).await;
-    //Transceiver::transmit(Frame::Ack, &mut WavSampleSender::default()).await;
-    //return;
 
     let native_options = eframe::NativeOptions::default();
     let _ = eframe::run_native(
@@ -526,203 +76,127 @@ async fn main() {
     );
 }
 
-//#[derive(Default)]
-
-struct DummySampleSender();
-
-impl SampleSender for DummySampleSender {
-    async fn open_link(&mut self) {}
-    async fn send_sample(&mut self, _sample: f32) {}
-    async fn close_link(&mut self) {}
-}
-
 struct EguiApp {
-    transceiver: Transceiver,
-
-    eyes: VecDeque<Vec<f32>>,
-    current_state: TransceiverState,
-    iface: Iface,
+    data: Vec<Vec<f32>>,
 }
 impl EguiApp {
     fn new(_cc: &eframe::CreationContext<'_>) -> Self {
-        let iface = Iface::new("radio%d", tun_tap::Mode::Tap).unwrap();
-        iface.set_non_blocking().unwrap();
-
-        let (up_sender, mut up_receiver) = channel::<Vec<f32>>(16);
-        let (down_sender, down_receiver) = channel::<f32>(1024);
-
-        let transceiver = Transceiver::start(down_receiver, up_sender);
-
-        let instance_id = unsafe { INSTANCE_ID };
-        tokio::task::spawn(async move {
-            eprintln!("Waiting for connection ...");
-
-            // let socket = Arc::new(
-            //     UdpSocket::bind(format!("0.0.0.0:{}", 9000 + instance_id))
-            //         .await
-            //         .unwrap(),
-            // );
-            // socket
-            //     .connect(format!("127.0.0.1:{}", 9000 + (1 - instance_id)))
-            //     .await
-            //     .unwrap();
-
-            // Receiving end
-            let host = cpal::default_host();
-
-            let device = host.default_input_device().expect("No input device");
-            let mut config = device
-                .supported_input_configs()
-                .unwrap()
-                .next()
-                .unwrap()
-                .with_sample_rate(cpal::SampleRate(48000));
-
-            let stream = device
-                .build_input_stream(
-                    &config.into(),
-                    move |data: &[f32], _| {
-                        for x in data.iter() {
-                            let _ = down_sender.blocking_send(*x * 30.); // non-blocking send
-                        }
-                    },
-                    move |err| eprintln!("Stream error: {}", err),
-                    None,
-                )
-                .unwrap();
-            stream.play().unwrap();
-
-            let device = host.default_output_device().unwrap();
-            let mut supported_configs_range = device.supported_output_configs().unwrap();
-            let supported_config = supported_configs_range
-                .find(|config| {
-                    config.sample_format() == cpal::SampleFormat::F32
-                        && config.min_sample_rate().0 <= 48000
-                        && config.max_sample_rate().0 >= 48000
-                })
-                .expect("Device does not support 48kHz f32 output");
-            let config = supported_config
-                .with_sample_rate(cpal::SampleRate(48_000))
-                .config();
-
-            while let Some(stream) = up_receiver.recv().await {
-                let stream_len = stream.len();
-                let progression = Arc::new(AtomicU64::new(0));
-                let (finished_tx, mut finished_rx) = channel::<()>(16);
-
-                print!("o");
-                stdout().flush().unwrap();
-                let send_stream = device
-                    .build_output_stream(
-                        &config,
-                        move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
-                            for d in data.iter_mut() {
-                                if progression.load(std::sync::atomic::Ordering::Relaxed) as usize
-                                    == stream.len()
-                                {
-                                    let _ = finished_tx.blocking_send(());
-                                    break;
-                                }
-
-                                *d = stream[progression
-                                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-                                    as usize];
-                            }
-                        },
-                        move |err| {
-                            eprintln!("Stream error: {}", err);
-                        },
-                        None,
-                    )
-                    .unwrap();
-                send_stream.play().unwrap();
-                let _ = finished_rx.recv().await;
-                print!("c");
-                stdout().flush().unwrap();
-            }
-        });
-
-        EguiApp {
-            transceiver,
-
-            eyes: VecDeque::new(),
-            current_state: TransceiverState::Waiting,
-            iface,
-        }
+        //let modulated = modulate();
+        //println!("{}", modulated.len());
+        EguiApp { data: demodulate() }
     }
 }
 
 impl eframe::App for EguiApp {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        egui::CentralPanel::default().show(ctx, |ui| {
-            let max_eyes = 100;
-
-            // INTERFACE
-            let mut frame = [0u8; 2000];
-            while let Ok(length) = self.iface.recv(&mut frame) {
-                //break;
-                let _ = self
-                    .transceiver
-                    .get_sender()
-                    .try_send(Vec::from(&frame[0..length]));
-            }
-
-            while let Ok(frame) = self.transceiver.try_recv() {
-                let _ = self.iface.send(frame.as_slice());
-            }
-
-            while let Ok(eye) = self.transceiver.try_recv_eye() {
-                self.eyes.push_back(eye);
-            }
-            while self.eyes.len() > max_eyes {
-                self.eyes.pop_front();
-            }
-            if let Ok(new_state) = self.transceiver.try_recv_state() {
-                self.current_state = new_state;
-            }
-
-            ui.horizontal(|ui| {
-                // if ui.button("Start").clicked() {
-                //     let snd = self.transceiver.get_sender();
-                //     let data = (0..rand::random_range(50..250))
-                //         .map(|_| rand::random::<char>() as u8)
-                //         .collect::<Vec<_>>();
-                //
-                //     tokio::spawn(async move {
-                //         let _ = snd.send(data).await;
-                //     });
-                // }
-                //
-                ui.label(
-                    RichText::new(format!("{:?}", self.current_state))
-                        .size(35.)
-                        .color(Color32::LIGHT_GREEN),
-                );
-            });
-
-            Plot::new("EyeA")
-                .legend(Legend::default())
-                .show(ui, |plot_ui| {
-                    //plot_ui.set_auto_bounds(Vec2b { x: false, y: false });
-                    for eye in self.eyes.iter() {
-                        let line = Line::new(
-                            "EyeA",
+        CentralPanel::default().show(ctx, |ui| {
+            Plot::new("Plot").show(ui, |plot_ui| {
+                for eye in self.data.iter().skip(BAUD_RATE as usize) {
+                    plot_ui.line(
+                        Line::new(
+                            "Bitstream",
                             eye.iter()
                                 .enumerate()
                                 .map(|(i, x)| [i as f64, *x as f64])
                                 .collect::<Vec<_>>(),
                         )
-                        .color(Color32::LIGHT_GREEN);
-                        plot_ui.line(line);
-                    }
-                });
-        }); // Central panel
-
-        std::thread::sleep(Duration::from_millis(16));
-        ctx.request_repaint();
+                        .color(Color32::GREEN),
+                    )
+                }
+            });
+        });
     }
 }
 
+fn modulate() -> Vec<f32> {
+    let sample_per_symbols = SAMPLE_RATE / BAUD_RATE;
+    let stream_len = (4 * SAMPLE_RATE) / sample_per_symbols;
+    let mut rng = rand::rngs::SmallRng::from_seed([0; 32]);
+    let data_stream = (0..stream_len)
+        .map(|_| rng.random::<bool>())
+        .collect::<Vec<_>>();
+
+    let bitstream = (0..(stream_len * sample_per_symbols)).map(|i| {
+        if data_stream[(i / sample_per_symbols) as usize] {
+            1.
+        } else {
+            -1.
+        }
+    });
+
+    // Synthesise impulse response
+    let mut impulse_response =
+        vec![Complex32::zero(); sample_per_symbols as usize].into_boxed_slice();
+    for (i, x) in impulse_response.iter_mut().enumerate() {
+        *x = Complex32::new(gaussian(0.3, i as f32 / sample_per_symbols as f32), 0.);
+    }
+
+    let mut gaussian_filter = FIRFilter::new(&impulse_response);
+    gaussian_filter.normalize_dc();
+    let filtered_bitstream = bitstream.map(|x| gaussian_filter.next_real(x));
+    //let filtered_bitstream = bitstream;
+
+    let mut nco = Nco::new(0.);
+    let mut lo = Nco::new(hz_to_rad_per_sample(CENTER_FREQ, SAMPLE_RATE as f32));
+
+    // Save to wav
+    let spec = hound::WavSpec {
+        channels: 1,
+        sample_rate: SAMPLE_RATE,
+        bits_per_sample: 16,
+        sample_format: hound::SampleFormat::Int,
+    };
+
+    let mut writer = hound::WavWriter::create("audio/gfsk.wav", spec).unwrap();
+
+    let res = filtered_bitstream
+        .map(|f| {
+            nco.set_frequency(hz_to_rad_per_sample(f * DEVIATION, SAMPLE_RATE as f32));
+            nco.step_n(1);
+            lo.step_n(1);
+            let val = (nco.cexp() * lo.cexp()).re;
+            writer.write_sample((val * i16::MAX as f32) as i16).unwrap();
+            val
+        })
+        .collect::<Vec<_>>();
+    writer.finalize().unwrap();
+    res
+}
+
+fn demodulate() -> Vec<Vec<f32>> {
+    let samples_per_symbol = SAMPLE_RATE / BAUD_RATE;
+    let mut reader = hound::WavReader::open("audio/gfsk_rec.wav").unwrap();
+    let mut iq_sampler = IQSampler::new(hz_to_rad_per_sample(CENTER_FREQ, SAMPLE_RATE as f32));
+    let mut phase_lowpass = FIRFilter::new(&vec![
+        Complex32::new(1.0, 0.);
+        (samples_per_symbol) as usize
+    ]);
+    phase_lowpass.normalize_dc();
+    let mut elgate_filter = FIRFilter::new(&impulse_response::design::pi_loop(
+        0.001,
+        0.,
+        samples_per_symbol,
+    ));
+    elgate_filter.normalize_dc();
+    let mut elgate = ELGate::new(samples_per_symbol as f32, elgate_filter);
+    let samples = reader
+        .samples::<i16>()
+        .map(|x| iq_sampler.sample(x.unwrap() as f32 / i16::MAX as f32))
+        .tuple_windows()
+        .map(|(x, y)| (x * y.conj()).arg())
+        .map(|x| phase_lowpass.next_real(x))
+        .collect::<Vec<_>>();
+
+    let mut eyes = vec![];
+    for x in samples {
+        if let Some((_, eye)) = elgate.next_eye(x) {
+            eyes.push(eye);
+        }
+    }
+    println!("{}", eyes.len());
+    eyes
+}
+
 fn byte_to_bits(byte: u8) -> Vec<bool> {
     vec![
         byte & 1 == 1,

src/ted/elg.rs

@@ -1,11 +1,10 @@
-use crate::filtering::fir::FIRFilter;
 use std::collections::VecDeque;
+use crate::filtering::fir::FIRFilter;
 
 // Crued Early late gate timing error detector
 pub struct ELGate {
     samples_per_symbol: f32,
     buffer: VecDeque<f32>, // Store baseband, matched filtered samples,
-    eye_buffer: VecDeque<f32>,
 
     loop_filter: FIRFilter,
     delta: f32,
@@ -19,7 +18,6 @@ impl ELGate {
             samples_per_symbol,
             loop_filter,
             buffer: VecDeque::with_capacity(2 * samples_per_symbol.ceil() as usize),
-            eye_buffer: VecDeque::with_capacity(2 * samples_per_symbol.ceil() as usize),
             delta: 0.5,
             next_sample: samples_per_symbol,
             current_position: 0.,
@@ -32,26 +30,8 @@ impl ELGate {
 
     pub fn next_eye(&mut self, sample: f32) -> Option<(f32, Vec<f32>)> {
         self.buffer.push_front(sample);
-        self.eye_buffer.push_front(sample);
-
         self.current_position += 1.;
         if self.current_position >= self.next_sample {
-            // Eye stuff
-            let mut eye = Vec::new();
-            if self.eye_buffer.len() >= (self.samples_per_symbol / 2.) as usize {
-                let start_index = (self.samples_per_symbol / 2.) as usize;
-                let end_index = (start_index * 3).min(self.eye_buffer.len());
-                eye = self
-                    .eye_buffer
-                    .range(start_index..)
-                    .copied()
-                    .collect::<Vec<_>>();
-
-                while self.eye_buffer.len() > start_index {
-                    self.eye_buffer.pop_back();
-                }
-            }
-
             // Sample center, early late
             let early_id = (self.samples_per_symbol / 2. + self.samples_per_symbol * self.delta)
                 .floor()
@@ -83,3 +63,4 @@ impl ELGate {
         }
     }
 }
+