Merge 25f695d20a into 7070810621

src/ds323x/datetime.rs

@@ -1,6 +1,8 @@
 //! Common implementation
 
-use super::{decimal_to_packed_bcd, hours_to_register, packed_bcd_to_decimal};
+use super::{
+    decimal_to_packed_bcd, hours_to_register, packed_bcd_to_decimal,
+};
 use crate::{
     interface::{ReadData, WriteData},
     BitFlags, DateTimeAccess, Datelike, Ds323x, Error, Hours, NaiveDate, NaiveDateTime, NaiveTime,
@@ -29,10 +31,8 @@ where
         let minute = packed_bcd_to_decimal(data[Register::MINUTES as usize + 1]);
         let second = packed_bcd_to_decimal(data[Register::SECONDS as usize + 1]);
 
-        let date = NaiveDate::from_ymd_opt(year.into(), month.into(), day.into())
+        let date = NaiveDate::from_ymd_opt(year.into(), month.into(), day.into()).ok_or(Error::InvalidDeviceState)?;
-            .ok_or(Error::InvalidDeviceState)?;
+        let time = NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into()).ok_or(Error::InvalidDeviceState)?;
-        let time = NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into())
-            .ok_or(Error::InvalidDeviceState)?;
         let datetime = NaiveDateTime::new(date, time);
 
         Ok(datetime)
@@ -61,47 +61,19 @@ where
     DI: ReadData<Error = Error<E>> + WriteData<Error = Error<E>>,
 {
     fn seconds(&mut self) -> Result<u8, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         self.read_register_decimal(Register::SECONDS)
     }
 
     fn minutes(&mut self) -> Result<u8, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         self.read_register_decimal(Register::MINUTES)
     }
 
     fn hours(&mut self) -> Result<Hours, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         let data = self.iface.read_register(Register::HOURS)?;
         Ok(hours_from_register(data))
     }
 
     fn time(&mut self) -> Result<NaiveTime, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         let mut data = [0; 4];
         self.iface.read_data(&mut data)?;
 
@@ -109,29 +81,14 @@ where
         let minute = packed_bcd_to_decimal(data[Register::MINUTES as usize + 1]);
         let second = packed_bcd_to_decimal(data[Register::SECONDS as usize + 1]);
 
-        NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into())
+        NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into()).ok_or(Error::InvalidDeviceState)
-            .ok_or(Error::InvalidDeviceState)
     }
 
     fn weekday(&mut self) -> Result<u8, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         self.read_register_decimal(Register::DOW)
     }
 
     fn day(&mut self) -> Result<u8, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
-
-        let century = data & BitFlags::CENTURY;
-        if century != 0 {
-            return Err(Error::InvalidDeviceCentury);
-        }
-
         self.read_register_decimal(Register::DOM)
     }
 
@@ -147,14 +104,18 @@ where
     }
 
     fn year(&mut self) -> Result<u16, Self::Error> {
-        let data = self.iface.read_register(Register::MONTH)?;
+        let mut data = [0; 3];
+        data[0] = Register::MONTH;
+        self.iface.read_data(&mut data)?;
 
-        let century = data & BitFlags::CENTURY;
+        let century = data[1] & BitFlags::CENTURY;
         if century != 0 {
             return Err(Error::InvalidDeviceCentury);
         }
 
-        Ok(2000 + (self.read_register_decimal(Register::YEAR)? as u16))
+        let year = 2000 + (packed_bcd_to_decimal(data[2]) as u16);
+
+        Ok(year)
     }
 
     fn date(&mut self) -> Result<NaiveDate, Self::Error> {
@@ -174,8 +135,7 @@ where
         let month = packed_bcd_to_decimal(data[Register::MONTH as usize + 1 - offset]);
         let day = packed_bcd_to_decimal(data[Register::DOM as usize + 1 - offset]);
 
-        NaiveDate::from_ymd_opt(year.into(), month.into(), day.into())
+        NaiveDate::from_ymd_opt(year.into(), month.into(), day.into()).ok_or(Error::InvalidDeviceState)
-            .ok_or(Error::InvalidDeviceState)
     }
 
     fn set_seconds(&mut self, seconds: u8) -> Result<(), Self::Error> {

tests/common/mod.rs

@@ -23,7 +23,6 @@ impl Register {
     pub const DOW: u8 = 0x03;
     pub const DOM: u8 = 0x04;
     pub const MONTH: u8 = 0x05;
-    pub const YEAR: u8 = 0x06;
     pub const ALARM1_SECONDS: u8 = 0x07;
     pub const ALARM2_MINUTES: u8 = 0x0B;
     pub const CONTROL: u8 = 0x0E;
@@ -37,7 +36,6 @@ pub struct BitFlags;
 
 #[allow(unused)]
 impl BitFlags {
-    pub const CENTURY: u8 = 0b1000_0000;
     pub const EOSC: u8 = 0b1000_0000;
     pub const BBSQW: u8 = 0b0100_0000;
     pub const TEMP_CONV: u8 = 0b0010_0000;
@@ -125,16 +123,6 @@ macro_rules! assert_invalid_input_data {
     };
 }
 
-#[macro_export]
-macro_rules! assert_invalid_device_century {
-    ($result:expr) => {
-        match $result {
-            Err(Error::InvalidDeviceCentury) => (),
-            _ => panic!("InvalidDeviceCentury error not returned."),
-        }
-    };
-}
-
 #[macro_export]
 macro_rules! set_invalid_test {
     ($name:ident, $method:ident, $create_method:ident, $destroy_method:ident, $value:expr) => {
@@ -147,19 +135,6 @@ macro_rules! set_invalid_test {
     };
 }
 
-#[macro_export]
-macro_rules! get_invalid_test {
-    ($name:ident, $method:ident, $create_method:ident, $destroy_method:ident, $transactions:expr) => {
-        #[test]
-        fn $name() {
-            let trans = $transactions;
-            let mut dev = $create_method(&trans);
-            assert_invalid_device_century!(dev.$method());
-            $destroy_method(dev);
-        }
-    };
-}
-
 #[macro_export]
 macro_rules! call_test {
     ($name:ident, $method:ident, $create_method:ident, $destroy_method:ident, $transactions:expr) => {

tests/datetime.rs

@@ -2,8 +2,8 @@ use embedded_hal_mock::eh1::{i2c::Transaction as I2cTrans, spi::Transaction as S
 use rtcc::NaiveDateTime;
 mod common;
 use self::common::{
-    destroy_ds3231, destroy_ds3232, destroy_ds3234, new_ds3231, new_ds3232, new_ds3234, BitFlags,
+    destroy_ds3231, destroy_ds3232, destroy_ds3234, new_ds3231, new_ds3232, new_ds3234, Register,
-    Register, DEVICE_ADDRESS as DEV_ADDR,
+    DEVICE_ADDRESS as DEV_ADDR,
 };
 #[allow(unused)] // Rust 1.31.0 is confused due to the macros
 use ds323x::Rtcc;
@@ -78,31 +78,6 @@ macro_rules! read_set_param_test {
     };
 }
 
-macro_rules! read_get_param_test {
-    ($name:ident, $method:ident, $register:ident, $value:expr, $binary_value:expr) => {
-        _get_param_test!(
-            $name,
-            $method,
-            $value,
-            [
-                I2cTrans::write_read(DEV_ADDR, vec![Register::MONTH], vec![1]),
-                I2cTrans::write_read(DEV_ADDR, vec![Register::$register], vec![$binary_value])
-            ],
-            [
-                SpiTrans::transaction_start(),
-                SpiTrans::transfer_in_place(vec![Register::MONTH, 0], vec![Register::MONTH, 1]),
-                SpiTrans::transaction_end(),
-                SpiTrans::transaction_start(),
-                SpiTrans::transfer_in_place(
-                    vec![Register::$register, 0],
-                    vec![Register::$register, $binary_value]
-                ),
-                SpiTrans::transaction_end(),
-            ]
-        );
-    };
-}
-
 macro_rules! set_invalid_param_test {
     ($name:ident, $method:ident, $value:expr) => {
         mod $name {
@@ -142,50 +117,6 @@ macro_rules! set_invalid_param_range_test {
     };
 }
 
-macro_rules! get_invalid_device_century_test {
-    ($name:ident, $method:ident) => {
-        mod $name {
-            use super::*;
-            get_invalid_test!(
-                cannot_get_invalid_ds3231,
-                $method,
-                new_ds3231,
-                destroy_ds3231,
-                [I2cTrans::write_read(
-                    DEV_ADDR,
-                    vec![Register::MONTH],
-                    vec![BitFlags::CENTURY]
-                )]
-            );
-            get_invalid_test!(
-                cannot_get_invalid_ds3232,
-                $method,
-                new_ds3232,
-                destroy_ds3232,
-                [I2cTrans::write_read(
-                    DEV_ADDR,
-                    vec![Register::MONTH],
-                    vec![BitFlags::CENTURY]
-                )]
-            );
-            get_invalid_test!(
-                cannot_get_invalid_ds3234,
-                $method,
-                new_ds3234,
-                destroy_ds3234,
-                [
-                    SpiTrans::transaction_start(),
-                    SpiTrans::transfer_in_place(
-                        vec![Register::MONTH, 0],
-                        vec![Register::MONTH, BitFlags::CENTURY | 0]
-                    ),
-                    SpiTrans::transaction_end(),
-                ]
-            );
-        }
-    };
-}
-
 macro_rules! for_all {
     ($name:ident) => {
         mod $name {
@@ -202,58 +133,51 @@ macro_rules! for_all {
 
 mod seconds {
     use super::*;
-    read_get_param_test!(get, seconds, SECONDS, 1, 1);
+    get_param_test!(get, seconds, SECONDS, 1, 1);
     set_param_test!(set, set_seconds, SECONDS, 1, 1);
     set_invalid_param_test!(invalid, set_seconds, 60);
-    get_invalid_device_century_test!(invalid_century, seconds);
 }
 
 mod minutes {
     use super::*;
-    read_get_param_test!(get, minutes, MINUTES, 1, 1);
+    get_param_test!(get, minutes, MINUTES, 1, 1);
     set_param_test!(set, set_minutes, MINUTES, 1, 1);
     set_invalid_param_test!(invalid, set_minutes, 60);
-    get_invalid_device_century_test!(invalid_century, minutes);
 }
 
 mod hours_24h {
     use super::*;
-    read_get_param_test!(get, hours, HOURS, Hours::H24(21), 0b0010_0001);
+    get_param_test!(get, hours, HOURS, Hours::H24(21), 0b0010_0001);
     set_param_test!(set, set_hours, HOURS, Hours::H24(21), 0b0010_0001);
     set_invalid_param_test!(invalid, set_hours, Hours::H24(24));
-    get_invalid_device_century_test!(invalid_century, hours);
 }
 
 mod hours_12h_am {
     use super::*;
-    read_get_param_test!(get, hours, HOURS, Hours::AM(12), 0b0101_0010);
+    get_param_test!(get, hours, HOURS, Hours::AM(12), 0b0101_0010);
     set_param_test!(set, set_hours, HOURS, Hours::AM(12), 0b0101_0010);
     set_invalid_param_range_test!(invalid, set_hours, Hours::AM(0), Hours::AM(13));
-    get_invalid_device_century_test!(invalid_century, hours);
 }
 
 mod hours_12h_pm {
     use super::*;
-    read_get_param_test!(get, hours, HOURS, Hours::PM(12), 0b0111_0010);
+    get_param_test!(get, hours, HOURS, Hours::PM(12), 0b0111_0010);
     set_param_test!(set, set_hours, HOURS, Hours::PM(12), 0b0111_0010);
     set_invalid_param_range_test!(invalid, set_hours, Hours::PM(0), Hours::PM(13));
-    get_invalid_device_century_test!(invalid_century, hours);
 }
 
 mod weekday {
     use super::*;
-    read_get_param_test!(get, weekday, DOW, 1, 1);
+    get_param_test!(get, weekday, DOW, 1, 1);
     set_param_test!(set, set_weekday, DOW, 1, 1);
     set_invalid_param_range_test!(invalid, set_weekday, 0, 8);
-    get_invalid_device_century_test!(invalid_century, weekday);
 }
 
 mod day {
     use super::*;
-    read_get_param_test!(get, day, DOM, 1, 1);
+    get_param_test!(get, day, DOM, 1, 1);
     set_param_test!(set, set_day, DOM, 1, 1);
     set_invalid_param_range_test!(invalid, set_day, 0, 32);
-    get_invalid_device_century_test!(invalid_century, day);
 }
 
 mod month {
@@ -261,14 +185,13 @@ mod month {
     get_param_test!(get, month, MONTH, 1, 1);
     read_set_param_test!(set, set_month, MONTH, 12, 0b0000_0010, 0b0001_0010);
     set_invalid_param_range_test!(invalid, set_month, 0, 13);
-    get_invalid_device_century_test!(invalid_century, month);
 }
 
 mod year {
     use super::*;
-    read_get_param_test!(get, year, YEAR, 2099, 0b1001_1001);
+    get_param_read_array_test!(century0_get, year, 2099, MONTH, [0, 0b1001_1001], [0, 0]);
     read_set_param_write_two_test!(
-        set,
+        century0_set,
         set_year,
         2099,
         MONTH,
@@ -278,7 +201,6 @@ mod year {
     );
 
     set_invalid_param_range_test!(invalid, set_year, 1999, 2100);
-    get_invalid_device_century_test!(invalid_century, year);
 }
 
 macro_rules! invalid_dt_test {
@@ -403,21 +325,11 @@ macro_rules! dt_test {
             #[test]
             fn get_time() {
                 let t = NaiveTime::from_hms_opt(23, 59, 58).unwrap();
-                let month_transaction = $mac_trans_read!(MONTH, [0], [0]);
+                let mut dev = $create_method(&$mac_trans_read!(
-                let time_transaction =
+                    SECONDS,
-                    $mac_trans_read!(SECONDS, [0b0101_1000, 0b0101_1001, 0b0010_0011], [0, 0, 0]);
+                    [0b0101_1000, 0b0101_1001, 0b0010_0011],
-                let mut transactions = vec![];
+                    [0, 0, 0]
-                let mut i: usize = 0;
+                ));
-                while i < month_transaction.len() {
-                    transactions.push(month_transaction[i].clone());
-                    i += 1;
-                }
-                let mut j: usize = 0;
-                while j < time_transaction.len() {
-                    transactions.push(time_transaction[j].clone());
-                    j += 1;
-                }
-                let mut dev = $create_method(&transactions);
                 assert_eq!(t, dev.time().unwrap());
                 $destroy_method(dev);
             }