display state

src/main.rs

@@ -43,9 +43,122 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
 }
 
 enum SegmentState {
-    Num(u8),
+    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::Off => (),
+        }
+    }
+}
+
+struct DispalyState(pub [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 DispalyState {
+    fn scan(&self, dp: &mut DispalyPins, seg: &mut SegmentPins) {
+        dp.scan(|no| {
+            self.0[no].apply(seg);
+        })
+    }
 }
 
 struct SegmentPins {
@@ -96,12 +209,29 @@ impl SegmentPins {
         self.kd_seg_dp.set_high();
     }
 
-    fn set_a(&mut self, state: bool) {
+    fn set_a(&mut self) {
-        if state {
+        self.kd_seg_a.set_low();
-            self.kd_seg_a.set_low();
+    }
-        } else {
+    fn set_b(&mut self) {
-            self.kd_seg_a.set_high();
+        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();
     }
 }
 
@@ -134,9 +264,9 @@ impl DispalyPins {
 
     fn scan(&mut self, mut segment: impl FnMut(usize) -> ()) {
         for (no, d) in self.0.iter_mut().enumerate() {
-            d.set_high();
             segment(no);
-            arduino_hal::delay_ms(100);
+            d.set_high();
+            arduino_hal::delay_ms(1);
             d.set_low();
         }
     }
@@ -167,7 +297,7 @@ fn main() -> ! {
         pins.d12.into_output(),
     );
 
-    let mut seg = SegmentPins::new(
+    let mut sp = SegmentPins::new(
         pins.d5.into_output(),
         pins.d8.into_output(),
         pins.d10.into_output(),
@@ -178,11 +308,20 @@ fn main() -> ! {
         pins.a4.into_output(),
     );
 
+    let mut display = DispalyState::default();
+    display.0[0] = SegmentState::Num(0, true);
+    display.0[1] = SegmentState::Num(1, false);
+    display.0[2] = SegmentState::Num(2, false);
+    display.0[3] = SegmentState::Num(3, false);
+    display.0[4] = SegmentState::Num(4, false);
+    display.0[5] = SegmentState::Num(5, false);
+    display.0[6] = SegmentState::Num(6, false);
+    display.0[7] = SegmentState::Num(7, false);
+    display.0[8] = SegmentState::Num(8, false);
+
     loop {
-        dp.scan(|no| {
+        display.scan(&mut dp, &mut sp);
-            seg.set_a(true);
+        arduino_hal::delay_ms(10);
-        });
-        arduino_hal::delay_ms(200);
     }
 
     // loop {