MEGR 3171 IoT Project - Radiator Temperature Sensor

//Include OneWire Library
#include <OneWire.h>
#include "DS18.h"

//Check Values Every 1 Second
#define TIME_INTERVAL 1000

//Make Pin D0 the Temperature Sensor Data Pin
DS18 tempSensor(D0);
//Make Pin A1 the Pin for the Flow Rate Data
int flowPin = A1;
//Make Pin D8 the Pin for the Wifi Connection Indicator LED
int wifiLED = D8;
//Make Pin D8 the Pin for the Low Battery Indicator LED
int battLED = D6;
//Make Pin A0 the Pin to Read Battery Voltage
int battPin = A0;


//Create "temp" Variable to Store the Temperature Value from the Sensor
int temp;
//Create "volt" Variable to Store the Battery Voltage
int volt;
//Create "rec" Variable to Store the Recording Value from the Home Base
int rec;
//Create "val" Variable to Store the Raw Voltage Value from the Flow Sensor
int val;
//Create "flow" Variable to Store the Calculated Flow Value from the Raw Data
int flow;
//Initialize the Last Time Values were Checked as 0
unsigned long lastCheck = 0;

//Create Function to Check the Temperature Reading from the Sensor
int checkTempHandler(String command) {
    checkTemp();
return 1;
}

//Create Function to Check the Flow Reading from the Sensor
int checkFlowHandler(String command) {
    checkFlow();
return 1;
}

//Create Function to Check the Voltage Reading from the Batteries
int checkVoltHandler(String command) {
    checkVolt();
return 1;
}

//Create Handler for Two Way Communication Using Subscribe Feature
void twowaycomm(const char *event, const char *data )
{
    String yes = data;
    rec = yes.toInt();
}

//Define the Function to Check Temperature
void checkTemp() {
    if (tempSensor.read()) {
        temp = (tempSensor.celsius());
        Particle.publish("TempIoT_2", String(temp), ALL_DEVICES);
    }
    else {
        
        
    }
}

//Define the Function to Check Flow
void checkFlow() {
    val = analogRead(flowPin);
    flow = (val + 4)/7.5;
    Particle.publish("FlowIoT_2", String(flow), ALL_DEVICES);
}

//Define the Function to Check Battery Voltage
void checkVolt() {
    volt = (analogRead(battPin));
    //Particle.publish("VoltIoT_2", String(volt), ALL_DEVICES);
}


void setup() {
    //Define LED Pins as Outputs
    pinMode(wifiLED, OUTPUT);
    pinMode(battLED, OUTPUT);
    pinMode(flowPin, INPUT);
    
    //Create Variables to Store Temperature and Voltage Values
    Particle.variable("TempIoT_2", temp);
    Particle.variable("FlowIoT_2", flow);
    Particle.variable("VoltIoT_2", volt);
    
    //Create Functions to Collect Temperature and Voltage Values
    Particle.function("checkTempIoT_2", checkTempHandler);
    Particle.function("checkVoltIoT_2", checkVoltHandler);
    Particle.function("checkFlowIoT_2", checkFlowHandler);

    //Subscribe to Record Variable Which is Published by Home Base
    Particle.subscribe("Record", twowaycomm);
}


void loop() {
    
    //If the Particle Argon is Connected to the Wifi Network, Flash the Indicator LED
    if (Particle.connected()) {
        digitalWrite(wifiLED, HIGH);
        delay(50);
        digitalWrite(wifiLED, LOW);
        delay(50);
    }
    
     if (lastCheck + TIME_INTERVAL < millis()) {
   lastCheck = millis();
   checkVolt();
 }
 
    //If the Comand has been Sent to Record Data, Check the Temperature Values Every 1 Second
 if (rec == 1) {
   checkTemp();
   //checkFlow();
 }
 if (rec == -1) {
     
 }
 
 //If the Voltage is Below 2800 mV, Turn on the Indicator LED to Notify User to Replace Batteries
 if (volt < 2800) {
     digitalWrite(battLED, HIGH);
 }
 else {
     digitalWrite(battLED, LOW);
 }

}

//Define Time Interval of 1 Second
#define TIME_INTERVAL 3000
//Create "temp" Variables to Store the Temperature Values from the Sensors
int temp1;
int temp2;
//Create "diff" Variable to Store the Temperature Difference
int diff;
//Create "KW" Variable to Store the Calculated Heat Dissipation Value
int KW;
//Create "rec" Variable to Store the Recording Value
int rec;
//Create "volt" Variable to Store the Battery Voltage
int volt;
//Create "val" Variable to Store the Raw Voltage Value from the Flow Sensor
int val;
//Create "flow" Variable to Store the Calculated Flow Value from the Raw Data
int flow;

//Make Pin A1 the Pin for the Flow Rate Data
int flowPin = A1;
//Make Pin D8 the Pin for the Wifi Connection Indicator LED
int wifiLED = D8;
//Make Pin D8 the Pin for the Low Battery Indicator LED
int battLED = D6;
//Make Pin A0 the Pin to Read Battery Voltage
int battPin = A0;

//Initialize the Last Time Values were Checked as 0
unsigned long lastCheck = 0;

void setup() 
{
    //Define LED Pins as Outputs
    pinMode(wifiLED, OUTPUT);
    pinMode(battLED, OUTPUT);
    pinMode(flowPin, INPUT);
    
    //Subscribe to "TempIoT_x" Variable Which Stores Temperature Recorded by Sensors and is Sent by Particle A/B
    Particle.subscribe("TempIoT_1", twowaycomm1);
    Particle.subscribe("TempIoT_2", twowaycomm2);
    
    //Subscribe to "FlowIoT_x" Variable Which Stores Flow Rate Recorded by Sensors and is Sent by Particle A/B
    //Particle.subscribe("FlowIoT_2", twowaycommflow);
    
    //Functions to Start/Stop Recording By Changing the Value of "rec"
    Particle.function("StartRecord", startRecordDataHandler);
    Particle.function("StopRecord", stopRecordDataHandler);
    
    //Variable to Store Battery Voltage
    Particle.variable("VoltIoT_HB", volt);
    //Function to Check Battery Voltage
    Particle.function("checkVoltIoT_HB", checkVoltHandler);

}

//Create Function to Check the Voltage Reading from the Batteries
int checkVoltHandler(String command) {
    checkVolt();
return 1;
}

//Create Function to Start Recording Data
int startRecordDataHandler(String command) {
    startRecordData();
return 1;
}

//Create Function to Stop Recording Data
int stopRecordDataHandler(String command) {
    stopRecordData();
return 0;
}

//Create Function to Check the Flow Reading from the Sensor
int checkFlowHandler(String command) {
    checkFlow();
return 1;
}

//Define Function to Start Recording Data
void startRecordData() {
    rec = 1;
    Particle.publish("Record", String(rec), ALL_DEVICES);
}

//Define Function to Stop Recording Data
void stopRecordData() {
    rec = -1;
    Particle.publish("Record", String(rec), ALL_DEVICES);
}


//Define the Function to Check Flow
void checkFlow() {
    val = digitalRead(flowPin);
    flow = (val + 4)/7.5;
    Particle.publish("flowRead", String(flow), ALL_DEVICES);
}

//Define the Function to Check Battery Voltage
void checkVolt() {
    volt = (analogRead(battPin));
    //Particle.publish("VoltIoT_1", String(volt), ALL_DEVICES);
}


    
//Define Function for Two Way Comms (Particle A)
void twowaycomm1(const char *event, const char *data )
{
    String pew = data;
    temp1 = pew.toInt();
}

//Define Function for Two Way Comms (Particle B)
void twowaycomm2(const char *event, const char *data )
{
    String ret = data;
    temp2 = ret.toInt();
}

//Define Function for Two Way Comms (Particle B)
//void twowaycommflow(const char *event, const char *data )
//{
    //String tim = data;
    //flow = tim.toInt();
//}

double readFlow(){
  int counter = 0;
  double sensorReading = 0;
  double priorReading = 0;
  double flow = 0;


  int starttime = millis();
  int endtime = starttime;
  while ((endtime - starttime) <=100){
    sensorReading = analogRead(flowPin);
    //count rotations per second based on voltage flips
    if ((sensorReading > 2500 && priorReading < 120) || (sensorReading < 120 && priorReading > 2500)){
      counter += 1;
    }
    priorReading = sensorReading;
    endtime = millis();
  }
  
  flow = (counter + 4) / 7.5;
  //flow = counter / 2*60*10;
  
  //Particle.publish("flowRead", String(flow), PRIVATE);
  
  return flow;
}

void calcKW() {
    diff = temp1 - temp2;
    KW = flow * 4.187 * diff;
}


void loop() {
    //flow = readFlow();
    //Particle.publish("flowRead", String(flow), PRIVATE);
    //delay(1000);
    
    //If the Particle Argon is Connected to the Wifi Network, Flash the Indicator LED
    if (Particle.connected()) {
        digitalWrite(wifiLED, HIGH);
        delay(50);
        digitalWrite(wifiLED, LOW);
        delay(50);
    }
    
    
    
    
    //If Data is Recording, Publish the Received Value Every 1 Second
    if ((lastCheck + TIME_INTERVAL < millis()) && (rec == 1)) {
   lastCheck = millis();
   Particle.publish("tempRead1", String(temp1), PRIVATE);
   Particle.publish("tempRead2", String(temp2), PRIVATE);
   flow = readFlow();
   //KW = flow * 4.187;
   Particle.publish("flowRead", String(flow), PRIVATE);
   //calcKW();
   //Particle.publish("heatDiss", String(KW), PRIVATE);
   }
   if (rec == -1) {
 }
 
  //If the Voltage is Below 2800 mV, Turn on the Indicator LED to Notify User to Replace Batteries
 if (volt < 2800) {
     digitalWrite(battLED, HIGH);
 }
 else {
     digitalWrite(battLED, LOW);
 }
 
}