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

Compare commits

base: avr:2a90cdee18579b8897c572f6cd110efbc1c82f02
Branches Tags
avr:master avr:example
..
compare: avr:3029c3cfe0a439a7693f39fa0d6511be92af5a63
Branches Tags
avr:example avr:master

3 Commits
2a90cdee18 ... 3029c3cfe0

Author SHA1 Message Date
BlackMark
3029c3cfe0 Add wrapper to write complete register 2020-05-17 18:59:38 +02:00
BlackMark
c3f9aa6a13 Automatically deduce register address by type 2020-05-17 18:59:19 +02:00
BlackMark
db5197b3b1 Add more flag operator overloads 2020-05-17 18:57:26 +02:00
3 changed files with 60 additions and 23 deletions
Expand all files Collapse all files

56
ds3231.hpp
View File

@@ -154,7 +154,7 @@ class DS3231 {
constexpr auto DATE_START_OFFSET = offsetof(detail::TimeReg, day); constexpr auto DATE_START_OFFSET = offsetof(detail::TimeReg, day);
constexpr auto DATE_END_OFFSET = offsetof(detail::TimeReg, year); constexpr auto DATE_END_OFFSET = offsetof(detail::TimeReg, year);
writePartialRegister<TIME_REG_ADDR, DATE_START_OFFSET, DATE_END_OFFSET>(timeReg); writePartialRegister<DATE_START_OFFSET, DATE_END_OFFSET>(timeReg);
} }
static void setTime(const Time &time) static void setTime(const Time &time)
{ {
@@ -166,7 +166,7 @@ class DS3231 {
constexpr auto TIME_START_OFFSET = offsetof(detail::TimeReg, seconds); constexpr auto TIME_START_OFFSET = offsetof(detail::TimeReg, seconds);
constexpr auto TIME_END_OFFSET = offsetof(detail::TimeReg, hours); constexpr auto TIME_END_OFFSET = offsetof(detail::TimeReg, hours);
writePartialRegister<TIME_REG_ADDR, TIME_START_OFFSET, TIME_END_OFFSET>(timeReg); writePartialRegister<TIME_START_OFFSET, TIME_END_OFFSET>(timeReg);
} }
static void setDateTime(const DateTime &dateTime) static void setDateTime(const DateTime &dateTime)
{ {
@@ -184,7 +184,7 @@ class DS3231 {
constexpr auto START_OFFSET = offsetof(detail::TimeReg, seconds); constexpr auto START_OFFSET = offsetof(detail::TimeReg, seconds);
constexpr auto END_OFFSET = offsetof(detail::TimeReg, year); constexpr auto END_OFFSET = offsetof(detail::TimeReg, year);
writePartialRegister<TIME_REG_ADDR, START_OFFSET, END_OFFSET>(timeReg); writePartialRegister<START_OFFSET, END_OFFSET>(timeReg);
} }
private: private:
@@ -224,9 +224,31 @@ class DS3231 {
} }
} }
template <uint8_t Address, uint8_t StartOffset, uint8_t EndOffset, typename Register> template <uint8_t StartOffset, uint8_t EndOffset, typename Register>
static void writePartialRegister(const Register &reg) static void writePartialRegister(const Register &reg)
{ {
constexpr auto getRegisterAddress = []() {
if constexpr (util::is_same_v<Register, detail::TimeReg>) {
return TIME_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::Alarm1Reg>) {
return ALARM1_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::Alarm2Reg>) {
return ALARM2_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::ControlReg>) {
return CONTROL_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::ControlStatusReg>) {
return CONTROL_STATUS_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::AgingOffsetReg>) {
return AGING_OFFSET_REG_ADDR;
} else if constexpr (util::is_same_v<Register, detail::TempReg>) {
return TEMP_REG_ADDR;
} else {
static_assert(util::always_false_v<Register>, "Invalid register type");
}
};
constexpr auto ADDRESS = getRegisterAddress();
static_assert(StartOffset <= EndOffset, "Invalid offset range"); static_assert(StartOffset <= EndOffset, "Invalid offset range");
static_assert(StartOffset < sizeof(Register), "Start offset out of bounds"); static_assert(StartOffset < sizeof(Register), "Start offset out of bounds");
static_assert(EndOffset < sizeof(Register), "End offset out of bounds"); static_assert(EndOffset < sizeof(Register), "End offset out of bounds");
@@ -234,30 +256,18 @@ class DS3231 {
constexpr auto WRITE_SIZE = EndOffset + 1 - StartOffset; constexpr auto WRITE_SIZE = EndOffset + 1 - StartOffset;
static_assert(StartOffset + WRITE_SIZE <= sizeof(Register), "Writing out of bounds"); 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");
}
i2c_t::template start<I2C_ADDRESS>(false); i2c_t::template start<I2C_ADDRESS>(false);
i2c_t::write(Address + StartOffset); i2c_t::write(ADDRESS + StartOffset);
i2c_t::template writeBytes<WRITE_SIZE>(reinterpret_cast<const uint8_t *>(&reg) + StartOffset); i2c_t::template writeBytes<WRITE_SIZE>(reinterpret_cast<const uint8_t *>(&reg) + StartOffset);
i2c_t::stop(); i2c_t::stop();
} }
template <typename Register>
static void writeRegister(const Register &reg)
{
writePartialRegister<0, sizeof(Register) - 1>(reg);
}
static uint8_t calcDayOfWeek(uint16_t year, uint8_t month, uint16_t day) static uint8_t calcDayOfWeek(uint16_t year, uint8_t month, uint16_t day)
{ {
day += month < 3 ? year-- : year - 2; day += month < 3 ? year-- : year - 2;

17
flags.hpp
View File

@@ -37,17 +37,34 @@ struct [[gnu::packed]] FlagsImpl
return *this; return *this;
} }
FlagsImpl &operator|=(const uint8_t &flag)
{
data |= flag;
return *this;
}
FlagsImpl &operator&=(const FlagsT &flag) FlagsImpl &operator&=(const FlagsT &flag)
{ {
data &= static_cast<uint8_t>(flag); data &= static_cast<uint8_t>(flag);
return *this; return *this;
} }
FlagsImpl &operator&=(const uint8_t &flag)
{
data &= flag;
return *this;
}
FlagsImpl &operator~() FlagsImpl &operator~()
{ {
data = ~data; data = ~data;
return *this; return *this;
} }
bool operator==(const FlagsT &flag) const
{
return data & static_cast<uint8_t>(flag);
}
}; };
template <typename FlagsT> template <typename FlagsT>

10
registers.hpp
View File

@@ -375,6 +375,11 @@ enum class ControlRegFlags : uint8_t {
A1IE = 1 << 0, A1IE = 1 << 0,
}; };
static inline uint8_t operator~(const ControlRegFlags &flag)
{
return ~static_cast<uint8_t>(flag);
}
struct [[gnu::packed]] ControlReg : FlagsImpl<ControlRegFlags>{}; struct [[gnu::packed]] ControlReg : FlagsImpl<ControlRegFlags>{};
static_assert(sizeof(ControlReg) == 1, "Invalid control register size"); static_assert(sizeof(ControlReg) == 1, "Invalid control register size");
@@ -389,6 +394,11 @@ enum class ControlStatusRegFlags : uint8_t {
A1F = 1 << 0, A1F = 1 << 0,
}; };
static inline uint8_t operator~(const ControlStatusRegFlags &flag)
{
return ~static_cast<uint8_t>(flag);
}
struct [[gnu::packed]] ControlStatusReg : FlagsImpl<ControlStatusRegFlags>{}; struct [[gnu::packed]] ControlStatusReg : FlagsImpl<ControlStatusRegFlags>{};
static_assert(sizeof(ControlStatusReg) == 1, "Invalid control/status register size"); static_assert(sizeof(ControlStatusReg) == 1, "Invalid control/status register size");