SystemClockLoop.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_SYSTEM_CLOCK_LOOP_H
#define ACE_TIME_SYSTEM_CLOCK_LOOP_H
 
#include <stdint.h>
#include <AceCommon.h> // TimingStats
#include "SystemClock.h"
 
class SystemClockLoopTest;
class SystemClockLoopTest_loop;
class SystemClockLoopTest_setup;
class SystemClockLoopTest_backupNow;
class SystemClockLoopTest_syncNow;
class SystemClockLoopTest_getNow;
 
namespace ace_time {
namespace clock {
 
template <typename T_SCCI>
class SystemClockLoopTemplate : public SystemClockTemplate<T_SCCI> {
  public:
    explicit SystemClockLoopTemplate(
        Clock* referenceClock /* nullable */,
        Clock* backupClock /* nullable */,
        uint16_t syncPeriodSeconds = 3600,
        uint16_t initialSyncPeriodSeconds = 5,
        uint16_t requestTimeoutMillis = 1000,
        ace_common::TimingStats* timingStats = nullptr):
      SystemClockTemplate<T_SCCI>(referenceClock, backupClock),
      mSyncPeriodSeconds(syncPeriodSeconds),
      mRequestTimeoutMillis(requestTimeoutMillis),
      mTimingStats(timingStats),
      mCurrentSyncPeriodSeconds(initialSyncPeriodSeconds) {}
 
    void loop() {
      this->keepAlive();
      if (this->getReferenceClock() == nullptr) return;
 
      uint32_t nowMillis = this->clockMillis();
 
      // Finite state machine based on mRequestStatus
      switch (mRequestStatus) {
        case kStatusReady:
          this->getReferenceClock()->sendRequest();
          mRequestStartMillis = nowMillis;
          mRequestStatus = kStatusSent;
          this->setPrevSyncAttemptMillis(nowMillis);
          this->setNextSyncAttemptMillis(nowMillis
              + mCurrentSyncPeriodSeconds * (uint32_t) 1000);
          break;
 
        case kStatusSent: {
          uint32_t elapsedMillis = nowMillis - mRequestStartMillis;
          if (mTimingStats) mTimingStats->update((uint16_t) elapsedMillis);
 
          if (this->getReferenceClock()->isResponseReady()) {
            acetime_t nowSeconds = this->getReferenceClock()->readResponse();
 
            if (nowSeconds == this->kInvalidSeconds) {
              // If response came back but was invalid, reschedule.
              mRequestStatus = kStatusWaitForRetry;
              this->setSyncStatusCode(this->kSyncStatusError);
            } else {
              // Request succeeded.
              this->syncNow(nowSeconds);
              mCurrentSyncPeriodSeconds = mSyncPeriodSeconds;
              mRequestStatus = this->kStatusOk;
              this->setSyncStatusCode(this->kSyncStatusOk);
            }
          } else {
            // If timed out, reschedule.
            if (elapsedMillis >= mRequestTimeoutMillis) {
              mRequestStatus = this->kStatusWaitForRetry;
              this->setSyncStatusCode(this->kSyncStatusTimedOut);
            }
          }
          break;
        }
 
        // The previous request succeeded, so wait until the next sync attempt.
        case kStatusOk: {
          uint32_t elapsedMillis = nowMillis - mRequestStartMillis;
          if (elapsedMillis >= mCurrentSyncPeriodSeconds * (uint32_t) 1000) {
            mRequestStatus = kStatusReady;
          }
          break;
        }
 
        // Previous request failed, so update timing parameters so that
        // subsequent loop() retries with an exponential backoff, until a
        // maximum of mSyncPeriodSeconds is reached.
        case kStatusWaitForRetry: {
          uint32_t elapsedMillis = nowMillis - mRequestStartMillis;
          // Adjust mCurrentSyncPeriodSeconds using exponential backoff.
          if (elapsedMillis >= mCurrentSyncPeriodSeconds * (uint32_t) 1000) {
            if (mCurrentSyncPeriodSeconds >= mSyncPeriodSeconds / 2) {
              mCurrentSyncPeriodSeconds = mSyncPeriodSeconds;
            } else {
              mCurrentSyncPeriodSeconds *= 2;
            }
            mRequestStatus = kStatusReady;
          }
          break;
        }
      }
    }
 
  protected:
    SystemClockLoopTemplate() {}
 
    // disable copy constructor and assignment operator
    SystemClockLoopTemplate(const SystemClockLoopTemplate&) = delete;
    SystemClockLoopTemplate& operator=(const SystemClockLoopTemplate&) = delete;
 
  private:
    friend class ::SystemClockLoopTest;
    friend class ::SystemClockLoopTest_loop;
    friend class ::SystemClockLoopTest_syncNow;
    friend class ::SystemClockLoopTest_setup;
    friend class ::SystemClockLoopTest_backupNow;
    friend class ::SystemClockLoopTest_getNow;
 
    static const uint8_t kStatusReady = 0;
 
    static const uint8_t kStatusSent = 1;
 
    static const uint8_t kStatusOk = 2;
 
    static const uint8_t kStatusWaitForRetry = 3;
 
    uint16_t const mSyncPeriodSeconds = 3600;
    uint16_t const mRequestTimeoutMillis = 1000;
    ace_common::TimingStats* const mTimingStats = nullptr;
 
    uint32_t mRequestStartMillis;
    uint16_t mCurrentSyncPeriodSeconds = 5;
    uint8_t mRequestStatus = kStatusReady;
};
 
using SystemClockLoop = SystemClockLoopTemplate<hw::ClockInterface>;
 
 
}
}
 
#endif