Houseplant Babysitter - MEGR3171 Team #26

// This is code to handle the control of a peristaltic water pump as part of an IOT plant babysitter
// Authors: Hunter Joyner, Nathalia Ochoa, Jonathan Krawchuk

SYSTEM_THREAD(ENABLED);     

int WaterPumpPin = D7;      // Set Digital pin 7 as the water pump pin
int PumpOn = 10000;         // Set initial pumping duration


void setup() {
  pinMode(WaterPumpPin,OUTPUT);                                
  // Set pin with pump to output
  Particle.subscribe("WaterPump", PumpHandler);                
  // Subscribe to water pump on call from SensorCluster
  Particle.function("PumpDuration", SetPumpTime);              
  // Cloud function enables updating of pump duration setting
  Particle.variable("CurrentPumpTimeSetting", &PumpOn, INT);  
  // Cloud function to retreve current duration setting
  Particle.function("ManualPumping", TurnOnPump);              
  // Clout function to manually trigger pump
}


void loop() { 
    // nada
}


// Handler function, responds with set action based on subscribe data
void PumpHandler(const char *event, const char *data)
{

  if (strcmp(data,"Pumping")==0) {
    Particle.publish("PumpResponding");      
    // Call to publish event confirming it heard the sensor cluster
    digitalWrite(WaterPumpPin,HIGH);        
    // Sends Digital high signal to 5V relay, turning on pump
    delay(PumpOn);                           
    // Lets pump run for 10 seconds, often first on cycle will not pump water as the tube empties overtime, this is desired to prevent spills
    digitalWrite(WaterPumpPin,LOW);          
    // Sends Digital low signal to 5V relay, turning off pump
  }
  else 
    digitalWrite(WaterPumpPin,LOW);          
    // If event is somehow published otherwise, we do not want the pump to turn on! Water kills!
  }

int SetPumpTime(String duration)           
// Responds to Pump Duration function to update the variable remotely
    {
        if(duration != "0")     // Sanity Check
        {
            PumpOn = duration.toInt();
            return 1;
        }
        
        else return -1;
    }

int TurnOnPump(String action)               
// Responds to Manual Pumping function to turn on the pump
    {
        if(action == "TurnOn")  // Sanity Check
        {
          Particle.publish("PumpResponding");     
          // Call to publish event confirming it heard the sensor cluster
          digitalWrite(WaterPumpPin,HIGH);         
          // Sends Digital high signal to 5V relay, turning on pump
          delay(PumpOn);                           
          // Lets pump run for 10 seconds, often first on cycle will not pump water as the tube empties overtime, this is desired to prevent spills
          digitalWrite(WaterPumpPin,LOW);          
          // Sends Digital low signal to 5V relay, turning off pump   
          return 1; 
        }
        else return -1;
    }

// This is code to handle OLED display of plant conditions remotely as part of an IOT plant babysitter
// Authors: Hunter Joyner, Nathalia Ochoa, Jonathan Krawchuk

// include req libraries
#include "Particle.h"
#include <Adafruit_SSD1306.h>
#include "application.h"
#define OLED_RESET D4

SYSTEM_THREAD(ENABLED);

Adafruit_SSD1306 oled(OLED_RESET);

void logEvent(const char *event, const char *data); //debug log func

// assign integer names
int temp;
int humidity;
int light;
int moisture;

void setup() {
    Particle.subscribe("OLEDinfo", OLED_Handler); 
    // Subscribe to sensor cluster data event, posted in alternative Json format
    oled.begin();  
    Time.zone(-4); // Set eastern std time
    Serial.begin(9600);
}

void loop() {
    
    // OLED time
    
oled.clearDisplay();
  delay(200);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
  oled.setCursor(0,0);
  oled.print("Time");
  oled.setCursor(0,32);
  oled.setTextSize(3);
  oled.print(Time.format(Time.now(), "%I:%M%p"));;
  oled.setTextColor(BLACK, WHITE); // 'inverted' text
  oled.display();
  delay(2500);
  
    // OLED Temperature
     
  oled.clearDisplay();
  delay(200);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
  oled.setCursor(0,0);
  oled.print("Temp");
  oled.setCursor(0,32);
  oled.setTextSize(3);
  oled.print(temp);
  oled.print(" deg");
  oled.setTextColor(BLACK, WHITE); // 'inverted' text
  oled.display();
  delay(2500);


  // OLED Light
  
  oled.clearDisplay();
  delay(200);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
  oled.setCursor(0,0);
  oled.print("Light");
  oled.setCursor(0,32);
  oled.setTextSize(3);
  oled.print(light);
  oled.print(" %");
  oled.setTextColor(BLACK, WHITE); // 'inverted' text
  oled.display();
  delay(2500);
  
    // OLED Moisture
    
  oled.clearDisplay();
  delay(200);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
  oled.setCursor(0,0);
  oled.print("Moisture");
  oled.setCursor(0,32);
  oled.setTextSize(3);
  oled.print(moisture);
  oled.print(" %");
  oled.setTextColor(BLACK, WHITE); // 'inverted' text
  oled.display();
  delay(2500);
  
 // OLED Water
  
  oled.clearDisplay();
  delay(200);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
  oled.setCursor(0,0);
  oled.print("Humidity");
  oled.setCursor(0,32);
  oled.setTextSize(3);
  oled.print(humidity);
  oled.print(" %");
  oled.setTextColor(BLACK, WHITE); // 'inverted' text
  oled.display();
  delay(2500);

}

// Logging function for debug purposes
void logValue(int indent, const char *key, JSONValue value) { 
    String prefixStr;
    if (indent > 0) {
        prefixStr.reserve(indent);
        for(int ii = 0; ii < indent; ii++) {
            prefixStr += String(" ");
        }
    }
    if (key) {
        prefixStr += String::format("key=\"%s\" ", key);
    }

    if (value.isNull()) {
        Log.info("%snull", prefixStr.c_str());
    }
    if (value.isNumber()) {
        Log.info("%sNumber: %s", prefixStr.c_str(), value.toString().data());
    }
    if (value.isBool()) {
        Log.info("%sBool: %s", prefixStr.c_str(), value.toString().data());
    }
    if (value.isString()) {
        Log.info("%sString: \"%s\"", prefixStr.c_str(), value.toString().data());
    }
    if (value.isArray()) {
        Log.info("%sArray", prefixStr.c_str());

        JSONArrayIterator iter(value);
        while (iter.next())
        {
            logValue(indent + 2, 0, iter.value());
        }
    }
    if (value.isObject()) {
        Log.info("%sObject", prefixStr.c_str());

        JSONObjectIterator iter(value);
        while (iter.next())
        {
            logValue(indent + 2, iter.name().data(), iter.value());
        }
    }

}

// Parse json data from subcribe function and assign variables
void OLED_Handler(const char *event, const char *data) 
{
    JSONValue outerObj = JSONValue::parseCopy(data);
    JSONObjectIterator iter(outerObj);
    while (iter.next())
    {
        if (iter.name() == "temp")       
        // Looks for which name is assigned to which set of data
        {
            temp = iter.value().toInt(); 
            // Assigns data value as integer under local variable name
        }
        else
        if (iter.name() == "humidity") 
        {
            humidity = iter.value().toInt();
        }
        else
        if (iter.name() == "light") 
        {
            light = iter.value().toInt();
        }
        else
        if (iter.name() == "moisture") 
        {
            moisture = iter.value().toInt();
        }

    }
}