An access controller for man doors at our facility. It receives Wiegand signals from a keypad/card reader and activates a relay to open the door. Access codes are stored in EEPROM. The active code list is updated from TFTP on a local server.
Dependencies: 24LCxx_I2C CardReader USBHOST
Diff: NTPClient.cpp
- Revision:
- 0:a56239ae90c2
diff -r 000000000000 -r a56239ae90c2 NTPClient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NTPClient.cpp Mon Sep 25 19:02:40 2017 +0000 @@ -0,0 +1,208 @@ +/* NTPClient.cpp */ +/* Copyright (C) 2012 mbed.org, MIT License + * + * 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. + */ + +#if 1 +//Enable debug +#define __DEBUG__ +#include <cstdio> +#define DBG(x, ...) std::printf("[NTPClient : DBG]"x"\r\n", ##__VA_ARGS__); +#define WARN(x, ...) std::printf("[NTPClient : WARN]"x"\r\n", ##__VA_ARGS__); +#define ERR(x, ...) std::printf("[NTPClient : ERR]"x"\r\n", ##__VA_ARGS__); + +#else +//Disable debug +#define DBG(x, ...) +#define WARN(x, ...) +#define ERR(x, ...) +#endif + +#include "NTPClient.h" + +#include "mbed.h" //time() and set_time() + +NTPClient::NTPClient() : m_sock() +{ + reset(); + + mQuerySent = false; + mResponseReceived = false; + mConversationComplete = true; + mStartTime = 0; +} + +void NTPClient::reset() +{ + if (outEndpoint) + { + delete outEndpoint; + } + if (inEndpoint) + { + delete inEndpoint; + } + outEndpoint = NULL; + inEndpoint = NULL; + + m_sock.close(); +} + +void NTPClient::process_result() +{ + //Correct Endianness + pkt.refTm_s = ntohl( pkt.refTm_s ); + pkt.refTm_f = ntohl( pkt.refTm_f ); + pkt.origTm_s = ntohl( pkt.origTm_s ); + pkt.origTm_f = ntohl( pkt.origTm_f ); + pkt.rxTm_s = ntohl( pkt.rxTm_s ); + pkt.rxTm_f = ntohl( pkt.rxTm_f ); + pkt.txTm_s = ntohl( pkt.txTm_s ); + pkt.txTm_f = ntohl( pkt.txTm_f ); + + //Compute offset, see RFC 4330 p.13 + uint32_t destTm_s = (NTP_TIMESTAMP_DELTA + time(NULL)); + int64_t offset = ( (int64_t)( pkt.rxTm_s - pkt.origTm_s ) + (int64_t) ( pkt.txTm_s - destTm_s ) ) / 2; //Avoid overflow + DBG("Received @%ul", pkt.txTm_s); + DBG("Offset: %lld", offset); + //Set time accordingly + set_time( time(NULL) + offset ); + + #ifdef __DEBUG__ + time_t ctTime; + ctTime = time(NULL); + DBG("Time is now (UTC): %s", ctime(&ctTime)); + #endif +} + +int NTPClient::update() +{ + int ntp_result = NTP_WAIT; + bool conversationComplete = true; + + if (mQuerySent && !mConversationComplete) + { + // Listen for a response from the NTP server. + int ret = m_sock.recvfrom( inEndpoint, (char*)&pkt, sizeof(NTPPacket) ); //FIXME need a DNS Resolver to actually compare the incoming address with the DNS name + + if (ret == NSAPI_ERROR_WOULD_BLOCK) + { + //DBG("Waiting..."); + + // Check for response timeout. + if ((time(NULL) - mStartTime) < mTimeout) + { + conversationComplete = false; + } + else + { + DBG("Timeout.\n"); + ntp_result = NTP_TIMEOUT; + } + } + else if(ret < 0) + { + ERR("Could not receive packet"); + ntp_result = NTP_CONN; + } + else if(ret < sizeof(NTPPacket)) //TODO: Accept chunks + { + ERR("Received packet size does not match"); + ntp_result = NTP_PRTCL; + } + else if( pkt.stratum == 0) //Kiss of death + { + ERR("Kissed to death!"); + ntp_result = NTP_PRTCL; + } + else + { + process_result(); + ntp_result = NTP_OK; + } + + if (conversationComplete) + { + reset(); + mConversationComplete = true; + } + } + + return ntp_result; +} + +NTPResult NTPClient::setTime(EthernetInterface* stack, const char* host, uint16_t port, uint32_t timeout) +{ + mQuerySent = false; + mResponseReceived = false; + mConversationComplete = false; + + mStartTime = time(NULL); + mTimeout = timeout; + +#ifdef __DEBUG__ + time_t ctTime; + ctTime = time(NULL); + DBG("Time is set to (UTC): %s", ctime(&ctTime)); +#endif + + //Create & bind socket + m_sock.open(stack); + DBG("Binding socket: %d", m_sock.bind(NTP_CLIENT_PORT)); //Bind to a random port + m_sock.set_blocking(false); //Set not blocking + + //Now ping the server and wait for response + DBG("Ping"); + //Prepare NTP Packet: + pkt.li = 0; //Leap Indicator : No warning + pkt.vn = 4; //Version Number : 4 + pkt.mode = 3; //Client mode + pkt.stratum = 0; //Not relevant here + pkt.poll = 0; //Not significant as well + pkt.precision = 0; //Neither this one is + + pkt.rootDelay = 0; //Or this one + pkt.rootDispersion = 0; //Or that one + pkt.refId = 0; //... + + pkt.refTm_s = 0; + pkt.origTm_s = 0; + pkt.rxTm_s = 0; + pkt.txTm_s = htonl( NTP_TIMESTAMP_DELTA + time(NULL) ); //WARN: We are in LE format, network byte order is BE + + pkt.refTm_f = pkt.origTm_f = pkt.rxTm_f = pkt.txTm_f = 0; + + outEndpoint = new SocketAddress(host, port); + inEndpoint = new SocketAddress(host, 0); + + //Set timeout, non-blocking and wait using select + DBG("Send packet to %s:%d", host, port); + int ret = m_sock.sendto(*outEndpoint, (void*)&pkt, sizeof(NTPPacket)); + if (ret < 0 ) + { + ERR("Could not send packet %d\n", ret); + m_sock.close(); + return NTP_CONN; + } + DBG("Sent..."); + + mQuerySent = true; + + return NTP_OK; +} + +