Automated Lake Environment Data Collection Probe

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "Co2Meter_K33.h"

//global variable declarations
Co2Meter_K33 k33;
const int CHIP_SELECT = 4; //CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
String logname = "DATA0.txt"; //name of logged data file
//use the blue of an RGB LED to indicate when a measurement cycle is initiated
int ledBlue = 9;           // the PWM pin the RGB LED blue is attached to
//use the red of an RGB LED to indicate errors
int ledRed = 3;           // the PWM pin the RGB LED red is attached to
//use the greed LED to indicate time between sets
int ledGreen = 10;  // the PWM pin the RGB LED green is attached to
int brightness = 100;    // how bright the RGB LED blue, green, and red will be

//establish delays and number of measurements
int measurementWait = 1500; // number of milliseconds to wait between measurements within a set
int setToSetWait = 10000; // number of milliseconds to wait between each set, within a set many measurements are taken
int measurementTake = 3; // number of measurements to take per set, don't exceed setToSetWait time

String dataString = ""; // make a string for assembling the data to log:
double co2 = 0; // holds co2 measurement taken from K33 sensor
double temp = 0; // holds temperature measurement taken from K33 sensor
double relTime = 0; // holds the time, relative to how long the Arduino has been powered on

//relay, pump, and ball valve variables
int prelay = 4; //define output pin for pre-relay
int bvalve = 5; //define output pin for the ball valve
int pump = 6; //define output pin for the pump



//In this example we will do a basic read of the CO2 value and checksum verification. 
//For more advanced applications please see the I2C Comm guide.

void setup() {
  Wire.begin();
  Serial.begin(4800); //start a serial port to communicate with the computer
  Serial.println("What a wonderful day, to read atmospheric CO2 concentrations!");
  pinMode(ledRed, OUTPUT); //declare red LED as an output
  pinMode(ledGreen, OUTPUT); //declare red LED as an output
  pinMode(ledBlue, OUTPUT); //declare blue LED as an output
  pinMode(bvalve,OUTPUT); //declare bvalve as an output
  pinMode(pump,OUTPUT);
  pinMode(prelay,OUTPUT);
 while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
 }

 Serial.print("Initializing SD card...");
  // see if the card is present and can be initialized:
  if (!SD.begin(CHIP_SELECT)) {
    Serial.println("Card failed, or not present");
    analogWrite(ledRed, brightness); // display error - LED Red
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  //find a filename that doesn't already exist
  String base = "DATA";  //base name of the log file
  String extension = ".txt"; //extension of the log file
  int iteration = 1; //a counter for which number the log file should be
  while (SD.exists(logname)) { // keep searching until we find a "logname" which won't overwrite an existing file
    ++iteration;
    logname = base + iteration + extension;
    Serial.println(logname); // print "logname"s for debugging purposes
  }

  // record the data text header to a file on the SD card
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
     File dataFile = SD.open(logname, FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println("CO2(ppm),Temp(C),RelH(%)");
    dataFile.close();
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening: " + logname);
    analogWrite(ledRed, brightness);
  }

  //ensure ball valve is open
  openBValve();
  
}

/*
 * co2 should be measured every few hours, this defines a "set"
 * within this "set" many measurements should be taken
 * after the measurments have been taken in relatively quick succession,
 * wait until next set to take more measurements
 */
void loop() {
  pumpRunThenStop(); // clear out the air
  closeBValve(); // seal air inside the tube
  for (int numMeasures = 0; numMeasures < 4; ++numMeasures) { // take specified number of measurements within the set
      // We keep the sample period >25s or so, else the sensor will start ignoring sample requests.
      analogWrite(ledBlue, brightness); //light blue LED while taking measurments
      Serial.println("Initializing sensor (20sec)...");
      k33.initPoll();
      //wait for sensor to warmup, "i" designates number of seconds to wait
      for (int i = 20; i > 0; --i) {
        Serial.print("" + String(i) + "..");
        delay(1000);
      }
      Serial.println(); //print a new line for visual appeal
      double tempValue = k33.readTemp();
      delay(20); 
      double rhValue = k33.readRh();
      delay(20);
      double co2Value = k33.readCo2();
      relTime = millis();
      dataString = "" + String(co2Value) + "," + String(tempValue) + "," + String(rhValue) + "," + String(relTime); //string that prints to file
      analogWrite(ledBlue, 0); //turn off blue LED when measurement ends
    
    // record the measurement to a file on the SD card
      // open the file. note that only one file can be open at a time,
      // so you have to close this one before opening another.
         File dataFile = SD.open(logname, FILE_WRITE);
    
      // if the file is available, write to it:
      if (dataFile) {
        dataFile.println(dataString);
        dataFile.close();
        // print to the serial port too:
        Serial.println(dataString);
      }
      // if the file isn't open, pop up an error:
      else {
        Serial.println("error opening: " + logname);
        analogWrite(ledRed, brightness);
      }
      
      if (co2Value >= 0) {
        Serial.print("CO2: ");
        Serial.print(co2Value);
        Serial.print("ppm Temp: ");
        Serial.print(tempValue);
        Serial.print("C Rh: ");
        Serial.print(rhValue);
        Serial.println("%");
      }
      else {
        Serial.println("Checksum failed / Communication failure");
        delay(9000);
      }
  }
  // here's the wait in between sets
  analogWrite(ledGreen, brightness); // show green LED in bewteen sets
  openBValve();
  delay(setToSetWait); // this is the amount of time to wait between sets
  analogWrite(ledGreen, 0); // show green LED in bewteen sets
}


///////////////////////////////////////////////////////////////////
// Function : void openBValve()
// Executes : opens the ball valve attached to a relay
/////////////////////////////////////////////////////////////////
void openBValve() {
//open the ball valve
  digitalWrite(prelay, LOW); // closes the relay "prelay" to feed power into relay "bvalve"
                            // since the close pin of the bvalve is attached to normally close,
                            // this action will make sure the bvalve is closed
  delay(4000); // wait 3 seconds before opeing ball valve, in case the ball valve was open when
              // Arduino is first started this time is allotted to physiccally let the ball
              // valve close
  digitalWrite(bvalve, LOW);  // closes the relay "bvalve" and opens the ball valve
  delay(4000); // wait for valve to open
  digitalWrite(prelay, HIGH); // opens the relay "prelay" which cuts power from the relay "bvalve"
                              // therefore leaving the bvalve in an open state w/o consuming extra power
}

///////////////////////////////////////////////////////////////////
// Function : void closeBValve()
// Executes : closes the ball valve attached to a relay
/////////////////////////////////////////////////////////////////
void closeBValve() {
//close the ball valve
  digitalWrite(prelay, LOW); // closes the relay "prelay" to feed power into relay "bvalve"
  delay(4000); // wait 4 seconds before opeing ball valve, in case the ball valve was open/close already
  digitalWrite(bvalve, HIGH);  // opens the relay "bvalve" and closes the ball valve
  delay(4000); // wait for valve to open
  digitalWrite(prelay, HIGH); // opens the relay "prelay" which cuts power from the relay "bvalve"
                              // therefore leaving the bvalve in a closed state w/o consuming extra power
}

///////////////////////////////////////////////////////////////////
// Function : void pumpRunThenStop()
// Executes : closes the ball valve attached to a relay
/////////////////////////////////////////////////////////////////
void pumpRunThenStop() {
  digitalWrite(pump, LOW); // closes relay "pump" to run the pump
  delay(5000); // waits for the pump to run, which ensures the device is working
  digitalWrite(pump, HIGH); // opens the relay "pump" which turns off the pump
}