diff --git a/interface/src/main.rs b/interface/src/main.rs
index 2cd69bc..1addf0e 100644
--- a/interface/src/main.rs
+++ b/interface/src/main.rs
@@ -1,5 +1,5 @@
 #![feature(iter_collect_into)]
-use std::{result, sync::Arc, thread::sleep, time::Duration};
+use std::{ops::ControlFlow, result, sync::Arc, thread::sleep, time::Duration};
 
 use anyhow::{Context, Ok, Result};
 use common::{ControlPacket, TelemetryPacket};
@@ -99,60 +99,9 @@ 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);
-            match note.pitch {
-                Pitch { letter: NoteLetter::A, accidental: 0}  => {
-                    println!("forward");
-                    control = ControlPacket::Twist(1.0, 0.0);
-                }
-                Pitch { letter: NoteLetter::A, accidental: 1}  => {
-                    println!("backward");
-                    control = ControlPacket::Twist(-1.0, 0.0);
-                }
-                Pitch { letter: NoteLetter::C, accidental: 0}  => {
-                    println!("right");
-                    control = ControlPacket::Twist(0.0, 1.0);
-                }
-                Pitch { letter: NoteLetter::C, accidental: 1}  => {
-                    println!("left");
-                    control = ControlPacket::Twist(0.0, -1.0);
-                }
-                Pitch { letter: NoteLetter::G, accidental: 0|1}  => {
-                    println!("fire");
-                    control = ControlPacket::Fire;
-                }
-                Pitch { letter: NoteLetter::F, accidental: 1}  => {
-                    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!("rly loud");
-                        //control = ControlPacket::FireOverride(1.0);
-                    } else {
-                        dbg!(pitch);
-                    }
+            if let ControlFlow::Break(_) = sax_control(&mut control, vol, &note) {
+                if let ControlFlow::Break(_) = recorder_control(&mut control, vol, note) {
+                    continue;
                 }
             }
 
@@ -163,6 +112,117 @@ async fn controller(mut notes: mpsc::Receiver<(Option<pitch_detection::Pitch<f32
     }
 }
 
+fn sax_control(control: &mut ControlPacket, vol: f32, note: &pitch_detection::Pitch<f32>) -> ControlFlow<()> {
+    if note.frequency < 150. {
+        println!("too low");
+        return ControlFlow::Break(());
+    }
+    if note.frequency > 270. {
+        println!("too high");
+        return ControlFlow::Break(());
+    }
+    let note = Note::from_freq(note.frequency, Tuning::EqualTemperament);
+    //dbg!(note.clarity);
+    //dbg!(vol);
+    match note.pitch {
+        Pitch { letter: NoteLetter::C, accidental: 1}  => {
+            println!("forward");
+            *control = ControlPacket::Twist(1.0, 0.0);
+        }
+        //Pitch { letter: NoteLetter::A, accidental: 1}  => {
+        //    println!("backward");
+        //    *control = ControlPacket::Twist(-1.0, 0.0);
+        //}
+        Pitch { letter: NoteLetter::B, accidental: 0}  => {
+            println!("right");
+            *control = ControlPacket::Twist(0.0, 1.0);
+        }
+        Pitch { letter: NoteLetter::A, accidental: 0}  => {
+            println!("left");
+            *control = ControlPacket::Twist(0.0, -1.0);
+        }
+        Pitch { letter: NoteLetter::G, accidental: 1}  => {
+            println!("fire");
+            *control = ControlPacket::Fire;
+        }
+        Pitch { letter: NoteLetter::F, accidental: 1}  => {
+            println!("stop flat");
+            *control = ControlPacket::Stop;
+        }
+        pitch => {
+            if vol > 3000. {
+                println!("rly loud");
+                //control = ControlPacket::FireOverride(1.0);
+                dbg!(pitch);
+            } else {
+                dbg!(pitch);
+            }
+        }
+    }
+    ControlFlow::Continue(())
+}
+
+
+fn recorder_control(control: &mut ControlPacket, vol: f32, note: pitch_detection::Pitch<f32>) -> ControlFlow<()> {
+    if note.frequency < 300. {
+        println!("too low");
+        return ControlFlow::Break(());
+    }
+    if note.frequency > 600. {
+        println!("too high");
+        return ControlFlow::Break(());
+    }
+    let note = Note::from_freq(note.frequency, Tuning::EqualTemperament);
+    //dbg!(note.clarity);
+    //dbg!(vol);
+    match note.pitch {
+        Pitch { letter: NoteLetter::A, accidental: 0}  => {
+            println!("forward");
+            *control = ControlPacket::Twist(1.0, 0.0);
+        }
+        Pitch { letter: NoteLetter::A, accidental: 1}  => {
+            println!("backward");
+            *control = ControlPacket::Twist(-1.0, 0.0);
+        }
+        Pitch { letter: NoteLetter::C, accidental: 0}  => {
+            println!("right");
+            *control = ControlPacket::Twist(0.0, 1.0);
+        }
+        Pitch { letter: NoteLetter::C, accidental: 1}  => {
+            println!("left");
+            *control = ControlPacket::Twist(0.0, -1.0);
+        }
+        Pitch { letter: NoteLetter::G, accidental: 0|1}  => {
+            println!("fire");
+            *control = ControlPacket::Fire;
+        }
+        Pitch { letter: NoteLetter::F, accidental: 1}  => {
+            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!("rly loud");
+                //control = ControlPacket::FireOverride(1.0);
+            } else {
+                dbg!(pitch);
+            }
+        }
+    }
+    ControlFlow::Continue(())
+}
+
 async fn send_packet(controller: &mut BufWriter<OwnedWriteHalf>, control: ControlPacket) -> Result<(), anyhow::Error> {
     let control: heapless::Vec<u8, 2048> = postcard::to_vec(&control)?;
     controller.write_u32(control.len() as u32).await?;