fabian/pitrix
1
0
Fork 0
Code Issues 8 Releases Activity

Extended platrofmio.ini to use libraries from the internet. Those are all forks by me, needing some small fixes or pull requests applied here and there.

Browse Source
This commit is contained in:
Fabian Schlenz 2019-06-06 06:39:00 +02:00
parent d4c1c1fc91
commit b2f25f933b
2 changed files with 3 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
platformio.ini
View File

@ -16,7 +16,9 @@ env_default = ota
[extra]
lib_deps =
PubSubClient
FastLED
https://github.com/fabianonline/FastLED.git
https://github.com/fabianonline/simplelist.git
https://github.com/fabianonline/NTPClient.git
[env:ota]
upload_port = 10.10.2.78

246
src/NTPClient.cpp
View File

@ -1,246 +0,0 @@
/**
* The MIT License (MIT)
* Copyright (c) 2015 by Fabrice Weinberg
*
* 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 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.
*/
#include "NTPClient.h"
#include "my_fastled.h"
NTPClient::NTPClient(UDP& udp) {
this->_udp = &udp;
}
NTPClient::NTPClient(UDP& udp, int timeOffset) {
this->_udp = &udp;
this->_timeOffset = timeOffset;
}
NTPClient::NTPClient(UDP& udp, const char* poolServerName) {
this->_udp = &udp;
this->_poolServerName = poolServerName;
}
NTPClient::NTPClient(UDP& udp, const char* poolServerName, int timeOffset) {
this->_udp = &udp;
this->_timeOffset = timeOffset;
this->_poolServerName = poolServerName;
}
NTPClient::NTPClient(UDP& udp, const char* poolServerName, int timeOffset, int updateInterval) {
this->_udp = &udp;
this->_timeOffset = timeOffset;
this->_poolServerName = poolServerName;
this->_updateInterval = updateInterval;
}
void NTPClient::begin() {
this->begin(NTP_DEFAULT_LOCAL_PORT);
}
void NTPClient::begin(int port) {
this->_port = port;
this->_udp->begin(this->_port);
this->_udpSetup = true;
}
bool NTPClient::checkResponse() {
if (this->_udp->parsePacket()) {
this->_lastUpdate = millis();
this->_lastRequest = 0; // no outstanding request
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 secsSince1900 = highWord << 16 | lowWord;
this->_currentEpoc = secsSince1900 - SEVENZYYEARS;
highWord = word(this->_packetBuffer[44], this->_packetBuffer[45]);
lowWord = word(this->_packetBuffer[46], this->_packetBuffer[47]);
this->_currentFraction = highWord << 16 | lowWord;
random16_add_entropy(this->_packetBuffer[44]<<8 | this->_packetBuffer[45]);
random16_add_entropy(this->_packetBuffer[46]<<8 | this->_packetBuffer[47]);
// if the user has set a callback function for when the time is updated, call it
if (_updateCallback) { _updateCallback(this); }
this->_timeValid = true;
return true;
} else {
return false;
}
}
bool NTPClient::forceUpdate() {
#ifdef DEBUG_NTPClient
Serial.println("Update from NTP Server");
#endif
this->_timeValid = false;
while(this->_udp->parsePacket() != 0) this->_udp->flush();
this->sendNTPPacket();
// Wait till data is there or timeout...
byte timeout = 0;
bool cb = 0;
do {
delay ( 10 );
cb = this->checkResponse();
if (timeout > 100) return false; // timeout after 1000 ms
timeout++;
} while (cb == false);
return true;
}
bool NTPClient::update() {
bool updated = false;
unsigned long now = millis();
if ( ((_lastRequest == 0) && (_lastUpdate == 0)) // Never requested or updated
|| ((_lastRequest == 0) && ((now - _lastUpdate) >= _updateInterval)) // Update after _updateInterval
|| ((_lastRequest != 0) && ((now - _lastRequest) > _retryInterval)) ) { // Update if there was no response to the request
this->_timeValid = false;
// setup the UDP client if needed
if (!this->_udpSetup) {
this->begin();
}
while(this->_udp->parsePacket() != 0) this->_udp->flush();
this->sendNTPPacket();
}
if (_lastRequest) {
updated = checkResponse();
}
return updated;
}
bool NTPClient::updated() {
return (_currentEpoc != 0);
}
bool NTPClient::getTimeValid() {
return this->_timeValid;
}
unsigned long NTPClient::getEpochTime() {
return this->_timeOffset + // User offset
this->_currentEpoc + // Epoc returned by the NTP server
((millis() - this->_lastUpdate + (_currentFraction / FRACTIONSPERMILLI)) / 1000); // Time since last update
}
unsigned long long NTPClient::getEpochMillis() {
unsigned long long epoch;
epoch = this->_timeOffset; // user offset
epoch += _currentEpoc; // last time returned via server
epoch *= 1000; // convert to millis
epoch += _currentFraction / FRACTIONSPERMILLI; // add the fraction from the server
epoch += millis() - this->_lastUpdate; // add the millis that have passed since the last update
return epoch;
}
int NTPClient::getDay() {
return (((this->getEpochTime() / 86400L) + 4 ) % 7); //0 is Sunday
}
int NTPClient::getHours() {
return ((this->getEpochTime() % 86400L) / 3600);
}
int NTPClient::getMinutes() {
return ((this->getEpochTime() % 3600) / 60);
}
int NTPClient::getSeconds() {
return (this->getEpochTime() % 60);
}
String NTPClient::getFormattedTime() {
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;
}
void NTPClient::end() {
this->_udp->stop();
this->_udpSetup = false;
}
void NTPClient::setTimeOffset(int timeOffset) {
this->_timeOffset = timeOffset;
}
void NTPClient::setUpdateInterval(int updateInterval) {
this->_updateInterval = updateInterval;
}
void NTPClient::setRetryInterval(int retryInterval) {
_retryInterval = retryInterval;
}
void NTPClient::setUpdateCallback(NTPUpdateCallbackFunction f) {
_updateCallback = f;
}
void NTPClient::sendNTPPacket() {
// set all bytes in the buffer to 0
memset(this->_packetBuffer, 0, NTP_PACKET_SIZE);
// Initialize values needed to form NTP request
// (see URL above for details on the packets)
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:
this->_udp->beginPacket(this->_poolServerName, 123); //NTP requests are to port 123
this->_udp->write(this->_packetBuffer, NTP_PACKET_SIZE);
this->_udp->endPacket();
this->_lastRequest = millis();
}