694 lines
16 KiB
C++
694 lines
16 KiB
C++
#include <Arduino.h>
|
|
#include "ntp_client_plus.h"
|
|
|
|
/**
|
|
* @brief Construct a new NTPClientPlus::NTPClientPlus object
|
|
*
|
|
* @param udp UDP client
|
|
* @param poolServerName time server name
|
|
* @param utcx UTC offset (in 1h)
|
|
* @param _swChange should summer/winter time be considered
|
|
*/
|
|
NTPClientPlus::NTPClientPlus(UDP &udp, const char *poolServerName, int utcx, bool _swChange)
|
|
{
|
|
this->_udp = &udp;
|
|
this->_utcx = utcx;
|
|
this->_timeOffset = this->secondperhour * this->_utcx;
|
|
this->_poolServerName = poolServerName;
|
|
this->_swChange = _swChange;
|
|
}
|
|
|
|
/**
|
|
* @brief Starts the underlying UDP client, get first NTP timestamp and calc date
|
|
*
|
|
*/
|
|
void NTPClientPlus::setupNTPClient()
|
|
{
|
|
this->_udp->begin(this->_port);
|
|
this->_udpSetup = true;
|
|
this->updateNTP();
|
|
this->calcDate();
|
|
}
|
|
|
|
/**
|
|
* @brief Get new update from NTP
|
|
*
|
|
* @return NTP_UPDATE_TIMEOUT timeout after 500 ms
|
|
* @return NTP_UPDATE_SUCCESS after successful update
|
|
* @return NTP_UPDATE_DIFFTOOHIGH too much difference to previous received time (try again)
|
|
* @return NTP_UPDATE_TIME_INVALID time value is invalid
|
|
*/
|
|
int NTPClientPlus::updateNTP()
|
|
{
|
|
|
|
// flush any existing packets
|
|
while (this->_udp->parsePacket() != 0)
|
|
{
|
|
this->_udp->flush();
|
|
}
|
|
|
|
this->sendNTPPacket();
|
|
|
|
// Wait till data is there or timeout...
|
|
uint8_t conn_tries = 0;
|
|
int received_bytes = 0;
|
|
|
|
while ((received_bytes == 0) && (conn_tries++ <= MAX_NTP_CONN_TRIES))
|
|
{
|
|
received_bytes = this->_udp->parsePacket();
|
|
wait(NTP_RECEIVE_WAIT_TIME_MS);
|
|
}
|
|
|
|
if (conn_tries >= MAX_NTP_CONN_TRIES)
|
|
{
|
|
return NTP_UPDATE_TIMEOUT;
|
|
}
|
|
|
|
this->_udp->read(this->_packetBuffer, NTP_PACKET_SIZE);
|
|
|
|
unsigned long highWord = word(this->_packetBuffer[40], this->_packetBuffer[41]);
|
|
unsigned long lowWord = word(this->_packetBuffer[42], this->_packetBuffer[43]);
|
|
// combine the four bytes (two words) into a long integer
|
|
// this is NTP time (seconds since Jan 1 1900):
|
|
unsigned long tempSecsSince1900 = highWord << 16 | lowWord;
|
|
|
|
if (tempSecsSince1900 < UNIX_TIMESTAMP_1900) // NTP time is not valid
|
|
{
|
|
return NTP_UPDATE_TIME_INVALID;
|
|
}
|
|
|
|
// check if time off last ntp update is roughly in the same range: 100sec apart (validation check)
|
|
if (this->_lastSecsSince1900 == 0 || tempSecsSince1900 - this->_lastSecsSince1900 < 100000)
|
|
{
|
|
// Only update time then
|
|
this->_lastUpdate = millis() - (NTP_RECEIVE_WAIT_TIME_MS * (conn_tries + 1)); // Account for delay in reading the time
|
|
this->_secsSince1900 = tempSecsSince1900;
|
|
this->_currentEpoc = this->_secsSince1900 - UNIX_TIMESTAMP_1900;
|
|
|
|
// Remember time of last update
|
|
this->_lastSecsSince1900 = tempSecsSince1900;
|
|
return NTP_UPDATE_SUCCESS; // return 0 after successful update
|
|
}
|
|
else
|
|
{
|
|
// Remember time of last update
|
|
this->_lastSecsSince1900 = tempSecsSince1900;
|
|
return NTP_UPDATE_DIFFTOOHIGH;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Stops the underlying UDP client
|
|
*
|
|
*/
|
|
void NTPClientPlus::end()
|
|
{
|
|
this->_udp->stop();
|
|
this->_udpSetup = false;
|
|
}
|
|
|
|
/**
|
|
* @brief Setter TimeOffset
|
|
*
|
|
* @param timeOffset offset from UTC in seconds
|
|
*/
|
|
void NTPClientPlus::setTimeOffset(int timeOffset)
|
|
{
|
|
this->_timeOffset = timeOffset;
|
|
}
|
|
|
|
long NTPClientPlus::getTimeOffset()
|
|
{
|
|
return this->_timeOffset;
|
|
}
|
|
|
|
/**
|
|
* @brief Set time server name
|
|
*
|
|
* @param poolServerName
|
|
*/
|
|
void NTPClientPlus::setPoolServerName(const char *poolServerName)
|
|
{
|
|
this->_poolServerName = poolServerName;
|
|
}
|
|
|
|
/**
|
|
* @brief Calc seconds since 1. Jan. 1900
|
|
*
|
|
* @return unsigned long seconds since 1. Jan. 1900
|
|
*/
|
|
unsigned long NTPClientPlus::getSecsSince1900() const
|
|
{
|
|
return this->_timeOffset + // User offset
|
|
this->_secsSince1900 + // seconds returned by the NTP server
|
|
((millis() - this->_lastUpdate) / 1000); // Time since last update
|
|
}
|
|
|
|
/**
|
|
* @brief Get UNIX Epoch time since 1. Jan. 1970
|
|
*
|
|
* @return unsigned long UNIX Epoch time since 1. Jan. 1970 in seconds
|
|
*/
|
|
unsigned long NTPClientPlus::getEpochTime() const
|
|
{
|
|
return this->getSecsSince1900() - UNIX_TIMESTAMP_1900;
|
|
}
|
|
|
|
/**
|
|
* @brief Get current hours in 24h format
|
|
*
|
|
* @return int
|
|
*/
|
|
int NTPClientPlus::getHours24() const
|
|
{
|
|
int hours = ((this->getEpochTime() % 86400L) / 3600);
|
|
return hours;
|
|
}
|
|
|
|
/**
|
|
* @brief Get current hours in 12h format
|
|
*
|
|
* @return int
|
|
*/
|
|
int NTPClientPlus::getHours12() const
|
|
{
|
|
int hours = this->getHours24();
|
|
if (hours >= 12)
|
|
{
|
|
hours = hours - 12;
|
|
}
|
|
return hours;
|
|
}
|
|
|
|
/**
|
|
* @brief Get current minutes
|
|
*
|
|
* @return int
|
|
*/
|
|
int NTPClientPlus::getMinutes() const
|
|
{
|
|
return ((this->getEpochTime() % 3600) / 60);
|
|
}
|
|
|
|
/**
|
|
* @brief Get current seconds
|
|
*
|
|
* @return int
|
|
*/
|
|
int NTPClientPlus::getSeconds() const
|
|
{
|
|
return (this->getEpochTime() % 60);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @return String time formatted like `hh:mm:ss`
|
|
*/
|
|
String NTPClientPlus::getFormattedTime() const
|
|
{
|
|
unsigned long rawTime = this->getEpochTime();
|
|
unsigned long hours = (rawTime % 86400L) / 3600;
|
|
String hoursStr = hours < 10 ? "0" + String(hours) : String(hours);
|
|
|
|
unsigned long minutes = (rawTime % 3600) / 60;
|
|
String minuteStr = minutes < 10 ? "0" + String(minutes) : String(minutes);
|
|
|
|
unsigned long seconds = rawTime % 60;
|
|
String secondStr = seconds < 10 ? "0" + String(seconds) : String(seconds);
|
|
|
|
return hoursStr + ":" + minuteStr + ":" + secondStr;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @return String date formatted like `dd.mm.yyyy`
|
|
*/
|
|
String NTPClientPlus::getFormattedDate()
|
|
{
|
|
this->calcDate();
|
|
unsigned int dateDay = this->_dateDay;
|
|
unsigned int dateMonth = this->_dateMonth;
|
|
unsigned int dateYear = this->_dateYear;
|
|
|
|
String dayStr = dateDay < 10 ? "0" + String(dateDay) : String(dateDay);
|
|
String monthStr = dateMonth < 10 ? "0" + String(dateMonth) : String(dateMonth);
|
|
String yearStr = dateYear < 10 ? "0" + String(dateYear) : String(dateYear);
|
|
|
|
return dayStr + "." + monthStr + "." + yearStr;
|
|
}
|
|
|
|
/**
|
|
* @brief Calc date from seconds since 1900
|
|
*
|
|
*/
|
|
void NTPClientPlus::calcDate()
|
|
{
|
|
// Start: Calc date
|
|
|
|
// get days since 1900
|
|
unsigned long days1900 = this->getSecsSince1900() / secondperday;
|
|
|
|
// calc current year
|
|
this->_dateYear = this->getYear();
|
|
|
|
// calc how many leap days since 1.Jan 1900
|
|
int leapDays = 0;
|
|
for (unsigned int i = 1900; i < this->_dateYear; i++)
|
|
{
|
|
// check if leap year
|
|
if (this->isLeapYear(i))
|
|
{
|
|
leapDays++;
|
|
}
|
|
}
|
|
leapDays = leapDays - 1;
|
|
|
|
// check if current year is leap year
|
|
if (this->isLeapYear(this->_dateYear))
|
|
{
|
|
daysInMonth[2] = 29;
|
|
}
|
|
else
|
|
{
|
|
daysInMonth[2] = 28;
|
|
}
|
|
|
|
unsigned int dayOfYear = (days1900 - ((this->_dateYear - 1900) * 365) - leapDays);
|
|
|
|
// calc current month
|
|
this->_dateMonth = this->getMonth(dayOfYear);
|
|
|
|
this->_dateDay = 0;
|
|
|
|
// calc day of month
|
|
for (unsigned int i = 0; i < this->_dateMonth; i++)
|
|
{
|
|
this->_dateDay = this->_dateDay + daysInMonth[i];
|
|
}
|
|
this->_dateDay = dayOfYear - this->_dateDay;
|
|
|
|
// calc day of week:
|
|
// Monday = 1, Tuesday = 2, Wednesday = 3, Thursday = 4, Friday = 5, Saturday = 6, Sunday = 7
|
|
// 1. Januar 1900 was a monday
|
|
this->_dayOfWeek = 1;
|
|
|
|
for (unsigned int i = 0; i < days1900; i++)
|
|
{
|
|
if (this->_dayOfWeek < 7)
|
|
{
|
|
this->_dayOfWeek = this->_dayOfWeek + 1;
|
|
}
|
|
else
|
|
{
|
|
this->_dayOfWeek = 1;
|
|
}
|
|
}
|
|
|
|
// End: Calc date (dateDay, dateMonth, dateYear)
|
|
|
|
// calc if summer time active
|
|
|
|
this->updateSWChange();
|
|
}
|
|
|
|
/**
|
|
* @brief Getter for day of the week
|
|
*
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int NTPClientPlus::getDayOfWeek()
|
|
{
|
|
return this->_dayOfWeek;
|
|
}
|
|
|
|
/**
|
|
* @brief Function to calc current year
|
|
*
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int NTPClientPlus::getYear()
|
|
{
|
|
|
|
unsigned long sec1900 = this->getSecsSince1900();
|
|
|
|
// NTP starts at 1. Jan 1900
|
|
unsigned int result = 1900;
|
|
unsigned int dayInYear = 0;
|
|
unsigned int days = 0;
|
|
unsigned int days1900 = 0;
|
|
|
|
unsigned int for_i = 0;
|
|
bool leapYear = LOW;
|
|
|
|
days1900 = sec1900 / this->secondperday;
|
|
|
|
for (for_i = 0; for_i < days1900; for_i++)
|
|
{
|
|
|
|
leapYear = this->isLeapYear(result);
|
|
|
|
if (leapYear)
|
|
{
|
|
dayInYear = 366;
|
|
}
|
|
|
|
else
|
|
{
|
|
dayInYear = 365;
|
|
}
|
|
|
|
days++;
|
|
|
|
if (days >= dayInYear)
|
|
{
|
|
result++;
|
|
days = 0;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief Function to check if given year is leap year
|
|
*
|
|
* @param year
|
|
* @return true
|
|
* @return false
|
|
*/
|
|
bool NTPClientPlus::isLeapYear(unsigned int year)
|
|
{
|
|
|
|
bool result = LOW;
|
|
|
|
// check for leap year
|
|
if ((year % 4) == 0)
|
|
{
|
|
|
|
result = HIGH;
|
|
|
|
if ((year % 100) == 0)
|
|
{
|
|
|
|
result = LOW;
|
|
|
|
if ((year % 400) == 0)
|
|
{
|
|
|
|
result = HIGH;
|
|
}
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
result = LOW;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief Get Month of given day of year
|
|
*
|
|
* @param dayOfYear
|
|
* @return int
|
|
*/
|
|
int NTPClientPlus::getMonth(int dayOfYear)
|
|
{
|
|
|
|
bool leapYear = this->isLeapYear(this->getYear());
|
|
|
|
// Month beginnings
|
|
int monthMin[13] = {0, 1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
|
|
// Month endings
|
|
int monthMax[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
|
|
|
|
int month = 0;
|
|
|
|
int y = 0;
|
|
|
|
// Calculation of the beginning and end of each month in the leap year
|
|
if (leapYear == HIGH)
|
|
{
|
|
|
|
for (y = 3; y < 13; y++)
|
|
{
|
|
monthMin[y] = monthMin[y] + 1;
|
|
}
|
|
|
|
for (y = 2; y < 13; y++)
|
|
{
|
|
monthMax[y] = monthMax[y] + 1;
|
|
}
|
|
}
|
|
|
|
// January
|
|
if (dayOfYear >= monthMin[1] && dayOfYear <= monthMax[1])
|
|
{
|
|
month = 1;
|
|
}
|
|
|
|
// February
|
|
if (dayOfYear >= monthMin[2] && dayOfYear <= monthMax[2])
|
|
{
|
|
month = 2;
|
|
}
|
|
|
|
// March
|
|
if (dayOfYear >= monthMin[3] && dayOfYear <= monthMax[3])
|
|
{
|
|
month = 3;
|
|
}
|
|
|
|
// April
|
|
if (dayOfYear >= monthMin[4] && dayOfYear <= monthMax[4])
|
|
{
|
|
month = 4;
|
|
}
|
|
|
|
// May
|
|
if (dayOfYear >= monthMin[5] && dayOfYear <= monthMax[5])
|
|
{
|
|
month = 5;
|
|
}
|
|
|
|
// June
|
|
if (dayOfYear >= monthMin[6] && dayOfYear <= monthMax[6])
|
|
{
|
|
month = 6;
|
|
}
|
|
|
|
// July
|
|
if (dayOfYear >= monthMin[7] && dayOfYear <= monthMax[7])
|
|
{
|
|
month = 7;
|
|
}
|
|
|
|
// August
|
|
if (dayOfYear >= monthMin[8] && dayOfYear <= monthMax[8])
|
|
{
|
|
month = 8;
|
|
}
|
|
|
|
// September
|
|
if (dayOfYear >= monthMin[9] && dayOfYear <= monthMax[9])
|
|
{
|
|
month = 9;
|
|
}
|
|
|
|
// October
|
|
if (dayOfYear >= monthMin[10] && dayOfYear <= monthMax[10])
|
|
{
|
|
month = 10;
|
|
}
|
|
|
|
// November
|
|
if (dayOfYear >= monthMin[11] && dayOfYear <= monthMax[11])
|
|
{
|
|
month = 11;
|
|
}
|
|
|
|
// December
|
|
if (dayOfYear >= monthMin[12] && dayOfYear <= monthMax[12])
|
|
{
|
|
month = 12;
|
|
}
|
|
|
|
return month;
|
|
}
|
|
|
|
/**
|
|
* @brief (private) Send NTP Packet to NTP server
|
|
*
|
|
*/
|
|
void NTPClientPlus::sendNTPPacket()
|
|
{
|
|
// set all bytes in the buffer to 0
|
|
memset(this->_packetBuffer, 0, NTP_PACKET_SIZE);
|
|
// Initialize values needed to form NTP request
|
|
this->_packetBuffer[0] = 0b11100011; // LI, Version, Mode
|
|
this->_packetBuffer[1] = 0; // Stratum, or type of clock
|
|
this->_packetBuffer[2] = 6; // Polling Interval
|
|
this->_packetBuffer[3] = 0xEC; // Peer Clock Precision
|
|
// 8 bytes of zero for Root Delay & Root Dispersion
|
|
this->_packetBuffer[12] = 49;
|
|
this->_packetBuffer[13] = 0x4E;
|
|
this->_packetBuffer[14] = 49;
|
|
this->_packetBuffer[15] = 52;
|
|
|
|
// all NTP fields have been given values, now
|
|
// you can send a packet requesting a timestamp:
|
|
if (this->_poolServerName)
|
|
{
|
|
this->_udp->beginPacket(this->_poolServerName, 123);
|
|
}
|
|
else
|
|
{
|
|
this->_udp->beginPacket(this->_poolServerIP, 123);
|
|
}
|
|
this->_udp->write(this->_packetBuffer, NTP_PACKET_SIZE);
|
|
this->_udp->endPacket();
|
|
}
|
|
|
|
/**
|
|
* @brief (private) Set time offset accordance to summer time
|
|
*
|
|
* @param summertime
|
|
*/
|
|
void NTPClientPlus::setSummertime(bool summertime)
|
|
{
|
|
if (summertime)
|
|
{
|
|
this->_timeOffset = this->secondperhour * (this->_utcx + 1);
|
|
}
|
|
else
|
|
{
|
|
this->_timeOffset = this->secondperhour * (this->_utcx);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief (private) Update Summer/Winter time change
|
|
*
|
|
* @returns bool summertime active
|
|
*/
|
|
bool NTPClientPlus::updateSWChange()
|
|
{
|
|
unsigned int dayOfWeek = this->_dayOfWeek;
|
|
unsigned int dateDay = this->_dateDay;
|
|
unsigned int dateMonth = this->_dateMonth;
|
|
|
|
bool summertimeActive = false;
|
|
|
|
if (this->_swChange)
|
|
{
|
|
// Start: Set summer-/ winter time
|
|
|
|
// current month is march
|
|
if (dateMonth == 3)
|
|
{
|
|
|
|
// it is last week in march
|
|
if ((this->daysInMonth[3] - dateDay) < 7)
|
|
{
|
|
|
|
// Example year 2020: March 31 days; Restart March 26, 2020 (Thursday = weekday = 4); 5 days remaining; Last Sunday March 29, 2020
|
|
// Calculation: 31 - 26 = 5; 5 + 4 = 9;
|
|
// Result: Last day in March is a Tuesday. There follows another Sunday in October => set winter time
|
|
|
|
// Example year 2021: March 31 days; Restart March 30, 2021 (Tuesday = weekday = 2); 1 days remaining; Last Sunday March 28, 2021
|
|
// Calculation: 31 - 30 = 1; 1 + 2 = 3;
|
|
// Result: Last day in March is a Wednesday. Changeover to summer time already done => set summer time
|
|
|
|
// There follows within the last week in March one more Sunday => set winter time
|
|
if (((this->daysInMonth[3] - dateDay) + dayOfWeek) >= 7)
|
|
{
|
|
this->setSummertime(0);
|
|
summertimeActive = false;
|
|
}
|
|
|
|
// last sunday in march already over -> summer time
|
|
else
|
|
{
|
|
this->setSummertime(1);
|
|
summertimeActive = true;
|
|
}
|
|
}
|
|
|
|
// restart in first three weeks of march -> winter time
|
|
else
|
|
{
|
|
this->setSummertime(0);
|
|
summertimeActive = false;
|
|
}
|
|
}
|
|
|
|
// current month is october
|
|
else if (dateMonth == 10)
|
|
{
|
|
|
|
// restart last week of october
|
|
if ((this->daysInMonth[10] - dateDay) < 7)
|
|
{
|
|
|
|
// Example year 2020: October 31 days; restart October 26, 2020 (Monday = weekday = 1); 5 days remaining; last Sunday October 25, 2020
|
|
// Calculation: 31 - 26 = 5; 5 + 1 = 6;
|
|
// Result: Last day in October is a Saturday. Changeover to winter time already done => set winter time
|
|
|
|
// Example year 2021: October 31 days; Restart 26. October 2021 (Tuesday = weekday = 2); 5 days remaining; Last Sunday 31. October 2021
|
|
// Calculation: 31 - 26 = 5; 5 + 2 = 7;
|
|
// Result: Last day in October is a Sunday. There follows another Sunday in October => set summer time
|
|
|
|
// There follows within the last week in October one more Sunday => summer time
|
|
if (((this->daysInMonth[10] - dateDay) + dayOfWeek) >= 7)
|
|
{
|
|
this->setSummertime(1);
|
|
summertimeActive = true;
|
|
}
|
|
|
|
// last sunday in october already over -> winter time
|
|
else
|
|
{
|
|
this->setSummertime(0);
|
|
summertimeActive = false;
|
|
}
|
|
}
|
|
|
|
// restart in first three weeks of october -> summer time
|
|
else
|
|
{
|
|
this->setSummertime(1);
|
|
summertimeActive = true;
|
|
}
|
|
}
|
|
|
|
// restart in summer time
|
|
else if (dateMonth > 3 && dateMonth < 10)
|
|
{
|
|
this->setSummertime(1);
|
|
summertimeActive = true;
|
|
}
|
|
|
|
// restart in winter time
|
|
else if (dateMonth < 3 || dateMonth > 10)
|
|
{
|
|
this->setSummertime(0);
|
|
summertimeActive = false;
|
|
}
|
|
}
|
|
|
|
return summertimeActive;
|
|
}
|
|
|
|
void wait(unsigned long time)
|
|
{
|
|
unsigned long start = millis();
|
|
while (millis() - start < time)
|
|
{
|
|
yield();
|
|
};
|
|
}
|