diff --git a/interface/src/main.rs b/interface/src/main.rs
index 61a704b..2cd69bc 100644
--- a/interface/src/main.rs
+++ b/interface/src/main.rs
@@ -1,12 +1,12 @@
 #![feature(iter_collect_into)]
-use std::{result, thread::sleep, time::Duration};
+use std::{result, sync::Arc, thread::sleep, time::Duration};
 
 use anyhow::{Context, Ok, Result};
 use common::{ControlPacket, TelemetryPacket};
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
 use pitch_detection::{detector::{mcleod::McLeodDetector, PitchDetector}, utils};
 use rust_music_theory::note::{Note, NoteLetter, Pitch, Tuning};
-use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufWriter, WriteHalf}, net::{tcp::{OwnedReadHalf, OwnedWriteHalf}, TcpStream}, sync::mpsc, time::timeout};
+use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufWriter, WriteHalf}, net::{tcp::{OwnedReadHalf, OwnedWriteHalf}, TcpStream}, spawn, sync::{self, mpsc, RwLock}, time::timeout};
 
 fn main() -> Result<()> {
     // assumes pulseaudio system with f32 samples and 2204 sample packets
@@ -43,6 +43,7 @@ fn main() -> Result<()> {
 
     let executor = tokio::runtime::Runtime::new()?;
 
+    //let latest_telem = Arc::new(RwLock::new(None));
 
     let control = executor.block_on(async {
         let cruisecontrol = TcpStream::connect("169.254.1.1:1234").await?;
@@ -78,8 +79,14 @@ async fn telemetry_handler(mut telem: OwnedReadHalf) -> Result<()> {
 
 async fn controller(mut notes: mpsc::Receiver<(Option<pitch_detection::Pitch<f32>>, f32)>, controller: OwnedWriteHalf) -> Result<()> {
     let mut controller = BufWriter::new(controller);
-    send_packet(&mut controller, ControlPacket::Arm(true)).await?;
-    println!("armed flipper");
+    //send_packet(&mut controller, ControlPacket::Arm(true)).await?;
+    //println!("armed flipper");
+
+    //let (auto_tx, mut auto_rx) = mpsc::channel(1);
+    //let mut auto = None;
+
+    //auto = Some(spawn(seek))
+
     loop {
         let mut control = ControlPacket::Stop;
 
@@ -92,6 +99,14 @@ async fn controller(mut notes: mpsc::Receiver<(Option<pitch_detection::Pitch<f32
         let (note,vol) = note.context("channel closed")?;
         if let Some(note) = note {
             dbg!(note.frequency);
+            if note.frequency < 300. {
+                println!("too low");
+                continue;
+            }
+            if note.frequency > 600. {
+                println!("too high");
+                continue;
+            }
             //dbg!(note.clarity);
             //dbg!(vol);
             let note = Note::from_freq(note.frequency, Tuning::EqualTemperament);
@@ -112,31 +127,38 @@ async fn controller(mut notes: mpsc::Receiver<(Option<pitch_detection::Pitch<f32
                     println!("left");
                     control = ControlPacket::Twist(0.0, -1.0);
                 }
-                Pitch { letter: NoteLetter::G, accidental: 0}  => {
+                Pitch { letter: NoteLetter::G, accidental: 0|1}  => {
                     println!("fire");
                     control = ControlPacket::Fire;
                 }
-                Pitch { letter: NoteLetter::E, accidental: 0}  => {
-                    println!("e");
-                }
                 Pitch { letter: NoteLetter::F, accidental: 1}  => {
-                    println!("fire");
-                    control = ControlPacket::FireOverride(1.0);
+                    println!("stop flat");
+                    control = ControlPacket::Stop;
+                }
+                Pitch { letter: NoteLetter::F, accidental: 0}  => {
+                    println!("stop");
+                    control = ControlPacket::Stop;
+                }
+                Pitch { letter: NoteLetter::E, accidental: 0}  => {
+                    println!("stop");
+                    control = ControlPacket::Stop;
+                    //if let result::Result::Ok(command) = auto_rx.try_recv() {
+                    //    control = command;
+                    //}
                 }
                 pitch => {
                     if vol > 3000. {
-                        println!("fire");
-                        control = ControlPacket::FireOverride(1.0);
+                        println!("rly loud");
+                        //control = ControlPacket::FireOverride(1.0);
                     } else {
                         dbg!(pitch);
                     }
                 }
             }
 
-
             send_packet(&mut controller, control).await?;
         } else {
-            send_packet(&mut controller, ControlPacket::Stop).await?;
+            send_packet(&mut controller, ControlPacket::Twist(0.0, 0.0)).await?;
         }
     }
 }
@@ -148,3 +170,15 @@ async fn send_packet(controller: &mut BufWriter<OwnedWriteHalf>, control: Contro
     controller.flush().await?;
     Ok(())
 }
+
+//async fn seek(data: TelemetryPacket) -> Result<()>{
+//
+//    let left_tof = data.sensors.tof1.context("missing tof1")?;
+//    let right_tof = data.sensors.tof2.context("missing tof2")?;
+//
+//    /// Distance (mm) where both tofs point at the same thing
+//    const CONVERGANCE_DISTANCE: u16 = 80;
+//    const DETECT_DISTANCE: u16 = 380;
+//
+//
+//}