avr/ds3231
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: avr:54b8917705125bdea47f74e4c911650da5bb025f
Branches Tags
avr:master avr:example
..
compare: avr:example
Branches Tags
avr:example avr:master

24 Commits
54b8917705 ... example

Author SHA1 Message Date
BlackMark
2147637385 Update submodule 2020-05-17 20:11:51 +02:00
BlackMark
966af1d5cf Add ability to read alarm times 2020-05-17 20:07:13 +02:00
BlackMark
a83671bda5 Add alarms to example 2020-05-17 19:56:11 +02:00
BlackMark
7e8a6b0dad Add power control for RTC 2020-05-17 15:40:29 +02:00
BlackMark
a897b7d9be Move comparison operator into library 2020-05-17 15:40:15 +02:00
BlackMark
f8ee536829 Only pass i2c backend to rtc class 2020-05-16 19:52:49 +02:00
BlackMark
2fd64c8611 Implement setting time through serial 2020-05-16 19:48:37 +02:00
BlackMark
97bb522189 Remove old rtc lib and systime 2020-05-16 19:20:32 +02:00
BlackMark
b8c7c9ec5c Adapt to moved type submodule 2020-05-16 17:44:16 +02:00
BlackMark
5d77cad8d7 Add setting date-time example with new rtc lib 2020-05-16 17:26:56 +02:00
BlackMark
4b3dd99ebc Add usage for new C++ driver 2020-05-15 19:48:22 +02:00
BlackMark
f00a154e59 Change i2c library 2020-05-15 11:51:51 +02:00
BlackMark
e9d3a95239 Move C time API glue from driver to user space 2020-05-15 10:21:34 +02:00
BlackMark
b2065b987a Switch from old usart to new uart library 2020-05-15 09:43:06 +02:00
BlackMark
85e37de950 Ran clang-format 2020-05-15 09:29:26 +02:00
BlackMark
7310eb2c9a Remove bootloader support 2020-05-15 09:28:05 +02:00
BlackMark
b02454c45b Update submodule 2020-05-15 09:26:08 +02:00
BlackMark
af4f2ed0e5 Update project file to C++17 config with gcc 9 2020-05-15 09:24:24 +02:00
BlackMark
7a8d31718f Add gitignore and clang-format file 2020-05-15 09:21:08 +02:00
BlackMark
05e8b1b53f Change to 16 MHz crystal 2020-05-15 09:14:31 +02:00
BlackMark
a340cb04d3 Actually use ds3231 submodule instead of duplicating code 2020-05-15 09:06:34 +02:00
BlackMark
4cffd8f56b Fix submodule path 2020-05-15 09:01:11 +02:00
BlackMark
6072c34eef Fixed setting time bug, because of uninitialized tm struct 2018-01-02 17:21:04 +01:00
BlackMark
4bc59d1a33 Changed wrong CPU FREQ define to central correct one 2017-12-17 10:53:38 +01:00
17 changed files with 523 additions and 1364 deletions
Expand all files Collapse all files

18
.gitmodules vendored Normal file
View File

@@ -0,0 +1,18 @@
[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

21
LICENSE
View File

@@ -1,21 +0,0 @@
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.

22
ds3231.atsln Normal file
View File

@@ -0,0 +1,22 @@
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

130
ds3231.hpp
View File

@@ -1,130 +0,0 @@
#pragma once
#include "../clock.hpp"
#include "../i2c/i2c.hpp"
#include "../type/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>
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) {}
static void setTime(const Time &time) {}
static void setDateTime(const DateTime &dateTime) {}
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(type::always_false_v<decltype(Address)>, "Invalid register address");
}
}
};
} // namespace rtc

4
ds3231/clock.hpp Normal file
View File

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

1
ds3231/ds3231 Submodule

Submodule ds3231/ds3231 added at 8a6170cb10

285
ds3231/ds3231.cppproj Normal file
View File

@@ -0,0 +1,285 @@
<?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>

1
ds3231/flash Submodule

Submodule ds3231/flash added at 6edb2e5a21

1
ds3231/i2c Submodule

Submodule ds3231/i2c added at 8af5afd00d

1
ds3231/io Submodule

Submodule ds3231/io added at 80de36ee7e

188
ds3231/main.cpp Normal file
View File

@@ -0,0 +1,188 @@
#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;
}

1
ds3231/uart Submodule

Submodule ds3231/uart added at 119de32445

1
ds3231/util Submodule

Submodule ds3231/util added at 81b3ae244c

71
flags.hpp
View File

@@ -1,71 +0,0 @@
#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;
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

419
registers.hpp
View File

@@ -1,419 +0,0 @@
#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;
uint8_t minutes;
uint8_t hours;
uint8_t day;
uint8_t date;
uint8_t month_century;
uint8_t year;
//////////////////////////////////////////////////////////////////////////
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;
uint8_t minutes;
uint8_t hours;
uint8_t day_date;
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;
uint8_t hours;
uint8_t day_date;
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;
};
static_assert(sizeof(AgingOffsetReg) == 1, "Invalid aging offset register size");
//////////////////////////////////////////////////////////////////////////
struct [[gnu::packed]] TempReg
{
uint8_t msb_temp;
uint8_t lsb_temp;
};
static_assert(sizeof(TempReg) == 2, "Invalid temperature register size");
//////////////////////////////////////////////////////////////////////////
} // namespace detail
} // namespace rtc

617
rtc.cpp
View File

@@ -1,617 +0,0 @@
/*
* 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;
}
}

106
rtc.h
View File

@@ -1,106 +0,0 @@
/*
* 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