new segment state

src/display.rs

@@ -82,136 +82,183 @@ impl SegmentPins {
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
-pub enum SegmentState {
+pub struct Segment {
-    Off,
+    a: bool,
-    Num(u8, bool),
+    b: bool,
-    Minus,
+    c: bool,
-    Prompt(bool),
+    d: bool,
-    Dot,
+    e: bool,
-    E,
+    f: bool,
+    g: bool,
+    dp: bool,
 }
 
-impl SegmentState {
+impl Segment {
-    pub fn apply(&self, seg: &mut SegmentPins) {
+    pub fn new() -> Segment {
-        seg.set_off();
+        Segment {
-        match self {
+            a: false,
-            SegmentState::Off => (),
+            b: false,
-            SegmentState::Num(no, dp) => {
+            c: false,
-                match no {
+            d: false,
-                    0 => {
+            e: false,
-                        seg.set_a();
+            f: false,
-                        seg.set_b();
+            g: false,
-                        seg.set_c();
+            dp: false,
-                        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!("SegmentState::Num out of range"),
-                }
-                if *dp {
-                    seg.set_dp()
-                }
-            }
-            SegmentState::Minus => seg.set_g(),
-            SegmentState::Dot => seg.set_dp(),
-            SegmentState::Prompt(dot) => {
-                seg.set_d();
-                if *dot {
-                    seg.set_dp()
-                }
-            }
-            SegmentState::E => {
-                seg.set_a();
-                seg.set_d();
-                seg.set_e();
-                seg.set_f();
-                seg.set_g();
-            }
         }
     }
-}
 
-pub struct DispalyState([SegmentState; DISPLAY_SEGMENTS]);
+    pub fn apply(&self, seg: &mut SegmentPins) {
+        seg.set_off();
+        if self.a {
+            seg.set_a();
+        }
+        if self.b {
+            seg.set_b();
+        }
+        if self.c {
+            seg.set_c();
+        }
+        if self.d {
+            seg.set_d();
+        }
+        if self.e {
+            seg.set_e();
+        }
+        if self.f {
+            seg.set_f();
+        }
+        if self.g {
+            seg.set_g();
+        }
+        if self.dp {
+            seg.set_dp();
+        }
+    }
 
-impl Default for DispalyState {
+    pub fn off(&mut self) -> &mut Self {
-    fn default() -> DispalyState {
+        self.a = false;
-        DispalyState([
+        self.b = false;
-            SegmentState::Off,
+        self.c = false;
-            SegmentState::Off,
+        self.d = false;
-            SegmentState::Off,
+        self.e = false;
-            SegmentState::Off,
+        self.f = false;
-            SegmentState::Off,
+        self.g = false;
-            SegmentState::Off,
+        self.dp = false;
-            SegmentState::Off,
+        self
-            SegmentState::Off,
+    }
-            SegmentState::Off,
+
-        ])
+    pub fn num(&mut self, no: u8) -> &mut Self {
+        match no {
+            0 => {
+                self.a = true;
+                self.b = true;
+                self.c = true;
+                self.d = true;
+                self.e = true;
+                self.f = true;
+            }
+            1 => {
+                self.b = true;
+                self.c = true;
+            }
+            2 => {
+                self.a = true;
+                self.b = true;
+                self.g = true;
+                self.e = true;
+                self.d = true;
+            }
+            3 => {
+                self.a = true;
+                self.b = true;
+                self.g = true;
+                self.c = true;
+                self.d = true;
+            }
+            4 => {
+                self.f = true;
+                self.g = true;
+                self.b = true;
+                self.c = true;
+            }
+            5 => {
+                self.a = true;
+                self.f = true;
+                self.g = true;
+                self.c = true;
+                self.d = true;
+            }
+            6 => {
+                self.a = true;
+                self.f = true;
+                self.g = true;
+                self.c = true;
+                self.d = true;
+                self.e = true;
+            }
+            7 => {
+                self.a = true;
+                self.b = true;
+                self.c = true;
+            }
+            8 => {
+                self.a = true;
+                self.b = true;
+                self.c = true;
+                self.d = true;
+                self.e = true;
+                self.f = true;
+                self.g = true;
+            }
+            9 => {
+                self.a = true;
+                self.b = true;
+                self.c = true;
+                self.d = true;
+                self.f = true;
+                self.g = true;
+            }
+            _ => panic!("Num out of range"),
+        }
+        self
+    }
+
+    pub fn dp(&mut self) -> &mut Self {
+        self.dp = true;
+        self
+    }
+
+    pub fn minus(&mut self) -> &mut Self {
+        self.g = true;
+        self
+    }
+
+    pub fn prompt(&mut self) -> &mut Self {
+        self.d = true;
+        self
+    }
+
+    pub fn e(&mut self) -> &mut Self {
+        self.a = true;
+        self.d = true;
+        self.e = true;
+        self.f = true;
+        self.g = true;
+        self
     }
 }
 
+impl Default for Segment {
+    fn default() -> Self {
+        Segment::new()
+    }
+}
+
+#[derive(Default)]
+pub struct DispalyState([Segment; DISPLAY_SEGMENTS]);
+
 impl Index<usize> for DispalyState {
-    type Output = SegmentState;
+    type Output = Segment;
 
     fn index(&self, index: usize) -> &Self::Output {
         &self.0[index]
@@ -225,50 +272,32 @@ impl IndexMut<usize> for DispalyState {
 }
 
 impl DispalyState {
-    pub fn iter_segments(&self) -> impl Iterator<Item = &SegmentState> {
+    pub fn iter_segments(&self) -> impl Iterator<Item = &Segment> {
         self.0.iter()
     }
+
+    pub fn iter_segments_mut(&mut self) -> impl Iterator<Item = &mut Segment> {
+        self.0.iter_mut()
+    }
 }
 
 impl DispalyState {
-    fn set(&mut self, seg: [SegmentState; DISPLAY_SEGMENTS]) {
+    pub fn off(&mut self) {
-        self.0 = seg;
+        for seg in self.iter_segments_mut() {
-    }
+            seg.off();
-
+        }
-    pub fn empty(&mut self) {
-        self.set([
-            SegmentState::Off,
-            SegmentState::Dot,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-            SegmentState::Off,
-        ])
-    }
-
-    pub fn prompt(&mut self, segment: usize) {
-        self[segment] = if segment == 1 {
-            SegmentState::Prompt(true)
-        } else {
-            SegmentState::Prompt(false)
-        };
     }
 
     pub fn error(&mut self) {
-        self.set([
+        self[0].off();
-            SegmentState::Off,
+        self[1].off();
-            SegmentState::Off,
+        self[2].off();
-            SegmentState::Off,
+        self[3].off().minus();
-            SegmentState::Minus,
+        self[4].off().e();
-            SegmentState::E,
+        self[5].off().minus();
-            SegmentState::Minus,
+        self[6].off();
-            SegmentState::Off,
+        self[7].off();
-            SegmentState::Off,
+        self[8].off();
-            SegmentState::Off,
-        ])
     }
 }
 

src/main.rs

@@ -9,7 +9,7 @@ use calc_math::{
     calc::{StackCalc, StackCalcError},
     Decimal,
 };
-use display::{DispalyState, SegmentPins, SegmentState, Show};
+use display::{DispalyState, SegmentPins, Show};
 use keyboard::{Debounce, KeyPress, KeyReadout, Keyboard};
 
 use arduino_hal::{
@@ -190,28 +190,24 @@ impl NumberInput {
 
 impl Show for NumberInput {
     fn show(&self, display: &mut DispalyState) {
-        display.empty();
+        display.off();
+        display[1].dp();
         if !self.enter_exponent && self.significant_pos < DISPLAY_SEGMENTS_SIG {
-            display.prompt(self.significant_pos + 1);
+            display[self.significant_pos + 1].prompt();
         } else if self.enter_exponent && self.exponent_pos < DISPLAY_SEGMENTS_EXP {
-            display.prompt(DISPLAY_SEGMENTS_SIG + 2 + self.exponent_pos);
+            display[DISPLAY_SEGMENTS_SIG + 2 + self.exponent_pos].prompt();
+        }
+        if self.minus {
+            display[DISPLAY_SEGMENT_SIG_MINUS].minus();
         }
-        display[DISPLAY_SEGMENT_SIG_MINUS] = if self.minus {
-            SegmentState::Minus
-        } else {
-            SegmentState::Off
-        };
         for i in 0..self.significant_pos {
-            display[DISPLAY_SEGMENT_SIG_MINUS + 1 + i] =
+            display[DISPLAY_SEGMENT_SIG_MINUS + 1 + i].num(self.significant[i]);
-                SegmentState::Num(self.significant[i], i == 0);
+        }
+        if self.minus_exponent {
+            display[DISPLAY_SEGMENT_EXP_MINUS].minus();
         }
-        display[DISPLAY_SEGMENT_EXP_MINUS] = if self.minus_exponent {
-            SegmentState::Minus
-        } else {
-            SegmentState::Off
-        };
         for i in 0..self.exponent_pos {
-            display[DISPLAY_SEGMENT_EXP_MINUS + 1 + i] = SegmentState::Num(self.exponent[i], false);
+            display[DISPLAY_SEGMENT_EXP_MINUS + 1 + i].num(self.exponent[i]);
         }
     }
 }