Generate an error for all time functions when the century bit is set.

src/ds323x/datetime.rs

@@ -1,8 +1,6 @@
 //! Common implementation
 
-use super::{
+use super::{decimal_to_packed_bcd, hours_to_register, packed_bcd_to_decimal};
-    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,
@@ -31,8 +29,10 @@ 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()).ok_or(Error::InvalidDeviceState)?;
+        let date = NaiveDate::from_ymd_opt(year.into(), month.into(), day.into())
-        let time = NaiveTime::from_hms_opt(hour.into(), minute.into(), second.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 datetime = NaiveDateTime::new(date, time);
 
         Ok(datetime)
@@ -61,19 +61,47 @@ 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)?;
 
@@ -81,14 +109,29 @@ 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()).ok_or(Error::InvalidDeviceState)
+        NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into())
+            .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)
     }
 
@@ -104,18 +147,14 @@ where
     }
 
     fn year(&mut self) -> Result<u16, Self::Error> {
-        let mut data = [0; 3];
+        let data = self.iface.read_register(Register::MONTH)?;
-        data[0] = Register::MONTH;
-        self.iface.read_data(&mut data)?;
 
-        let century = data[1] & BitFlags::CENTURY;
+        let century = data & BitFlags::CENTURY;
         if century != 0 {
             return Err(Error::InvalidDeviceCentury);
         }
 
-        let year = 2000 + (packed_bcd_to_decimal(data[2]) as u16);
+        Ok(2000 + (self.read_register_decimal(Register::YEAR)? as u16))
-
-        Ok(year)
     }
 
     fn date(&mut self) -> Result<NaiveDate, Self::Error> {
@@ -135,7 +174,8 @@ 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()).ok_or(Error::InvalidDeviceState)
+        NaiveDate::from_ymd_opt(year.into(), month.into(), day.into())
+            .ok_or(Error::InvalidDeviceState)
     }
 
     fn set_seconds(&mut self, seconds: u8) -> Result<(), Self::Error> {

tests/common/mod.rs

@@ -23,6 +23,7 @@ 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;
@@ -36,6 +37,7 @@ 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;
@@ -123,6 +125,16 @@ 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) => {
@@ -135,6 +147,19 @@ 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, Register,
+    destroy_ds3231, destroy_ds3232, destroy_ds3234, new_ds3231, new_ds3232, new_ds3234, BitFlags,
-    DEVICE_ADDRESS as DEV_ADDR,
+    Register, DEVICE_ADDRESS as DEV_ADDR,
 };
 #[allow(unused)] // Rust 1.31.0 is confused due to the macros
 use ds323x::Rtcc;
@@ -78,6 +78,31 @@ 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 {
@@ -117,6 +142,50 @@ 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 {
@@ -133,51 +202,58 @@ macro_rules! for_all {
 
 mod seconds {
     use super::*;
-    get_param_test!(get, seconds, SECONDS, 1, 1);
+    read_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::*;
-    get_param_test!(get, minutes, MINUTES, 1, 1);
+    read_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::*;
-    get_param_test!(get, hours, HOURS, Hours::H24(21), 0b0010_0001);
+    read_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::*;
-    get_param_test!(get, hours, HOURS, Hours::AM(12), 0b0101_0010);
+    read_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::*;
-    get_param_test!(get, hours, HOURS, Hours::PM(12), 0b0111_0010);
+    read_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::*;
-    get_param_test!(get, weekday, DOW, 1, 1);
+    read_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::*;
-    get_param_test!(get, day, DOM, 1, 1);
+    read_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 {
@@ -185,13 +261,14 @@ 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::*;
-    get_param_read_array_test!(century0_get, year, 2099, MONTH, [0, 0b1001_1001], [0, 0]);
+    read_get_param_test!(get, year, YEAR, 2099, 0b1001_1001);
     read_set_param_write_two_test!(
-        century0_set,
+        set,
         set_year,
         2099,
         MONTH,
@@ -201,6 +278,7 @@ 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 {
@@ -325,11 +403,21 @@ macro_rules! dt_test {
             #[test]
             fn get_time() {
                 let t = NaiveTime::from_hms_opt(23, 59, 58).unwrap();
-                let mut dev = $create_method(&$mac_trans_read!(
+                let month_transaction = $mac_trans_read!(MONTH, [0], [0]);
-                    SECONDS,
+                let time_transaction =
-                    [0b0101_1000, 0b0101_1001, 0b0010_0011],
+                    $mac_trans_read!(SECONDS, [0b0101_1000, 0b0101_1001, 0b0010_0011], [0, 0, 0]);
-                    [0, 0, 0]
+                let mut transactions = vec![];
-                ));
+                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);
             }