Struct Pcf8563Async 

pub struct Pcf8563Async<I2CImpl: RegisterInterface<AddressType = u8, Error = RtcError<I2CBusErr>>, I2CBusErr: Debug> {
    pub ll: Pcf8563LowLevel<I2CImpl>,
    /* private fields */
}

Fields

ll: Pcf8563LowLevel<I2CImpl>

Implementations

impl<I2CBus, E> Pcf8563<Pcf8563Interface<I2CBus>, E>

where I2CBus: I2c<Error = E>, E: Debug,

pub fn new(i2c: I2CBus) -> Self

impl<I2CImpl, I2CBusErr> Pcf8563<I2CImpl, I2CBusErr>

where I2CImpl: RegisterInterface<AddressType = u8, Error = RtcError<I2CBusErr>>, I2CBusErr: Debug,

pub async fn get_datetime(&mut self) -> Result<DateTime, RtcError<I2CBusErr>>

Get the current date and time

Reads all 7 time/date registers (0x02-0x08) in a single I2C burst read, as recommended by the datasheet to ensure consistency.

pub async fn set_datetime( &mut self, dt: &DateTime, ) -> Result<(), RtcError<I2CBusErr>>

Set the date and time

Writes all 7 time/date registers (0x02-0x08) in a single I2C burst write. Also clears the VL (voltage-low) flag.

pub async fn set_time(&mut self, time: &Time) -> Result<(), RtcError<I2CBusErr>>

Set only the time (hours, minutes, seconds)

pub async fn is_clock_valid(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if clock integrity is guaranteed

Returns false if the VL (Voltage Low) flag is set, indicating the clock data may be invalid due to power loss.

pub async fn clear_voltage_low_flag( &mut self, ) -> Result<(), RtcError<I2CBusErr>>

Clear the voltage-low flag

Should be called after setting the time to indicate clock is valid.

pub async fn get_century_flag(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Get the century flag

Returns true if century is X+1 (e.g., 2100s), false if century is X (e.g., 2000s)

pub async fn set_century_flag( &mut self, century: bool, ) -> Result<(), RtcError<I2CBusErr>>

Set the century flag

pub async fn set_clock_running( &mut self, running: bool, ) -> Result<(), RtcError<I2CBusErr>>

Start or stop the RTC clock

pub async fn is_clock_running(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if the RTC clock is running

pub async fn get_alarm(&mut self) -> Result<Alarm, RtcError<I2CBusErr>>

Get the current alarm configuration

pub async fn set_alarm( &mut self, alarm: &Alarm, ) -> Result<(), RtcError<I2CBusErr>>

Set the alarm configuration

Set a field to Some(value) to enable that alarm component, or None to disable it.

pub async fn disable_alarm(&mut self) -> Result<(), RtcError<I2CBusErr>>

Disable all alarm components

pub async fn get_alarm_flag(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if alarm flag is set (alarm has triggered)

pub async fn clear_alarm_flag(&mut self) -> Result<(), RtcError<I2CBusErr>>

Clear the alarm flag

pub async fn set_alarm_interrupt( &mut self, enable: bool, ) -> Result<(), RtcError<I2CBusErr>>

Enable or disable alarm interrupt

pub async fn is_alarm_interrupt_enabled( &mut self, ) -> Result<bool, RtcError<I2CBusErr>>

Check if alarm interrupt is enabled

pub async fn set_timer_value( &mut self, value: u8, ) -> Result<(), RtcError<I2CBusErr>>

Set the timer countdown value (0-255)

pub async fn get_timer_value(&mut self) -> Result<u8, RtcError<I2CBusErr>>

Get the current timer countdown value

pub async fn set_timer_frequency( &mut self, freq: TimerFrequency, ) -> Result<(), RtcError<I2CBusErr>>

Set the timer source clock frequency

pub async fn get_timer_frequency( &mut self, ) -> Result<TimerFrequency, RtcError<I2CBusErr>>

Get the timer source clock frequency

pub async fn set_timer_enabled( &mut self, enable: bool, ) -> Result<(), RtcError<I2CBusErr>>

Enable or disable the timer

pub async fn is_timer_enabled(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if timer is enabled

pub async fn get_timer_flag(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if timer flag is set (timer has triggered)

pub async fn clear_timer_flag(&mut self) -> Result<(), RtcError<I2CBusErr>>

Clear the timer flag

pub async fn set_timer_interrupt( &mut self, enable: bool, ) -> Result<(), RtcError<I2CBusErr>>

Enable or disable timer interrupt

pub async fn is_timer_interrupt_enabled( &mut self, ) -> Result<bool, RtcError<I2CBusErr>>

Check if timer interrupt is enabled

pub async fn set_timer_interrupt_pulse_mode( &mut self, pulse: bool, ) -> Result<(), RtcError<I2CBusErr>>

Set timer interrupt mode (level or pulse)

pub async fn set_clkout_enabled( &mut self, enable: bool, ) -> Result<(), RtcError<I2CBusErr>>

Enable or disable the CLKOUT output

pub async fn is_clkout_enabled(&mut self) -> Result<bool, RtcError<I2CBusErr>>

Check if CLKOUT is enabled

pub async fn set_clkout_frequency( &mut self, freq: ClkoutFrequency, ) -> Result<(), RtcError<I2CBusErr>>

Set the CLKOUT frequency

pub async fn get_clkout_frequency( &mut self, ) -> Result<ClkoutFrequency, RtcError<I2CBusErr>>

Get the CLKOUT frequency setting

pub async fn init(&mut self) -> Result<(), RtcError<I2CBusErr>>

Initialize the RTC with default settings

• Clears all control bits
• Clears voltage-low flag
• Disables all alarms
• Sets timer to lowest frequency (1/60 Hz) for power saving