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
NTPClient.cpp
- Committer:
- acesrobertm
- Date:
- 2017-09-25
- Revision:
- 0:a56239ae90c2
File content as of revision 0:a56239ae90c2:
/* 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; }