wip:(

Cargo.lock

···
 ]
 
 [[package]]
+name = "deranged"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
 name = "diff"
 version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
 name = "num-traits"
 version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
 name = "ppv-lite86"
 version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "serde-json-core",
  "shtcx",
  "static_cell",
+ "time",
  "tinybmp",
  "uc8151",
 ]
···
  "quote",
  "syn 2.0.106",
 ]
+
+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
 
 [[package]]
 name = "tiny-keccak"

Cargo.toml

···
 tinybmp = "0.5.0"
 shtcx = "1.0.0"
 postcard = "1.0.8"
+time = { version = "0.3.17", default-features = false }
+#pcf85063a = "0.1.1"
 
 [profile.release]
 debug = 2

src/main.rs

···
-//! This example test the RP Pico W on board LED.
-//!
-//! It does not work with the RP Pico board.
-
 #![no_std]
 #![no_main]
 
···
 use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
 use defmt::info;
 use defmt::*;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_executor::Spawner;
 use embassy_net::StackResources;
 use embassy_net::dns::DnsSocket;
···
 use gpio::{Level, Output, Pull};
 use heapless::{String, Vec};
 use helpers::easy_format;
+use pcf85063a::PCF85063;
 use reqwless::client::{HttpClient, TlsConfig, TlsVerify};
 use reqwless::request::Method;
 use save::{Save, read_postcard_from_flash, save_postcard_to_flash};
···
 mod badge_display;
 mod env;
 mod helpers;
+mod pcf85063a;
 mod save;
 mod temp_sensor;
 
···
             &mut tls_write_buffer,
             TlsVerify::None,
         );
+        // let mut http_client = HttpClient::new(&tcp_client, &dns_client);
+        let mut http_client = HttpClient::new_with_tls(&tcp_client, &dns_client, tls_config);
 
-        let mut http_client = HttpClient::new_with_tls(&tcp_client, &dns_client, tls_config);
         let url = env_value("TIME_API");
         info!("connecting to {}", &url);
 
-        let mut request = match http_client.request(Method::GET, &url).await {
-            Ok(req) => req,
-            Err(e) => {
-                error!("Failed to make HTTP request: {:?}", e);
-                return; // handle the error
-            }
-        };
-
-        let response = match request.send(&mut rx_buffer).await {
-            Ok(resp) => resp,
-            Err(_e) => {
-                error!("Failed to send HTTP request");
-                return; // handle the error;
-            }
-        };
-
-        let body = match from_utf8(response.body().read_to_end().await.unwrap()) {
-            Ok(b) => b,
-            Err(_e) => {
-                error!("Failed to read response body");
-                return; // handle the error
-            }
-        };
-        info!("Response body: {:?}", &body);
+        //If the call goes through set the rtc
+        match http_client.request(Method::GET, &url).await {
+            Ok(mut request) => {
+                let response = match request.send(&mut rx_buffer).await {
+                    Ok(resp) => resp,
+                    Err(e) => {
+                        error!("Failed to send HTTP request: {:?}", e);
+                        // error!("Failed to send HTTP request");
+                        return; // handle the error;
+                    }
+                };
 
-        let bytes = body.as_bytes();
-        match serde_json_core::de::from_slice::<TimeApiResponse>(bytes) {
-            Ok((output, _used)) => {
-                //Deadlines am i right?
-                info!("Datetime: {:?}", output.datetime);
-                //split at T
-                let datetime = output.datetime.split('T').collect::<Vec<&str, 2>>();
-                //split at -
-                let date = datetime[0].split('-').collect::<Vec<&str, 3>>();
-                let year = date[0].parse::<u16>().unwrap();
-                let month = date[1].parse::<u8>().unwrap();
-                let day = date[2].parse::<u8>().unwrap();
-                //split at :
-                let time = datetime[1].split(':').collect::<Vec<&str, 4>>();
-                let hour = time[0].parse::<u8>().unwrap();
-                let minute = time[1].parse::<u8>().unwrap();
-                //split at .
-                let second_split = time[2].split('.').collect::<Vec<&str, 2>>();
-                let second = second_split[0].parse::<f64>().unwrap();
-                let rtc_time = DateTime {
-                    year: year,
-                    month: month,
-                    day: day,
-                    day_of_week: match output.day_of_week {
-                        0 => DayOfWeek::Sunday,
-                        1 => DayOfWeek::Monday,
-                        2 => DayOfWeek::Tuesday,
-                        3 => DayOfWeek::Wednesday,
-                        4 => DayOfWeek::Thursday,
-                        5 => DayOfWeek::Friday,
-                        6 => DayOfWeek::Saturday,
-                        _ => DayOfWeek::Sunday,
-                    },
-                    hour,
-                    minute,
-                    second: second as u8,
+                let body = match from_utf8(response.body().read_to_end().await.unwrap()) {
+                    Ok(b) => b,
+                    Err(_e) => {
+                        error!("Failed to read response body");
+                        return; // handle the error
+                    }
                 };
-                rtc.set_datetime(rtc_time).unwrap();
-                time_was_set = true;
-                let _ = control.leave().await;
+                info!("Response body: {:?}", &body);
+
+                let bytes = body.as_bytes();
+                match serde_json_core::de::from_slice::<TimeApiResponse>(bytes) {
+                    Ok((output, _used)) => {
+                        //Deadlines am i right?
+                        info!("Datetime: {:?}", output.datetime);
+                        //split at T
+                        let datetime = output.datetime.split('T').collect::<Vec<&str, 2>>();
+                        //split at -
+                        let date = datetime[0].split('-').collect::<Vec<&str, 3>>();
+                        let year = date[0].parse::<u16>().unwrap();
+                        let month = date[1].parse::<u8>().unwrap();
+                        let day = date[2].parse::<u8>().unwrap();
+                        //split at :
+                        let time = datetime[1].split(':').collect::<Vec<&str, 4>>();
+                        let hour = time[0].parse::<u8>().unwrap();
+                        let minute = time[1].parse::<u8>().unwrap();
+                        //split at .
+                        let second_split = time[2].split('.').collect::<Vec<&str, 2>>();
+                        let second = second_split[0].parse::<f64>().unwrap();
+                        let rtc_time = DateTime {
+                            year: year,
+                            month: month,
+                            day: day,
+                            day_of_week: match output.day_of_week {
+                                0 => DayOfWeek::Sunday,
+                                1 => DayOfWeek::Monday,
+                                2 => DayOfWeek::Tuesday,
+                                3 => DayOfWeek::Wednesday,
+                                4 => DayOfWeek::Thursday,
+                                5 => DayOfWeek::Friday,
+                                6 => DayOfWeek::Saturday,
+                                _ => DayOfWeek::Sunday,
+                            },
+                            hour,
+                            minute,
+                            second: second as u8,
+                        };
+                        rtc.set_datetime(rtc_time).unwrap();
+                        time_was_set = true;
+                        let _ = control.leave().await;
+                    }
+                    Err(_e) => {
+                        error!("Failed to parse response body");
+                        // return; // handle the error
+                    }
+                }
             }
-            Err(_e) => {
-                error!("Failed to parse response body");
+            Err(e) => {
+                error!("Failed to make HTTP request: {:?}", e);
                 // return; // handle the error
             }
-        }
+        };
     }
 
     //Set up saving
···
     static I2C_BUS: StaticCell<I2c0Bus> = StaticCell::new();
     let i2c_bus = NoopMutex::new(RefCell::new(i2c));
     let i2c_bus = I2C_BUS.init(i2c_bus);
+
+    let i2c_dev = I2cDevice::new(i2c_bus);
+    let mut rtc_device = PCF85063::new(i2c_dev);
 
     //Task spawning
     spawner.must_spawn(run_the_temp_sensor(i2c_bus));

src/pcf85063a/alarm.rs

···
+use super::{BitFlags, Control, DEVICE_ADDRESS, Error, PCF85063, Register, decode_bcd, encode_bcd};
+use embedded_hal_async::i2c::I2c;
+use time::Time;
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    /// Set the alarm seconds, minutes and hours, keeping the AE bit unchanged.
+    pub async fn set_alarm_time(&mut self, time: Time) -> Result<(), Error<E>> {
+        self.set_alarm_seconds(time.second()).await?;
+        self.set_alarm_minutes(time.minute()).await?;
+        self.set_alarm_hours(time.hour()).await?;
+        Ok(())
+    }
+
+    /// Set the alarm seconds [0-59], keeping the AE bit unchanged.
+    pub fn set_alarm_seconds(&mut self, seconds: u8) -> Result<(), Error<E>> {
+        if seconds > 59 {
+            return Err(Error::InvalidInputData);
+        }
+        let data: u8 = self.read_register(Register::SECOND_ALARM)?; // read current value
+        let data: u8 = data & BitFlags::AE; // keep the AE bit as is
+        let setting: u8 = encode_bcd(seconds);
+        let data: u8 = data | setting;
+        self.write_register(Register::SECOND_ALARM, data).await
+    }
+
+    /// Set the alarm minutes [0-59], keeping the AE bit unchanged.
+    pub async fn set_alarm_minutes(&mut self, minutes: u8) -> Result<(), Error<E>> {
+        if minutes > 59 {
+            return Err(Error::InvalidInputData);
+        }
+        let data: u8 = self.read_register(Register::MINUTE_ALARM).await?; // read current value
+        let data: u8 = data & BitFlags::AE; // keep the AE bit as is
+        let setting: u8 = encode_bcd(minutes);
+        let data: u8 = data | setting;
+        self.write_register(Register::MINUTE_ALARM, data).await
+    }
+
+    /// Set the alarm hours [0-23], keeping the AE bit unchanged.
+    pub async fn set_alarm_hours(&mut self, hours: u8) -> Result<(), Error<E>> {
+        if hours > 23 {
+            return Err(Error::InvalidInputData);
+        }
+        let data: u8 = self.read_register(Register::HOUR_ALARM).await?; // read current value
+        let data: u8 = data & BitFlags::AE; // keep the AE bit as is
+        let setting: u8 = encode_bcd(hours);
+        let data: u8 = data | setting;
+        self.write_register(Register::HOUR_ALARM, data).await
+    }
+
+    /// Set the alarm day [1-31], keeping the AE bit unchanged.
+    pub async fn set_alarm_day(&mut self, day: u8) -> Result<(), Error<E>> {
+        if !(1..=31).contains(&day) {
+            return Err(Error::InvalidInputData);
+        }
+        let data: u8 = self.read_register(Register::DAY_ALARM).await?; // read current value
+        let data: u8 = data & BitFlags::AE; // keep the AE bit as is
+        let setting: u8 = encode_bcd(day);
+        let data: u8 = data | setting;
+        self.write_register(Register::DAY_ALARM, data).await
+    }
+
+    /// Set the alarm weekday [0-6], keeping the AE bit unchanged.
+    pub async fn set_alarm_weekday(&mut self, weekday: u8) -> Result<(), Error<E>> {
+        if weekday > 6 {
+            return Err(Error::InvalidInputData);
+        }
+        let data: u8 = self.read_register(Register::WEEKDAY_ALARM).await?; // read current value
+        let data: u8 = data & BitFlags::AE; // keep the AE bit as is
+        let setting: u8 = encode_bcd(weekday);
+        let data: u8 = data | setting;
+        self.write_register(Register::WEEKDAY_ALARM, data).await
+    }
+
+    /// Control alarm seconds (On: alarm enabled, Off: alarm disabled).
+    pub async fn control_alarm_seconds(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::Off => {
+                self.set_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE)
+                    .await
+            }
+            Control::On => {
+                self.clear_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE)
+                    .await
+            }
+        }
+    }
+
+    /// Is alarm seconds enabled?
+    pub async fn is_alarm_seconds_enabled(&mut self) -> Result<bool, Error<E>> {
+        Ok(!self
+            .is_register_bit_flag_high(Register::SECOND_ALARM, BitFlags::AE)
+            .await?)
+    }
+
+    /// Control alarm minutes (On: alarm enabled, Off: alarm disabled).
+    pub async fn control_alarm_minutes(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::Off => {
+                self.set_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE)
+                    .await
+            }
+            Control::On => {
+                self.clear_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE)
+                    .await
+            }
+        }
+    }
+
+    /// Is alarm minutes enabled?
+    pub async fn is_alarm_minutes_enabled(&mut self) -> Result<bool, Error<E>> {
+        Ok(!self
+            .is_register_bit_flag_high(Register::MINUTE_ALARM, BitFlags::AE)
+            .await?)
+    }
+
+    /// Control alarm hours (On: alarm enabled, Off: alarm disabled).
+    pub async fn control_alarm_hours(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::Off => {
+                self.set_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE)
+                    .await
+            }
+            Control::On => {
+                self.clear_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE)
+                    .await
+            }
+        }
+    }
+
+    /// Is alarm hours enabled?
+    pub async fn is_alarm_hours_enabled(&mut self) -> Result<bool, Error<E>> {
+        Ok(!self
+            .is_register_bit_flag_high(Register::HOUR_ALARM, BitFlags::AE)
+            .await?)
+    }
+
+    /// Control alarm day (On: alarm enabled, Off: alarm disabled).
+    pub async fn control_alarm_day(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::Off => {
+                self.set_register_bit_flag(Register::DAY_ALARM, BitFlags::AE)
+                    .await
+            }
+            Control::On => {
+                self.clear_register_bit_flag(Register::DAY_ALARM, BitFlags::AE)
+                    .await
+            }
+        }
+    }
+
+    /// Is alarm day enabled?
+    pub async fn is_alarm_day_enabled(&mut self) -> Result<bool, Error<E>> {
+        Ok(!self
+            .is_register_bit_flag_high(Register::DAY_ALARM, BitFlags::AE)
+            .await?)
+    }
+
+    /// Control alarm weekday (On: alarm enabled, Off: alarm disabled).
+    pub async fn control_alarm_weekday(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::Off => {
+                self.set_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE)
+                    .await
+            }
+            Control::On => {
+                self.clear_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE)
+                    .await
+            }
+        }
+    }
+
+    /// Is alarm weekday enabled?
+    pub async fn is_alarm_weekday_enabled(&mut self) -> Result<bool, Error<E>> {
+        Ok(!self
+            .is_register_bit_flag_high(Register::WEEKDAY_ALARM, BitFlags::AE)
+            .await?)
+    }
+
+    /// Enable or disable alarm interrupt.
+    pub async fn control_alarm_interrupt(&mut self, status: Control) -> Result<(), Error<E>> {
+        match status {
+            Control::On => {
+                self.set_register_bit_flag(Register::CONTROL_2, BitFlags::AIE)
+                    .await
+            }
+            Control::Off => {
+                self.clear_register_bit_flag(Register::CONTROL_2, BitFlags::AIE)
+                    .await
+            }
+        }
+    }
+
+    pub async fn get_alarm_time(&mut self) -> Result<Time, Error<E>> {
+        Ok(Time::from_hms(
+            self.get_alarm_hours().await?,
+            self.get_alarm_minutes().await?,
+            self.get_alarm_seconds().await?,
+        )?)
+    }
+
+    /// Read the alarm seconds setting.
+    pub async fn get_alarm_seconds(&mut self) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::SECOND_ALARM], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+        Ok(decode_bcd(data[0]))
+    }
+
+    /// Read the alarm minutes setting.
+    pub async fn get_alarm_minutes(&mut self) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::MINUTE_ALARM], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+        Ok(decode_bcd(data[0]))
+    }
+
+    /// Read the alarm hours setting.
+    pub async fn get_alarm_hours(&mut self) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::HOUR_ALARM], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+        Ok(decode_bcd(data[0]))
+    }
+
+    /// Read the alarm day setting.
+    pub async fn get_alarm_day(&mut self) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::DAY_ALARM], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+        Ok(decode_bcd(data[0]))
+    }
+
+    /// Read the alarm weekday setting.
+    pub async fn get_alarm_weekday(&mut self) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::WEEKDAY_ALARM], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+        Ok(decode_bcd(data[0]))
+    }
+
+    /// Get the alarm flag (if true, alarm event happened).
+    pub async fn get_alarm_flag(&mut self) -> Result<bool, Error<E>> {
+        self.is_register_bit_flag_high(Register::CONTROL_2, BitFlags::AF)
+            .await
+    }
+
+    /// Clear the alarm flag.
+    pub async fn clear_alarm_flag(&mut self) -> Result<(), Error<E>> {
+        self.clear_register_bit_flag(Register::CONTROL_2, BitFlags::AF)
+            .await
+    }
+
+    /// Check if alarm interrupt is enabled.
+    pub async fn is_alarm_interrupt_enabled(&mut self) -> Result<bool, Error<E>> {
+        self.is_register_bit_flag_high(Register::CONTROL_2, BitFlags::AIE)
+            .await
+    }
+
+    /// Shut off the alarms at once.
+    pub async fn disable_all_alarms(&mut self) -> Result<(), Error<E>> {
+        self.control_alarm_seconds(Control::Off).await?;
+        self.control_alarm_minutes(Control::Off).await?;
+        self.control_alarm_hours(Control::Off).await?;
+        self.control_alarm_day(Control::Off).await?;
+        self.control_alarm_weekday(Control::Off).await?;
+        Ok(())
+    }
+}

src/pcf85063a/datetime.rs

···
+//! All date and time-related functions will be defined here.
+//!
+//! Reading and setting single elements (seconds, hours, months) will NOT be implemented
+//! following the recommendations in the NXP datasheet to set and read all the seven date and time registers in one go.
+//!
+//! TO DO: As the chip may be used for devices that are clocks only, without the calendar function
+//! a convenient set_time() function could be added (sets only seconds, minutes and hours)
+
+use super::{DEVICE_ADDRESS, Error, PCF85063, Register, decode_bcd, encode_bcd};
+use embedded_hal_async::i2c::I2c;
+use time::{Date, PrimitiveDateTime, Time};
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    /// Read date and time all at once.
+    pub async fn get_datetime(&mut self) -> Result<PrimitiveDateTime, Error<E>> {
+        let mut data = [0; 7];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[Register::SECONDS], &mut data)
+            .await
+            .map_err(Error::I2C)?;
+
+        Ok(PrimitiveDateTime::new(
+            Date::from_calendar_date(
+                2000 + decode_bcd(data[6]) as i32,
+                decode_bcd(data[5] & 0x1f).try_into()?,
+                decode_bcd(data[3] & 0x3f),
+            )?,
+            Time::from_hms(
+                decode_bcd(data[2] & 0x3f),
+                decode_bcd(data[1] & 0b0111_1111),
+                decode_bcd(data[0] & 0b0111_1111),
+            )?,
+        ))
+    }
+
+    /// Set date and time all at once.
+    pub async fn set_datetime(&mut self, datetime: &PrimitiveDateTime) -> Result<(), Error<E>> {
+        let payload = [
+            Register::SECONDS, //first register
+            encode_bcd(datetime.second()),
+            encode_bcd(datetime.minute()),
+            encode_bcd(datetime.hour()),
+            encode_bcd(datetime.day()),
+            encode_bcd(datetime.weekday().number_days_from_sunday()),
+            encode_bcd(datetime.month().into()),
+            encode_bcd((datetime.year() - 2000) as u8),
+        ];
+        self.i2c
+            .write(DEVICE_ADDRESS, &payload)
+            .await
+            .map_err(Error::I2C)
+    }
+
+    /// Set only the time, date remains unchanged.
+    ///
+    /// Will return an 'Error::InvalidInputData' if any of the parameters is out of range.
+    pub async fn set_time(&mut self, time: &Time) -> Result<(), Error<E>> {
+        let payload = [
+            Register::SECONDS, //first register
+            encode_bcd(time.second()),
+            encode_bcd(time.minute()),
+            encode_bcd(time.hour()),
+        ];
+        self.i2c
+            .write(DEVICE_ADDRESS, &payload)
+            .await
+            .map_err(Error::I2C)
+    }
+}

src/pcf85063a/mod.rs

···
+#![no_std]
+
+mod alarm;
+mod datetime;
+
+use embedded_hal_1::i2c::I2c;
+
+/// All possible errors in this crate
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Error<E> {
+    /// I2C bus error
+    I2C(E),
+    /// Invalid input data
+    InvalidInputData,
+    /// A time component was out of range
+    ComponentRange,
+}
+
+impl<E> From<time::error::ComponentRange> for Error<E> {
+    fn from(_: time::error::ComponentRange) -> Self {
+        Self::ComponentRange
+    }
+}
+
+pub struct Register;
+
+impl Register {
+    // control and status registers
+    pub const CONTROL_1: u8 = 0x00;
+    pub const CONTROL_2: u8 = 0x01;
+    pub const OFFSET: u8 = 0x02;
+    pub const RAM_BYTE: u8 = 0x03;
+
+    // time and date registers
+    pub const SECONDS: u8 = 0x04;
+    pub const MINUTES: u8 = 0x05;
+    pub const HOURS: u8 = 0x06;
+    pub const DAYS: u8 = 0x07;
+    pub const WEEKDAYS: u8 = 0x08;
+    pub const MONTHS: u8 = 0x09;
+    pub const YEARS: u8 = 0x0A;
+
+    // alarm registers
+    pub const SECOND_ALARM: u8 = 0x0B;
+    pub const MINUTE_ALARM: u8 = 0x0C;
+    pub const HOUR_ALARM: u8 = 0x0D;
+    pub const DAY_ALARM: u8 = 0x0E;
+    pub const WEEKDAY_ALARM: u8 = 0x0F;
+
+    // timer registers
+    pub const TIMER_VALUE: u8 = 0x10;
+    pub const TIMER_MODE: u8 = 0x11;
+}
+
+pub struct BitFlags;
+
+impl BitFlags {
+    // control 1
+    pub const CAP_SEL: u8 = 0b0000_0001; // internal oscillator capacitor selection
+    pub const MODE_12_24: u8 = 0b0000_0010; // 12 or 24-hour mode
+    pub const CIE: u8 = 0b0000_0100; // connection interrupt enable
+    // 3: UNUSED
+    pub const SR: u8 = 0b0001_0000; // software reset
+    pub const STOP: u8 = 0b0010_0000; // RTC clock stop bit
+    // 6: UNUSED
+    pub const EXT_TEST: u8 = 0b1000_0000; // external clock test mode
+
+    // control 2
+    pub const COF: u8 = 0b0000_0111; // clkout control
+    pub const TF: u8 = 0b0000_1000; // timer flag
+    pub const HMI: u8 = 0b0001_0000; // half minute interrupt
+    pub const MI: u8 = 0b0010_0000; // minute interrupt
+    pub const AF: u8 = 0b0100_0000; // alarm flag
+    pub const AIE: u8 = 0b1000_0000; // alarm interrupt enabled
+
+    pub const AE: u8 = 0b1000_0000; // alarm enable/disable for all five (s/m/h/d/wd) settings
+}
+
+const DEVICE_ADDRESS: u8 = 0b1010001;
+
+/// Two possible choices, used for various enable/disable bit flags
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Control {
+    /// Enable some feature, eg. timer
+    On,
+    /// Disable some feature, eg. timer
+    Off,
+}
+
+/// PCF8563 driver
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PCF85063<I2C> {
+    /// The concrete I2C device implementation.
+    i2c: I2C,
+}
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    /// Create a new instance of the PCF8563 driver.
+    pub fn new(i2c: I2C) -> Self {
+        PCF85063 { i2c }
+    }
+
+    /// Reset the RTC
+    pub fn reset(&mut self) -> Result<(), Error<E>> {
+        self.set_register_bit_flag(Register::CONTROL_1, BitFlags::SR)
+    }
+
+    /// Destroy driver instance, return I2C bus instance.
+    pub fn destroy(self) -> I2C {
+        self.i2c
+    }
+
+    /// Let the device reset itself
+    pub fn perform_software_reset(&mut self) -> Result<(), Error<E>> {
+        self.write_register(Register::CONTROL_1, 0b01011000)
+    }
+
+    /// Write to a register.
+    pub fn write_register(&mut self, register: u8, data: u8) -> Result<(), Error<E>> {
+        let payload: [u8; 2] = [register, data];
+        self.i2c.write(DEVICE_ADDRESS, &payload).map_err(Error::I2C)
+    }
+
+    /// Read from a register.
+    pub fn read_register(&mut self, register: u8) -> Result<u8, Error<E>> {
+        let mut data = [0];
+        self.i2c
+            .write_read(DEVICE_ADDRESS, &[register], &mut data)
+            .map_err(Error::I2C)
+            .and(Ok(data[0]))
+    }
+
+    /// Check if specific bits are set.
+    pub fn is_register_bit_flag_high(
+        &mut self,
+        address: u8,
+        bitmask: u8,
+    ) -> Result<bool, Error<E>> {
+        let data = self.read_register(address)?;
+        Ok((data & bitmask) != 0)
+    }
+
+    /// Set specific bits.
+    pub fn set_register_bit_flag(&mut self, address: u8, bitmask: u8) -> Result<(), Error<E>> {
+        let data = self.read_register(address)?;
+        if (data & bitmask) == 0 {
+            self.write_register(address, data | bitmask)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Clear specific bits.
+    pub fn clear_register_bit_flag(&mut self, address: u8, bitmask: u8) -> Result<(), Error<E>> {
+        let data = self.read_register(address)?;
+        if (data & bitmask) != 0 {
+            self.write_register(address, data & !bitmask)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    pub fn read_ram_byte(&mut self) -> Result<u8, Error<E>> {
+        self.read_register(Register::RAM_BYTE)
+    }
+
+    pub fn write_ram_byte(&mut self, byte: u8) -> Result<(), Error<E>> {
+        self.write_register(Register::RAM_BYTE, byte)
+    }
+}
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    pub fn stop_clock(&mut self) -> Result<(), Error<E>> {
+        self.set_register_bit_flag(Register::CONTROL_1, BitFlags::STOP)
+    }
+
+    pub fn start_clock(&mut self) -> Result<(), Error<E>> {
+        self.clear_register_bit_flag(Register::CONTROL_1, BitFlags::STOP)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+pub enum OutputFrequency {
+    Hz32768 = 0b000,
+    Hz16384 = 0b001,
+    Hz8192 = 0b010,
+    Hz4096 = 0b011,
+    Hz2048 = 0b100,
+    Hz1024 = 0b101,
+    Hz1 = 0b110,
+    Hz0 = 0b111,
+}
+
+impl Default for OutputFrequency {
+    fn default() -> Self {
+        OutputFrequency::Hz32768
+    }
+}
+
+impl OutputFrequency {
+    pub const fn bits(self) -> u8 {
+        self as u8
+    }
+}
+
+impl<I2C, E> PCF85063<I2C>
+where
+    I2C: I2c<Error = E>,
+{
+    pub fn read_clock_output_frequency(&mut self) -> Result<OutputFrequency, Error<E>> {
+        let value = self.read_register(Register::CONTROL_2)? & BitFlags::COF;
+
+        Ok(unsafe { core::mem::transmute(value) })
+    }
+
+    pub fn write_clock_output_frequency(&mut self, freq: OutputFrequency) -> Result<(), Error<E>> {
+        let value = self.read_register(Register::CONTROL_2)?;
+        let cleared = value ^ BitFlags::COF;
+        let set = cleared | freq as u8;
+
+        self.write_register(Register::CONTROL_2, set)
+    }
+}
+
+/// Convert the Binary Coded Decimal value to decimal (only the lowest 7 bits).
+fn decode_bcd(input: u8) -> u8 {
+    let digits: u8 = input & 0xf;
+    let tens: u8 = (input >> 4) & 0x7;
+    10 * tens + digits
+}
+
+/// Convert the decimal value to Binary Coded Decimal.
+fn encode_bcd(input: u8) -> u8 {
+    let digits: u8 = input % 10;
+    let tens: u8 = input / 10;
+    let tens = tens << 4;
+    tens + digits
+}