Sine wave pH

.github/actions/spelling/expect.txt

@@ -61,6 +61,7 @@ highpoint
 HIGHTHRESH
 homepage
 HSCROLL
+HSet
 http
 ifdef
 ine

GUI/libTC.cpp

@@ -22,7 +22,7 @@
 #include "EEPROM_TC.h"
 #include "Keypad_TC.h"
 #include "LiquidCrystal_TC.h"
-#include "PHProbe.h"
+#include "PhProbe.h"
 #include "SD_TC.h"
 #include "Serial_TC.h"
 #include "TC_util.h"
@@ -48,7 +48,7 @@ char *dateTime() {
 float eeprom(uint8_t index) {
   switch (index) {
     case 0:
-      return EEPROM_TC::instance()->getPH();
+      return EEPROM_TC::instance()->getPh();
     case 1:
       return EEPROM_TC::instance()->getTemp();
     case 2:
@@ -74,17 +74,17 @@ float eeprom(uint8_t index) {
     case 12:
       return EEPROM_TC::instance()->getMaxDataAge();
     case 13:
-      return EEPROM_TC::instance()->getPHSeriesSize();
+      return EEPROM_TC::instance()->getPhSeriesSize();
     case 14:
-      return EEPROM_TC::instance()->getPHSeriesPointer();
+      return EEPROM_TC::instance()->getPhSeriesPointer();
     case 15:
       return EEPROM_TC::instance()->getTempSeriesSize();
     case 16:
       return EEPROM_TC::instance()->getTempSeriesPointer();
     case 17:
-      return EEPROM_TC::instance()->getPHInterval();
+      return EEPROM_TC::instance()->getPhInterval();
     case 18:
-      return EEPROM_TC::instance()->getPHDelay();
+      return EEPROM_TC::instance()->getPhDelay();
     case 19:
       return EEPROM_TC::instance()->getTempInterval();
     case 20:
@@ -132,7 +132,7 @@ uint32_t millisecondsSinceEpoch() {
   return std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
 }
 
-float readPH() {
+float readPh() {
   return PHProbe::instance()->getPh();
 }
 

scripts/testAndBuild.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 bundle config set --local path 'vendor/bundle'
 bundle install
-bundle exec arduino_ci.rb --min-free-space=5990 | tee output.txt
+bundle exec arduino_ci.rb --min-free-space=5960 | tee output.txt
 result="${PIPESTATUS[0]}"
 tail -n 4 output.txt | head -n 2 > size.txt
 exit "$result"

size.txt

@@ -1,2 +1,2 @@
-Sketch uses 75918 bytes (29%) of program storage space. Maximum is 253952 bytes.
-Global variables use 2194 bytes (26%) of dynamic memory, leaving 5998 bytes for local variables. Maximum is 8192 bytes.
+Sketch uses 77948 bytes (30%) of program storage space. Maximum is 253952 bytes.
+Global variables use 2224 bytes (27%) of dynamic memory, leaving 5968 bytes for local variables. Maximum is 8192 bytes.

src/Devices/EEPROM_TC.cpp

@@ -93,30 +93,39 @@ void EEPROM_TC::getMac(uint8_t* bytes) {
 float EEPROM_TC::getMaxDataAge() {
   return eepromReadFloat(MAX_DATA_AGE_ADDRESS);
 }
-float EEPROM_TC::getPH() {
+float EEPROM_TC::getPh() {
   return eepromReadFloat(PH_ADDRESS);
 }
-float EEPROM_TC::getPHDelay() {
+float EEPROM_TC::getPhDelay() {
   return eepromReadFloat(PH_DELAY_ADDRESS);
 }
-float EEPROM_TC::getPHInterval() {
+float EEPROM_TC::getPhInterval() {
   return eepromReadFloat(PH_INTERVAL_ADDRESS);
 }
-float EEPROM_TC::getPHSeriesPointer() {
+float EEPROM_TC::getPhSeriesPointer() {
   return eepromReadFloat(PH_SERIES_POINTER_ADDRESS);
 }
-float EEPROM_TC::getPHSeriesSize() {
+float EEPROM_TC::getPhSeriesSize() {
   return eepromReadFloat(PH_SERIES_SIZE_ADDRESS);
 }
-uint32_t EEPROM_TC::getRampTimeStart() {
+uint32_t EEPROM_TC::getPhRampTimeStart() {
   return eepromReadInt(RAMP_TIME_START_PH_ADDRESS);
 }
-uint32_t EEPROM_TC::getRampTimeEnd() {
+uint32_t EEPROM_TC::getPhRampTimeEnd() {
   return eepromReadInt(RAMP_TIME_END_PH_ADDRESS);
 }
-float EEPROM_TC::getRampStartingPH() {
+float EEPROM_TC::getRampStartingPh() {
   return eepromReadFloat(RAMP_STARTING_PH_ADDRESS);
 }
+uint32_t EEPROM_TC::getPhSineStartTime() {
+  return eepromReadInt(PH_SINE_START_TIME_ADDRESS);
+}
+uint32_t EEPROM_TC::getPhSinePeriod() {
+  return eepromReadInt(PH_SINE_AMPLITUDE_ADDRESS);
+}
+float EEPROM_TC::getPhSineAmplitude() {
+  return eepromReadFloat(PH_SINE_PERIOD_ADDRESS);
+}
 uint32_t EEPROM_TC::getRampTimeStartTemp() {
   return eepromReadInt(RAMP_TIME_START_TEMP_ADDRESS);
 }
@@ -126,6 +135,9 @@ uint32_t EEPROM_TC::getRampTimeEndTemp() {
 float EEPROM_TC::getRampStartingTemp() {
   return eepromReadFloat(RAMP_STARTING_TEMP_ADDRESS);
 }
+uint16_t EEPROM_TC::getPhSetType() {
+  return static_cast<uint16_t>(eepromReadFloat(PH_SET_TYPE_ADDRESS));
+}
 uint16_t EEPROM_TC::getTankID() {
   return static_cast<uint16_t>(eepromReadFloat(TANK_ID_ADDRESS));
 }
@@ -180,19 +192,19 @@ void EEPROM_TC::setMac(uint8_t* bytes) {
 void EEPROM_TC::setMaxDataAge(float value) {
   eepromWriteFloat(MAX_DATA_AGE_ADDRESS, value);
 }
-void EEPROM_TC::setPH(float value) {
+void EEPROM_TC::setPh(float value) {
   eepromWriteFloat(PH_ADDRESS, value);
 }
-void EEPROM_TC::setPHDelay(float value) {
+void EEPROM_TC::setPhDelay(float value) {
   eepromWriteFloat(PH_DELAY_ADDRESS, value);
 }
-void EEPROM_TC::setPHInterval(float value) {
+void EEPROM_TC::setPhInterval(float value) {
   eepromWriteFloat(PH_INTERVAL_ADDRESS, value);
 }
-void EEPROM_TC::setPHSeriesPointer(float value) {
+void EEPROM_TC::setPhSeriesPointer(float value) {
   eepromWriteFloat(PH_SERIES_POINTER_ADDRESS, value);
 }
-void EEPROM_TC::setPHSeriesSize(float value) {
+void EEPROM_TC::setPhSeriesSize(float value) {
   eepromWriteFloat(PH_SERIES_SIZE_ADDRESS, value);
 }
 void EEPROM_TC::setPhRampTimeStart(uint32_t value) {
@@ -201,9 +213,18 @@ void EEPROM_TC::setPhRampTimeStart(uint32_t value) {
 void EEPROM_TC::setPhRampTimeEnd(uint32_t value) {
   eepromWriteInt(RAMP_TIME_END_PH_ADDRESS, value);
 }
-void EEPROM_TC::setRampStartingPH(float value) {
+void EEPROM_TC::setRampStartingPh(float value) {
   eepromWriteFloat(RAMP_STARTING_PH_ADDRESS, value);
 }
+void EEPROM_TC::setPhSineStartTime(uint32_t value) {
+  eepromWriteInt(PH_SINE_START_TIME_ADDRESS, value);
+}
+void EEPROM_TC::setPhSinePeriod(uint32_t value) {
+  eepromWriteInt(PH_SINE_AMPLITUDE_ADDRESS, value);
+}
+void EEPROM_TC::setPhSineAmplitude(float value) {
+  eepromWriteFloat(PH_SINE_PERIOD_ADDRESS, value);
+}
 void EEPROM_TC::setRampTimeStartTemp(uint32_t value) {
   eepromWriteInt(RAMP_TIME_START_TEMP_ADDRESS, value);
 }
@@ -213,6 +234,9 @@ void EEPROM_TC::setRampTimeEndTemp(uint32_t value) {
 void EEPROM_TC::setRampStartingTemp(float value) {
   eepromWriteFloat(RAMP_STARTING_TEMP_ADDRESS, value);
 }
+void EEPROM_TC::setPhSetType(uint16_t value) {
+  eepromWriteFloat(PH_SET_TYPE_ADDRESS, (float)value);
+}
 void EEPROM_TC::setTankID(uint16_t value) {
   eepromWriteFloat(TANK_ID_ADDRESS, (float)value);
 }

src/Devices/EEPROM_TC.h

@@ -25,17 +25,21 @@ class EEPROM_TC {
   float getKP();                      // constants used for PID to calculate bubbler timer
   void getMac(uint8_t* bytes);        // used for DHCP request for IP address
   float getMaxDataAge();              // not used
-  float getPH();                      // target pH
-  uint32_t getRampTimeStart();
-  uint32_t getRampTimeEnd();
-  float getRampStartingPH();
+  float getPh();                      // target pH
+  uint32_t getPhRampTimeStart();
+  uint32_t getPhRampTimeEnd();
+  float getRampStartingPh();
+  uint32_t getPhSineStartTime();
+  uint32_t getPhSinePeriod();
+  float getPhSineAmplitude();
   uint32_t getRampTimeStartTemp();
   uint32_t getRampTimeEndTemp();
   float getRampStartingTemp();
-  float getPHDelay();            // not used
-  float getPHInterval();         // not used
-  float getPHSeriesPointer();    // not used
-  float getPHSeriesSize();       // not used
+  float getPhDelay();          // not used
+  float getPhInterval();       // not used
+  float getPhSeriesPointer();  // not used
+  float getPhSeriesSize();     // not used
+  uint16_t getPhSetType();
   uint16_t getTankID();          // unique tank identifier for reporting
   float getTemp();               // target temperature
   float getTempDelay();          // not used
@@ -55,17 +59,21 @@ class EEPROM_TC {
   void setKP(float value);
   void setMac(uint8_t* bytes);
   void setMaxDataAge(float value);
-  void setPH(float value);
+  void setPh(float value);
   void setPhRampTimeStart(uint32_t value);
   void setPhRampTimeEnd(uint32_t value);
-  void setRampStartingPH(float value);
+  void setRampStartingPh(float value);
+  void setPhSineStartTime(uint32_t value);
+  void setPhSinePeriod(uint32_t value);
+  void setPhSineAmplitude(float value);
   void setRampTimeStartTemp(uint32_t value);
   void setRampTimeEndTemp(uint32_t value);
   void setRampStartingTemp(float value);
-  void setPHDelay(float value);
-  void setPHInterval(float value);
-  void setPHSeriesPointer(float value);
-  void setPHSeriesSize(float value);
+  void setPhDelay(float value);
+  void setPhInterval(float value);
+  void setPhSeriesPointer(float value);
+  void setPhSeriesSize(float value);
+  void setPhSetType(uint16_t value);
   void setTankID(uint16_t value);
   void setTemp(float value);
   void setTempDelay(float value);
@@ -104,9 +112,13 @@ class EEPROM_TC {
   const uint16_t RAMP_STARTING_PH_ADDRESS = 112;
   const uint16_t RAMP_TIME_START_PH_ADDRESS = 116;
   const uint16_t RAMP_TIME_END_PH_ADDRESS = 120;
+  const uint16_t PH_SINE_AMPLITUDE_ADDRESS = 112;
+  const uint16_t PH_SINE_START_TIME_ADDRESS = 116;
+  const uint16_t PH_SINE_PERIOD_ADDRESS = 120;
   const uint16_t RAMP_STARTING_TEMP_ADDRESS = 124;
   const uint16_t RAMP_TIME_START_TEMP_ADDRESS = 128;
   const uint16_t RAMP_TIME_END_TEMP_ADDRESS = 132;
+  const uint16_t PH_SET_TYPE_ADDRESS = 136;
 
   // class variables
   static EEPROM_TC* _instance;

src/Devices/PHControl.cpp

@@ -1,5 +1,7 @@
 #include "PHControl.h"
 
+#include <math.h>
+
 #include "Devices/DateTime_TC.h"
 #include "Devices/EEPROM_TC.h"
 #include "Devices/PHProbe.h"
@@ -37,20 +39,36 @@ void PHControl::clearInstance() {
 PHControl::PHControl() {
   pinMode(PH_CONTROL_PIN, OUTPUT);
   digitalWrite(PH_CONTROL_PIN, TURN_SOLENOID_OFF);
-  targetPh = EEPROM_TC::instance()->getPH();
+  targetPh = EEPROM_TC::instance()->getPh();
   if (isnan(targetPh)) {
     targetPh = DEFAULT_PH;
-    EEPROM_TC::instance()->setPH(targetPh);
+    EEPROM_TC::instance()->setPh(targetPh);
   }
-  rampTimeEnd = EEPROM_TC::instance()->getRampTimeEnd();
-  if (rampTimeEnd == 0xFFFFFFFF || rampTimeEnd == 0) {
-    rampTimeEnd = 0;
-    EEPROM_TC::instance()->setPhRampTimeEnd(rampTimeEnd);
-    rampTimeStart = 0;
-    EEPROM_TC::instance()->setPhRampTimeStart(rampTimeStart);
-  } else {
-    rampTimeStart = EEPROM_TC::instance()->getRampTimeStart();
-    rampStartingPh = EEPROM_TC::instance()->getRampStartingPH();
+  pHSetType = EEPROM_TC::instance()->getPhSetType();
+  if (pHSetType == 0xFFFFFFFF) {
+    pHSetType = FLAT_TYPE;
+    EEPROM_TC::instance()->setPhSetType(pHSetType);
+  }
+  switch (pHSetType) {
+    case RAMP_TYPE:
+      rampTimeEnd = EEPROM_TC::instance()->getPhRampTimeEnd();
+      if (rampTimeEnd == 0xFFFFFFFF || rampTimeEnd == 0) {
+        rampTimeEnd = 0;
+        EEPROM_TC::instance()->setPhRampTimeEnd(rampTimeEnd);
+        rampTimeStart = 0;
+        EEPROM_TC::instance()->setPhRampTimeStart(rampTimeStart);
+      } else {
+        rampTimeStart = EEPROM_TC::instance()->getPhRampTimeStart();
+        rampStartingPh = EEPROM_TC::instance()->getRampStartingPh();
+      }
+      break;
+    case SINE_TYPE:
+      period = EEPROM_TC::instance()->getPhSinePeriod();
+      amplitude = EEPROM_TC::instance()->getPhSineAmplitude();
+      sineStartTime = EEPROM_TC::instance()->getPhSineStartTime();
+      break;
+    default:
+      break;
   }
   char buffer[40];
   strncpy_P(buffer, (PGM_P)F("PHControl with target pH = "), sizeof(buffer));
@@ -67,7 +85,7 @@ void PHControl::setTargetPh(float newPh) {
     dtostrf(newPh, 5, 3, buffer + strnlen(buffer, sizeof(buffer)));
     serial(buffer);
     targetPh = newPh;
-    EEPROM_TC::instance()->setPH(newPh);
+    EEPROM_TC::instance()->setPh(newPh);
   }
 }
 
@@ -83,16 +101,31 @@ void PHControl::setRampDuration(float newPhRampDuration) {
     rampTimeStart = DateTime_TC::now().secondstime();
     rampTimeEnd = rampTimeStart + (newPhRampDuration * 3600);
     rampStartingPh = PHProbe::instance()->getPh();
+    pHSetType = phSetTypeTypes::RAMP_TYPE;
+    EEPROM_TC::instance()->setPhSetType(pHSetType);
     EEPROM_TC::instance()->setPhRampTimeStart(rampTimeStart);
     EEPROM_TC::instance()->setPhRampTimeEnd(rampTimeEnd);
-    EEPROM_TC::instance()->setRampStartingPH(rampStartingPh);
+    EEPROM_TC::instance()->setRampStartingPh(rampStartingPh);
   } else {
     rampTimeEnd = 0;
+    pHSetType = phSetTypeTypes::FLAT_TYPE;
+    EEPROM_TC::instance()->setPhSetType(pHSetType);
     EEPROM_TC::instance()->setPhRampTimeEnd(rampTimeEnd);
     serial("set ramp time to 0");
   }
 }
 
+void PHControl::setSine(float sineAmplitude, float sinePeriodInHours) {
+  period = (sinePeriodInHours * 3600);
+  amplitude = sineAmplitude;
+  pHSetType = phSetTypeTypes::SINE_TYPE;
+  sineStartTime = DateTime_TC::now().secondstime();
+  EEPROM_TC::instance()->setPhSetType(pHSetType);
+  EEPROM_TC::instance()->setPhSinePeriod(period);
+  EEPROM_TC::instance()->setPhSineAmplitude(amplitude);
+  EEPROM_TC::instance()->setPhSineStartTime(sineStartTime);
+}
+
 void PHControl::enablePID(bool flag) {
   usePID = flag;
   // save to EEPROM?
@@ -106,13 +139,37 @@ bool PHControl::isOn() {
 void PHControl::updateControl(float pH) {
   int msToBeOn;
   int nowModWindow = millis() % WINDOW_SIZE;
-  float currentTime = DateTime_TC::now().secondstime();
-  // if ramp is being used
-  if (currentTime < rampTimeEnd) {
-    currentPHTarget =
-        rampStartingPh + ((currentTime - rampTimeStart) * (targetPh - rampStartingPh) / (rampTimeEnd - rampTimeStart));
-  } else {
-    currentPHTarget = targetPh;
+  uint32_t currentTime = DateTime_TC::now().secondstime();
+  switch (pHSetType) {
+    case FLAT_TYPE: {
+      currentPHTarget = targetPh;
+      break;
+    }
+    case RAMP_TYPE: {
+      if (currentTime < rampTimeEnd) {
+        currentPHTarget = rampStartingPh +
+                          ((currentTime - rampTimeStart) * (targetPh - rampStartingPh) / (rampTimeEnd - rampTimeStart));
+      } else {
+        currentPHTarget = targetPh;
+      }
+      break;
+    }
+    case SINE_TYPE: {
+      uint32_t sineEndTime = sineStartTime + period;
+      if (currentTime >= sineEndTime) {
+        sineStartTime = DateTime_TC::now().secondstime();
+        sineEndTime = sineStartTime + period;
+        EEPROM_TC::instance()->setPhSineStartTime(sineStartTime);
+      }
+      float timeLeftTillPeriodEnd = sineEndTime - currentTime;
+      float percentNOTThroughPeriod = timeLeftTillPeriodEnd / period;
+      float percentThroughPeriod = 1 - percentNOTThroughPeriod;
+      float x = percentThroughPeriod * (2 * PI);        // the x position for our sine wave
+      currentPHTarget = amplitude * sin(x) + targetPh;  // y position in our sine wave
+      break;
+    }
+    default:
+      break;
   }
   COUT("PHControl::updateControl(" << pH << ") at " << millis());
   if (usePID) {