Adapt to moved type submodule

.gitmodules

@@ -1,18 +0,0 @@
-[submodule "ds3231/ds3231"]
-	path = ds3231/ds3231
-	url = git@git.blackmark.me:avr/ds3231.git
-[submodule "ds3231/uart"]
-	path = ds3231/uart
-	url = git@git.blackmark.me:avr/uart.git
-[submodule "ds3231/io"]
-	path = ds3231/io
-	url = git@git.blackmark.me:avr/io.git
-[submodule "ds3231/flash"]
-	path = ds3231/flash
-	url = git@git.blackmark.me:avr/flash.git
-[submodule "ds3231/i2c"]
-	path = ds3231/i2c
-	url = git@git.blackmark.me:avr/i2c.git
-[submodule "ds3231/util"]
-	path = ds3231/util
-	url = git@git.blackmark.me:avr/util.git

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 BlackMark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ds3231.atsln

@@ -1,22 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Atmel Studio Solution File, Format Version 11.00
-VisualStudioVersion = 14.0.25420.1
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{E66E83B9-2572-4076-B26E-6BE79FF3018A}") = "ds3231", "ds3231\ds3231.cppproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|AVR = Debug|AVR
-		Release|AVR = Release|AVR
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.ActiveCfg = Debug|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.Build.0 = Debug|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.ActiveCfg = Release|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.Build.0 = Release|AVR
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

ds3231.hpp

@@ -0,0 +1,214 @@
+#pragma once
+
+#include "../clock.hpp"
+
+#include <stddef.h>
+
+#include "../i2c/i2c.hpp"
+#include "../util/type.hpp"
+
+#include "registers.hpp"
+
+namespace rtc {
+
+struct Date {
+	uint16_t year;
+	uint8_t month;
+	uint8_t day;
+};
+
+struct Time {
+	uint8_t hour;
+	uint8_t minute;
+	uint8_t second;
+};
+
+struct DateTime : Date, Time {
+};
+
+template <typename I2cDriver, bool SetDayOfWeek = true>
+class DS3231 {
+  public:
+	static constexpr auto I2C_ADDRESS = 0x68;
+
+	static constexpr auto TIME_REG_ADDR = 0x00;
+	static constexpr auto ALARM1_REG_ADDR = 0x07;
+	static constexpr auto ALARM2_REG_ADDR = 0x0B;
+	static constexpr auto CONTROL_REG_ADDR = 0x0E;
+	static constexpr auto CONTROL_STATUS_REG_ADDR = 0x0F;
+	static constexpr auto AGING_OFFSET_REG_ADDR = 0x10;
+	static constexpr auto TEMP_REG_ADDR = 0x11;
+
+	// Construction does not call init and is only available for convenience
+	DS3231() = default;
+
+	// Moving and copying ds3231 objects is not supported
+	DS3231(const DS3231 &) = delete;
+	DS3231(DS3231 &&) = delete;
+	DS3231 &operator=(const DS3231 &) = delete;
+	DS3231 &operator=(DS3231 &&) = delete;
+
+	static inline void init()
+	{
+		I2cDriver::init();
+	}
+
+	static auto getDate()
+	{
+		const auto timeReg = readRegister<TIME_REG_ADDR>();
+
+		Date date;
+		date.year = timeReg.getYear();
+		date.month = timeReg.getMonth();
+		date.day = timeReg.getDate();
+		return date;
+	}
+	static auto getTime()
+	{
+		const auto timeReg = readRegister<TIME_REG_ADDR>();
+
+		Time time;
+		time.hour = timeReg.getHours();
+		time.minute = timeReg.getMinutes();
+		time.second = timeReg.getSeconds();
+		return time;
+	}
+	static auto getDateTime()
+	{
+		const auto timeReg = readRegister<TIME_REG_ADDR>();
+
+		DateTime dateTime;
+		dateTime.year = timeReg.getYear();
+		dateTime.month = timeReg.getMonth();
+		dateTime.day = timeReg.getDate();
+		dateTime.hour = timeReg.getHours();
+		dateTime.minute = timeReg.getMinutes();
+		dateTime.second = timeReg.getSeconds();
+		return dateTime;
+	}
+
+	static void setDate(const Date &date)
+	{
+		detail::TimeReg timeReg;
+		timeReg.setYear(date.year);
+		timeReg.setMonth(date.month);
+		timeReg.setDate(date.day);
+		if constexpr (SetDayOfWeek)
+			timeReg.setDay(calcDayOfWeek(date.year, date.month, date.day) + 1);
+
+		constexpr auto DATE_START_OFFSET = offsetof(detail::TimeReg, day);
+		constexpr auto DATE_END_OFFSET = offsetof(detail::TimeReg, year);
+
+		writePartialRegister<TIME_REG_ADDR, DATE_START_OFFSET, DATE_END_OFFSET>(timeReg);
+	}
+	static void setTime(const Time &time)
+	{
+		detail::TimeReg timeReg;
+		timeReg.setHours(time.hour);
+		timeReg.setMinutes(time.minute);
+		timeReg.setSeconds(time.second);
+
+		constexpr auto TIME_START_OFFSET = offsetof(detail::TimeReg, seconds);
+		constexpr auto TIME_END_OFFSET = offsetof(detail::TimeReg, hours);
+
+		writePartialRegister<TIME_REG_ADDR, TIME_START_OFFSET, TIME_END_OFFSET>(timeReg);
+	}
+	static void setDateTime(const DateTime &dateTime)
+	{
+		detail::TimeReg timeReg;
+		timeReg.setYear(dateTime.year);
+		timeReg.setMonth(dateTime.month);
+		timeReg.setDate(dateTime.day);
+		if constexpr (SetDayOfWeek)
+			timeReg.setDay(calcDayOfWeek(dateTime.year, dateTime.month, dateTime.day) + 1);
+
+		timeReg.setHours(dateTime.hour);
+		timeReg.setMinutes(dateTime.minute);
+		timeReg.setSeconds(dateTime.second);
+
+		constexpr auto START_OFFSET = offsetof(detail::TimeReg, seconds);
+		constexpr auto END_OFFSET = offsetof(detail::TimeReg, year);
+
+		writePartialRegister<TIME_REG_ADDR, START_OFFSET, END_OFFSET>(timeReg);
+	}
+
+  private:
+	template <uint8_t Address, typename Register>
+	static Register readRegisterHelper()
+	{
+		I2cDriver::template start<I2C_ADDRESS>(false);
+		I2cDriver::write(Address);
+		I2cDriver::stop();
+
+		Register reg;
+		I2cDriver::template start<I2C_ADDRESS>(true);
+		I2cDriver::template readBytes<sizeof(Register)>(reinterpret_cast<uint8_t *>(&reg));
+		I2cDriver::stop();
+		return reg;
+	}
+
+	template <uint8_t Address>
+	static auto readRegister()
+	{
+		if constexpr (Address == TIME_REG_ADDR) {
+			return readRegisterHelper<Address, detail::TimeReg>();
+		} else if constexpr (Address == ALARM1_REG_ADDR) {
+			return readRegisterHelper<Address, detail::Alarm1Reg>();
+		} else if constexpr (Address == ALARM2_REG_ADDR) {
+			return readRegisterHelper<Address, detail::Alarm2Reg>();
+		} else if constexpr (Address == CONTROL_REG_ADDR) {
+			return readRegisterHelper<Address, detail::ControlReg>();
+		} else if constexpr (Address == CONTROL_STATUS_REG_ADDR) {
+			return readRegisterHelper<Address, detail::ControlStatusReg>();
+		} else if constexpr (Address == AGING_OFFSET_REG_ADDR) {
+			return readRegisterHelper<Address, detail::AgingOffsetReg>();
+		} else if constexpr (Address == TEMP_REG_ADDR) {
+			return readRegisterHelper<Address, detail::TempReg>();
+		} else {
+			static_assert(util::always_false_v<decltype(Address)>, "Invalid register address");
+		}
+	}
+
+	template <uint8_t Address, uint8_t StartOffset, uint8_t EndOffset, typename Register>
+	static void writePartialRegister(const Register &reg)
+	{
+		static_assert(StartOffset <= EndOffset, "Invalid offset range");
+		static_assert(StartOffset < sizeof(Register), "Start offset out of bounds");
+		static_assert(EndOffset < sizeof(Register), "End offset out of bounds");
+
+		constexpr auto WRITE_SIZE = EndOffset + 1 - StartOffset;
+		static_assert(StartOffset + WRITE_SIZE <= sizeof(Register), "Writing out of bounds");
+
+		if constexpr (Address == TIME_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::TimeReg>, "Invalid register type");
+		} else if constexpr (Address == ALARM1_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::Alarm1Reg>, "Invalid register type");
+		} else if constexpr (Address == ALARM2_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::Alarm2Reg>, "Invalid register type");
+		} else if constexpr (Address == CONTROL_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::ControlReg>, "Invalid register type");
+		} else if constexpr (Address == CONTROL_STATUS_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::ControlStatusReg>, "Invalid register type");
+		} else if constexpr (Address == AGING_OFFSET_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::AgingOffsetReg>, "Invalid register type");
+		} else if constexpr (Address == TEMP_REG_ADDR) {
+			static_assert(util::is_same_v<Register, detail::TempReg>, "Invalid register type");
+		} else {
+			static_assert(util::always_false_v<Register>, "Invalid register address");
+		}
+
+		I2cDriver::template start<I2C_ADDRESS>(false);
+		I2cDriver::write(Address + StartOffset);
+		I2cDriver::template writeBytes<WRITE_SIZE>(reinterpret_cast<const uint8_t *>(&reg) + StartOffset);
+		I2cDriver::stop();
+	}
+
+	static uint8_t calcDayOfWeek(uint16_t year, uint8_t month, uint16_t day)
+	{
+		day += month < 3 ? year-- : year - 2;
+		const auto dayOfWeek = (23 * month / 9 + day + 4 + year / 4 - year / 100 + year / 400);
+		return dayOfWeek % 7;
+	}
+};
+
+} // namespace rtc

ds3231/clock.hpp

@@ -1,4 +0,0 @@
-#pragma once
-
-#define F_CPU 16'000'000
-#include <util/delay.h>

ds3231/ds3231.cppproj

@@ -1,285 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
-  <PropertyGroup>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectVersion>7.0</ProjectVersion>
-    <ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
-    <ProjectGuid>dce6c7e3-ee26-4d79-826b-08594b9ad897</ProjectGuid>
-    <avrdevice>ATmega328P</avrdevice>
-    <avrdeviceseries>none</avrdeviceseries>
-    <OutputType>Executable</OutputType>
-    <Language>CPP</Language>
-    <OutputFileName>$(MSBuildProjectName)</OutputFileName>
-    <OutputFileExtension>.elf</OutputFileExtension>
-    <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
-    <AssemblyName>DailySafe</AssemblyName>
-    <Name>DailySafe</Name>
-    <RootNamespace>DailySafe</RootNamespace>
-    <ToolchainFlavour>avr-g++-9.1.0</ToolchainFlavour>
-    <KeepTimersRunning>true</KeepTimersRunning>
-    <OverrideVtor>false</OverrideVtor>
-    <CacheFlash>true</CacheFlash>
-    <ProgFlashFromRam>true</ProgFlashFromRam>
-    <RamSnippetAddress>0x20000000</RamSnippetAddress>
-    <UncachedRange />
-    <preserveEEPROM>true</preserveEEPROM>
-    <OverrideVtorValue>exception_table</OverrideVtorValue>
-    <BootSegment>2</BootSegment>
-    <ResetRule>0</ResetRule>
-    <eraseonlaunchrule>0</eraseonlaunchrule>
-    <EraseKey />
-    <avrtool>com.atmel.avrdbg.tool.atmelice</avrtool>
-    <avrtoolserialnumber>J41800099437</avrtoolserialnumber>
-    <avrdeviceexpectedsignature>0x1E950F</avrdeviceexpectedsignature>
-    <com_atmel_avrdbg_tool_stk500>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>ISP</InterfaceName>
-      </ToolOptions>
-      <ToolType>com.atmel.avrdbg.tool.stk500</ToolType>
-      <ToolNumber>
-      </ToolNumber>
-      <ToolName>STK500</ToolName>
-    </com_atmel_avrdbg_tool_stk500>
-    <avrtoolinterface>ISP</avrtoolinterface>
-    <avrtoolinterfaceclock>125000</avrtoolinterfaceclock>
-    <AsfFrameworkConfig>
-      <framework-data xmlns="">
-        <options />
-        <configurations />
-        <files />
-        <documentation help="" />
-        <offline-documentation help="" />
-        <dependencies>
-          <content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.47.0" />
-        </dependencies>
-      </framework-data>
-    </AsfFrameworkConfig>
-    <com_atmel_avrdbg_tool_atmelice>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>ISP</InterfaceName>
-      </ToolOptions>
-      <ToolType>com.atmel.avrdbg.tool.atmelice</ToolType>
-      <ToolNumber>J41800099437</ToolNumber>
-      <ToolName>Atmel-ICE</ToolName>
-    </com_atmel_avrdbg_tool_atmelice>
-    <custom>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>
-        </InterfaceName>
-      </ToolOptions>
-      <ToolType>custom</ToolType>
-      <ToolNumber>
-      </ToolNumber>
-      <ToolName>Custom Programming Tool</ToolName>
-    </custom>
-    <AAFDebugger>
-      <AAFDebugFiles>
-        <DebugFile>
-          <path>\Debug\ds3231.lss</path>
-          <AAFSetting>
-            <Label>Lss Files</Label>
-            <Extention>.lss</Extention>
-            <Regex>^\s*(?&lt;address&gt;[a-f0-9]*):\s*.*$</Regex>
-            <DebugEnabled>true</DebugEnabled>
-            <RegexGroups>address</RegexGroups>
-            <DebuggerExpression>$pc</DebuggerExpression>
-          </AAFSetting>
-        </DebugFile>
-      </AAFDebugFiles>
-    </AAFDebugger>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <ToolchainSettings>
-      <AvrGccCpp>
-        <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
-        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
-        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
-        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
-        <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
-        <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
-        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
-        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
-        <avrgcc.compiler.symbols.DefSymbols>
-          <ListValues>
-            <Value>NDEBUG</Value>
-          </ListValues>
-        </avrgcc.compiler.symbols.DefSymbols>
-        <avrgcc.compiler.directories.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcc.compiler.directories.IncludePaths>
-        <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
-        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
-        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
-        <avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
-        <avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
-        <avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c11</avrgcc.compiler.miscellaneous.OtherFlags>
-        <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
-        <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
-        <avrgcccpp.compiler.symbols.DefSymbols>
-          <ListValues>
-            <Value>NDEBUG</Value>
-          </ListValues>
-        </avrgcccpp.compiler.symbols.DefSymbols>
-        <avrgcccpp.compiler.directories.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcccpp.compiler.directories.IncludePaths>
-        <avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
-        <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
-        <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
-        <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
-        <avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -std=c++17</avrgcccpp.compiler.miscellaneous.OtherFlags>
-        <avrgcccpp.linker.libraries.Libraries>
-          <ListValues>
-            <Value>libm</Value>
-          </ListValues>
-        </avrgcccpp.linker.libraries.Libraries>
-        <avrgcccpp.assembler.general.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcccpp.assembler.general.IncludePaths>
-      </AvrGccCpp>
-    </ToolchainSettings>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <ToolchainSettings>
-      <AvrGccCpp>
-        <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
-        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
-        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
-        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
-        <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
-        <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
-        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
-        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
-        <avrgcc.compiler.symbols.DefSymbols>
-          <ListValues>
-            <Value>DEBUG</Value>
-          </ListValues>
-        </avrgcc.compiler.symbols.DefSymbols>
-        <avrgcc.compiler.directories.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcc.compiler.directories.IncludePaths>
-        <avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
-        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
-        <avrgcc.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcc.compiler.optimization.DebugLevel>
-        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
-        <avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
-        <avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
-        <avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c11</avrgcc.compiler.miscellaneous.OtherFlags>
-        <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
-        <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
-        <avrgcccpp.compiler.symbols.DefSymbols>
-          <ListValues>
-            <Value>DEBUG</Value>
-          </ListValues>
-        </avrgcccpp.compiler.symbols.DefSymbols>
-        <avrgcccpp.compiler.directories.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcccpp.compiler.directories.IncludePaths>
-        <avrgcccpp.compiler.optimization.level>Optimize debugging experience (-Og)</avrgcccpp.compiler.optimization.level>
-        <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
-        <avrgcccpp.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcccpp.compiler.optimization.DebugLevel>
-        <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
-        <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
-        <avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -std=c++17</avrgcccpp.compiler.miscellaneous.OtherFlags>
-        <avrgcccpp.linker.libraries.Libraries>
-          <ListValues>
-            <Value>libm</Value>
-          </ListValues>
-        </avrgcccpp.linker.libraries.Libraries>
-        <avrgcccpp.assembler.general.IncludePaths>
-          <ListValues>
-            <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-          </ListValues>
-        </avrgcccpp.assembler.general.IncludePaths>
-        <avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
-      </AvrGccCpp>
-    </ToolchainSettings>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="clock.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="ds3231\alarms.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="ds3231\ds3231.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="ds3231\flags.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="ds3231\registers.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="flash\flash.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="i2c\hardware.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="i2c\i2c.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="io\io.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="main.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\config.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware0.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware1.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\software.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\uart.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="util\func.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="util\type.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="util\util.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="ds3231" />
-    <Folder Include="io" />
-    <Folder Include="flash" />
-    <Folder Include="i2c" />
-    <Folder Include="util" />
-    <Folder Include="uart" />
-  </ItemGroup>
-  <Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
-</Project>

ds3231/main.cpp

@@ -1,188 +0,0 @@
-#include "clock.hpp"
-
-#include <stdlib.h>
-
-#include "ds3231/ds3231.hpp"
-#include "uart/uart.hpp"
-
-using uart_t = uart::Uart0<>;
-
-REGISTER_UART0_INT_VECTORS(uart_t);
-
-static inline bool isEuDst(const rtc::DateTime &dateTime)
-{
-	constexpr auto calcDstBegin = [](const auto &year) {
-		const auto beginDay = (31 - ((((5 * year) / 4) + 4) % 7));
-		return beginDay;
-	};
-
-	constexpr auto calcDstEnd = [](const auto &year) {
-		const auto endDay = (31 - ((((5 * year) / 4) + 1) % 7));
-		return endDay;
-	};
-
-	if (dateTime.month > 10 || dateTime.month < 3)
-		return false;
-	else if (dateTime.month > 3 && dateTime.month < 10)
-		return true;
-	else if (dateTime.month == 3) {
-		if (dateTime.day > calcDstBegin(dateTime.year)) {
-			return true;
-		} else if (dateTime.day == calcDstBegin(dateTime.year) && dateTime.hour >= 1)
-			return true;
-		return false;
-	}
-	// month == 10
-	if (dateTime.day < calcDstEnd(dateTime.year)) {
-		return true;
-	} else if (dateTime.day == calcDstEnd(dateTime.year) && dateTime.hour < 1)
-		return true;
-	return false;
-}
-
-inline uart_t &operator<<(uart_t &serial, const rtc::DateTime &dateTime)
-{
-	serial.txNumber<uint16_t, 10, 4>(dateTime.year);
-	serial << '-';
-	serial.txNumber<uint8_t, 10, 2>(dateTime.month);
-	serial << '-';
-	serial.txNumber<uint8_t, 10, 2>(dateTime.day);
-	serial << ' ';
-	serial.txNumber<uint8_t, 10, 2>(dateTime.hour);
-	serial << ':';
-	serial.txNumber<uint8_t, 10, 2>(dateTime.minute);
-	serial << ':';
-	serial.txNumber<uint8_t, 10, 2>(dateTime.second);
-	return serial;
-}
-
-static inline void printLocalTime(const rtc::DateTime &dateTime)
-{
-	const auto dst = isEuDst(dateTime);
-
-	uart_t serial;
-	serial << dateTime << (dst ? F(" +2") : F(" +1")) << F("\r\n");
-}
-
-static inline size_t receiveLine(char *buffer, const size_t maxLength)
-{
-	uart_t serial;
-	size_t received = 0;
-
-	while (received < maxLength) {
-		if (serial.rxByte(*reinterpret_cast<uint8_t *>(&buffer[received]))) {
-			++received;
-			if (buffer[received - 1] == '\r' || buffer[received - 1] == '\n')
-				break;
-		}
-	}
-
-	return received;
-}
-
-static inline rtc::DateTime receiveTime()
-{
-	uart_t serial;
-
-	rtc::DateTime dateTime;
-	constexpr auto BUF_LEN = 8;
-	char receiveBuffer[BUF_LEN];
-
-	serial << F("Enter year: ");
-	auto receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.year = atoi(receiveBuffer);
-
-	serial << F("\r\nEnter month: ");
-	receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.month = atoi(receiveBuffer);
-
-	serial << F("\r\nEnter date: ");
-	receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.day = atoi(receiveBuffer);
-
-	serial << F("\r\nEnter hour: ");
-	receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.hour = atoi(receiveBuffer);
-
-	serial << F("\r\nEnter minute: ");
-	receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.minute = atoi(receiveBuffer);
-
-	serial << F("\r\nEnter second: ");
-	receivedLen = receiveLine(receiveBuffer, BUF_LEN);
-	receiveBuffer[receivedLen] = '\0';
-	dateTime.second = atoi(receiveBuffer);
-	serial << F("\r\n");
-
-	return dateTime;
-}
-
-int main()
-{
-	uart_t serial;
-	rtc::DS3231<i2c::Hardware<100'000>, false> ds3231;
-	io::Pin<io::P::C3> rtcPwr;
-
-	rtcPwr = false;
-	rtcPwr.dir(io::Dir::OUT);
-
-	rtcPwr = true;
-	_delay_ms(1000);
-
-	ds3231.init();
-	serial.init();
-
-	ds3231.clearAlarm1();
-	ds3231.clearAlarm2();
-
-	rtc::DateTime alarmTime;
-	alarmTime.second = 17;
-	alarmTime.minute = 54;
-
-	ds3231.setAlarm1(alarmTime, rtc::Alarm1Rate::WHEN_S_MATCH);
-	ds3231.setAlarm2(alarmTime, rtc::Alarm2Rate::WHEN_M_MATCH);
-
-	auto oldDate = ds3231.getDateTime();
-
-	while (true) {
-		const auto date = ds3231.getDateTime();
-
-		if (oldDate != date) {
-			oldDate = date;
-			printLocalTime(date);
-		}
-
-		if (ds3231.checkAlarm1()) {
-			serial << F("Alarm1!\r\n");
-			ds3231.clearAlarm1();
-		}
-
-		if (ds3231.checkAlarm2()) {
-			serial << F("Alarm2!\r\n");
-			ds3231.clearAlarm2();
-		}
-
-		uint8_t receivedByte;
-
-		if (serial.rxByte(receivedByte)) {
-			if (receivedByte == 's') {
-				const auto newDate = receiveTime();
-				ds3231.setDateTime(newDate);
-			} else if (receivedByte == '1') {
-				const auto alarm = ds3231.getAlarm1();
-				serial << F("Alarm1: ") << alarm << F("\r\n");
-			} else if (receivedByte == '2') {
-				const auto alarm = ds3231.getAlarm2();
-				serial << F("Alarm2: ") << alarm << F("\r\n");
-			} else
-				serial << F("Invalid input: ") << static_cast<char>(receivedByte) << F("\r\n");
-		}
-	}
-
-	return 0;
-}

flags.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+namespace rtc {
+
+namespace detail {
+
+template <typename FlagsT>
+struct [[gnu::packed]] FlagsImpl
+{
+	static_assert(sizeof(FlagsT) == sizeof(uint8_t), "Must use uint8_t enum class flags");
+
+	uint8_t data = 0;
+	using Flags = FlagsT;
+
+	FlagsImpl() : data(0) {}
+	FlagsImpl(const Flags &flag) : data(static_cast<uint8_t>(flag)) {}
+
+	FlagsImpl(const FlagsImpl &other) : data(other.data) {}
+	FlagsImpl(const FlagsImpl &&) = delete;
+
+	FlagsImpl &operator=(const FlagsImpl &rhs)
+	{
+		data = rhs.data;
+		return *this;
+	}
+	FlagsImpl &operator=(const FlagsImpl &&) = delete;
+
+	FlagsImpl &operator=(const FlagsT &rhs)
+	{
+		data = static_cast<uint8_t>(rhs);
+		return *this;
+	}
+
+	FlagsImpl &operator|=(const FlagsT &flag)
+	{
+		data |= static_cast<uint8_t>(flag);
+		return *this;
+	}
+
+	FlagsImpl &operator&=(const FlagsT &flag)
+	{
+		data &= static_cast<uint8_t>(flag);
+		return *this;
+	}
+
+	FlagsImpl &operator~()
+	{
+		data = ~data;
+		return *this;
+	}
+};
+
+template <typename FlagsT>
+FlagsT operator|(const FlagsT &lhs, const FlagsT &rhs)
+{
+	const auto lhsInt = static_cast<uint8_t>(lhs);
+	const auto rhsInt = static_cast<uint8_t>(rhs);
+	return static_cast<FlagsT>(lhsInt | rhsInt);
+}
+
+template <typename FlagsT>
+FlagsT operator&(const FlagsT &lhs, const FlagsT &rhs)
+{
+	const auto lhsInt = static_cast<uint8_t>(lhs);
+	const auto rhsInt = static_cast<uint8_t>(rhs);
+	return static_cast<FlagsT>(lhsInt & rhsInt);
+}
+
+} // namespace detail
+
+} // namespace rtc

registers.hpp

@@ -0,0 +1,419 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "flags.hpp"
+
+namespace rtc {
+
+namespace detail {
+
+//////////////////////////////////////////////////////////////////////////
+
+template <uint8_t Mask = 0xFF>
+static inline uint8_t toBcd(const uint8_t &data)
+{
+	return ((data / 10 * 16) + (data % 10)) & Mask;
+}
+
+template <uint8_t Mask = 0xFF>
+static inline uint8_t fromBcd(const uint8_t &data)
+{
+	const auto maskedData = data & Mask;
+	return ((maskedData / 16 * 10) + (maskedData % 16));
+}
+
+static inline uint8_t convertTo24Hour(const uint8_t &hoursReg)
+{
+	constexpr auto FLAG_12_HOUR = 6;
+	constexpr auto FLAG_PM = 5;
+
+	const bool time12HourFormat = (hoursReg >> FLAG_12_HOUR) & 1;
+
+	if (time12HourFormat) {
+		const auto pmFlag = (hoursReg >> FLAG_PM) & 1;
+		constexpr auto HOUR_12_MASK = 0b00011111;
+		const auto hour12 = fromBcd<HOUR_12_MASK>(hoursReg);
+		if (hour12 == 12 && !pmFlag)
+			return 0;
+		return hour12 + pmFlag ? 12 : 0;
+	} else // 24 hour format
+	{
+		constexpr auto HOUR_MASK = 0b00111111;
+		return fromBcd<HOUR_MASK>(hoursReg);
+	}
+}
+
+template <uint8_t Mask = 0b01111111>
+static inline uint8_t getMaskedBcd(const uint8_t &reg)
+{
+	return fromBcd<Mask>(reg);
+}
+
+template <uint8_t Mask = 0b01111111>
+static inline void setMaskedBcd(uint8_t &reg, const uint8_t &value)
+{
+	reg &= ~Mask;
+	reg |= toBcd<Mask>(value);
+}
+
+static inline bool getEncodedDay(uint8_t &value, const uint8_t &reg)
+{
+	constexpr auto DAY_FLAG = 6;
+	if ((reg >> DAY_FLAG) & 1) {
+		constexpr auto DAY_MASK = 0b00001111;
+		value = reg & DAY_MASK;
+		return true;
+	}
+
+	return false;
+}
+
+static inline bool getEncodedDate(uint8_t &value, const uint8_t &reg)
+{
+	constexpr auto DAY_FLAG = 6;
+	if (!((reg >> DAY_FLAG) & 1)) {
+		value = getMaskedBcd<0b00111111>(reg);
+		return true;
+	}
+
+	return false;
+}
+
+static inline void setEncodedDay(uint8_t &reg, const uint8_t &value)
+{
+	constexpr auto DAY_MASK = 0b11110000;
+	reg &= DAY_MASK;
+	reg |= value & DAY_MASK;
+	constexpr auto DAY_FLAG = 6;
+	reg |= (1 << DAY_FLAG);
+}
+
+static inline void setEncodedDate(uint8_t &reg, const uint8_t &value)
+{
+	setMaskedBcd<0b00111111>(reg, value);
+	constexpr auto DAY_FLAG = 6;
+	reg &= ~(1 << DAY_FLAG);
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct [[gnu::packed]] TimeReg
+{
+	uint8_t seconds = 0;
+	uint8_t minutes = 0;
+	uint8_t hours = 0;
+	uint8_t day = 1; // Range 1-7 according to datasheet
+	uint8_t date = 0;
+	uint8_t month_century = 0;
+	uint8_t year = 0;
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline uint8_t getSeconds() const
+	{
+		return getMaskedBcd(seconds);
+	}
+	inline uint8_t getMinutes() const
+	{
+		return getMaskedBcd(minutes);
+	}
+	inline uint8_t getHours() const
+	{
+		return convertTo24Hour(hours);
+	}
+	inline uint8_t getDay() const
+	{
+		return getMaskedBcd<0b00000111>(day);
+	}
+	inline uint8_t getDate() const
+	{
+		return getMaskedBcd<0b00111111>(date);
+	}
+	inline uint8_t getMonth() const
+	{
+		return getMaskedBcd<0b00011111>(month_century);
+	}
+	inline bool getCentury() const
+	{
+		constexpr auto CENTURY_FLAG = 7;
+		return (month_century >> CENTURY_FLAG) & 1;
+	}
+	inline uint16_t getYear() const
+	{
+		return 2000 + fromBcd(year);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void setSeconds(uint8_t seconds)
+	{
+		setMaskedBcd(this->seconds, seconds);
+	}
+	inline void setMinutes(uint8_t minutes)
+	{
+		setMaskedBcd(this->minutes, minutes);
+	}
+	inline void setHours(uint8_t hours)
+	{
+		setMaskedBcd(this->hours, hours);
+	}
+	inline void setDay(uint8_t day)
+	{
+		this->day = day & 0b111;
+	}
+	inline void setDate(uint8_t date)
+	{
+		setMaskedBcd<0b00111111>(this->date, date);
+	}
+	inline void setMonth(uint8_t month)
+	{
+		setMaskedBcd<0b00011111>(month_century, month);
+	}
+	inline void setCentury(bool century)
+	{
+		constexpr auto CENTURY_POS = 7;
+		month_century &= ~(1 << CENTURY_POS);
+		month_century |= (century << CENTURY_POS);
+	}
+	inline void setYear(uint16_t year)
+	{
+		year = year % 100;
+		this->year = toBcd(year);
+	}
+};
+
+static_assert(sizeof(TimeReg) == 7, "Invalid time register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+struct [[gnu::packed]] Alarm1Reg
+{
+	uint8_t seconds = 0;
+	uint8_t minutes = 0;
+	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
+	{
+		return getMaskedBcd(seconds);
+	}
+	inline uint8_t getMinutes() const
+	{
+		return getMaskedBcd(minutes);
+	}
+	inline uint8_t getHours() const
+	{
+		return convertTo24Hour(hours);
+	}
+	inline bool getDay(uint8_t & day) const
+	{
+		return getEncodedDay(day, day_date);
+	}
+	inline bool getDate(uint8_t & date) const
+	{
+		return getEncodedDate(date, day_date);
+	}
+	inline AlarmRate getAlarmRate() const
+	{
+		constexpr auto M_FLAG = 7;
+		const auto m1 = (seconds >> M_FLAG) & 1;
+		const auto m2 = (minutes >> M_FLAG) & 1;
+		const auto m3 = (hours >> M_FLAG) & 1;
+		const auto m4 = (day_date >> M_FLAG) & 1;
+		const auto m = (m4 << 3) | (m3 << 2) | (m2 << 1) | (m1 << 0);
+		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<AlarmRate>(m);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void setSeconds(uint8_t seconds)
+	{
+		setMaskedBcd(this->seconds, seconds);
+	}
+	inline void setMinutes(uint8_t minutes)
+	{
+		setMaskedBcd(this->minutes, minutes);
+	}
+	inline void setHours(uint8_t hours)
+	{
+		setMaskedBcd(this->hours, hours);
+	}
+	inline void setDay(uint8_t day)
+	{
+		setEncodedDay(day_date, day);
+	}
+	inline void setDate(uint8_t date)
+	{
+		setEncodedDate(day_date, date);
+	}
+	inline void setAlarmRate(const AlarmRate &alarmRate)
+	{
+		const auto alarmRateFlags = static_cast<uint8_t>(alarmRate);
+		constexpr auto M_FLAG = 7;
+		seconds &= ~(1 << M_FLAG);
+		seconds |= (alarmRateFlags & 1) << M_FLAG;
+		minutes &= ~(1 << M_FLAG);
+		minutes |= ((alarmRateFlags >> 1) & 1) << M_FLAG;
+		hours &= ~(1 << M_FLAG);
+		hours |= ((alarmRateFlags >> 2) & 1) << M_FLAG;
+		day_date &= ~(1 << M_FLAG);
+		day_date |= ((alarmRateFlags >> 3) & 1) << M_FLAG;
+	}
+};
+
+static_assert(sizeof(Alarm1Reg) == 4, "Invalid alarm1 register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+struct [[gnu::packed]] Alarm2Reg
+{
+	uint8_t minutes = 0;
+	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
+	{
+		return getMaskedBcd(minutes);
+	}
+	inline uint8_t getHours() const
+	{
+		return convertTo24Hour(hours);
+	}
+	inline bool getDay(uint8_t & day) const
+	{
+		return getEncodedDay(day, day_date);
+	}
+	inline bool getDate(uint8_t & date) const
+	{
+		return getEncodedDate(date, day_date);
+	}
+	inline AlarmRate getAlarmRate() const
+	{
+		constexpr auto M_FLAG = 7;
+		const auto m2 = (minutes >> M_FLAG) & 1;
+		const auto m3 = (hours >> M_FLAG) & 1;
+		const auto m4 = (day_date >> M_FLAG) & 1;
+		const auto m = (m4 << 2) | (m3 << 1) | (m2 << 0);
+		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<AlarmRate>(m);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void setMinutes(uint8_t minutes)
+	{
+		setMaskedBcd(this->minutes, minutes);
+	}
+	inline void setHours(uint8_t hours)
+	{
+		setMaskedBcd(this->hours, hours);
+	}
+	inline void setDay(uint8_t day)
+	{
+		setEncodedDay(day_date, day);
+	}
+	inline void setDate(uint8_t date)
+	{
+		setEncodedDate(day_date, date);
+	}
+	inline void setAlarmRate(const AlarmRate &alarmRate)
+	{
+		const auto alarmRateFlags = static_cast<uint8_t>(alarmRate);
+		constexpr auto M_FLAG = 7;
+		minutes &= ~(1 << M_FLAG);
+		minutes |= (alarmRateFlags & 1) << M_FLAG;
+		hours &= ~(1 << M_FLAG);
+		hours |= ((alarmRateFlags >> 1) & 1) << M_FLAG;
+		day_date &= ~(1 << M_FLAG);
+		day_date |= ((alarmRateFlags >> 2) & 1) << M_FLAG;
+	}
+};
+
+static_assert(sizeof(Alarm2Reg) == 3, "Invalid alarm2 register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+enum class ControlRegFlags : uint8_t {
+	N_EOSC = 1 << 7,
+	BBSQW = 1 << 6,
+	CONV = 1 << 5,
+	RS2 = 1 << 4,
+	RS1 = 1 << 3,
+	INTCN = 1 << 2,
+	A2IE = 1 << 1,
+	A1IE = 1 << 0,
+};
+
+struct [[gnu::packed]] ControlReg : FlagsImpl<ControlRegFlags>{};
+
+static_assert(sizeof(ControlReg) == 1, "Invalid control register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+enum class ControlStatusRegFlags : uint8_t {
+	OSF = 1 << 7,
+	EN32KHZ = 1 << 3,
+	BSY = 1 << 2,
+	A2F = 1 << 1,
+	A1F = 1 << 0,
+};
+
+struct [[gnu::packed]] ControlStatusReg : FlagsImpl<ControlStatusRegFlags>{};
+
+static_assert(sizeof(ControlStatusReg) == 1, "Invalid control/status register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+struct [[gnu::packed]] AgingOffsetReg
+{
+	uint8_t data = 0;
+};
+
+static_assert(sizeof(AgingOffsetReg) == 1, "Invalid aging offset register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+struct [[gnu::packed]] TempReg
+{
+	uint8_t msb_temp = 0;
+	uint8_t lsb_temp = 0;
+};
+
+static_assert(sizeof(TempReg) == 2, "Invalid temperature register size");
+
+//////////////////////////////////////////////////////////////////////////
+
+} // namespace detail
+
+} // namespace rtc

rtc.cpp

@@ -0,0 +1,617 @@
+/*
+ * DS RTC Library: DS1307 and DS3231 driver library
+ * (C) 2011 Akafugu Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ *
+ */
+
+/*
+ * DS1307 register map
+ *
+ *  00h-06h: seconds, minutes, hours, day-of-week, date, month, year (all in BCD)
+ *     bit 7 of seconds enables/disables clock
+ *     bit 6 of hours toggles 12/24h mode (1 for 12h, 0 for 24h)
+ *       when 12h mode is selected bit 5 is high for PM, low for AM
+ *  07h: control
+ *      bit7: OUT
+ *      bit6: 0
+ *      bit5: 0
+ *      bit4: SQWE
+ *      bit3: 0
+ *      bit2: 0
+ *      bit1: RS0
+ *      bit0: RS1
+ *  08h-3fh: 56 bytes of SRAM
+ *
+ * DS3231 register map
+ *
+ *  00h-06h: seconds, minutes, hours, day-of-week, date, month, year (all in BCD)
+ *       bit 7 should be set to zero: The DS3231 clock is always running
+ *  07h: A1M1  Alarm 1 seconds
+ *  08h: A1M2  Alarm 1 minutes
+ *  09h: A1M3  Alarm 1 hour (bit6 is am/pm flag in 12h mode)
+ *  0ah: A1M4  Alarm 1 day/date (bit6: 1 for day, 0 for date)
+ *  0bh: A2M2  Alarm 2 minutes
+ *  0ch: A2M3  Alarm 2 hour (bit6 is am/pm flag in 12h mode)
+ *  0dh: A2M4  Alarm 2 day/data (bit6: 1 for day, 0 for date)
+ *       <see data sheet page12 for Alarm register mask bit tables:
+ *        for alarm when hours, minutes and seconds match set 1000 for alarm 1>
+ *  0eh: control
+ *      bit7: !EOSC
+ *      bit6: BBSQW
+ *      bit5: CONV
+ *      bit4: RS2
+ *      bit3: RS1
+ *      bit2: INTCN
+ *      bit1: A2IE
+ *      bit0: A1IE
+ *  0fh: control/status
+ *      bit7: OSF
+ *      bit6: 0
+ *      bit5: 0
+ *      bit4: 0
+ *      bit3: EN32kHz
+ *      bit2: BSY
+ *      bit1: A2F alarm 2 flag
+ *      bit0: A1F alarm 1 flag
+ * 10h: aging offset (signed)
+ * 11h: MSB of temp (signed)
+ * 12h: LSB of temp in bits 7 and 6 (0.25 degrees for each 00, 01, 10, 11)
+ *
+ */
+
+#include <avr/io.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#include "../clock.hpp"
+
+#include "../i2c/i2c.hpp"
+using i2c_t = i2c::I2c<i2c::Hardware<100'000>>;
+
+#include "rtc.h"
+
+#define RTC_ADDR 0x68 // I2C address
+#define CH_BIT 7 // clock halt bit
+
+// statically allocated structure for time value
+struct rtc_tm _rtc_tm;
+
+uint8_t dec2bcd(uint8_t d)
+{
+  return ((d/10 * 16) + (d % 10));
+}
+
+uint8_t bcd2dec(uint8_t b)
+{
+  return ((b/16 * 10) + (b % 16));
+}
+
+uint8_t rtc_read_byte(uint8_t offset)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(offset);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	const auto received = i2c_t::read<true>();
+	i2c_t::stop();
+
+	return received;
+}
+
+void rtc_write_byte(uint8_t b, uint8_t offset)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(offset);
+	i2c_t::write(b);
+	i2c_t::stop();
+}
+
+static bool s_is_ds1307 = false;
+static bool s_is_ds3231 = false;
+
+void rtc_init(void)
+{
+	i2c_t::init();
+
+	// Attempt autodetection:
+	// 1) Read and save temperature register
+	// 2) Write a value to temperature register
+	// 3) Read back the value
+	//   equal to the one written: DS1307, write back saved value and return
+	//   different from written:   DS3231
+
+	uint8_t temp1 = rtc_read_byte(0x11);
+	uint8_t temp2 = rtc_read_byte(0x12);
+
+	rtc_write_byte(0xee, 0x11);
+	rtc_write_byte(0xdd, 0x12);
+
+	if (rtc_read_byte(0x11) == 0xee && rtc_read_byte(0x12) == 0xdd) {
+		s_is_ds1307 = true;
+		// restore values
+		rtc_write_byte(temp1, 0x11);
+		rtc_write_byte(temp2, 0x12);
+	}
+	else {
+		s_is_ds3231 = true;
+	}
+}
+
+// Autodetection
+bool rtc_is_ds1307(void) { return s_is_ds1307; }
+bool rtc_is_ds3231(void) { return s_is_ds3231; }
+
+// Autodetection override
+void rtc_set_ds1307(void) { s_is_ds1307 = true;   s_is_ds3231 = false; }
+void rtc_set_ds3231(void) { s_is_ds1307 = false;  s_is_ds3231 = true;  }
+
+struct rtc_tm* rtc_get_time(void)
+{
+	uint8_t rtc[9];
+	uint8_t century = 0;
+
+	// read 7 bytes starting from register 0
+	// sec, min, hour, day-of-week, date, month, year
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	i2c_t::readBytes<7>(rtc);
+	i2c_t::stop();
+
+	// Clear clock halt bit from read data
+	// This starts the clock for a DS1307, and has no effect for a DS3231
+	rtc[0] &= ~(_BV(CH_BIT)); // clear bit
+
+	_rtc_tm.sec = bcd2dec(rtc[0]);
+	_rtc_tm.min = bcd2dec(rtc[1]);
+	_rtc_tm.hour = bcd2dec(rtc[2]);
+	_rtc_tm.mday = bcd2dec(rtc[4]);
+	_rtc_tm.mon = bcd2dec(rtc[5] & 0x1F); // returns 1-12
+	century = (rtc[5] & 0x80) >> 7;
+	_rtc_tm.year = century == 1 ? 2000 + bcd2dec(rtc[6]) : 1900 + bcd2dec(rtc[6]); // year 0-99
+	_rtc_tm.wday = bcd2dec(rtc[3]); // returns 1-7
+
+	if (_rtc_tm.hour == 0) {
+		_rtc_tm.twelveHour = 0;
+		_rtc_tm.am = 1;
+	} else if (_rtc_tm.hour < 12) {
+		_rtc_tm.twelveHour = _rtc_tm.hour;
+		_rtc_tm.am = 1;
+	} else {
+		_rtc_tm.twelveHour = _rtc_tm.hour - 12;
+		_rtc_tm.am = 0;
+	}
+
+	return &_rtc_tm;
+}
+
+void rtc_get_time_s(uint8_t* hour, uint8_t* min, uint8_t* sec)
+{
+	uint8_t rtc[9];
+
+	// read 7 bytes starting from register 0
+	// sec, min, hour, day-of-week, date, month, year
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	i2c_t::readBytes<7>(rtc);
+	i2c_t::stop();
+
+	if (sec)  *sec =  bcd2dec(rtc[0]);
+	if (min)  *min =  bcd2dec(rtc[1]);
+	if (hour) *hour = bcd2dec(rtc[2]);
+}
+
+// fixme: support 12-hour mode for setting time
+void rtc_set_time(struct rtc_tm* tm_)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0);
+
+	uint8_t century;
+	if (tm_->year > 2000) {
+		century = 0x80;
+		tm_->year = tm_->year - 2000;
+	} else {
+		century = 0;
+		tm_->year = tm_->year - 1900;
+	}
+
+	// clock halt bit is 7th bit of seconds: this is always cleared to start the clock
+	i2c_t::write(dec2bcd(tm_->sec)); // seconds
+	i2c_t::write(dec2bcd(tm_->min)); // minutes
+	i2c_t::write(dec2bcd(tm_->hour)); // hours
+	i2c_t::write(dec2bcd(tm_->wday)); // day of week
+	i2c_t::write(dec2bcd(tm_->mday)); // day
+	i2c_t::write(dec2bcd(tm_->mon) + century); // month
+	i2c_t::write(dec2bcd(tm_->year)); // year
+
+	i2c_t::stop();
+}
+
+void rtc_set_time_s(uint8_t hour, uint8_t min, uint8_t sec)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0);
+
+	// clock halt bit is 7th bit of seconds: this is always cleared to start the clock
+	i2c_t::write(dec2bcd(sec)); // seconds
+	i2c_t::write(dec2bcd(min)); // minutes
+	i2c_t::write(dec2bcd(hour)); // hours
+
+	i2c_t::stop();
+}
+
+// DS1307 only (has no effect when run on DS3231)
+// halt/start the clock
+// 7th bit of register 0 (second register)
+// 0 = clock is running
+// 1 = clock is not running
+void rtc_run_clock(bool run)
+{
+  if (s_is_ds3231) return;
+
+  uint8_t b = rtc_read_byte(0x0);
+
+  if (run)
+    b &= ~(_BV(CH_BIT)); // clear bit
+  else
+    b |= _BV(CH_BIT); // set bit
+
+  rtc_write_byte(b, 0x0);
+}
+
+// DS1307 only
+// Returns true if the clock is running, false otherwise
+// For DS3231, it always returns true
+bool rtc_is_clock_running(void)
+{
+  if (s_is_ds3231) return true;
+
+  uint8_t b = rtc_read_byte(0x0);
+
+  if (b & _BV(CH_BIT)) return false;
+  return true;
+}
+
+void ds3231_get_temp_int(int8_t* i, uint8_t* f)
+{
+	uint8_t msb, lsb;
+
+	*i = 0;
+	*f = 0;
+
+	if (s_is_ds1307) return; // only valid on DS3231
+
+	i2c_t::start<RTC_ADDR>(false);
+	// temp registers 0x11 and 0x12
+	i2c_t::write(0x11);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	msb = i2c_t::read(); // integer part (in twos complement)
+	lsb = i2c_t::read<true>(); // fraction part
+
+	// integer part in entire byte
+	*i = msb;
+	// fractional part in top two bits (increments of 0.25)
+	*f = (lsb >> 6) * 25;
+
+	// float value can be read like so:
+	// float temp = ((((short)msb << 8) | (short)lsb) >> 6) / 4.0f;
+}
+
+void rtc_force_temp_conversion(uint8_t block)
+{
+	if (s_is_ds1307) return; // only valid on DS3231
+
+	// read control register (0x0E)
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0E);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	uint8_t ctrl = i2c_t::read<true>();
+	i2c_t::stop();
+
+	ctrl |= 0b00100000; // Set CONV bit
+
+	// write new control register value
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0E);
+	i2c_t::write(ctrl);
+	i2c_t::stop();
+
+	if (!block) return;
+
+	// Temp conversion is ready when control register becomes 0
+	do {
+		// Block until CONV is 0
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x0E);
+		i2c_t::stop();
+
+		i2c_t::start<RTC_ADDR>(true);
+		// HACK: Missing stop after read, might still work though
+	} while ((i2c_t::read<true>() & 0b00100000) != 0);
+}
+
+
+#define DS1307_SRAM_ADDR 0x08
+
+// SRAM: 56 bytes from address 0x08 to 0x3f (DS1307-only)
+void rtc_get_sram(uint8_t* data)
+{
+	// cannot receive 56 bytes in one go, because of the TWI library buffer limit
+	// so just receive one at a time for simplicity
+  	for(int i=0;i<56;i++)
+		data[i] = rtc_get_sram_byte(i);
+}
+
+void rtc_set_sram(uint8_t *data)
+{
+	// cannot send 56 bytes in one go, because of the TWI library buffer limit
+	// so just send one at a time for simplicity
+  	for(int i=0;i<56;i++)
+		rtc_set_sram_byte(data[i], i);
+}
+
+uint8_t rtc_get_sram_byte(uint8_t offset)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(DS1307_SRAM_ADDR + offset);
+	i2c_t::stop();
+
+	i2c_t::start<RTC_ADDR>(true);
+	const auto received = i2c_t::read<true>();
+	i2c_t::stop();
+	return received;
+}
+
+void rtc_set_sram_byte(uint8_t b, uint8_t offset)
+{
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(DS1307_SRAM_ADDR + offset);
+	i2c_t::write(b);
+	i2c_t::stop();
+}
+
+void rtc_SQW_enable(bool enable)
+{
+	if (s_is_ds1307) {
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x07);
+		i2c_t::stop();
+
+		// read control
+		i2c_t::start<RTC_ADDR>(true);
+		uint8_t control = i2c_t::read<true>();
+		i2c_t::stop();
+
+		if (enable)
+			control |=  0b00010000; // set SQWE to 1
+		else
+			control &= ~0b00010000; // set SQWE to 0
+
+		// write control back
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x07);
+		i2c_t::write(control);
+		i2c_t::stop();
+
+	}
+	else { // DS3231
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x0E);
+		i2c_t::stop();
+
+		// read control
+		i2c_t::start<RTC_ADDR>(true);
+		uint8_t control = i2c_t::read<true>();
+		i2c_t::stop();
+
+		if (enable) {
+			control |=  0b01000000; // set BBSQW to 1
+			control &= ~0b00000100; // set INTCN to 0
+		}
+		else {
+			control &= ~0b01000000; // set BBSQW to 0
+		}
+
+		// write control back
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x0E);
+		i2c_t::write(control);
+		i2c_t::stop();
+	}
+}
+
+void rtc_SQW_set_freq(enum RTC_SQW_FREQ freq)
+{
+	if (s_is_ds1307) {
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x07);
+		i2c_t::stop();
+
+		// read control (uses bits 0 and 1)
+		i2c_t::start<RTC_ADDR>(true);
+		uint8_t control = i2c_t::read<true>();
+		i2c_t::stop();
+
+		control &= ~0b00000011; // Set to 0
+		control |= freq; // Set freq bitmask
+
+		// write control back
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x07);
+		i2c_t::write(control);
+		i2c_t::stop();
+
+	}
+	else { // DS3231
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x0E);
+		i2c_t::stop();
+
+		// read control (uses bits 3 and 4)
+		i2c_t::start<RTC_ADDR>(true);
+		uint8_t control = i2c_t::read<true>();
+		i2c_t::stop();
+
+		control &= ~0b00011000; // Set to 0
+		control |= (freq << 4); // Set freq bitmask
+
+		// write control back
+		i2c_t::start<RTC_ADDR>(false);
+		i2c_t::write(0x0E);
+		i2c_t::write(control);
+		i2c_t::stop();
+	}
+}
+
+void rtc_osc32kHz_enable(bool enable)
+{
+	if (!s_is_ds3231) return;
+
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0F);
+	i2c_t::stop();
+
+	// read status
+	i2c_t::start<RTC_ADDR>(true);
+	uint8_t status = i2c_t::read<true>();
+	i2c_t::stop();
+
+	if (enable)
+		status |= 0b00001000; // set to 1
+	else
+		status &= ~0b00001000; // Set to 0
+
+	// write status back
+	i2c_t::start<RTC_ADDR>(false);
+	i2c_t::write(0x0F);
+	i2c_t::write(status);
+	i2c_t::stop();
+}
+
+// Alarm functionality
+// fixme: should decide if "alarm disabled" mode should be available, or if alarm should always be enabled
+// at 00:00:00. Currently, "alarm disabled" only works for ds3231
+void rtc_reset_alarm(void)
+{
+	if (s_is_ds1307) {
+		rtc_set_sram_byte(0, 0); // hour
+		rtc_set_sram_byte(0, 1); // minute
+		rtc_set_sram_byte(0, 2); // second
+	}
+	else {
+		// writing 0 to bit 7 of all four alarm 1 registers disables alarm
+		rtc_write_byte(0, 0x07); // second
+		rtc_write_byte(0, 0x08); // minute
+		rtc_write_byte(0, 0x09); // hour
+		rtc_write_byte(0, 0x0a); // day
+	}
+}
+
+// fixme: add an option to set whether or not the INTCN and Interrupt Enable flag is set when setting the alarm
+void rtc_set_alarm_s(uint8_t hour, uint8_t min, uint8_t sec)
+{
+	if (hour > 23) return;
+	if (min > 59) return;
+	if (sec > 59) return;
+
+	if (s_is_ds1307) {
+		rtc_set_sram_byte(hour, 0); // hour
+		rtc_set_sram_byte(min,  1); // minute
+		rtc_set_sram_byte(sec,  2); // second
+	}
+	else {
+		/*
+		 *  07h: A1M1:0  Alarm 1 seconds
+		 *  08h: A1M2:0  Alarm 1 minutes
+		 *  09h: A1M3:0  Alarm 1 hour (bit6 is am/pm flag in 12h mode)
+		 *  0ah: A1M4:1  Alarm 1 day/date (bit6: 1 for day, 0 for date)
+		 *  Sets alarm to fire when hour, minute and second matches
+		 */
+		rtc_write_byte(dec2bcd(sec),  0x07); // second
+		rtc_write_byte(dec2bcd(min),  0x08); // minute
+		rtc_write_byte(dec2bcd(hour), 0x09); // hour
+		rtc_write_byte(0b10000001,         0x0a); // day (upper bit must be set)
+
+		// clear alarm flag
+		uint8_t val = rtc_read_byte(0x0f);
+		rtc_write_byte(val & ~0b00000001, 0x0f);
+	}
+}
+
+void rtc_set_alarm(struct rtc_tm* tm_)
+{
+	if (!tm_) return;
+	rtc_set_alarm_s(tm_->hour, tm_->min, tm_->sec);
+}
+
+void rtc_get_alarm_s(uint8_t* hour, uint8_t* min, uint8_t* sec)
+{
+	if (s_is_ds1307) {
+		if (hour) *hour = rtc_get_sram_byte(0);
+		if (min)  *min  = rtc_get_sram_byte(1);
+		if (sec)  *sec  = rtc_get_sram_byte(2);
+	}
+	else {
+		*sec  = bcd2dec(rtc_read_byte(0x07) & ~0b10000000);
+		*min  = bcd2dec(rtc_read_byte(0x08) & ~0b10000000);
+		*hour = bcd2dec(rtc_read_byte(0x09) & ~0b10000000);
+	}
+}
+
+struct rtc_tm* rtc_get_alarm(void)
+{
+	uint8_t hour, min, sec;
+
+	rtc_get_alarm_s(&hour, &min, &sec);
+	_rtc_tm.hour = hour;
+	_rtc_tm.min = min;
+	_rtc_tm.sec = sec;
+	return &_rtc_tm;
+}
+
+bool rtc_check_alarm(void)
+{
+	if (s_is_ds1307) {
+		uint8_t hour = rtc_get_sram_byte(0);
+		uint8_t min  = rtc_get_sram_byte(1);
+		uint8_t sec  = rtc_get_sram_byte(2);
+
+		uint8_t cur_hour, cur_min, cur_sec;
+		rtc_get_time_s(&cur_hour, &cur_min, &cur_sec);
+
+		if (cur_hour == hour && cur_min == min && cur_sec == sec)
+			return true;
+		return false;
+	}
+	else {
+		// Alarm 1 flag (A1F) in bit 0
+		uint8_t val = rtc_read_byte(0x0f);
+
+		// clear flag when set
+		if (val & 1)
+			rtc_write_byte(val & ~0b00000001, 0x0f);
+
+		return val & 1 ? 1 : 0;
+	}
+}

rtc.h

@@ -0,0 +1,106 @@
+/*
+ * DS RTC Library: DS1307 and DS3231 driver library
+ * (C) 2011 Akafugu Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ *
+ */
+
+#ifndef DS1307_H
+#define DS1307_H
+
+#include <stdbool.h>
+#include <avr/io.h>
+
+#define DS1307_SLAVE_ADDR 0b11010000
+
+/** Time structure
+ *
+ * Both 24-hour and 12-hour time is stored, and is always updated when rtc_get_time is called.
+ *
+ * When setting time and alarm, 24-hour mode is always used.
+ *
+ * If you run your clock in 12-hour mode:
+ * - set time hour to store in twelveHour and set am to true or false.
+ * - call rtc_12h_translate (this will put the correct value in hour, so you don't have to
+ *   calculate it yourself.
+ * - call rtc_set_alarm or rtc_set_clock
+ *
+ * Note that rtc_set_clock_s, rtc_set_alarm_s, rtc_get_time_s, rtc_set_alarm_s always operate in 24-hour mode
+ * and translation has to be done manually (you can call rtc_24h_to_12h to perform the calculation)
+ *
+ */
+struct rtc_tm {
+	int sec;      // 0 to 59
+	int min;      // 0 to 59
+	int hour;     // 0 to 23
+	int mday;     // 1 to 31
+	int mon;      // 1 to 12
+	int year;     // year-99
+	int wday;     // 1-7
+
+    // 12-hour clock data
+    bool am; // true for AM, false for PM
+    int twelveHour; // 12 hour clock time
+};
+
+// statically allocated
+extern struct rtc_tm _rtc_tm;
+
+// Initialize the RTC and autodetect type (DS1307 or DS3231)
+void rtc_init(void);
+
+// Autodetection
+bool rtc_is_ds1307(void);
+bool rtc_is_ds3231(void);
+
+void rtc_set_ds1307(void);
+void rtc_set_ds3231(void);
+
+// Get/set time
+// Gets the time: Supports both 24-hour and 12-hour mode
+struct rtc_tm* rtc_get_time(void);
+// Gets the time: 24-hour mode only
+void rtc_get_time_s(uint8_t* hour, uint8_t* min, uint8_t* sec);
+// Sets the time: Supports both 24-hour and 12-hour mode
+void rtc_set_time(struct rtc_tm* tm_);
+// Sets the time: Supports 12-hour mode only
+void rtc_set_time_s(uint8_t hour, uint8_t min, uint8_t sec);
+
+// start/stop clock running (DS1307 only)
+void rtc_run_clock(bool run);
+bool rtc_is_clock_running(void);
+
+// Read Temperature (DS3231 only)
+void  ds3231_get_temp_int(int8_t* i, uint8_t* f);
+void rtc_force_temp_conversion(uint8_t block);
+
+// SRAM read/write DS1307 only
+void rtc_get_sram(uint8_t* data);
+void rtc_set_sram(uint8_t *data);
+uint8_t rtc_get_sram_byte(uint8_t offset);
+void rtc_set_sram_byte(uint8_t b, uint8_t offset);
+
+  // Auxillary functions
+enum RTC_SQW_FREQ { FREQ_1 = 0, FREQ_1024, FREQ_4096, FREQ_8192 };
+
+void rtc_SQW_enable(bool enable);
+void rtc_SQW_set_freq(enum RTC_SQW_FREQ freq);
+void rtc_osc32kHz_enable(bool enable);
+
+// Alarm functionality
+void rtc_reset_alarm(void);
+void rtc_set_alarm(struct rtc_tm* tm_);
+void rtc_set_alarm_s(uint8_t hour, uint8_t min, uint8_t sec);
+struct rtc_tm* rtc_get_alarm(void);
+void rtc_get_alarm_s(uint8_t* hour, uint8_t* min, uint8_t* sec);
+bool rtc_check_alarm(void);
+
+#endif