diff --git a/src/main.rs b/src/main.rs
index 287b05c..4555252 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,11 +2,13 @@
 #![no_main]
 
 use arduino_hal::{
+    adc::channel::{ADC6, ADC7},
     hal::port::{
         PB0, PB1, PB2, PB3, PB4, PC0, PC1, PC2, PC3, PC4, PC5, PD2, PD3, PD4, PD5, PD6, PD7,
     },
     port::{mode::Output, Pin},
     prelude::*,
+    Adc,
 };
 
 // NOTE: 115200 @ 16MHz is 3.5% off, try 9600 or 1M if it causes issues (https://wormfood.net/avrbaudcalc.php)
@@ -42,6 +44,127 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
     }
 }
 
+struct SegmentPins {
+    kd_seg_a: Pin<Output, PD5>,
+    kd_seg_b: Pin<Output, PB0>,
+    kd_seg_c: Pin<Output, PB2>,
+    kd_seg_d: Pin<Output, PC5>,
+    kd_seg_e: Pin<Output, PB1>,
+    kd_seg_f: Pin<Output, PD6>,
+    kd_seg_g: Pin<Output, PC0>,
+    kd_seg_dp: Pin<Output, PC4>,
+}
+
+impl SegmentPins {
+    fn new(
+        kd_seg_a: Pin<Output, PD5>,
+        kd_seg_b: Pin<Output, PB0>,
+        kd_seg_c: Pin<Output, PB2>,
+        kd_seg_d: Pin<Output, PC5>,
+        kd_seg_e: Pin<Output, PB1>,
+        kd_seg_f: Pin<Output, PD6>,
+        kd_seg_g: Pin<Output, PC0>,
+        kd_seg_dp: Pin<Output, PC4>,
+    ) -> SegmentPins {
+        let mut out = SegmentPins {
+            kd_seg_a,
+            kd_seg_b,
+            kd_seg_c,
+            kd_seg_d,
+            kd_seg_e,
+            kd_seg_f,
+            kd_seg_g,
+            kd_seg_dp,
+        };
+
+        out.set_off();
+        out
+    }
+
+    fn set_off(&mut self) {
+        self.kd_seg_a.set_high();
+        self.kd_seg_b.set_high();
+        self.kd_seg_c.set_high();
+        self.kd_seg_d.set_high();
+        self.kd_seg_e.set_high();
+        self.kd_seg_f.set_high();
+        self.kd_seg_g.set_high();
+        self.kd_seg_dp.set_high();
+    }
+
+    fn set_a(&mut self) {
+        self.kd_seg_a.set_low();
+    }
+    fn set_b(&mut self) {
+        self.kd_seg_b.set_low();
+    }
+    fn set_c(&mut self) {
+        self.kd_seg_c.set_low();
+    }
+    fn set_d(&mut self) {
+        self.kd_seg_d.set_low();
+    }
+    fn set_e(&mut self) {
+        self.kd_seg_e.set_low();
+    }
+    fn set_f(&mut self) {
+        self.kd_seg_f.set_low();
+    }
+    fn set_g(&mut self) {
+        self.kd_seg_g.set_low();
+    }
+    fn set_dp(&mut self) {
+        self.kd_seg_dp.set_low();
+    }
+}
+
+struct IOPins([Pin<Output>; 9]);
+
+impl IOPins {
+    fn new(
+        kd_d1_1c: Pin<Output, PD2>,
+        kd_d2_5div: Pin<Output, PD3>,
+        kd_d3_6mul: Pin<Output, PD4>,
+        kd_d4_7up: Pin<Output, PC3>,
+        kd_d5_8e: Pin<Output, PC2>,
+        kd_d6_90: Pin<Output, PD7>,
+        kd_d7_2down: Pin<Output, PC1>,
+        kd_d8_3plus: Pin<Output, PB3>,
+        kd_d9_4min: Pin<Output, PB4>,
+    ) -> IOPins {
+        IOPins([
+            kd_d1_1c.downgrade(),
+            kd_d2_5div.downgrade(),
+            kd_d3_6mul.downgrade(),
+            kd_d4_7up.downgrade(),
+            kd_d5_8e.downgrade(),
+            kd_d6_90.downgrade(),
+            kd_d7_2down.downgrade(),
+            kd_d8_3plus.downgrade(),
+            kd_d9_4min.downgrade(),
+        ])
+    }
+
+    fn scan_output(&mut self, mut segment: impl FnMut(usize) -> ()) {
+        for (no, d) in self.0.iter_mut().enumerate() {
+            segment(no);
+            d.set_high();
+            arduino_hal::delay_ms(1);
+            d.set_low();
+        }
+    }
+
+    fn scan_input(&mut self, mut segment: impl FnMut(usize) -> ()) {
+        for (no, d) in self.0.iter_mut().enumerate() {
+            d.set_high();
+            arduino_hal::delay_ms(1);
+            segment(no);
+            arduino_hal::delay_ms(1);
+            d.set_low();
+        }
+    }
+}
+
 enum SegmentState {
     Num(u8, bool),
     Minus,
@@ -154,122 +277,35 @@ impl Default for DispalyState {
 }
 
 impl DispalyState {
-    fn scan(&self, dp: &mut DispalyPins, seg: &mut SegmentPins) {
-        dp.scan(|no| {
+    fn scan(&self, dp: &mut IOPins, seg: &mut SegmentPins) {
+        dp.scan_output(|no| {
             self.0[no].apply(seg);
-        })
+        });
+        seg.set_off();
     }
 }
 
-struct SegmentPins {
-    kd_seg_a: Pin<Output, PD5>,
-    kd_seg_b: Pin<Output, PB0>,
-    kd_seg_c: Pin<Output, PB2>,
-    kd_seg_d: Pin<Output, PC5>,
-    kd_seg_e: Pin<Output, PB1>,
-    kd_seg_f: Pin<Output, PD6>,
-    kd_seg_g: Pin<Output, PC0>,
-    kd_seg_dp: Pin<Output, PC4>,
+struct Input<KN, KO> {
+    kn: KN,
+    ko: KO,
 }
 
-impl SegmentPins {
-    fn new(
-        kd_seg_a: Pin<Output, PD5>,
-        kd_seg_b: Pin<Output, PB0>,
-        kd_seg_c: Pin<Output, PB2>,
-        kd_seg_d: Pin<Output, PC5>,
-        kd_seg_e: Pin<Output, PB1>,
-        kd_seg_f: Pin<Output, PD6>,
-        kd_seg_g: Pin<Output, PC0>,
-        kd_seg_dp: Pin<Output, PC4>,
-    ) -> SegmentPins {
-        let mut out = SegmentPins {
-            kd_seg_a,
-            kd_seg_b,
-            kd_seg_c,
-            kd_seg_d,
-            kd_seg_e,
-            kd_seg_f,
-            kd_seg_g,
-            kd_seg_dp,
-        };
+impl<KN, KO> Input<KN, KO> {
+    fn new(kn: KN, ko: KO) -> Input<KN, KO> {
+        Input { kn, ko }
+    }
 
-        out.set_off();
+    fn scan(&self, io: &mut IOPins, adc: &mut Adc) -> Option<(usize, u16, u16)> {
+        let mut out = None;
+        io.scan_input(|no| {
+            let kn = adc.read_blocking(&ADC7);
+            let ko = adc.read_blocking(&ADC6);
+            if kn > 500 || ko > 500 {
+                out = Some((no, kn, ko));
+            }
+        });
         out
     }
-
-    fn set_off(&mut self) {
-        self.kd_seg_a.set_high();
-        self.kd_seg_b.set_high();
-        self.kd_seg_c.set_high();
-        self.kd_seg_d.set_high();
-        self.kd_seg_e.set_high();
-        self.kd_seg_f.set_high();
-        self.kd_seg_g.set_high();
-        self.kd_seg_dp.set_high();
-    }
-
-    fn set_a(&mut self) {
-        self.kd_seg_a.set_low();
-    }
-    fn set_b(&mut self) {
-        self.kd_seg_b.set_low();
-    }
-    fn set_c(&mut self) {
-        self.kd_seg_c.set_low();
-    }
-    fn set_d(&mut self) {
-        self.kd_seg_d.set_low();
-    }
-    fn set_e(&mut self) {
-        self.kd_seg_e.set_low();
-    }
-    fn set_f(&mut self) {
-        self.kd_seg_f.set_low();
-    }
-    fn set_g(&mut self) {
-        self.kd_seg_g.set_low();
-    }
-    fn set_dp(&mut self) {
-        self.kd_seg_dp.set_low();
-    }
-}
-
-struct DispalyPins([Pin<Output>; 9]);
-
-impl DispalyPins {
-    fn new(
-        kd_d1_1c: Pin<Output, PD2>,
-        kd_d2_5div: Pin<Output, PD3>,
-        kd_d3_6mul: Pin<Output, PD4>,
-        kd_d4_7up: Pin<Output, PC3>,
-        kd_d5_8e: Pin<Output, PC2>,
-        kd_d6_90: Pin<Output, PD7>,
-        kd_d7_2down: Pin<Output, PC1>,
-        kd_d8_3plus: Pin<Output, PB3>,
-        kd_d9_4min: Pin<Output, PB4>,
-    ) -> DispalyPins {
-        DispalyPins([
-            kd_d1_1c.downgrade(),
-            kd_d2_5div.downgrade(),
-            kd_d3_6mul.downgrade(),
-            kd_d4_7up.downgrade(),
-            kd_d5_8e.downgrade(),
-            kd_d6_90.downgrade(),
-            kd_d7_2down.downgrade(),
-            kd_d8_3plus.downgrade(),
-            kd_d9_4min.downgrade(),
-        ])
-    }
-
-    fn scan(&mut self, mut segment: impl FnMut(usize) -> ()) {
-        for (no, d) in self.0.iter_mut().enumerate() {
-            segment(no);
-            d.set_high();
-            arduino_hal::delay_ms(1);
-            d.set_low();
-        }
-    }
 }
 
 #[arduino_hal::entry]
@@ -285,7 +321,7 @@ fn main() -> ! {
     // let mut kd_KN = pins..into_input();
     // let mut kd_KO = *pins.a.into_output();
 
-    let mut dp = DispalyPins::new(
+    let mut io = IOPins::new(
         pins.d2.into_output(),
         pins.d3.into_output(),
         pins.d4.into_output(),
@@ -297,7 +333,7 @@ fn main() -> ! {
         pins.d12.into_output(),
     );
 
-    let mut sp = SegmentPins::new(
+    let mut seg = SegmentPins::new(
         pins.d5.into_output(),
         pins.d8.into_output(),
         pins.d10.into_output(),
@@ -308,6 +344,9 @@ fn main() -> ! {
         pins.a4.into_output(),
     );
 
+    let mut adc = Adc::new(dp.ADC, Default::default());
+    let input = Input::new(ADC7, ADC6);
+
     let mut display = DispalyState::default();
     display.0[0] = SegmentState::Num(0, true);
     display.0[1] = SegmentState::Num(1, false);
@@ -320,8 +359,11 @@ fn main() -> ! {
     display.0[8] = SegmentState::Num(8, false);
 
     loop {
-        display.scan(&mut dp, &mut sp);
+        display.scan(&mut io, &mut seg);
         arduino_hal::delay_ms(10);
+        if let Some((no, kn, ko)) = input.scan(&mut io, &mut adc) {
+            ufmt::uwriteln!(&mut serial, "no: {} kn: {} ko: {}", no, kn, ko).unwrap_infallible();
+        }
     }
 
     // loop {