Struct mcp794xx::Mcp794xx

pub struct Mcp794xx<DI, IC> { /* private fields */ }

MCP794xx RTCC driver

Implementations

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>,
    IC: WithBatteryPower, 

pub fn has_power_failed(&mut self) -> Result<bool, Error<E>>

Returns whether the primary power has failed.

pub fn clear_power_failed(&mut self) -> Result<(), Error<E>>

Clears the power failed status flag and power-fail time-stamp registers.

pub fn get_power_down_datetime(&mut self) -> Result<PowerFailDateTime, Error<E>>

Returns date/time when the power failed went down (under Vtrip).

Note that the registers need to be cleared by calling clear_power_failed()

pub fn get_power_up_datetime(&mut self) -> Result<PowerFailDateTime, Error<E>>

Returns date/time when the power went back up (above Vtrip).

Note that the registers need to be cleared by calling clear_power_failed()

pub fn enable_backup_battery_power(&mut self) -> Result<(), Error<E>>

Enable usage of backup battery power.

Note that this clears the power failed flag.

pub fn disable_backup_battery_power(&mut self) -> Result<(), Error<E>>

Disable usage of backup battery power (default).

Note that this clears the power failed flag.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>, 

pub fn enable_alarm(&mut self, alarm: Alarm) -> Result<(), Error<E>>

Enable alarm

pub fn disable_alarm(&mut self, alarm: Alarm) -> Result<(), Error<E>>

Disable alarm

pub fn set_alarm(
    &mut self,
    alarm: Alarm,
    when: AlarmDateTime,
    matching: AlarmMatching,
    polarity: AlarmOutputPinPolarity
) -> Result<(), Error<E>>

Set alarm for date/time with a trigger rate and an output pin polarity.

Note that this clears the alarm has matched flag and the alarm needs to be enabled separately. Note that the output pin polarity will be set to the same value for both alarms.

pub fn has_alarm_matched(&mut self, alarm: Alarm) -> Result<bool, Error<E>>

Returns whether the alarm has matched.

Once this is true, it will stay as such until cleared. e.g. with clear_alarm_matched_flag()

pub fn clear_alarm_matched_flag(&mut self, alarm: Alarm) -> Result<(), Error<E>>

Clears the alarm matched flag.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: ReadData<Error = Error<E>>, 

pub fn is_leap_year(&mut self) -> Result<bool, Error<E>>

Returns whether the current year is a leap year.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>, 

pub fn read_sram_byte(&mut self, address: u8) -> Result<u8, Error<E>>

Read a single byte from an address.

Valid addresses are from 0x20 to 0x5F. Otherwise an Error::InvalidInputData will be returned.

pub fn write_sram_byte(&mut self, address: u8, data: u8) -> Result<(), Error<E>>

Write a single byte to an address.

Valid addresses are from 0x20 to 0x5F. Otherwise an Error::InvalidInputData will be returned.

pub fn read_sram_data(
    &mut self,
    address: u8,
    data: &mut [u8]
) -> Result<(), Error<E>>

Read SRAM starting in an address as many bytes as necessary to fill the data array provided.

pub fn write_sram_data(
    &mut self,
    address: u8,
    data: &[u8]
) -> Result<(), Error<E>>

Write data array to SRAM starting in an address.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: ReadCurrent<Error = Error<E>>, 

pub fn read_sram_current_byte(&mut self) -> Result<u8, Error<E>>

Read a single byte from the current address.

The current address corresponds to the last accessed address (including addresses accessed in EEPROM) incremented by 1.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>, 

pub fn enable(&mut self) -> Result<(), Error<E>>

Enable the oscillator (set the clock running).

pub fn disable(&mut self) -> Result<(), Error<E>>

Disable the oscillator (stops the clock) (default).

pub fn is_oscillator_running(&mut self) -> Result<bool, Error<E>>

Returns whether the oscillator is running.

pub fn enable_external_oscillator(&mut self) -> Result<(), Error<E>>

Enable usage of external oscillator source.

pub fn disable_external_oscillator(&mut self) -> Result<(), Error<E>>

Disable usage of external oscillator source (Will use internal source).

pub fn enable_square_wave(&mut self) -> Result<(), Error<E>>

Enable square-wave output.

Note that this is not available when running on backup battery power.

pub fn disable_square_wave(&mut self) -> Result<(), Error<E>>

Disable square-wave output.

pub fn set_square_wave_frequency(
    &mut self,
    frequency: SqWFreq
) -> Result<(), Error<E>>

Set square-wave output frequency.

Note that this setting will be ignored if the square-wave output is not enabled or digital trimming is enabled.

pub fn set_output_pin(&mut self, level: OutputPinLevel) -> Result<(), Error<E>>

Set output pin logic level.

Note that this setting will be ignored if the square-wave output or any of the alarm interrupt outputs are enabled.

pub fn enable_coarse_trim(&mut self) -> Result<(), Error<E>>

Enable coarse trim mode.

pub fn disable_coarse_trim(&mut self) -> Result<(), Error<E>>

Disable coarse trim mode.

pub fn set_trimming(&mut self, value: i8) -> Result<(), Error<E>>

Set digital trimming value.

The sign determines whether the value will be added or substracted to or from the 32.768kHz clock signal. The argument value is always multiplied by two, so a value of 127 will add 254 clock cycles and a value of -50 will substract 100 cycles. Depending on the digital trimming setting, this will be applied either once per minute or 128 times per second. Set to 0 or -128 to disable digital trimming.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>,
    IC: WithProtectedEeprom, 

pub fn read_protected_eeprom_byte(&mut self, address: u8) -> Result<u8, Error<E>>

Read a single byte from an address in the protected EEPROM.

Valid addresses are in the range [0xF0-0xF7]. Error::InvalidInputData will be returned for invalid addresses.

pub fn read_protected_eeprom_data(
    &mut self,
    address: u8,
    data: &mut [u8]
) -> Result<(), Error<E>>

Read protected EEPROM starting in an address as many bytes as necessary to fill the data array provided.

Valid addresses are in the range [0xF0-0xF7]. Error::InvalidInputData will be returned for invalid addresses or if the reading would overflow the size of the protected EEPROM.

pub fn write_protected_eeprom_byte(
    &mut self,
    address: u8,
    data: u8
) -> Result<(), Error<E>>

Unlock protected EEPROM and write a single byte to an address.

Valid addresses are in the range [0xF0-0xF7]. Error::InvalidInputData will be returned for invalid addresses.

pub fn write_protected_eeprom_data(
    &mut self,
    address: u8,
    data: &[u8]
) -> Result<(), Error<E>>

Write data array starting in an address in the protected EEPROM.

Valid addresses are in the range [0xF0-0xF7]. Error::InvalidInputData will be returned for invalid addresses or if the writing would overflow the size of the protected EEPROM.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>,
    IC: WithEeprom, 

pub fn set_eeprom_write_protection(
    &mut self,
    protection: EepromWriteProtection
) -> Result<(), Error<E>>

Set the EEPROM block write protection

pub fn read_eeprom_byte(&mut self, address: u8) -> Result<u8, Error<E>>

Read a single byte from an address in EEPROM.

Valid addresses are in the range [0x00-0x7F]. Error::InvalidInputData will be returned for invalid addresses.

pub fn read_eeprom_data(
    &mut self,
    address: u8,
    data: &mut [u8]
) -> Result<(), Error<E>>

Read EEPROM starting in an address as many bytes as necessary to fill the data array provided.

Valid addresses are in the range [0x00-0x7F]. Error::InvalidInputData will be returned for invalid addresses or if the reading would overflow the size of the EEPROM.

pub fn write_eeprom_byte(&mut self, address: u8, data: u8) -> Result<(), Error<E>>

Write a single byte to an address in EEPROM.

Valid addresses are in the range [0x00-0x7F]. Error::InvalidInputData will be returned for invalid addresses.

pub fn write_eeprom_data(
    &mut self,
    address: u8,
    data: &[u8]
) -> Result<(), Error<E>>

Write data array starting in an address in EEPROM.

Valid addresses are in the range [0x00-0x7F]. Error::InvalidInputData will be returned for invalid addresses or if the writing would overflow the size of the EEPROM.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: ReadCurrent<Error = Error<E>>, 

pub fn read_eeprom_current_byte(&mut self) -> Result<u8, Error<E>>

Read a single byte from the current address in EEPROM.

The current address corresponds to the last accessed address (including addresses accessed in SRAM/RTCC) incremented by 1.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: ReadData<Error = Error<E>>,
    IC: WithEui48, 

pub fn read_eui48(&mut self) -> Result<[u8; 6], Error<E>>

Read pre-programmed EUI-48 node address from EEPROM.

impl<DI, E, IC> Mcp794xx<DI, IC> where
    DI: ReadData<Error = Error<E>>,
    IC: WithEui64, 

pub fn read_eui64(&mut self) -> Result<[u8; 8], Error<E>>

Read pre-programmed EUI-64 node address from EEPROM.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp7940n> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp7940n(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp7940m> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp7940m(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79400> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79400(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79401> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79401(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79402> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79402(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79410> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79410(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79411> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79411(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E> Mcp794xx<I2cInterface<I2C>, Mcp79412> where
    I2C: Write<Error = E> + WriteRead<Error = E>, 

pub fn new_mcp79412(i2c: I2C) -> Self

Create a new instance of the device.

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

Trait Implementations

impl<DI, E, IC> DateTimeAccess for Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>, 

fn datetime(&mut self) -> Result<NaiveDateTime, Self::Error>

This device can compensate for leap years up to 2399 but only the two last year digits are stored so we will return the year as in the range 2000-2099.

fn set_datetime(&mut self, datetime: &NaiveDateTime) -> Result<(), Self::Error>

Note that this clears the power failed flag. This device can compensate for leap years up to 2399 but only the two last year digits are stored so we only support the range 2000-2099.

type Error = Error<E>

Error type

impl<DI: Debug, IC: Debug> Debug for Mcp794xx<DI, IC>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<DI, E, IC> Rtcc for Mcp794xx<DI, IC> where
    DI: WriteData<Error = Error<E>> + ReadData<Error = Error<E>>, 

fn year(&mut self) -> Result<u16, Self::Error>

This device can compensate for leap years up to 2399 but only the two last year digits are stored so we will return the year as in the range 2000-2099.

fn set_weekday(&mut self, weekday: u8) -> Result<(), Self::Error>

Note that this clears the power failed flag.

fn set_year(&mut self, year: u16) -> Result<(), Self::Error>

This device can compensate for leap years up to 2399 but only the two last year digits are stored so we only support the range 2000-2099.

fn seconds(&mut self) -> Result<u8, Self::Error>

Read the seconds.

fn minutes(&mut self) -> Result<u8, Self::Error>

Read the minutes.

fn hours(&mut self) -> Result<Hours, Self::Error>

Read the hours.

fn time(&mut self) -> Result<NaiveTime, Self::Error>

Read the time.

fn weekday(&mut self) -> Result<u8, Self::Error>

Read the day of the week [1-7].

fn day(&mut self) -> Result<u8, Self::Error>

Read the day of the month [1-31].

fn month(&mut self) -> Result<u8, Self::Error>

Read the month [1-12].

fn date(&mut self) -> Result<NaiveDate, Self::Error>

Read the date.

fn set_seconds(&mut self, seconds: u8) -> Result<(), Self::Error>

Set the seconds [0-59].

fn set_minutes(&mut self, minutes: u8) -> Result<(), Self::Error>

Set the minutes [0-59].

fn set_hours(&mut self, hours: Hours) -> Result<(), Self::Error>

Set the hours.

fn set_time(&mut self, time: &NaiveTime) -> Result<(), Self::Error>

Set the time.

fn set_day(&mut self, day: u8) -> Result<(), Self::Error>

Set the day of month [1-31].

fn set_month(&mut self, month: u8) -> Result<(), Self::Error>

Set the month [1-12].

fn set_date(&mut self, date: &NaiveDate) -> Result<(), Self::Error>

Set the date.