NixieTubeClock/Nixie_Firmware_Rust/src/ds3231.rs

use field_offset::offset_of;
use stm32l4xx_hal::prelude::{
    _embedded_hal_blocking_i2c_Write, _embedded_hal_blocking_i2c_WriteRead,
};
use tock_registers::{
    interfaces::{ReadWriteable, Readable, Writeable},
    register_bitfields, register_structs,
    registers::InMemoryRegister,
};

const DS3231_ADDR: u8 = 0x68;

register_bitfields![
    u8,
    T_SECOND [
        Value OFFSET(0) NUMBITS(7) [],
    ],
    T_MINUTE [
        Value OFFSET(0) NUMBITS(7) [],
    ],
    T_HOUR [
        Value OFFSET(0) NUMBITS(6) [],
        n24 OFFSET(6) NUMBITS(1) [],
    ],
    T_WEEKDAY [
        Value OFFSET(0) NUMBITS(3) [],
    ],
    T_DAY [
        Value OFFSET(0) NUMBITS(6) [],
    ],
    T_MONTH [
        Value OFFSET(0) NUMBITS(5) [],
        Century OFFSET(7) NUMBITS(1) [],
    ],
    T_YEAR [
        Value OFFSET(0) NUMBITS(8) [],
    ],
    A_SECOND [
        Value OFFSET(0) NUMBITS(7) [],
        M1 OFFSET(7) NUMBITS(1) [],
    ],
    A_MINUTE [
        Value OFFSET(0) NUMBITS(7) [],
        M2 OFFSET(7) NUMBITS(1) [],
    ],
    A_HOUR [
        Value OFFSET(0) NUMBITS(6) [],
        n24 OFFSET(6) NUMBITS(1) [],
        M3 OFFSET(7) NUMBITS(1) [],
    ],
    A_DAY_DATE [
        Value OFFSET(0) NUMBITS(6) [],
        nDT OFFSET(6) NUMBITS(1) [],
        M4 OFFSET(7) NUMBITS(1) [],
    ],
    CONTROL_1 [
        A1IE 0,
        A2IE 1,
        INTCN 2,
        RS1 3,
        RS2 4,
        CONV 5,
        BBSQW 6,
        nEOSC 7,
    ],
    CONTROL_2 [
        A1F 0,
        A2F 1,
        BSY 2,
        EN32KHZ 3,
        OSF 7,
    ],
    AGING_OFFSET [
        Value OFFSET(0) NUMBITS(7) [],
        Sign OFFSET(7) NUMBITS(1) [],
    ],
    TEMP_MSB [
        Value OFFSET(0) NUMBITS(7) [],
        Sign OFFSET(7) NUMBITS(1) [],
    ],
    TEMP_LSB [
        Value OFFSET(6) NUMBITS(2) [],
    ],
];

register_structs! {
    Ds3231Registers {
        (0x00 => second: InMemoryRegister<u8, T_SECOND::Register>),
        (0x01 => minute: InMemoryRegister<u8, T_MINUTE::Register>),
        (0x02 => hour: InMemoryRegister<u8, T_HOUR::Register>),
        (0x03 => weekday: InMemoryRegister<u8, T_WEEKDAY::Register>),
        (0x04 => day: InMemoryRegister<u8, T_DAY::Register>),
        (0x05 => month: InMemoryRegister<u8, T_MONTH::Register>),
        (0x06 => year: InMemoryRegister<u8, T_YEAR::Register>),
        (0x07 => a1_second: InMemoryRegister<u8, A_SECOND::Register>),
        (0x08 => a1_minute: InMemoryRegister<u8, A_MINUTE::Register>),
        (0x09 => a1_hour: InMemoryRegister<u8, A_HOUR::Register>),
        (0x0A => a1_day_date: InMemoryRegister<u8, A_DAY_DATE::Register>),
        (0x0B => a2_minute: InMemoryRegister<u8, A_MINUTE::Register>),
        (0x0C => a2_hour: InMemoryRegister<u8, A_HOUR::Register>),
        (0x0D => a2_day_date: InMemoryRegister<u8, A_DAY_DATE::Register>),
        (0x0E => control_1: InMemoryRegister<u8, CONTROL_1::Register>),
        (0x0F => control_2: InMemoryRegister<u8, CONTROL_2::Register>),
        (0x10 => aging_offset: InMemoryRegister<u8, AGING_OFFSET::Register>),
        (0x11 => temp_msb: InMemoryRegister<u8, TEMP_MSB::Register>),
        (0x12 => temp_lsb: InMemoryRegister<u8, TEMP_LSB::Register>),
        (0x13 => @END),
    }
}

pub enum Weekday {
    Sunday = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
}

impl From<u8> for Weekday {
    fn from(value: u8) -> Self {
        match value {
            0 => Weekday::Sunday,
            1 => Weekday::Monday,
            2 => Weekday::Tuesday,
            3 => Weekday::Wednesday,
            4 => Weekday::Thursday,
            5 => Weekday::Friday,
            6 => Weekday::Saturday,
            _ => panic!(),
        }
    }
}

impl Ds3231Registers {
    const fn default() -> Self {
        Self {
            second: InMemoryRegister::new(0x00),
            minute: InMemoryRegister::new(0x00),
            hour: InMemoryRegister::new(0x00),
            weekday: InMemoryRegister::new(0x00),
            day: InMemoryRegister::new(0x00),
            month: InMemoryRegister::new(0x00),
            year: InMemoryRegister::new(0x00),
            a1_second: InMemoryRegister::new(0x00),
            a1_minute: InMemoryRegister::new(0x00),
            a1_hour: InMemoryRegister::new(0x00),
            a1_day_date: InMemoryRegister::new(0x00),
            a2_minute: InMemoryRegister::new(0x00),
            a2_hour: InMemoryRegister::new(0x00),
            a2_day_date: InMemoryRegister::new(0x00),
            control_1: InMemoryRegister::new(0x00),
            control_2: InMemoryRegister::new(0x00),
            aging_offset: InMemoryRegister::new(0x00),
            temp_msb: InMemoryRegister::new(0x00),
            temp_lsb: InMemoryRegister::new(0x00),
        }
    }
    fn i2c_write_ctrl(&self, address: u8, i2c: &mut impl _embedded_hal_blocking_i2c_Write) {
        let mut buffer: [u8; 3] = [0; 3];
        buffer[0] = offset_of!(Ds3231Registers => control_1).get_byte_offset() as u8;
        buffer[1] = self.control_1.get();
        buffer[2] = self.control_2.get();

        match i2c.write(address, &buffer) {
            Ok(_) => (),
            Err(_) => panic!(),
        }
    }
    fn i2c_write_time(&self, address: u8, i2c: &mut impl _embedded_hal_blocking_i2c_Write) {
        let mut buffer: [u8; 4] = [0; 4];
        buffer[0] = offset_of!(Ds3231Registers => second).get_byte_offset() as u8;
        buffer[1] = self.second.get();
        buffer[2] = self.minute.get();
        buffer[3] = self.hour.get();

        match i2c.write(address, &buffer) {
            Ok(_) => (),
            Err(_) => panic!(),
        }
    }
    fn i2c_write_date(&self, address: u8, i2c: &mut impl _embedded_hal_blocking_i2c_Write) {
        let mut buffer: [u8; 5] = [0; 5];
        buffer[0] = offset_of!(Ds3231Registers => weekday).get_byte_offset() as u8;
        buffer[1] = self.weekday.get();
        buffer[2] = self.day.get();
        buffer[3] = self.month.get();
        buffer[4] = self.year.get();

        match i2c.write(address, &buffer) {
            Ok(_) => (),
            Err(_) => panic!(),
        }
    }
    // Returns the second, minute, and hour from the RTC
    fn i2c_read_time(&mut self, address: u8, i2c: &mut impl _embedded_hal_blocking_i2c_WriteRead) {
        let mut buffer: [u8; 3] = [0; 3];

        match i2c.write_read(
            address,
            &[offset_of!(Ds3231Registers => second).get_byte_offset() as u8],
            &mut buffer,
        ) {
            Ok(_) => (),
            Err(_) => panic!(),
        }
    }
    // Returns the weekday, day, month, year, and century from the RTC
    fn i2c_read_date(&mut self, address: u8, i2c: &mut impl _embedded_hal_blocking_i2c_WriteRead) {
        let mut buffer: [u8; 4] = [0; 4];

        match i2c.write_read(
            address,
            &[offset_of!(Ds3231Registers => weekday).get_byte_offset() as u8],
            &mut buffer,
        ) {
            Ok(_) => (),
            Err(_) => panic!(),
        }
    }
}

pub fn init(i2c: &mut impl _embedded_hal_blocking_i2c_Write) {
    let regs = Ds3231Registers::default();

    regs.control_1.modify(
        CONTROL_1::nEOSC::CLEAR // Enable internal oscillator on VBAT
            + CONTROL_1::BBSQW::CLEAR // Disable outputs on VBAT
            + CONTROL_1::RS1::CLEAR   // Set square wave output to 1Hz
            + CONTROL_1::RS2::CLEAR   // Set square wave output to 1Hz
            + CONTROL_1::INTCN::CLEAR // Enable square wave output
            + CONTROL_1::A1IE::CLEAR  // Disable alarm 1
            + CONTROL_1::A2IE::CLEAR, // Disable alarm 2
    );

    // Disable 32kHz output
    regs.control_2.modify(CONTROL_2::EN32KHZ::CLEAR);

    regs.i2c_write_ctrl(DS3231_ADDR, i2c);
}

pub fn set_time(
    i2c: &mut impl _embedded_hal_blocking_i2c_Write,
    second: u32,
    minute: u32,
    hour: u32,
) {
    let regs = Ds3231Registers::default();

    regs.second
        .write(T_SECOND::Value.val(decimal_to_bcd(second)));
    regs.minute
        .write(T_MINUTE::Value.val(decimal_to_bcd(minute)));
    regs.hour.write(T_HOUR::Value.val(decimal_to_bcd(hour)));

    regs.i2c_write_time(DS3231_ADDR, i2c);
}

pub fn set_date(
    i2c: &mut impl _embedded_hal_blocking_i2c_Write,
    weekday: Weekday,
    day: u32,
    month: u32,
    year: u32,
    century: u32,
) {
    let regs = Ds3231Registers::default();

    regs.weekday
        .write(T_WEEKDAY::Value.val(decimal_to_bcd(weekday as u32)));
    regs.day.write(T_DAY::Value.val(decimal_to_bcd(day)));
    regs.month.modify(
        T_MONTH::Value.val(decimal_to_bcd(month)) + T_MONTH::Century.val(decimal_to_bcd(century)),
    );
    regs.year.write(T_YEAR::Value.val(decimal_to_bcd(year)));

    regs.i2c_write_time(DS3231_ADDR, i2c);
}

pub fn get_time(
    i2c: &mut impl _embedded_hal_blocking_i2c_WriteRead,
) -> (u32, u32, u32) {
    let mut regs = Ds3231Registers::default();

    regs.i2c_read_time(DS3231_ADDR, i2c);

    let second = bcd_to_decimal(regs.second.read(T_SECOND::Value));
    let minute = bcd_to_decimal(regs.minute.read(T_MINUTE::Value));
    let hour = bcd_to_decimal(regs.hour.read(T_HOUR::Value));

    (second, minute, hour)
}

pub fn get_date(
    i2c: &mut impl _embedded_hal_blocking_i2c_WriteRead,
) -> (Weekday, u32, u32, u32, u32) {
    let mut regs = Ds3231Registers::default();

    regs.i2c_read_date(DS3231_ADDR, i2c);

    let weekday: Weekday = regs.weekday.read(T_WEEKDAY::Value).into();
    let day = bcd_to_decimal(regs.day.read(T_DAY::Value));
    let month = bcd_to_decimal(regs.month.read(T_MONTH::Value));
    let year = bcd_to_decimal(regs.year.read(T_YEAR::Value));
    let century = bcd_to_decimal(regs.month.read(T_MONTH::Century));

    (weekday, day, month, year, century)
}

#[inline]
fn bcd_to_decimal(value: u8) -> u32 {
    (((value >> 4) * 10) + (value & 0xF)) as u32
}
#[inline]
fn decimal_to_bcd(value: u32) -> u8 {
    (((value / 10) << 4) | (value % 10)) as u8
}

pub fn in_dst(weekday: Weekday, day: u32, month: u32, hour_24: u32) -> bool {
    let prev_sunday: i32 = day as i32 - weekday as i32;
    match month {
        0..=2 | 12.. => false,
        4..=10 => true,
        3 => match prev_sunday {
            ..8 => false,
            15.. => true,
            d if d == day as i32 => hour_24 >= 2,
            _ => true,
        },
        11 => match prev_sunday {
            ..=0 => true,
            8.. => false,
            d if d == day as i32 => hour_24 < 2,
            _ => false,
        },
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn dst_test() {
        // 2020 - begins Mar 8th @ 2AM (Sunday), ends Nov 1st @ 2AM (Sunday)
        assert!(in_dst(Weekday::Sunday, 8, 3, 1) == false);
        assert!(in_dst(Weekday::Sunday, 8, 3, 2) == true);
        assert!(in_dst(Weekday::Sunday, 8, 3, 3) == true);
        assert!(in_dst(Weekday::Sunday, 1, 11, 1) == true);
        assert!(in_dst(Weekday::Sunday, 1, 11, 2) == false);
        assert!(in_dst(Weekday::Sunday, 1, 11, 3) == false);

        // 2021 - begins Mar 14th @ 2AM (Sunday), ends Nov 7th @ 2AM (Sunday)
        assert!(in_dst(Weekday::Sunday, 14, 3, 1) == false);
        assert!(in_dst(Weekday::Sunday, 14, 3, 2) == true);
        assert!(in_dst(Weekday::Sunday, 14, 3, 3) == true);
        assert!(in_dst(Weekday::Sunday, 7, 11, 1) == true);
        assert!(in_dst(Weekday::Sunday, 7, 11, 2) == false);
        assert!(in_dst(Weekday::Sunday, 7, 11, 3) == false);

        // 2022 - begins Mar 13th @ 2AM (Sunday), ends Nov 6th @ 2AM (Sunday)
        assert!(in_dst(Weekday::Sunday, 13, 3, 1) == false);
        assert!(in_dst(Weekday::Sunday, 13, 3, 2) == true);
        assert!(in_dst(Weekday::Sunday, 13, 3, 3) == true);
        assert!(in_dst(Weekday::Sunday, 6, 11, 1) == true);
        assert!(in_dst(Weekday::Sunday, 6, 11, 2) == false);
        assert!(in_dst(Weekday::Sunday, 6, 11, 3) == false);

        // 2023 - begins Mar 12th @ 2AM (Sunday), ends Nov 5th @ 2AM (Sunday)
        assert!(in_dst(Weekday::Sunday, 12, 3, 1) == false);
        assert!(in_dst(Weekday::Sunday, 12, 3, 2) == true);
        assert!(in_dst(Weekday::Sunday, 12, 3, 3) == true);
        assert!(in_dst(Weekday::Sunday, 5, 11, 1) == true);
        assert!(in_dst(Weekday::Sunday, 5, 11, 2) == false);
        assert!(in_dst(Weekday::Sunday, 5, 11, 3) == false);

        // Sanity check other dates in 2021
        assert!(in_dst(Weekday::Friday, 1, 1, 0) == false);
        assert!(in_dst(Weekday::Monday, 1, 2, 0) == false);
        assert!(in_dst(Weekday::Monday, 1, 3, 0) == false);
        assert!(in_dst(Weekday::Thursday, 1, 4, 0) == true);
        assert!(in_dst(Weekday::Saturday, 1, 5, 0) == true);
        assert!(in_dst(Weekday::Tuesday, 1, 6, 0) == true);
        assert!(in_dst(Weekday::Thursday, 1, 7, 0) == true);
        assert!(in_dst(Weekday::Sunday, 1, 8, 0) == true);
        assert!(in_dst(Weekday::Wednesday, 1, 9, 0) == true);
        assert!(in_dst(Weekday::Friday, 1, 10, 0) == true);
        assert!(in_dst(Weekday::Monday, 1, 11, 0) == true);
        assert!(in_dst(Weekday::Wednesday, 1, 12, 0) == false);
    }
}