Add get alarm helper to reduce code duplication

alarms.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace rtc {
+
+enum class Alarm1Rate : uint8_t {
+	ONCE_PER_S = 0b1111,
+	WHEN_S_MATCH = 0b1110,
+	WHEN_M_S_MATCH = 0b1100,
+	WHEN_H_M_S_MATCH = 0b1000,
+	WHEN_DATE_H_M_S_MATCH = 0b00000,
+	WHEN_DAY_H_N_S_MATCH = 0b10000,
+};
+
+enum class Alarm2Rate : uint8_t {
+	ONCE_PER_M = 0b111,
+	WHEN_M_MATCH = 0b110,
+	WHEN_H_M_MATCH = 0b100,
+	WHEN_DATE_H_M_MATCH = 0b0000,
+	WHEN_DAY_H_N_MATCH = 0b1000,
+};
+
+} // namespace rtc

ds3231.hpp

@@ -142,6 +142,15 @@ class DS3231 {
 		return dateTime;
 	}
 
+	static DateTime getAlarm1()
+	{
+		return getAlarmHelper<ALARM1_REG_ADDR>();
+	}
+	static DateTime getAlarm2()
+	{
+		return getAlarmHelper<ALARM2_REG_ADDR>();
+	}
+
 	static void setDate(const Date &date)
 	{
 		detail::TimeReg timeReg;
@@ -187,6 +196,37 @@ class DS3231 {
 		writePartialRegister<START_OFFSET, END_OFFSET>(timeReg);
 	}
 
+	static void setAlarm1(const DateTime &alarmTime, const Alarm1Rate &alarmRate, bool enableInterrupt = true)
+	{
+		setAlarmHelper(alarmTime, alarmRate);
+		if (enableInterrupt)
+			enableInterruptHelper<detail::ControlRegFlags::A1IE>();
+	}
+	static void setAlarm2(const DateTime &alarmTime, const Alarm2Rate &alarmRate, bool enableInterrupt = true)
+	{
+		setAlarmHelper(alarmTime, alarmRate);
+		if (enableInterrupt)
+			enableInterruptHelper<detail::ControlRegFlags::A2IE>();
+	}
+
+	static bool checkAlarm1()
+	{
+		return checkAlarmHelper<detail::ControlStatusRegFlags::A1F>();
+	}
+	static bool checkAlarm2()
+	{
+		return checkAlarmHelper<detail::ControlStatusRegFlags::A2F>();
+	}
+
+	static void clearAlarm1()
+	{
+		clearAlarmHelper<detail::ControlStatusRegFlags::A1F>();
+	}
+	static void clearAlarm2()
+	{
+		clearAlarmHelper<detail::ControlStatusRegFlags::A2F>();
+	}
+
   private:
 	template <uint8_t Address, typename Register>
 	static Register readRegisterHelper()
@@ -268,6 +308,79 @@ class DS3231 {
 		writePartialRegister<0, sizeof(Register) - 1>(reg);
 	}
 
+	template <uint8_t Address>
+	static inline auto getAlarmHelper()
+	{
+		constexpr auto IsAlarm1 = Address == ALARM1_REG_ADDR;
+		static_assert(IsAlarm1 || Address == ALARM2_REG_ADDR, "Must use valid alarm address");
+
+		const auto alarmReg = readRegister<Address>();
+
+		DateTime alarmTime = {};
+		alarmReg.getDate(alarmTime.day);
+		alarmTime.hour = alarmReg.getHours();
+		alarmTime.minute = alarmReg.getMinutes();
+		if constexpr (IsAlarm1)
+			alarmTime.second = alarmReg.getSeconds();
+
+		return alarmTime;
+	}
+
+	template <typename AlarmRate>
+	static inline void setAlarmHelper(const DateTime &alarmTime, const AlarmRate &alarmRate)
+	{
+		constexpr auto IsAlarm1 = util::is_same_v<AlarmRate, Alarm1Rate>;
+		static_assert(IsAlarm1 || util::is_same_v<AlarmRate, Alarm2Rate>, "Must use valid alarm rate");
+
+		using alarm_reg_t = util::conditional_t<IsAlarm1, detail::Alarm1Reg, detail::Alarm2Reg>;
+
+		alarm_reg_t alarmReg;
+		alarmReg.setAlarmRate(alarmRate);
+		alarmReg.setDate(alarmTime.day);
+		alarmReg.setHours(alarmTime.hour);
+		alarmReg.setMinutes(alarmTime.minute);
+		if constexpr (IsAlarm1)
+			alarmReg.setSeconds(alarmTime.second);
+		writeRegister(alarmReg);
+	}
+
+	template <detail::ControlRegFlags AlarmFlag>
+	static inline void enableInterruptHelper()
+	{
+		constexpr auto IsAlarm1Flag = AlarmFlag == detail::ControlRegFlags::A1IE;
+		constexpr auto IsAlarm2Flag = AlarmFlag == detail::ControlRegFlags::A2IE;
+		static_assert(IsAlarm1Flag || IsAlarm2Flag, "Must use valid alarm flag");
+
+		auto controlReg = readRegister<CONTROL_REG_ADDR>();
+		using Flags = typename decltype(controlReg)::Flags;
+		controlReg &= ~Flags::BBSQW;
+		controlReg |= Flags::INTCN | AlarmFlag;
+		writeRegister(controlReg);
+	}
+
+	template <detail::ControlStatusRegFlags AlarmFlag>
+	static inline bool checkAlarmHelper()
+	{
+		constexpr auto IsAlarm1Flag = AlarmFlag == detail::ControlStatusRegFlags::A1F;
+		constexpr auto IsAlarm2Flag = AlarmFlag == detail::ControlStatusRegFlags::A2F;
+		static_assert(IsAlarm1Flag || IsAlarm2Flag, "Must use valid alarm flag");
+
+		const auto alarmStatus = readRegister<CONTROL_STATUS_REG_ADDR>();
+		return alarmStatus == AlarmFlag;
+	}
+
+	template <detail::ControlStatusRegFlags AlarmFlag>
+	static inline void clearAlarmHelper()
+	{
+		constexpr auto IsAlarm1Flag = AlarmFlag == detail::ControlStatusRegFlags::A1F;
+		constexpr auto IsAlarm2Flag = AlarmFlag == detail::ControlStatusRegFlags::A2F;
+		static_assert(IsAlarm1Flag || IsAlarm2Flag, "Must use valid alarm flag");
+
+		auto controlStatusReg = readRegister<CONTROL_STATUS_REG_ADDR>();
+		controlStatusReg &= ~AlarmFlag;
+		writeRegister(controlStatusReg);
+	}
+
 	static uint8_t calcDayOfWeek(uint16_t year, uint8_t month, uint16_t day)
 	{
 		day += month < 3 ? year-- : year - 2;

registers.hpp

@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 
+#include "alarms.hpp"
 #include "flags.hpp"
 
 namespace rtc {
@@ -194,15 +195,6 @@ struct [[gnu::packed]] Alarm1Reg
 	uint8_t hours = 0;
 	uint8_t day_date = 0;
 
-	enum class AlarmRate {
-		ONCE_PER_S = 0b1111,
-		WHEN_S_MATCH = 0b1110,
-		WHEN_M_S_MATCH = 0b1100,
-		WHEN_H_M_S_MATCH = 0b1000,
-		WHEN_DATE_H_M_S_MATCH = 0b00000,
-		WHEN_DAY_H_N_S_MATCH = 0b10000,
-	};
-
 	//////////////////////////////////////////////////////////////////////////
 
 	inline uint8_t getSeconds() const
@@ -225,7 +217,7 @@ struct [[gnu::packed]] Alarm1Reg
 	{
 		return getEncodedDate(date, day_date);
 	}
-	inline AlarmRate getAlarmRate() const
+	inline Alarm1Rate getAlarmRate() const
 	{
 		constexpr auto M_FLAG = 7;
 		const auto m1 = (seconds >> M_FLAG) & 1;
@@ -236,9 +228,9 @@ struct [[gnu::packed]] Alarm1Reg
 		if (m == 0) {
 			constexpr auto DAY_FLAG = 6;
 			const auto dayFormat = ((day_date >> DAY_FLAG) & 1) << 4;
-			return static_cast<AlarmRate>(dayFormat);
+			return static_cast<Alarm1Rate>(dayFormat);
 		}
-		return static_cast<AlarmRate>(m);
+		return static_cast<Alarm1Rate>(m);
 	}
 
 	//////////////////////////////////////////////////////////////////////////
@@ -263,7 +255,7 @@ struct [[gnu::packed]] Alarm1Reg
 	{
 		setEncodedDate(day_date, date);
 	}
-	inline void setAlarmRate(const AlarmRate &alarmRate)
+	inline void setAlarmRate(const Alarm1Rate &alarmRate)
 	{
 		const auto alarmRateFlags = static_cast<uint8_t>(alarmRate);
 		constexpr auto M_FLAG = 7;
@@ -288,14 +280,6 @@ struct [[gnu::packed]] Alarm2Reg
 	uint8_t hours = 0;
 	uint8_t day_date = 0;
 
-	enum class AlarmRate {
-		ONCE_PER_M = 0b111,
-		WHEN_M_MATCH = 0b110,
-		WHEN_H_M_MATCH = 0b100,
-		WHEN_DATE_H_M_MATCH = 0b0000,
-		WHEN_DAY_H_N_MATCH = 0b1000,
-	};
-
 	//////////////////////////////////////////////////////////////////////////
 
 	inline uint8_t getMinutes() const
@@ -314,7 +298,7 @@ struct [[gnu::packed]] Alarm2Reg
 	{
 		return getEncodedDate(date, day_date);
 	}
-	inline AlarmRate getAlarmRate() const
+	inline Alarm2Rate getAlarmRate() const
 	{
 		constexpr auto M_FLAG = 7;
 		const auto m2 = (minutes >> M_FLAG) & 1;
@@ -324,9 +308,9 @@ struct [[gnu::packed]] Alarm2Reg
 		if (m == 0) {
 			constexpr auto DAY_FLAG = 6;
 			const auto dayFormat = ((day_date >> DAY_FLAG) & 1) << 3;
-			return static_cast<AlarmRate>(dayFormat);
+			return static_cast<Alarm2Rate>(dayFormat);
 		}
-		return static_cast<AlarmRate>(m);
+		return static_cast<Alarm2Rate>(m);
 	}
 
 	//////////////////////////////////////////////////////////////////////////
@@ -347,7 +331,7 @@ struct [[gnu::packed]] Alarm2Reg
 	{
 		setEncodedDate(day_date, date);
 	}
-	inline void setAlarmRate(const AlarmRate &alarmRate)
+	inline void setAlarmRate(const Alarm2Rate &alarmRate)
 	{
 		const auto alarmRateFlags = static_cast<uint8_t>(alarmRate);
 		constexpr auto M_FLAG = 7;