kirbylife
/
ds323x-rs
mirror of https://github.com/eldruin/ds323x-rs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: kirbylife:cdfc6d8c74594c3b3c843b0e9d9fcc048ac73f88
Branches Tags
kirbylife:master
kirbylife:embedded-time-no-error-trait
kirbylife:v0.7.0
kirbylife:v0.6.0
kirbylife:v0.5.1
kirbylife:v0.5.0
kirbylife:v0.4.0
kirbylife:v0.3.2
kirbylife:v0.3.1
kirbylife:v0.3.0
kirbylife:v0.2.0
kirbylife:v0.1.0
..
compare: kirbylife:3682b9a512b1de06d064b62e54e6fca22edb347d
Branches Tags
kirbylife:master
kirbylife:embedded-time-no-error-trait
kirbylife:v0.7.0
kirbylife:v0.6.0
kirbylife:v0.5.1
kirbylife:v0.5.0
kirbylife:v0.4.0
kirbylife:v0.3.2
kirbylife:v0.3.1
kirbylife:v0.3.0
kirbylife:v0.2.0
kirbylife:v0.1.0

1 Commits
cdfc6d8c74 ... 3682b9a512

Author SHA1 Message Date
Paul Bender 3682b9a512
Merge 25f695d20a into 7070810621 2025-10-11 15:36:00 +00:00
3 changed files with 30 additions and 183 deletions
Show Stats Expand all files Collapse all files

68
src/ds323x/datetime.rs
View File

@ -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())
.ok_or(Error::InvalidDeviceState)?;
let time = NaiveTime::from_hms_opt(hour.into(), minute.into(), second.into())
.ok_or(Error::InvalidDeviceState)?;
let date = NaiveDate::from_ymd_opt(year.into(), month.into(), day.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())
.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)
}
@ -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())
.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> {

25
tests/common/mod.rs
View File

@ -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) => {

120
tests/datetime.rs
View File

@ -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,
Register, DEVICE_ADDRESS as DEV_ADDR,
destroy_ds3231, destroy_ds3232, destroy_ds3234, new_ds3231, new_ds3232, new_ds3234, Register,
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 time_transaction =
$mac_trans_read!(SECONDS, [0b0101_1000, 0b0101_1001, 0b0010_0011], [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);
let mut dev = $create_method(&$mac_trans_read!(
SECONDS,
[0b0101_1000, 0b0101_1001, 0b0010_0011],
[0, 0, 0]
));
assert_eq!(t, dev.time().unwrap());
$destroy_method(dev);
}