factored out display file

src/display.rs

@@ -0,0 +1,239 @@
+use core::ops::{Index, IndexMut};
+
+use arduino_hal::{
+    hal::port::{PB0, PB1, PB2, PC0, PC4, PC5, PD5, PD6},
+    port::{mode::Output, Pin},
+};
+
+pub 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 {
+    pub 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
+    }
+
+    pub 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();
+    }
+
+    pub fn set_a(&mut self) {
+        self.kd_seg_a.set_low();
+    }
+    pub fn set_b(&mut self) {
+        self.kd_seg_b.set_low();
+    }
+    pub fn set_c(&mut self) {
+        self.kd_seg_c.set_low();
+    }
+    pub fn set_d(&mut self) {
+        self.kd_seg_d.set_low();
+    }
+    pub fn set_e(&mut self) {
+        self.kd_seg_e.set_low();
+    }
+    pub fn set_f(&mut self) {
+        self.kd_seg_f.set_low();
+    }
+    pub fn set_g(&mut self) {
+        self.kd_seg_g.set_low();
+    }
+    pub fn set_dp(&mut self) {
+        self.kd_seg_dp.set_low();
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum SegmentState {
+    Num(u8, bool),
+    Minus,
+    Dot,
+    Off,
+}
+
+impl SegmentState {
+    pub fn apply(&self, seg: &mut SegmentPins) {
+        seg.set_off();
+        match self {
+            SegmentState::Num(no, dp) => {
+                match no {
+                    0 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_c();
+                        seg.set_d();
+                        seg.set_e();
+                        seg.set_f();
+                    }
+                    1 => {
+                        seg.set_b();
+                        seg.set_c();
+                    }
+                    2 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_g();
+                        seg.set_e();
+                        seg.set_d();
+                    }
+                    3 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_g();
+                        seg.set_c();
+                        seg.set_d();
+                    }
+                    4 => {
+                        seg.set_f();
+                        seg.set_g();
+                        seg.set_b();
+                        seg.set_c();
+                    }
+                    5 => {
+                        seg.set_a();
+                        seg.set_f();
+                        seg.set_g();
+                        seg.set_c();
+                        seg.set_d();
+                    }
+                    6 => {
+                        seg.set_a();
+                        seg.set_f();
+                        seg.set_g();
+                        seg.set_c();
+                        seg.set_d();
+                        seg.set_e();
+                    }
+                    7 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_c();
+                    }
+                    8 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_c();
+                        seg.set_d();
+                        seg.set_e();
+                        seg.set_f();
+                        seg.set_g();
+                    }
+                    9 => {
+                        seg.set_a();
+                        seg.set_b();
+                        seg.set_c();
+                        seg.set_d();
+                        seg.set_f();
+                        seg.set_g();
+                    }
+                    _ => panic!("Can't dispaly {}", no),
+                }
+                if *dp {
+                    seg.set_dp()
+                }
+            }
+            SegmentState::Minus => seg.set_g(),
+            SegmentState::Dot => seg.set_dp(),
+            SegmentState::Off => (),
+        }
+    }
+}
+
+pub struct DispalyState([SegmentState; 9]);
+
+impl Default for DispalyState {
+    fn default() -> DispalyState {
+        DispalyState([
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+        ])
+    }
+}
+
+impl Index<usize> for DispalyState {
+    type Output = SegmentState;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+impl IndexMut<usize> for DispalyState {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.0[index]
+    }
+}
+
+impl DispalyState {
+    pub fn iter_segments(&self) -> impl Iterator<Item = &SegmentState> {
+        self.0.iter()
+    }
+}
+
+impl DispalyState {
+    fn set(&mut self, seg: [SegmentState; 9]) {
+        self.0 = seg;
+    }
+
+    fn busy(&mut self) {
+        self.set([
+            SegmentState::Off,
+            SegmentState::Dot,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+            SegmentState::Off,
+        ])
+    }
+}
+
+// Show data on segment display
+pub trait Show {
+    fn show(&self, display: &mut DispalyState);
+}

src/main.rs

@@ -1,18 +1,16 @@
 #![no_std]
 #![no_main]
 
+mod display;
 mod keyboard;
 
-use calc_math::calc::StackCalc;
+use calc_math::{calc::StackCalc, Decimal};
-use calc_math::Decimal;
+use display::{DispalyState, SegmentPins, SegmentState, Show};
-use core::ops::{Index, IndexMut};
 use keyboard::{Debounce, KeyPress, KeyReadout, Keyboard};
 
 use arduino_hal::{
     adc::channel::{ADC6, ADC7},
-    hal::port::{
+    hal::port::{PB3, PB4, PC1, PC2, PC3, PD2, PD3, PD4, PD7},
-        PB0, PB1, PB2, PB3, PB4, PC0, PC1, PC2, PC3, PC4, PC5, PD2, PD3, PD4, PD5, PD6, PD7,
-    },
     port::{mode::Output, Pin},
     prelude::*,
     Adc,
@@ -57,80 +55,6 @@ 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 IOSelect<'p> {
     display_no: usize,
     pin: &'p mut Pin<Output>,
@@ -184,156 +108,8 @@ impl IOPins {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum SegmentState {
-    Num(u8, bool),
-    Minus,
-    Dot,
-    Off,
-}
-
-impl SegmentState {
-    fn apply(&self, seg: &mut SegmentPins) {
-        seg.set_off();
-        match self {
-            SegmentState::Num(no, dp) => {
-                match no {
-                    0 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_c();
-                        seg.set_d();
-                        seg.set_e();
-                        seg.set_f();
-                    }
-                    1 => {
-                        seg.set_b();
-                        seg.set_c();
-                    }
-                    2 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_g();
-                        seg.set_e();
-                        seg.set_d();
-                    }
-                    3 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_g();
-                        seg.set_c();
-                        seg.set_d();
-                    }
-                    4 => {
-                        seg.set_f();
-                        seg.set_g();
-                        seg.set_b();
-                        seg.set_c();
-                    }
-                    5 => {
-                        seg.set_a();
-                        seg.set_f();
-                        seg.set_g();
-                        seg.set_c();
-                        seg.set_d();
-                    }
-                    6 => {
-                        seg.set_a();
-                        seg.set_f();
-                        seg.set_g();
-                        seg.set_c();
-                        seg.set_d();
-                        seg.set_e();
-                    }
-                    7 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_c();
-                    }
-                    8 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_c();
-                        seg.set_d();
-                        seg.set_e();
-                        seg.set_f();
-                        seg.set_g();
-                    }
-                    9 => {
-                        seg.set_a();
-                        seg.set_b();
-                        seg.set_c();
-                        seg.set_d();
-                        seg.set_f();
-                        seg.set_g();
-                    }
-                    _ => panic!("Can't dispaly {}", no),
-                }
-                if *dp {
-                    seg.set_dp()
-                }
-            }
-            SegmentState::Minus => seg.set_g(),
-            SegmentState::Dot => seg.set_dp(),
-            SegmentState::Off => (),
-        }
-    }
-}
-
-struct DispalyState([SegmentState; 9]);
-
-impl Default for DispalyState {
-    fn default() -> DispalyState {
-        DispalyState([
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-        ])
-    }
-}
-
-impl Index<usize> for DispalyState {
-    type Output = SegmentState;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        &self.0[index]
-    }
-}
-
-impl IndexMut<usize> for DispalyState {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        &mut self.0[index]
-    }
-}
-
-impl DispalyState {
-    fn set(&mut self, seg: [SegmentState; 9]) {
-        self.0 = seg;
-    }
-
-    fn busy(&mut self) {
-        self.set([
-            SegmentState::Off,
-            SegmentState::Dot,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-        ])
-    }
-}
-
 #[derive(Default)]
-struct NumberInput {
+pub struct NumberInput {
     minus: bool,
     significant: [u8; 5],
     minus_exponent: bool,
@@ -344,10 +120,11 @@ struct NumberInput {
 }
 
 impl NumberInput {
-    fn reset(&mut self) {
+    pub fn reset(&mut self) {
         *self = Self::default();
     }
-    fn input_significant(&mut self, val: u8) -> Result<(), ()> {
+
+    pub fn input_significant(&mut self, val: u8) -> Result<(), ()> {
         if val > 9 {
             panic!("Bad significatn val");
         }
@@ -359,7 +136,7 @@ impl NumberInput {
         return Ok(());
     }
 
-    fn input_exponent(&mut self, val: u8) -> Result<(), ()> {
+    pub fn input_exponent(&mut self, val: u8) -> Result<(), ()> {
         if val > 9 {
             panic!("Bad exponent val");
         }
@@ -371,7 +148,7 @@ impl NumberInput {
         Ok(())
     }
 
-    fn input(&mut self, val: u8) -> Result<(), ()> {
+    pub fn input(&mut self, val: u8) -> Result<(), ()> {
         if self.enter_exponent {
             self.input_exponent(val)
         } else {
@@ -379,13 +156,13 @@ impl NumberInput {
         }
     }
 
-    fn toggle_enter_exponent(&mut self) {
+    pub fn toggle_enter_exponent(&mut self) {
         self.significant_pos = 0;
         self.exponent_pos = 0;
         self.enter_exponent = !self.enter_exponent;
     }
 
-    fn toggle_minus(&mut self) {
+    pub fn toggle_minus(&mut self) {
         if self.enter_exponent {
             self.minus_exponent = !self.minus_exponent;
         } else {
@@ -393,7 +170,7 @@ impl NumberInput {
         }
     }
 
-    fn to_decimal(&self) -> Decimal<5, u8> {
+    pub fn to_decimal(&self) -> Decimal<5, u8> {
         Decimal::new(
             self.minus,
             self.significant,
@@ -402,7 +179,7 @@ impl NumberInput {
         )
     }
 
-    fn set_decimal(&mut self, dec: Decimal<5, u8>) {
+    pub fn set_decimal(&mut self, dec: Decimal<5, u8>) {
         let (minus, significant, minus_exponent, exponent) = dec.into_parts();
         self.minus = minus;
         self.significant = significant;
@@ -412,11 +189,6 @@ impl NumberInput {
     }
 }
 
-// Show data on segment display
-trait Show {
-    fn show(&self, display: &mut DispalyState);
-}
-
 impl Show for NumberInput {
     fn show(&self, display: &mut DispalyState) {
         display[0] = if self.minus {
@@ -492,7 +264,7 @@ fn main() -> ! {
 
     loop {
         let mut last_key_readout: Option<KeyReadout> = None;
-        for (mut io_select, ss) in io.iter_mut().zip(display.0.iter()) {
+        for (mut io_select, ss) in io.iter_mut().zip(display.iter_segments()) {
             ss.apply(&mut seg);
             io_select.set_on();
             arduino_hal::delay_ms(1);