linear dimming

src/display.rs

@@ -5,7 +5,7 @@ use arduino_hal::{
     port::{mode::Output, Pin},
 };
 
-use crate::DISPLAY_SEGMENTS;
+use crate::{DISPLAY_SEGMENTS, IO_SEGMENT_ON_MAX_US, IO_SEGMENT_ON_MIN_US};
 
 pub struct SegmentPins {
     kd_seg_a: Pin<Output, PD5>,
@@ -96,6 +96,16 @@ impl Brightness {
     pub const fn unwrap(self) -> u8 {
         self.0
     }
+
+    pub fn dimm(self, dimming: u8) -> Brightness {
+        Brightness(self.0.saturating_sub(dimming))
+    }
+
+    // Scales brightness (0-255) to range between IO_SEGMENT_ON_MIN_US and IO_SEGMENT_ON_MAX_US
+    pub fn scale_brightness(self) -> u32 {
+        // Using >> to avoid 32bit division which take ~576 cycles
+        IO_SEGMENT_ON_MIN_US + ((IO_SEGMENT_ON_MAX_US - IO_SEGMENT_ON_MIN_US) * self.0 as u32 >> 8)
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -106,8 +116,8 @@ impl Segment {
         Segment(0, Brightness::full())
     }
 
-    pub fn brightness(&mut self, b: u8) -> &mut Self {
-        self.1 = Brightness(b);
+    pub fn brightness(&mut self, b: Brightness) -> &mut Self {
+        self.1 = b;
         self
     }
 

src/main.rs

@@ -50,14 +50,11 @@ pub const IO_SEGMENT_RATE_US: u32 = 1000; // Time in μs between segment updates
 pub const IO_SEGMENT_ON_MIN_US: u32 = 80; // How long in μs to hold segment LEDs on (dark)
 pub const IO_SEGMENT_ON_MAX_US: u32 = 700; // How long in μs to hold segment LEDs on (bright)
 
-//TODO: When inline it is much slower due to use of Brightness instead of const 0xFF?!
-#[inline(never)]
-fn scale_brightness(b: Brightness) -> u32 {
-    assert_eq!((Brightness::full().unwrap() as u32), 0xFF);
-    IO_SEGMENT_ON_MIN_US
-        + (IO_SEGMENT_ON_MAX_US - IO_SEGMENT_ON_MIN_US) * b.unwrap() as u32
-            / (Brightness::full().unwrap() as u32)
-}
+// Dimming
+pub const DISPLAY_FPS: u16 = (1_000_000 / (IO_SEGMENT_RATE_US * DISPLAY_SEGMENTS as u32)) as u16;
+pub const DISPLAY_DIMM_FRAMES: u16 = DISPLAY_FPS * 10; // How many frames of inactivity before dimming
+pub const DISPLAY_DIMM_SPEED: u8 = 4; // Dimm by amount every frame when sleeping
+pub const DISPLAY_UNDIMM_SPEED: u8 = 16; // Brighten by amount every frame when not sleeping
 
 // Calculator setup
 pub const STACK_DEPTH: usize = 7;
@@ -91,9 +88,11 @@ fn access_global<'cs, 'v: 'cs, T, O>(
 #[avr_device::interrupt(atmega328p)]
 unsafe fn TIMER0_COMPA() {
     avr_device::interrupt::free(|cs| {
-        let brightness = access_global(&IO_LOOP, cs, |io_loop| io_loop.display_on());
-        access_global(&SEGMENT_TIMER, cs, |st| {
-            st.segment_on_time(scale_brightness(brightness))
+        access_global(&IO_LOOP, cs, |io_loop| {
+            access_global(&SEGMENT_TIMER, cs, |st| {
+                let brightness = io_loop.display_on();
+                st.segment_on_time(brightness.scale_brightness());
+            });
         });
     });
 }
@@ -115,24 +114,30 @@ unsafe fn TIMER0_COMPB() {
 
 pub struct IOLoop {
     index: usize,
+    frame: u16,
     io_pins: IOPins,
     segment_pins: SegmentPins,
     dispaly: DispalyState,
     keyboard: Keyboard,
     readount: Option<KeyReadout>,
     debounce: Debounce,
+    sleep_timer: u16,
+    dimming: u8,
 }
 
 impl IOLoop {
     pub fn new(io_pins: IOPins, segment_pins: SegmentPins, keyboard: Keyboard) -> IOLoop {
         IOLoop {
             index: 0,
+            frame: 0,
             io_pins,
             segment_pins,
             dispaly: Default::default(),
             keyboard,
             readount: None,
             debounce: Default::default(),
+            sleep_timer: 0,
+            dimming: u8::MAX,
         }
     }
 
@@ -151,22 +156,47 @@ impl IOLoop {
     pub fn advance(&mut self) -> Option<KeyPress> {
         self.index += 1;
         if self.index == self.io_pins.len() || self.index == self.dispaly.len() {
+            // Frame done
+            self.frame = self.frame.wrapping_add(1);
             // Start from first segment
             self.index = 0;
 
-            // Full keyboard scan complete, debounce and return result
-            self.debounce.input(self.readount.take())
+            // Full keyboard scan complete, debounce
+            let key = self.debounce.input(self.readount.take());
+
+            // Reset or advance sleep timer
+            if key.is_some() {
+                self.sleep_timer = 0;
+            } else {
+                self.sleep_timer = self.sleep_timer.saturating_add(1);
+            }
+
+            if self.is_sleep() {
+                self.dimming = self.dimming.saturating_add(DISPLAY_DIMM_SPEED);
+            } else {
+                self.dimming = self.dimming.saturating_sub(DISPLAY_UNDIMM_SPEED);
+            }
+
+            key
         } else {
             None
         }
     }
 
+    pub fn is_sleep(&self) -> bool {
+        self.sleep_timer >= DISPLAY_DIMM_FRAMES
+    }
+
+    pub fn dimming(&self) -> u8 {
+        self.dimming
+    }
+
     pub fn display_on(&mut self) -> Brightness {
         self.select_off();
         let segment = self.dispaly[self.index];
         let brighness = segment.apply(&mut self.segment_pins);
         self.select_on();
-        brighness
+        brighness.dimm(self.dimming)
     }
 
     pub fn display_off(&mut self) {
@@ -181,6 +211,10 @@ impl IOLoop {
         }
         self.select_off();
     }
+
+    pub fn frame(&self) -> (u16, usize) {
+        (self.frame, self.index)
+    }
 }
 
 #[derive(uDebug)]
@@ -603,11 +637,7 @@ fn main() -> ! {
                     .take(calc.len())
                 {
                     seg.dp();
-                }
-                for (no, seg) in display.slice(0, DISPLAY_SEGMENTS).iter_mut().enumerate() {
-                    seg.brightness(
-                        (no * (Brightness::full().unwrap() as usize) / DISPLAY_SEGMENTS) as u8,
-                    );
+                    seg.brightness(Brightness::full());
                 }
             }
             TransientState::Err { .. } => display.error(),
@@ -616,7 +646,7 @@ fn main() -> ! {
         avr_device::interrupt::free(|cs| {
             access_global(&IO_LOOP, cs, |io_loop| {
                 io_loop.update_display(&display);
-            });
+            })
         });
     }
 }

src/timer.rs

@@ -10,7 +10,9 @@ const fn us_to_ticks(us: u32) -> u32 {
 }
 
 // Timer 0 (8bit)
-pub struct SegmentTimer(TC0);
+pub struct SegmentTimer {
+    timer: TC0,
+}
 
 impl SegmentTimer {
     // Sets up timer to rise interrupts:
@@ -36,19 +38,17 @@ impl SegmentTimer {
         tc0.timsk0
             .write(|w| w.ocie0a().set_bit().ocie0b().set_bit());
 
-        SegmentTimer(tc0)
+        SegmentTimer { timer: tc0 }
     }
 
     // Set for how long the segment LEDs should be on in μs
     // Controls TIMER0_COMPB interrupt time after TIMER0_COMPA
     pub fn segment_on_time(&mut self, segment_on_us: u32) {
-        let ocrb = us_to_ticks(segment_on_us);
+        let delay: u8 = us_to_ticks(segment_on_us)
+            .try_into()
+            .expect("timer init segment_on_us out of rage");
+        let elapsed = self.timer.tcnt0.read().bits();
         // Set the compare value for B match
-        self.0.ocr0b.write(|w| {
-            w.bits(
-                ocrb.try_into()
-                    .expect("timer init segment_on_us out of rage"),
-            )
-        });
+        self.timer.ocr0b.write(|w| w.bits(elapsed + delay));
     }
 }