control word refactor

Author: nonik0

src/control.rs src/control_word.rs

@@ -6,21 +6,27 @@ pub const DEVICE_CHARS: usize = 4;
 pub struct ControlWord0(u8);
 
 impl ControlWord0 {
+    pub const WORD_SELECT_BIT: u8 = 0b1000_0000; // MSB is 1 for control word 1
     pub const WAKE_BIT: u8 = 0b0100_0000;
     pub const PEAK_CURRENT_MASK: u8 = 0b0011_0000;
     pub const BRIGHTNESS_MASK: u8 = 0b0000_1111;
+    pub const BRIGHTNESS_DEFAULT: u8 = 0b0000_1100;
 
     pub fn new() -> Self {
-        ControlWord0(0b0000_0000) // MSB is always 0
+        let mut word = ControlWord0(Self::WORD_SELECT_BIT); // MSB is always 0
+        word.set_brightness_bits(Self::BRIGHTNESS_DEFAULT);
+        word.set_peak_current_bits(PeakCurrent::default());
+        word.set_wake_bit(SleepMode::default());
+        word
     }
 
-    pub fn set_brightness_bits(&mut self, bits: u8) {
+    pub fn set_brightness_bits(&mut self, brightness: u8) {
         // just truncate the bits rather than enforce or check for a max value
-        self.0 = (self.0 & !Self::BRIGHTNESS_MASK) | (bits & Self::BRIGHTNESS_MASK);
+        self.0 = (self.0 & !Self::BRIGHTNESS_MASK) | (brightness & Self::BRIGHTNESS_MASK);
     }
 
-    pub fn set_peak_current_bits(&mut self, bits: PeakCurrent) {
-        self.0 = (self.0 & !Self::PEAK_CURRENT_MASK) | bits as u8;
+    pub fn set_peak_current_bits(&mut self, current: PeakCurrent) {
+        self.0 = (self.0 & !Self::PEAK_CURRENT_MASK) | current as u8;
     }
 
     pub fn set_wake_bit(&mut self, mode: SleepMode) {
@@ -37,6 +43,12 @@ pub enum SleepMode {
     Normal = 0b0100_0000,
 }
 
+impl Default for SleepMode {
+    fn default() -> Self {
+        SleepMode::Normal
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PeakCurrent {
     Max4_0Ma = 0b0010_0000,
@@ -45,35 +57,38 @@ pub enum PeakCurrent {
     Max12_8Ma = 0b0011_0000,
 }
 
-impl PeakCurrent {
-    pub fn bitmask(&self) -> u8 {
-        *self as u8
+// impl PeakCurrent {
+//     pub fn bitmask(&self) -> u8 {
+//         *self as u8
+//     }
+// }
+
+impl Default for PeakCurrent {
+    fn default() -> Self {
+        PeakCurrent::Max12_8Ma
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ControlWord1(u8);
 
 impl ControlWord1 {
+    pub const WORD_SELECT_BIT: u8 = 0b1000_0000; // MSB is 1 for control word 1
     pub const DATA_OUT_BIT: u8 = 0b0000_0001;
     pub const EXT_OSC_PRESCALER_BIT: u8 = 0b0000_0010;
 
     pub fn new() -> Self {
-        ControlWord1(0b1000_0000) // MSB is always 1
-    }
-
-    pub fn data_out_mode(&self) -> DataOutModeBit {
-        match self.0 & Self::DATA_OUT_BIT {
-            0 => DataOutModeBit::Serial,
-            _ => DataOutModeBit::Simultaneous,
-        }
+        let mut word = ControlWord1(Self::WORD_SELECT_BIT);
+        word.set_data_out_mode_bit(DataOutMode::default());
+        word.set_ext_osc_prescaler_bit(ExtOscPrescaler::default());
+        word
     }
 
-    pub fn set_data_out_mode_bit(&mut self, bit: DataOutModeBit) {
+    pub fn set_data_out_mode_bit(&mut self, bit: DataOutMode) {
         self.0 = (self.0 & !Self::DATA_OUT_BIT) | (bit as u8);
     }
 
-    pub fn set_ext_osc_prescaler_bit(&mut self, bit: ExtOscPrescalerBit) {
+    pub fn set_ext_osc_prescaler_bit(&mut self, bit: ExtOscPrescaler) {
         self.0 = (self.0 & !Self::EXT_OSC_PRESCALER_BIT) | (bit as u8);
     }
 
@@ -83,25 +98,25 @@ impl ControlWord1 {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DataOutModeBit {
+pub enum DataOutMode {
     Serial = 0b0000_0000,
     Simultaneous = 0b0000_0001,
 }
 
-impl Default for DataOutModeBit {
+impl Default for DataOutMode {
     fn default() -> Self {
-        DataOutModeBit::Serial
+        DataOutMode::Serial
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ExtOscPrescalerBit {
+pub enum ExtOscPrescaler {
     Clock1 = 0b0000_0000,
     Clock8 = 0b0000_0001,
 }
 
-impl Default for ExtOscPrescalerBit {
+impl Default for ExtOscPrescaler {
     fn default() -> Self {
-        ExtOscPrescalerBit::Clock1
+        ExtOscPrescaler::Clock1
     }
 }

src/lib.rs

@@ -1,9 +1,12 @@
 #![no_std]
 
-pub mod control;
+
+mod control_word;
 mod font5x7;
 
-use crate::control::*;
+pub use control_word::PeakCurrent;
+
+use control_word::*;
 use core::cell::RefCell;
 use embedded_hal::digital::{ErrorType, OutputPin};
 
@@ -46,7 +49,8 @@ pub struct Hcms29xx<
     reset: Option<RefCell<ResetPin>>,
     control_word_0: ControlWord0,
     control_word_1: ControlWord1,
-    data_out_mode: DataOutModeBit, // we keep track of just this to avoid more bookkeeping when updating local state of control word before updating
+    // state kept locally to simplify/reduce overall code size
+    data_out_mode: DataOutMode,
     font_ascii_start_index: u8,
 }
 
@@ -125,29 +129,29 @@ where
             reset: reset_ref_cell,
             control_word_0: ControlWord0::new(),
             control_word_1: ControlWord1::new(),
-            data_out_mode: DataOutModeBit::Serial,
+            data_out_mode: DataOutMode::Serial,
             font_ascii_start_index: font5x7::FONT5X7.load_at(0) - 1,
         })
     }
 
-    pub fn begin(&mut self) -> Result<(), Hcms29xxError<PinErr>> {
-        self.clear()?;
+    // pub fn begin(&mut self) -> Result<(), Hcms29xxError<PinErr>> {
+    //     self.clear()?;
 
-        self.update_control_word(
-            control::control_word_0::WAKE_BIT
-                | control::control_word_0::DEFAULT_CURRENT
-                | control::control_word_0::DEFAULT_BRIGHTNESS,
-        )?;
-        self.update_control_word(
-            control::CONTROL_WORD_SELECT_BIT | control::control_word_1::DEFAULT_DATA_OUT_MODE,
-        )?;
+    //     self.update_control_word(
+    //         control::control_word_0::WAKE_BIT
+    //             | control::control_word_0::DEFAULT_CURRENT
+    //             | control::control_word_0::DEFAULT_BRIGHTNESS,
+    //     )?;
+    //     self.update_control_word(
+    //         control::CONTROL_WORD_SELECT_BIT | control::control_word_1::DEFAULT_DATA_OUT_MODE,
+    //     )?;
 
-        Ok(())
-    }
+    //     Ok(())
+    // }
 
     pub fn clear(&mut self) -> Result<(), Hcms29xxError<PinErr>> {
         self.set_dot_data()?;
-        for _ in 0..NUM_CHARS * control::CHAR_WIDTH {
+        for _ in 0..NUM_CHARS * control_word::CHAR_WIDTH {
             self.send_byte(0x00)?;
         }
         self.end_transfer()?;
@@ -161,8 +165,8 @@ where
                 break;
             }
             let char_start_index: usize =
-                (c_str[i] - self.font_ascii_start_index) as usize * control::CHAR_WIDTH;
-            for j in 0..control::CHAR_WIDTH {
+                (c_str[i] - self.font_ascii_start_index) as usize * control_word::CHAR_WIDTH;
+            for j in 0..control_word::CHAR_WIDTH {
                 self.send_byte(font5x7::FONT5X7.load_at(char_start_index + j))?;
             }
         }
@@ -292,24 +296,32 @@ where
     }
 
     pub fn set_serial_data_out(&mut self) -> Result<(), Hcms29xxError<PinErr>> {
-        self.control_word_1.set_data_out_mode_bit(DataOutModeBit::Serial);
+        self.control_word_1
+            .set_data_out_mode_bit(DataOutMode::Serial);
         self.update_control_word(self.control_word_1.bits())?;
+
+        // update local state once change is sent to device
+        self.data_out_mode = DataOutMode::Serial;
+
         Ok(())
     }
 
     pub fn set_simultaneous_data_out(&mut self) -> Result<(), Hcms29xxError<PinErr>> {
-        self.control_word_1.set_data_out_mode_bit(DataOutModeBit::Simultaneous);
+        self.control_word_1
+            .set_data_out_mode_bit(DataOutMode::Simultaneous);
         self.update_control_word(self.control_word_1.bits())?;
+
+        // update local state once change is sent to device
+        self.data_out_mode = DataOutMode::Simultaneous;
+
         Ok(())
     }
 
     fn update_control_word(&mut self, control_word: u8) -> Result<(), Hcms29xxError<PinErr>> {
-        // read current data out mode before potentially changing it
-        let times_to_send = if (self.control_word_1 & control::control_word_1::DATA_OUT_BIT) != 0
-        {
-            1
+        let times_to_send = if self.data_out_mode == DataOutMode::Serial {
+            NUM_CHARS as u8 / control_word::DEVICE_CHARS as u8
         } else {
-            NUM_CHARS as u8 / control::DEVICE_CHARS as u8
+            1
         };
 
         self.set_control_data()?;
@@ -318,12 +330,6 @@ where
         }
         self.end_transfer()?;
 
-        if (control_word & control::CONTROL_WORD_SELECT_BIT) != 0 {
-            self.control_word_1 = control_word;
-        } else {
-            self.control_word_0 = control_word;
-        }
-
         Ok(())
     }