swimtracker-firmware/firmware/lib/session/SessionManager.h

// NTP headers
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <NTPClient.h>

#include "AutoStartStop.h"

template <typename SessionT>
class SessionManager
{
public:
    using MeasurementType = typename SessionT::MeasurementType;

    SessionManager();

    void begin(int scaleDoutPin, int scaleSckPin, uint8_t tareAvgCount, int valueRightShift, MeasurementType autoStartMinTh, MeasurementType autoStartMaxTh, uint32_t autoStartMeasuresBetweenPeaks,
               MeasurementType autoStopTh, uint32_t autoStopNumMeasures);

    void tare();
    long tareOffset() const { return scale_.offset(); };
    int valueRightShift() const { return scale_.valueRightShift(); }

    void startMeasurements();
    void stopMeasurements();
    bool isMeasuring() const { return measuring_; }
    SessionT &session() { return session_; }

    void iteration();

private:
    void onMeasurementTaken(MeasurementType measurement);

    WiFiUDP ntpUDP_;
    NTPClient timeClient_;

    Scale scale_;
    //MockScale scale;
    SessionT session_;
    bool measuring_;
    long lastCallTime_;

    int scaleDoutPin_;
    int scaleSckPin_;
    uint8_t tareAvgCount_;
    int valueRightShift_;

    AutoStart<MeasurementT> autoStart_;
    AutoStop<MeasurementT> autoStop_;
};

// ------------------------------------------------------------------------------------------------

template <typename SessionT>
SessionManager<SessionT>::SessionManager()
    : timeClient_(ntpUDP_, "pool.ntp.org"),
      measuring_(false),
      lastCallTime_(0)
{
}

template <typename SessionT>
void SessionManager<SessionT>::tare()
{
    if (measuring_)
        stopMeasurements();
    Serial.println("Beginning tare");
    scale_.begin(scaleDoutPin_, scaleSckPin_, valueRightShift_);
    scale_.tare(CONFIG_TARE_AVG_COUNT);
    Serial.println("Finished tare");
}

template <typename SessionT>
void SessionManager<SessionT>::begin(int scaleDoutPin, int scaleSckPin, uint8_t tareAvgCount, int valueRightShift,
                                     MeasurementType autoStartMinTh, MeasurementType autoStartMaxTh, uint32_t autoStartMeasuresBetweenPeaks,
                                     MeasurementType autoStopTh, uint32_t autoStopNumMeasures)
{
    scaleDoutPin_ = scaleDoutPin;
    scaleSckPin_ = scaleSckPin;
    tareAvgCount_ = tareAvgCount;

    timeClient_.begin();
    timeClient_.update();
    tare();
    session_.init(timeClient_.getEpochTime());

    autoStart_.begin(autoStartMinTh, autoStartMaxTh, autoStartMeasuresBetweenPeaks);
    autoStop_.begin(autoStopTh, autoStopNumMeasures);
}

template <typename SessionT>
void SessionManager<SessionT>::startMeasurements()
{
    if (measuring_ == true)
        return;
    measuring_ = true;
    lastCallTime_ = 0;
    session_.init(timeClient_.getEpochTime());
}

template <typename SessionT>
void SessionManager<SessionT>::stopMeasurements()
{
    if (measuring_ == false)
        return;
    session_.finalize();
    measuring_ = false;
}

/*
template <typename SessionT>
void SessionManager<SessionT>::iteration()
{
    if (!measuring_)
    {
        delay(1);
        return; // give control to HTTP server thread
    }

    MeasurementType measurement = -1;
    bool measurementDone = false;
    while (!measurementDone)
        measurementDone = scale_.measure(measurement);
    bool addPointSuccessful = session_.addPoint(measurement);
    //Serial.printf("Measured: %d\n", measurement);
    if (!addPointSuccessful)
    {
        Serial.println("Maximum time of session reached - stopping");
        stopMeasurements();
        delay(1); // give control to HTTP server thread
        return;
    }
    if (lastCallTime_ != 0)
    {
        const long cycleDuration = millis() - lastCallTime_;
        if (cycleDuration <= CONFIG_MEASURE_DELAY)
        {
            delay(CONFIG_MEASURE_DELAY - cycleDuration);
        }
        else
        {
            const long skipped = (cycleDuration / CONFIG_MEASURE_DELAY);
            Serial.printf("Measurements skipped: %ld, cycleDuration %ld\n", skipped, cycleDuration);

            for (int i = 0; i < skipped; ++i)
                session_.addPoint(measurement);

            delay(CONFIG_MEASURE_DELAY * (skipped + 1) - cycleDuration);
        }
    }
    lastCallTime_ = millis();
}
*/

template <typename SessionT>
void SessionManager<SessionT>::iteration()
{
    MeasurementType measurement = -1;
    bool measurementDone = false;
    while (!measurementDone)
        measurementDone = scale_.measure(measurement);

    onMeasurementTaken(measurement);

    if (lastCallTime_ != 0)
    {
        const long cycleDuration = millis() - lastCallTime_;
        if (cycleDuration <= CONFIG_MEASURE_DELAY)
        {
            delay(CONFIG_MEASURE_DELAY - cycleDuration);
        }
        else
        {
            const long skipped = (cycleDuration / CONFIG_MEASURE_DELAY);
            Serial.printf("Measurements skipped: %ld, cycleDuration %ld\n", skipped, cycleDuration);

            for (int i = 0; i < skipped; ++i)
                onMeasurementTaken(measurement);

            delay(CONFIG_MEASURE_DELAY * (skipped + 1) - cycleDuration);
        }
    }
    lastCallTime_ = millis();
}

template <typename SessionT>
void SessionManager<SessionT>::onMeasurementTaken(MeasurementType measurement)
{
    if (measuring_)
    {
        bool autoStop = autoStop_.autoStop(measurement);
        if (autoStop)
        {
            Serial.println("Auto stop");
            stopMeasurements();
            return;
        }

        bool addPointSuccessful = session_.addPoint(measurement);
        if (!addPointSuccessful)
        {
            Serial.println("Maximum time of session reached - stopping");
            stopMeasurements();
            return;
        }
    }
    else
    {
        if (autoStart_.autoStart(measurement))
        {
            Serial.println("Auto start");
            startMeasurements();
            return;
        }
    }
}