ntp.cpp

#include "ntp.h"

NTP::NTP(UDP &sock)
    : _sock(sock),
      _address("pool.ntp.org")
{
}

NTP::NTP(UDP &sock, const char *address)
    : _sock(sock),
      _address(address ? address : "pool.ntp.org")
{
}

void NTP::begin(uint16_t port)
{
  _sock.begin(port);
}

void NTP::end()
{
  _sock.stop();
}

void NTP::setServer(const char *address)
{
  if (address && address[0] != '\0')
  {
    _address = address;
  }
}

void NTP::setTimeOffset(int32_t timeOffsetSeconds)
{
  _timeOffset = timeOffsetSeconds;
}

bool NTP::isValid() const
{
  return _valid;
}

uint32_t NTP::_nowUtc() const
{
  if (!_valid)
  {
    return 0;
  }

  // handle millis() rollover by unsigned arithmetic
  uint32_t nowMs = millis();
  uint32_t elapsed = (nowMs - _lastSyncMillis) / 1000;

  return _timestamp + elapsed;
}

uint32_t NTP::getTimestamp() const
{
  return _nowUtc(); // pure UTC
}

uint32_t NTP::getEpochTime() const
{
  if (!_valid)
  {
    return 0;
  }

  uint32_t utc = _nowUtc();
  int32_t local = (int32_t)utc + _timeOffset;

  if (local < 0)
  {
    // Before 1970; clamp to 0 to avoid underflow on cast
    return 0;
  }

  return (uint32_t)local;
}

bool NTP::update(uint16_t timeoutMs)
{
  // Clear any pending packets from previous tries
  while (_sock.parsePacket() > 0)
  {
    _sock.flush();
  }

  uint8_t *b = _buffer;
  memset(b, 0, NTP_PACKET_SIZE);

  // NTP header:
  //  LI (2 bits) = 0 (no warning)
  //  VN (3 bits) = 4 (version 4)
  //  Mode (3 bits) = 3 (client)
  b[0] = 0b00100011; // 0x23
  b[1] = 0;          // Stratum (unspecified)
  b[2] = 6;          // Polling interval (not critical for simple client)
  b[3] = 0xEC;       // Peer clock precision (example value)

  // "1N14" magic reference ID
  b[12] = 0x31;
  b[13] = 0x4E;
  b[14] = 0x31;
  b[15] = 0x34;

  // Send request to NTP server (port 123)
  if (!_sock.beginPacket(_address, 123))
  {
    return false;
  }
  _sock.write(b, NTP_PACKET_SIZE);
  _sock.endPacket();

  // Wait for response with proper timeout
  uint32_t start = millis();
  int packetSize = 0;

  do
  {
    delay(10);
    packetSize = _sock.parsePacket();

    if ((millis() - start) >= timeoutMs)
    {
      return false; // timeout
    }
  } while (packetSize == 0);

  // Basic sanity check: full NTP packet
  if (packetSize < NTP_PACKET_SIZE)
  {
    _sock.flush();
    return false;
  }

  _sock.read(_buffer, NTP_PACKET_SIZE);
  const uint8_t *r = _buffer;

  // Validate response mode and version
  const uint8_t li = (r[0] >> 6) & 0x03;
  const uint8_t vn = (r[0] >> 3) & 0x07;
  const uint8_t mode = r[0] & 0x07;

  // mode should be 4 (server) or 5 (broadcast); vn >= 3 typical
  if (mode != 4 && mode != 5)
  {
    return false;
  }
  if (vn < 3 || li == 3)
  {
    // Unsynchronized server or very old version
    return false;
  }

  // Bytes 40..43: Transmit Timestamp (high 32 bits: seconds since 1900-01-01)
  uint32_t ntpSeconds =
      ((uint32_t)r[40] << 24) |
      ((uint32_t)r[41] << 16) |
      ((uint32_t)r[42] << 8) |
      ((uint32_t)r[43]);

  if (ntpSeconds < NTP_TIMESTAMP_DIFFERENCE)
  {
    // Should never happen for real NTP servers; sanity check
    return false;
  }

  _timestamp = ntpSeconds - NTP_TIMESTAMP_DIFFERENCE; // UTC seconds since 1970-01-01
  _lastSyncMillis = millis();
  _valid = true;

  return true;
}

ntp_datetime_t NTP::getDateTime() const
{
  ntp_datetime_t r = {0, 0, 0, 0, 0, 0};

  if (!_valid)
  {
    return r;
  }

  uint32_t s = getEpochTime(); // local time (with offset)
  if (s == 0)
  {
    return r;
  }

  // Day/date calculation:
  // Based on Howard Hinnant's "civil_from_days" algorithm

  uint32_t z = s / 86400 + 719468; // days since 0000-03-01
  uint32_t era = z / 146097;
  uint32_t doe = z - era * 146097; // [0, 146096]
  uint32_t yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
  uint32_t y = yoe + era * 400;
  uint32_t doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
  uint32_t mp = (5 * doy + 2) / 153;
  uint32_t d = doy - (153 * mp + 2) / 5 + 1;
  uint32_t m = mp + (mp < 10 ? 3 : -9);

  y += (m <= 2);

  r.year = (uint16_t)y;
  r.month = (uint8_t)m;
  r.day = (uint8_t)d;
  r.hour = (uint8_t)((s % 86400) / 3600);
  r.minute = (uint8_t)((s % 3600) / 60);
  r.second = (uint8_t)(s % 60);

  return r;
}