133 lines
3.3 KiB
C++
133 lines
3.3 KiB
C++
|
|
// NTP headers
|
|
#include <NTPClient.h>
|
|
#include <WiFiUdp.h>
|
|
#include <NTPClient.h>
|
|
|
|
template <typename SessionT>
|
|
class SessionManager
|
|
{
|
|
public:
|
|
using MeasurementType = typename SessionT::MeasurementType;
|
|
|
|
SessionManager(int scaleDoutPin, int scaleSckPin, uint8_t tareAvgCount);
|
|
|
|
void begin();
|
|
|
|
void tare();
|
|
long tareOffset() const { return scale_.offset(); };
|
|
void startMeasurements();
|
|
void stopMeasurements();
|
|
bool isMeasuring() const { return measuring_; }
|
|
SessionT &session() { return session_; }
|
|
|
|
void iteration();
|
|
|
|
private:
|
|
WiFiUDP ntpUDP_;
|
|
NTPClient timeClient_;
|
|
|
|
Scale<CONFIG_VALUE_DIVIDER> scale_;
|
|
//MockScale scale;
|
|
SessionT session_;
|
|
bool measuring_;
|
|
long lastCallTime_;
|
|
|
|
int scaleDoutPin_;
|
|
int scaleSckPin_;
|
|
uint8_t tareAvgCount_;
|
|
};
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
template <typename SessionT>
|
|
SessionManager<SessionT>::SessionManager(int scaleDoutPin, int scaleSckPin, uint8_t tareAvgCount)
|
|
: timeClient_(ntpUDP_, "pool.ntp.org"),
|
|
measuring_(false),
|
|
lastCallTime_(0),
|
|
scaleDoutPin_(scaleDoutPin),
|
|
scaleSckPin_(scaleSckPin),
|
|
tareAvgCount_(tareAvgCount)
|
|
{
|
|
}
|
|
|
|
template <typename SessionT>
|
|
void SessionManager<SessionT>::tare()
|
|
{
|
|
if(measuring_)
|
|
stopMeasurements();
|
|
Serial.println("Beginning tare");
|
|
scale_.begin(scaleDoutPin_, scaleSckPin_);
|
|
scale_.tare(CONFIG_TARE_AVG_COUNT);
|
|
Serial.println("Finished tare");
|
|
}
|
|
|
|
template <typename SessionT>
|
|
void SessionManager<SessionT>::begin()
|
|
{
|
|
timeClient_.begin();
|
|
timeClient_.update();
|
|
tare();
|
|
session_.init(timeClient_.getEpochTime());
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
uint16_t 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();
|
|
} |