added json, more pump code, bugs

lib/Pump/pump.cpp

@@ -1,74 +1,62 @@
 #include "pump.h"
 
-Pump::Pump(uint8_t pumpPin, uint8_t pressurePin, uint8_t flowPin, uint8_t errorLedPin) {
+Pump::Pump(uint8_t pumpPin, uint8_t pressurePin, uint8_t flowPin, uint8_t ledPin) {
     this->pumpPin = pumpPin;
     this->pressurePin = pressurePin;
     this->flowPin = flowPin;
-    this->errorLedPin = errorLedPin;
+    this->ledPin = ledPin;
 
     pinMode(this->pumpPin, OUTPUT);
-    pinMode(this->errorLedPin, OUTPUT);
+    pinMode(this->ledPin, OUTPUT);
     pinMode(this->pressurePin, INPUT);
     // Hall flow sensor?
 
     digitalWrite(this->pumpPin, LOW);
-    digitalWrite(this->errorLedPin, LOW);
+    digitalWrite(this->ledPin, LOW);
 }
 
 void Pump::loop() {
     switch (this->state) {
         case State::Off :
-            
             break;
 
         case State::On :
-            
+            this->timerStandby = false;
+            this->checkSensors();
             break;
 
         case State::Timer :
-            
+            this->stateTimer();
             break;
 
         case State::Standby :
-            
+            this->stateStandby();
             break;
 
         case State::Error :
-            if (millis() - this->startTime > Pump::blinkTime) {
-                this->startTime = millis();
-                if (this->ledState) {
-                    this->ledState = false;
-                    digitalWrite(this->errorLedPin, LOW);
-                } else {
-                    this->ledState = true;
-                    digitalWrite(this->errorLedPin, HIGH);
-                }
-            }
-            break;
-
-        default:
+            this->stateError();
             break;
     }
 }
 
 void Pump::activate(uint32_t duration) {
-    this->startTime = millis();
     if (duration) {
-        this->state = State::Timer;
+        this->changeState(State::Timer);
         this->duration = duration;
     } else {
-        this->state = State::On;
+        this->changeState(State::On);
     }
 }
 
 void Pump::stop() {
-    if (this->state != State::Error)
-        this->state = State::Off;
+    this->changeState(State::Off);
 }
 
 void Pump::clearError() {
-    if (this->state == State::Error)
+    if (this->state == State::Error) {
         this->state = State::Off;
+        this->changeState(State::Off);
+    }
 }
 
 uint16_t Pump::getPressure() {
@@ -76,13 +64,151 @@ uint16_t Pump::getPressure() {
 }
 
 uint32_t Pump::getRunningTime() {
-    return millis() -this->startTime;
+    if (this->state == State::Off)
+        return 0;
+
+    return (millis() - this->startTime) / 1000;
 }
 
 uint16_t Pump::getFlow() {
     return 0;
 }
 
-void Pump::checkSensors() {
+uint16_t Pump::getStatus() {
+    switch (this->state) {
+        case State::Off :
+            return 0;
+            break;
+
+        case State::On :
+            return 1;
+            break;
+
+        case State::Timer :
+            return 2;
+            break;
+
+        case State::Standby :
+            return 3;
+            break;
+
+        case State::Error :
+            return -1;
+            break;
+        
+        default:
+            return -2;
+            break;
+    }
+}
+
+bool Pump::checkSensors() {
+    if (millis() - this->lastMillisCheckSensor < Pump::delayCheckSensor)
+        return;
+    this->lastMillisCheckSensor = millis();
     
-}
+    //TODO: read pressure
+    //TODO: read flow
+
+    if (this->flow) {
+        return true;
+    }
+
+    if (!this->pressure) {
+        this->changeState(State::Error);
+        return false;
+    }
+
+    if (pressure > Pump::maxPressure) {
+        if (this->maxPressureStart == 0)
+            this->maxPressureStart = millis();
+        else if (millis() - this->maxPressureStart > Pump::maxMaxPressureTime)
+            this->changeState(State::Standby);
+    }
+
+    return true;
+}
+
+void Pump::handlePins(bool state) {
+    digitalWrite(this->pumpPin, state);
+    digitalWrite(this->ledPin, state);
+    if (state) {
+        this->timerStandby = false;
+        this->startTime = millis();
+        this->maxPressureStart = 0;
+    }
+}
+
+void Pump::changeState(State state) {
+    if (this->state == State::Error)
+        return;
+
+    if (this->state == state)
+        return;
+
+    switch (state) {
+        case State::Off :
+            this->handlePins(false);
+            this->pressure = 0;
+            this->flow = 0;
+            break;
+
+        case State::On :
+            this->handlePins(true);
+            break;
+
+        case State::Timer :
+            this->handlePins(true);
+            break;
+
+        case State::Standby :
+            if (this->state == State::Timer)
+                this->timerStandby = true;
+            this->handlePins(false);
+            break;
+
+        case State::Error :
+            this->handlePins(false);
+            break;
+
+        default:
+            break;
+    }
+    this->state = state;
+}
+
+void Pump::stateTimer() {
+    if (!this->checkSensors())
+        return;
+
+    if (millis() - this->lastMillisTimer < Pump::delayTimer)
+        return;
+    this->lastMillisTimer = millis();
+
+    uint8_t minutesOn = (millis() - this->startTime) / 1000 / 60;
+        if (minutesOn >= this->duration)
+            this->changeState(State::Off);
+}
+
+void Pump::stateStandby() {
+    this->checkSensors();
+    if (this->pressure < Pump::maxPressure / 2) {
+        if (this->timerStandby)
+            this->changeState(State::Timer);
+        else
+            this->changeState(State::On);
+    }
+}
+
+void Pump::stateError() {
+    if (millis() - this->startTime > Pump::blinkTime) {
+        this->startTime = millis();
+        if (this->ledState) {
+            this->ledState = false;
+            digitalWrite(this->ledPin, LOW);
+        } else {
+            this->ledState = true;
+            digitalWrite(this->ledPin, HIGH);
+        }
+    }
+}

lib/Pump/pump.h

@@ -4,7 +4,6 @@
 
 class Pump {
     public:
-        static const uint16_t blinkTime = 1000;
         enum State {
             Off,
             On,
@@ -13,7 +12,7 @@ class Pump {
             Error
         };
 
-        Pump(uint8_t pumpPin, uint8_t pressurePin, uint8_t flowPin, uint8_t errorLedPin);
+        Pump(uint8_t pumpPin, uint8_t pressurePin, uint8_t flowPin, uint8_t ledPin);
 
         void loop();
 
@@ -24,20 +23,40 @@ class Pump {
         uint16_t getPressure();
         uint32_t getRunningTime();
         uint16_t getFlow();
+        uint16_t getStatus();
 
         State getState() { return this->state; }
 
     private:
-        void checkSensors();
+        static const uint8_t delayCheckSensor = 50;
+        static const uint16_t blinkTime = 1000;
+        static const uint16_t maxPressure = 1000;
+        static const uint16_t maxMaxPressureTime = 30000;
+        static const uint16_t delayTimer = 1000;
+
+        bool checkSensors();
+        void handlePins(bool state);
+        void changeState(State state);
+        void stateTimer();
+        void stateStandby();
+        void stateError();
         State state = State::Off;
 
         bool ledState = false;
+        bool timerStandby = false;
 
         uint8_t pumpPin;
         uint8_t pressurePin;
         uint8_t flowPin;
-        uint8_t errorLedPin;
+        uint8_t ledPin;
+
+        uint16_t delayTimer = 1000;
+        uint16_t flow;
+        uint16_t pressure;
 
         uint32_t startTime;
         uint32_t duration;
+        uint32_t lastMillisTimer = 0;
+        uint32_t lastMillisCheckSensor = 0;
+        uint32_t maxPressureStart = 0;
 };

lib/Valve/valve.cpp

@@ -10,7 +10,9 @@ void Valve::loop() {
     this->loopLastMillis = millis();
 
     for (uint8_t i = 0; i < this->valveCount; i++) {
-        uint8_t minutesOn = (millis() - this->valves[i].startTime) / 1000;
+        if (this->valves[i].duration == 0)
+            continue;
+        uint8_t minutesOn = (millis() - this->valves[i].startTime) / 1000 / 60;
         if (minutesOn >= this->valves[i].duration)
             this->close(i);
     }
@@ -38,6 +40,9 @@ void Valve::open(uint8_t valveNumber, uint8_t minutes) {
     this->valves[valveNumber].duration = minutes;
     this->valves[valveNumber].startTime = millis();
     this->setValve(valveNumber, true);
+
+    Serial.print(F("Opened valve: "));
+    Serial.println(valveNumber);
 }
 
 void Valve::close(uint8_t valveNumber) {
@@ -46,13 +51,13 @@ void Valve::close(uint8_t valveNumber) {
 
     this->valves[valveNumber].duration = 0;
     this->setValve(valveNumber, false);
+    Serial.print(F("Closed valve: "));
+    Serial.println(valveNumber);
 }
 
 void Valve::closeAll() {
-    for (uint8_t i = 0; i < this->valveCount; i++) {
-        this->valves[i].duration = 0;
-        this->setValve(i, false);
-    }
+    for (uint8_t i = 0; i < this->valveCount; i++) 
+        this->close(i);
 }
 
 uint8_t Valve::getNumOfOpen() {
@@ -63,12 +68,15 @@ uint8_t Valve::getNumOfOpen() {
     return res;
 }
 
-uint8_t Valve::getTimeLeft(uint8_t valveNumber) {
+uint16_t Valve::getTimeLeft(uint8_t valveNumber) {
     if (valveNumber >= this->valveCount)
         return -1;
 
+    if (this->valves[valveNumber].duration == 0)
+        return 0;
+
     uint32_t millisOn = millis() - this->valves[valveNumber].startTime;
-    return this->valves[valveNumber].duration - (millisOn / 1000);
+    return this->valves[valveNumber].duration * 60 - (millisOn / 1000);
 }
 
 void Valve::setValve(uint8_t valveNumber, bool state) {

lib/Valve/valve.h

@@ -25,8 +25,7 @@ class Valve {
         void closeAll();
 
         uint8_t getNumOfOpen();
-        uint8_t getTimeLeft(uint8_t valveNumber);
-
+        uint16_t getTimeLeft(uint8_t valveNumber);
 
     private:
         void setValve(uint8_t valveNumber, bool state);