Photon 2 Sump Water Level Monitor and Email & Logging

/* 
 * Project SumpLevel
 * Author: Scott McNabb
 * Start Date: 10-Jan-2026
 * Last Edit Date: 12-Apr-2026
 */

// Include Particle Device OS APIs
#include "Particle.h" //automatically included
#include "barometer.h"
#include "c420mar.h"
#include "sd-card-library-photon-compat.h"
#include "sd-fat.h"
// Median filter from GitHub tmick0
// Readings are placed in a circular buffer. The buffer content is copied to a second array,
// where the median is computed using the quickselect algorithm.
#include "MedianFilter.h"

// Let Device OS manage the connection to the Particle Cloud
SYSTEM_MODE(AUTOMATIC);

// Show system, cloud connectivity, and application logs over USB
// View logs with CLI using 'particle serial monitor --follow'
//SerialLogHandler logHandler(LOG_LEVEL_INFO);

// MedianFilter size (odd numbers only) NOTE that large numbers cause a delay, e.g. 99 causes 48 s delay, but very good at smoothing the data
#define MEDIANFILTERSIZE 25
// barometer config for I2C bus 1, I2C address = 0x5D (0x5C if jumper moved) (use terminal click on left feather wing)
// MOTE: Make SURE that D18/CS and D19/INT/EN are disabled, as they will conflict with 420mar SPI 1
#define BAROMBUS MIKROBUS_1
// c420mar config for SPI 1 on left feather wing (NOTE: As of 2026/03/14, c420mar is way too noisy to be used!)
#define C420MARBUS MIKROBUS_1
// So 4-20 mA relative H20 sensor is 0.0 cm when not in any water (i.e. calibration constant)
#define FMACOMPENSATION 0.06
// The following definitions are based on the assessment of lots of data graphed in Excel
// Use UT Height (median 25) values to count sump operations (or sump not working)
// NOTE: reduce CMHIGH from 38 to 36 due to sometimes sump motor wire limits low water detection
#define CMERRORLOW 5.0
#define CMTOOLOW 26.0
#define CMZERO 29.0
#define CMLOW 32.0
#define CMHIGH 36.0
#define CM100 42.0
#define CMERRORHIGH 60.0
// Use raw Vref, Vin+ to calculate Depth1 (median 25) of water from 4-20 mA probe, and count sump operations (or sump not working)
#define D1ERRORLOW 5.0
#define D1ZERO 13.0
#define D1LOW 15.0
#define D1HIGH 21.0
#define D1100 26.0
#define D1TOOHIGH 28.0
#define D1ERRORHIGH 60.0
// Interrupt routine delay in ms between each operation, where all data is collected (1000 = 1 s)
#define DATACOLLECTIONTIMER 1000
// TCP logging default port (default 23 for telnet, but can be changed to something else if needed)
#define TCPLOGGINGPORT 23
// Use any number above 1024
#define TCPEMAILPORT 10000

static c420mar_t c420mar;
static barometer_t barometer; // I2C 0x5D
MedianFilter <float, MEDIANFILTERSIZE> fCmMedFilter; // always an odd number for median filter
MedianFilter <float, MEDIANFILTERSIZE> fD1MedFilter; // always an odd number for median filter
TCPClient client, clientEmail;
byte server[] = {192, 168, 1, 99}; // last digit needs to be set
byte serverEmail[] = {192, 168, 1, 100}; // Raspberry Pi (port 10000)
String sEmail = ""; // used for message to Raspberry Pi to Email
char cEmail[100]; // used for message to Raspberry Pi to Email
int iEmailSent = 0; // used to keep track of whether email was sent successfully (1 = True, 0 = False), possibly >1 for multiple emails
bool bHighWaterAlertSent = FALSE; // used to keep track of whether high water alert email was sent, so that it doesn't send multiple emails during the same high water event
bool bDailySumpOperationsSent = FALSE; // used to keep track of whether daily sump operations email was sent, so that it doesn't send multiple emails during the same day
String sLastDate = ""; // used to keep track of the last date, for daily sump pump operations email alert

// c420mar config for soldered connections to raw Vref, Vin+ on left feather wing (NOTE: Use this instead of c420mar)
const uint8_t VrefPin = A0;
const uint8_t VinPin = A2;
int boardLed = D7; // blue board LED
// HC-SR04-33 Ultrasonic Sensor on left feather wing
int trig_pin = D8; // TX pin
int echo_pin = D9; // RX pin
// microSD config for SPI 2 on right feather wing (SPI 1: CS = D18 on left feather wing)
const uint8_t chipSelect = D5;    // Also used for HARDWARE SPI setup on right feather wing
const uint8_t mosiPin = D15;
const uint8_t misoPin = D16;
const uint8_t clockPin = D17;
bool bSDEnabled; // flag used to indicate whether to write data to microSD card
int iNewDataAvailable; // count to indicate new data is available for processing
long lTimeLoopStart; // used to time total loop time, from data Interrupt start, to file data saved
int iLastDayTimeSynced; // used to initiate Particle.syncTime() once per day
long lmsGetData; // used to measure time (ms) for getting all data
String smsGetData; // used for cloud variable
long lmsWriteFile; // used to measure (ms) to save data to SD file
String smsWriteFile; // used for cloud variable
long lmsTotalLoop; // used to measure (ms) for entire loop to get data and save it to SD file
String smsTotalLoop; // used for cloud variable
float fCm; // HC-SR04-33 Ultrasonic Sensor
String sCm; // used for cloud variable
float fBTemperature_c; // Baromteric sensor temperature
float fBPressure; // Barometric sensor pressure
String sBar; // used for cloud variable
float fDepth; // 4-20 mA pressure sensor for 0-100 cm water depth
//String sD; // used for cloud variable
float fmA; // 4-20 mA pressure sensor raw data
//String smA; // used for cloud variable
int iVref; // A/D 4-20 mA raw voltage reference (2.048V)
String sVref; // used for cloud variable
int iVin; // A/D 4-20 mA raw voltage input (nominal 0.4 V to 2.0 V, corresponding to 4-20 mA input)
String sVin; // used for cloud variable
float fD1; // water depth calculated from raw voltage inputs from 4-20 mA board
String sD1; // used for cloud variable
int iSumpCmDailyOps; // count of how many times the sump pump operated each day
float fCmMedNowTooHigh; // keep track of the value that triggered the Too High flag
int iSumpD1DailyOps; // count of how many times the sump pump operated each day
float fD1MedNowTooHigh; // keep track of the value that triggered the Too High flag
String sSumpTodayOperations; // used for cloud variable
String sSumpYesterdayOperations; // used for cloud variable
String sStatus; // used for cloud variable to indicate value(s) that caused high water
bool bCmLow, bCmHigh, bCmTooLow; //  flags to keep track of water level changing during sump pump operation (low cm = high water level)
bool bD1Low, bD1High, bD1TooHigh; //  flags to keep track of water level changing during sump pump operation
int iYear, iMonth, iDay, iHour, iMinute, iSecond;
bool bNewDay; // flag to indicate that header to be added to a new file, since date has changed
bool bHeaderDataSaved; // flag to indicate that header needs to be saved to file, but not yet done
char cDataString[140]; // used for data string to be added to log file on microSD card (limit of 200??)
char cData[15]; // used for individual data type to be added to log file data
String sDisplayTime = "15:45:01"; //example
String sDisplayDate = "2026/02/28"; // example
String sLogFileName = "20260221.txt"; // use String so easy to create file name, then convert to char array
char cFileName[13]; // make sure file name is 8.3 format, including string Nul char at end
float fVref, fVin; // raw 4-20 mA input (ref = 2.048V, nominal 0.4V - 2.0V, corresponding to 4-20 mA input)
float fCmMedNow; // use a median 3 filter
String sCmMedAll; // used for cloud variables
float fDMedNow; // // use a median 5 filter
String sDMedAll; // used for cloud variables
float fD1MedNow; // use a median 5 filter
String sD1MedAll; // used for cloud variables
bool bTCPLoggingEnabled; // used to indicate whether to (try to) send data to TCP

// Create a file name for the log file on the microSD card, based on the date (e.g. 20260219.txt)
void CreateFilename() {
  sLogFileName = String(iYear);
  if (iMonth < 10) sLogFileName += "0"; //make sure 2 digits for month
  sLogFileName += String(iMonth);
  if (iDay < 10) sLogFileName += "0"; //make sure 2 digits for day
  sLogFileName += String(iDay) + ".txt"; //e.g. 20260219.txt (max 8.3 digits)
  // Now, convert String file name (sLogFileName1) to an array (sFileName), needed to open file
  strncpy(cFileName, sLogFileName, 12);
  cFileName[12] = 0; // Null char to indicate end of characters
}

// Update the date and time variables (iYear, iMonth, iDay, iHour, iMinute, iSecond) based on the Particle Cloud time, if available, or by incrementing the local time variables if not.
void UpdateDateAndTime() {
  if (Time.isValid()) { // update local time variables from cloud
    Time.zone(-4); // DST, else -5
    iYear = Time.year(); // 4 digit year
    iMonth = Time.month(); // 1-12 month
    iDay = Time.day(); // 1-31 day
    iHour = Time.hour(); // 0-23
    iMinute = Time.minute(); // 0-59
    iSecond = Time.second(); // 0-59
    if (iDay != iLastDayTimeSynced) {
      Particle.syncTime(); // do this only once per day
      iLastDayTimeSynced = iDay;
    }
  }
  else { // increment local time variables (change this if DATACOLLECTIONTIMER is changed from 1000 ms)
    iSecond += (DATACOLLECTIONTIMER/1000); // convert ms to s, only works without error if data is collected on multiples of seconds
    if (iSecond >= 60) {
      iSecond -= 60; // e.g. if updating time every 2 s, then iSecond coud be 59+2 = 61
      iMinute += 1;
      if (iMinute >= 60) {
        iMinute = 0; // starts at 0
        iHour += 1;
        if (iHour >= 24) {
          iHour = 0; // starts at 0
          iDay += 1; // Note that this could produce an incorrect date, but data can still be fixed later
          if (iDay >= 32) { // Note that this could produce incorrect dates
            iDay = 1; // starts at 1
            iMonth += 1;
            if (iMonth >= 13) {
              iMonth = 1; // starts at 1
              iYear += 1;
            }
          }
        }
      }
    }
  }

  sDisplayDate = String(iYear) + "/";
  if (iMonth < 10) sDisplayDate += "0"; // make sure 2 digits for month
  sDisplayDate += String(iMonth) + "/";
  if (iDay < 10) sDisplayDate += "0"; // make sure 2 digits for day
  sDisplayDate += String(iDay); //e.g. "2026/02/28"

  sDisplayTime = "";
  if (iHour < 10) sDisplayTime += "0"; // make sure 2 digits for hour
  sDisplayTime += String(iHour) + ":";
  if (iMinute < 10) sDisplayTime += "0"; // make sure 2 digits for minuute
  sDisplayTime += String(iMinute) + ":";
  if (iSecond < 10) sDisplayTime += "0"; // make sure 2 digits for second
  sDisplayTime += String(iSecond); // e.g. "15:45:01"

  if ((iHour == 0) && (iMinute == 0) && (iSecond < 10)) {
    bNewDay = TRUE; // flag to indicate a header is to be added to new file name (once per day)
  }
  else {
    bNewDay = FALSE;
    sLastDate = sDisplayDate; // save the last date, for use in daily operations email alert at the next new day (since the date will have changed by then)
  }
}

// Save the collected data to a file on the microSD card.
void SaveInfoToFile() { // Save info to microSD Click
  long lTimeSDStart;

  if (bSDEnabled) { //only save to SD if available (and logging not turned off by Particle StopDataLogging function)
    lTimeSDStart = millis(); // START TIME for the duration of saving data to 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.
    // SM - changed sd-fat.cpp, SdFile::open() and sync() to put timestamps with todays date and time,
    // FAT_DATE(Time.year(), Time.month(), Time.day());
    // FAT_TIME(Time.hour(), Time.minute(), Time.second());
    File dataFile = SD.open(cFileName, FILE_WRITE);

    // if the file is available, write to it:
    if (dataFile) {
      dataFile.println(cDataString);
      dataFile.close();
      lmsWriteFile = millis() - lTimeSDStart; // END TIME for the duration of saving data to SD card (7-62 ms)
      if (lmsWriteFile > 1000) {
        lmsWriteFile = 999; // cap at 999 ms (in case millis() overflows after ~49 days, or some other issue causes a really long loop time, so that it doesn't mess up the data formatting in the file and remote TCP)
      }
      // print to the serial port too:
      //Serial.println(dataString);
    }
    // if the file isn't open, pop up an error:
    else {
//      Serial.printf("Error opening %s on SD card", cFileName); // comment out when not needed for testing
//      Serial.println(); // comment out when not needed for testing
      bSDEnabled = FALSE; // don't bother trying to save to SD file again
      lmsWriteFile = 0;
    }
  }
  else {
    lmsWriteFile = 0;
  }
}

// Collect data from the sensors (HC-SR04-33 Ultrasonic Sensor, 4-20 mA pressure sensor, and Barometer). This function is called by a software timer interrupt at a defined interval (DATACOLLECTIONTIMER, typically 1000 ms).
void GetDataInput() { // takes 7-11 ms, typically 8 ms
  unsigned long lDuration;
  float fTempD;
  long lTimeStart;

  lTimeLoopStart = millis(); // NOTE millis() overflows after ~49 days, so only use during software testing phase

  lTimeStart = lTimeLoopStart; // START TIME for the duration of getting all input data

  digitalWrite(boardLed,HIGH);  // pulse the board blue LED on for the duration of the data sampling AND processing time

  // Get top of water height using UT sensor (typically 29 - 42 cm)
  /* Trigger the UT sensor by sending a HIGH pulse of 10 or more microseconds */
  digitalWriteFast(trig_pin, HIGH);
  delayMicroseconds(1); // delay of 1 results in a pulse of 15-17 usec (10 => 22-23 usec !)
  digitalWriteFast(trig_pin, LOW);
  lDuration = pulseIn(echo_pin, HIGH);
  /* Convert the time into a distance */
  // Sound travels at 340 m/s (29 us/cm), out and back so divide by 2
  // Ref: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  // cm = duration / 29 / 2
  fCm = lDuration / 58.3;
  if (fCm < 0.0) {fCm = 0.0;} // lower limit
  if (fCm > 400.0) {fCm = 400.0;} // upper limit

  // get 4-20 mA current for depth of water (0-1 m), typically 2 - 34 cm ???
  // not sure if the following two lines are needed, or if they help ???
  pinMode(D19, OUTPUT);
  digitalWrite(D19, HIGH);
  // since 4-20 mA R click data is way too noisy, use Vref (2.048 V) and Vin+ (0.4-2.0 V, for 4-20 mA) to calculate mA
  iVref = analogRead(VrefPin); // 0-4095, for 0-3.3V
  iVin = analogRead(VinPin); // 0-4095, for 0-3.3V
  fVref = 3.3 * (iVref / 4095.0); // convert to voltage
  fVin = 3.3 * (iVin / 4095.0); // convert to voltage
  fD1 = 100.0 * ((((C420MARVREF / fVref) * fVin) - 0.4) / 1.6); // compensate based on Vref, convert to cm of depth
  if (fD1 < 0.0) {fD1 = 0.0;} // lower limit, 0 m
  if (fD1 > 100.0) {fD1 = 100.0;} // upper limit, 1 m
  // now, get 4-20 mA values (just log the values to assess sometime later, since way too noisy for use at present)
  fmA = c420mar_read_data( &c420mar );
  if (fmA < 4.0) {fmA = 4.0;} // lower limit
  if (fmA > 20.0) {fmA = 20.0;} // upeer limit
  fTempD = (fmA - 4.0) / 16.0; // convert 4-20 mA to m of water
  fDepth = 100.0 * ((fTempD + FMACOMPENSATION)); // correct for present probe's relative offset, and convert to cm (i.e. can ignore Barom.)

  // Get Barometer info (not sure if this might interfere with 4-20 mA, so do last ???)
  fBTemperature_c = barometer_get_temperature_c( &barometer );
  //Delay_100ms( );
  fBPressure = barometer_get_pressure( &barometer ); // hPa (typically 1000.0)

  lmsGetData = millis() - lTimeStart; // END TIME for the duration of getting all input data (7-11, typically 7 ms)
  if (lmsGetData > 1000) {
    lmsGetData = 999; // cap at 999 ms (in case millis() overflows after ~49 days, or some other issue causes a really long loop time, so that it doesn't mess up the data formatting in the file and remote TCP)
  }

  iNewDataAvailable += 1; // used to indicate new data is available from interrupt routine
  //bWaitForData = FALSE; // used to indicate interrupt routine has started 1st time, so can exit setup() and run loop()
}

// Create a software timer to call the GetDataInput() function at a defined interval (DATACOLLECTIONTIMER, typically 1000 ms) to collect data from all input sensors.
Timer timer1(DATACOLLECTIONTIMER, GetDataInput); // set data input interrupt routine rate, typically 1000 ms

// Update the data string (cDataString) that will be saved to the log file on the microSD card. This function formats the collected data (date, time, sensor readings) into a comma-separated string that can be easily saved to a CSV file for later analysis.
void UpdateDataForFileOutput() { // make sure cDataString[] is big enough to hold all data below!!
    cDataString[0]='\0'; // also used by PrepareHeaderForFile
    
    snprintf(cData, sizeof(cData), "%d", iYear);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    
    snprintf(cData, sizeof(cData), "%d", iMonth);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    
    snprintf(cData, sizeof(cData), "%d", iDay);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    
    snprintf(cData, sizeof(cData), "%d", iHour);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    
    snprintf(cData, sizeof(cData), "%d", iMinute);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    
    snprintf(cData, sizeof(cData), "%d", iSecond);
    strcat(cDataString, cData);
    strcat(cDataString, ",");    // 20 bytes (typical)

    snprintf(cData, sizeof(cData), "%.1f", fCm);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.1f", fBTemperature_c);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.1f", fBPressure);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.1f", fDepth);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.3f", fmA);
    strcat(cDataString, cData);
    strcat(cDataString, ",");   // 28-29 bytes

    snprintf(cData, sizeof(cData), "%.3f", fVref);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.3f", fVin);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.1f", fD1);
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%d", int(lmsGetData));
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%d", int(lmsWriteFile));
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%d", int(lmsTotalLoop));
    strcat(cDataString, cData);
    strcat(cDataString, ",");     // 25-28 bytes

    snprintf(cData, sizeof(cData), "%.1f", fCmMedNow); // changed from med 3 to med 25 2026-03-30
    strcat(cDataString, cData);
    strcat(cDataString, ",");
    snprintf(cData, sizeof(cData), "%.1f", fD1MedNow); // changed from med 5 to med 25 2026-03-30
    strcat(cDataString, cData);
    //strcat(cDataString, ",");
    //snprintf(cData, sizeof(cData), "%.1f", fD1MxNow);
    //strcat(cDataString, cData);   // 14+1 bytes, total 88-92 bytes
    //strcat(cDataString, ",");
}

// Prepare the header string (cDataString) that will be saved as the first line of the log file on the microSD card.
void PrepareHeaderForFile() { // make sure cDataString[] is big enough to hold all data below!!
    cDataString[0]='\0'; // also used by UpdateDataForFileOutput
    
    strcat(cDataString, "Year,");    
    strcat(cDataString, "Month,");    
    strcat(cDataString, "Day,");    
    strcat(cDataString, "Hour,");    
    strcat(cDataString, "Min,");    
    strcat(cDataString, "Sec,");   // 28 bytes
    strcat(cDataString, "H (cm),");
    strcat(cDataString, "T (C),");
    strcat(cDataString, "B (hPa),");
    strcat(cDataString, "D (cm),");
    strcat(cDataString, "D (mA),");   // 35 bytes
    strcat(cDataString, "Vref (V),");
    strcat(cDataString, "V1 (V),");
    strcat(cDataString, "D1 (cm),");
    strcat(cDataString, "T1 (ms),");
    strcat(cDataString, "T2 (ms),");
    strcat(cDataString, "TT (ms),");  // 48 bytes
    strcat(cDataString, "Hm25,");
    strcat(cDataString, "D1m25,");
    //strcat(cDataString, "D1m99");     // 16+1 bytes, total 128 bytes
}

// Print the collected data to the serial port for debugging and assessment purposes.
//void PrintOutputToSerial() {
  // print outputs to assess what is working
//  Serial.printf("cm = %i", iCm);
//  Serial.printf(", T = %.1f", fBTemperature_c); //floats default to 6 decimal places
//  Serial.printf(", Barom = %.1f", fBPressure);
//  Serial.printf(", Depth = %.1f", fDepth);
//  Serial.printf(", mA = %.3f", fmA);
//  Serial.printf(", Vref = %.3f", fVref);
//  Serial.printf(", Vin = %.3f", fVin);
//  Serial.printf(", D1 = %.1f", fD1);
//  Serial.printf(", Present time: %4i:%2i:%2i %2i:%2i:%2i", iYear, iMonth, iDay, iHour, iMinute, iSecond);
//  Serial.printf(", msData = %i, msFile = %i, msTotal = %i", int(lmsGetData), int(lmsWriteFile), int(lmsTotalLoop));
//  Serial.println();
//}

// Update the cloud variables that are displayed on the Particle Cloud and can be accessed through the Particle API.
void UpdateCloudVariables() { // NOTE: UpdateDateAndTime() used to update sDisplayDate, sDisplayTime
  float fPercent;

  sCm = String(fCm,1);                    // raw data, distance from UT sensor to top of water, cm
  fPercent = ((CM100 - fCmMedNow) / (CM100 - CMZERO)) * 100.0;
  sCmMedAll = String(CM100,0) + ", " + String(fCmMedNow,1) + "(" + String(fPercent,0) + "%), " + String(CMZERO,0);      // median UT cm, Now

  sD1 = String(fD1,1);                  // raw Vref from 4-20 mA input (2.048V)
  fPercent = ((fD1MedNow - D1ZERO) / (D1100 - D1ZERO)) * 100.0;
  sD1MedAll = String(D1ZERO,0) + ", " + String(fD1MedNow,1) + "(" + String(fPercent,0) + "%), " + String(D1100,0);      // median depth1 of water, cm, Now

  sBar = String(fBTemperature_c,1) + ", " + String(fBPressure,1); // temperature and barometric pressure

  sSumpTodayOperations = String(iSumpCmDailyOps) + ", " + String(iSumpD1DailyOps); // number of times the sump pump has operated today

  sStatus = "Normal";
  if ((bCmTooLow) || (bD1TooHigh)) { // used to indicate value(s) that caused high water, if any
    sStatus = "High Water ";
  }
  if (bCmTooLow) {
    sStatus = sStatus + "H: " + String(fCmMedNowTooHigh,1); // add the value that triggered the high water flag
  }
  if (bD1TooHigh) {
    if (bCmTooLow) {
      sStatus = sStatus + ", ";
    }
    sStatus = sStatus + "D1: " + String(fD1MedNowTooHigh,1); // add the value that triggered the high water flag
  }

  smsTotalLoop = String(lmsGetData) + ", " + String(lmsWriteFile) + ", " + String(lmsTotalLoop);  // time (ms) for total loop processing of data
}

// Set up the cloud variables that will be displayed on the Particle Cloud dashboard and can be accessed through the Particle API.
void SetupCloudVariables() {
  //Particle.variable("d_Time_ms", dTime); //text description must NOT have any spaces
  //items are listed in alphabetical order on iPhone App (max 20)
  Particle.variable("1 Date",sDisplayDate);
  Particle.variable("2 Time", sDisplayTime);
  Particle.variable("3 Height (cm)", sCm);
  Particle.variable("4 Hm25", sCmMedAll);
  Particle.variable("5 Depth1 (cm)",sD1);
  Particle.variable("6 D1m25", sD1MedAll);
  Particle.variable("7 C, hPa", sBar);
  Particle.variable("81 Sump # Now", sSumpTodayOperations);
  Particle.variable("82 Sump # Yesterday", sSumpYesterdayOperations); // gets updated at midnight, so shows yesterday's total operations
  Particle.variable("83 Status",sStatus);
  Particle.variable("9 Timer ms",smsTotalLoop);
}

// send information to Raspberry Pi for email alerts
void SendTCPemail() {
  strncpy(cEmail, sEmail.c_str(), sizeof(cEmail) - 1); // fills rest of cEmail with null chars if sTestEmail is shorter than cEmail, and ensures no buffer overflow if sTestEmail is longer than cEmail
  cEmail[sizeof(cEmail) - 1] = '\0'; // Ensure null-termination
  if (clientEmail.connect(serverEmail, TCPEMAILPORT)) {
    clientEmail.println(cEmail);
    clientEmail.stop();
    iEmailSent = 1; // use as binary for now, but might consider changing to a count of emails sent, if want to track that at some point
  } else {
    iEmailSent = 0;
  }
}





// Particle Functions
int SendTestEmail (String command) {
  sEmail = "Sump1 test email from Particle Sump at " + sDisplayDate + " " + sDisplayTime;
  SendTCPemail();
  return iEmailSent;
}
// Set last digit of IP for Raspberry Pi for email alerts
int SetEmailTCPAddr (String sAddr) {
  int Addr = 100;
  if (sscanf(sAddr, "%d", &Addr) == 1) {
    serverEmail[3] = Addr;
  } else {
    serverEmail[3] = 100; // default
  }
  return Addr;
}
// Stop data logging, so power can be removed to take out SD card
int StopDataLogging (String command) { //allow any text to stop data logging to SD file
  bSDEnabled = FALSE;
  //Serial.println("Data Logging to SD file stopped!");
  return 1;
}
// Restart system, such as if the system Time is incorrect
int ResartSystem (String command) { // allow any text to reset the values
  System.reset();
  return 1;
}
// Reset high water flags due to false trigger (sump is working, so reset flags)
int ResetHighWaterFlags(String command) { // allow any text to reset the values
  bCmTooLow = FALSE;
  bD1TooHigh = FALSE;
  bHighWaterAlertSent = FALSE; // reset flag to allow another high water email alert to be sent if needed
  return 1;
}
// Enable remote TCP logging to port TCPLOGGINGPORT (23 for Telnet by default)
int EnableTCPLogging (String command) {
  if (client.connect(server, TCPLOGGINGPORT)) {
    bTCPLoggingEnabled = TRUE;
    return 0;
  }
  return 1;
}
// Disable remote TCP logging to port 23 (Telnet)
int DisableTCPLogging (String command) {
  bTCPLoggingEnabled = FALSE;
  client.stop();
  return 0;
}
// Set last digit of IP for TCP logging to port 23 (Telnet)
int SetTCPAddr (String sAddr) {
  int Addr = 99;
  if (sscanf(sAddr, "%d", &Addr) == 1) {
    server[3] = Addr;
  } else {
    server[3] = 99; // default
  }
  return Addr;
}





// setup() runs once, when the device is first turned on
void setup() {
  // Register Particle.variable() within 30 s of connecting to the cloud so that we can access the values from the cloud.
  SetupCloudVariables();
  Particle.function("StopDataLogging", StopDataLogging); //so that data logging can be stopped, for power off and SD card removal
  Particle.function("ResartSystem", ResartSystem); // restart system, such as when Date/Time is incorrect
  Particle.function("ResetHighWaterFlags", ResetHighWaterFlags); // reset the flags that indicate water level is too high (sump off)
  Particle.function("EnableTCPLogging", EnableTCPLogging);
  Particle.function("DisableTCPLogging", DisableTCPLogging);
  Particle.function("SetTCPAddr", SetTCPAddr);
  Particle.function("SetEmailTCPAddr", SetEmailTCPAddr);
  Particle.function("SendTestEmail", SendTestEmail);

  // Declare variables needed for initialization
  c420mar_cfg_t c420mar_cfg;
  barometer_cfg_t barometer_cfg;

  pinMode(boardLed, OUTPUT);  // use blue board LED to blink ON whenever data sampling is occurring
  digitalWrite(boardLed, HIGH); // turn on while initializing

  // set up USB serial printing to computer terminal, comment out when not needed for testing
  //Serial.begin(9600);   // open serial over USB (COM3 on PuTTY, on my computer USB)
  //waitFor(Serial.isConnected, 30000); // Wait for a USB serial connection for up to 30 seconds
  //Serial.println("Hello there!");

  // setup for HC-SR04-33 Ultrasonic Sensor on Terminal Click on left feather wing
  //Serial.println("HC-SR04-33 UT initializing"); // comment out when not needed for testing
  pinMode(trig_pin, OUTPUT);
  digitalWriteFast(trig_pin, LOW);
  pinMode(echo_pin, INPUT);

  // since 4-20 mA R click data is way too noisy, read Vref and Vin+ directly, to calculate mA
  //Serial.println("c420mar raw connections initializing"); // comment out when not needed for testing
  pinMode(VrefPin, AN_INPUT);
  pinMode(VinPin, AN_INPUT);
  // SM - force EN high for c420mar on left feather wing for now, but check if this is done in code somewhere
  //pinMode(D19, OUTPUT);
  //digitalWrite(D19, HIGH);

  //  4-20 mA Input Click initialization
  //Serial.println("4-20 mA initializing"); // comment out when not needed for testing
  c420mar_cfg_setup( &c420mar_cfg );
  c420MAR_MAP_MIKROBUS( c420mar_cfg, C420MARBUS ); // uses SPI 1 on left feather wing
  c420mar_init( &c420mar, &c420mar_cfg );

  // Initialize microSD using HARDWARE SPI
  if (!SD.begin(chipSelect)) {                    // uses SPI 1 on right feather wing
    bSDEnabled = FALSE; // microSD card is not available for data logging
  //  Serial.println("SD Card failed, or is not present"); // comment out when not needed for testing
  }
  else {
    //Serial.println("SD card initialized"); // comment out when not needed for testing
    bSDEnabled = TRUE; // microSD card is available for data logging
  }

  // Barometer Click initialization (I2C-1) SM NOTE: needed to disable cs and rdy, since they conflict with 420mar
  //Serial.println("Barometer initializing"); // comment out when not needed for testing
  barometer_cfg_setup( &barometer_cfg ); // initialize mainly I2C and SPI stuff
  BAROMETER_MAP_MIKROBUS( barometer_cfg, BAROMBUS ); // initialize remaining stuff for using SPI or I2C bus 1
  // scl=D1, sda=D0, miso=S1/D16, mosi=S0/D15, sck=S2/D17, cs=S3/D18, rdy/int=S4/D19, I2C Address = 0x5D
  barometer_init( &barometer, &barometer_cfg );
  barometer_default_cfg( &barometer );
  // Check sensor ID, comment out when not needed for testing
  if ( barometer_check_id( &barometer ) != BAROMETER_DEVICE_ID ) {
    //  Serial.println("    ERROR when initializing Barometer" );
    delay(1);
  }
  
  // The date and time is not valid for power up and the first few reboots, so see if waiting a bit helps
  delay(30000); // delay for 30 s so cloud connection can be made for getting correct date and time
  //Serial.println("Waiting for up to 60 s for date & time from cloud"); // comment out when not needed for testing
  waitFor(Time.isValid, 60000); // wait up to 60 s for time from cloud (not sure if the delay works !??)
  if (!(Time.isValid())) { // initialize to some dummy date and time
    iYear = 2000;
    iMonth = 1;
    iDay = 1;
    iHour = 0;
    iMinute = 0;
    iSecond = 10;
  //  Serial.println("Cloud not presently available, so setting date and time manually"); // comment out when not needed for testing
  }
  else {
    //  Serial.println("Date and time set from Cloud"); // comment out when not needed for testing
    delay(1); // not needed?
  }

  iNewDataAvailable = 0; // counter to indicate how many data sets are available for processing (typically every data set is processed immediatiely)
  timer1.start(); // start getting input data every DATACOLLECTIONTIMER ms (typically 1000 ms = 1 s)
  while (iNewDataAvailable < 1) { // get data for iCm, fDepth, fD1, etc.
    delay(1); // do nothing while waiting for Interrupt routine to start (so data is available for loop() to run)
  }
  iNewDataAvailable = 0; // reset re Interrupt routine data available

  // initialize variables used in loop()
  for (int i = 0; i < MEDIANFILTERSIZE; i++) {
    fCmMedFilter.addSample(34.0); // NOTE: Need MEDIANFILTERSIZE samples before median is calculated
    fD1MedFilter.addSample(19.0); // NOTE: Need MEDIANFILTERSIZE samples before median is calculated
  }
  
  EEPROM.get(20, iSumpCmDailyOps); // yesterday's count sump pump operations based on UT Cm
  if ((iSumpCmDailyOps > 100) || (iSumpCmDailyOps < 0)) { // if the value was not initialized
    iSumpCmDailyOps = 0;
    EEPROM.put(20, iSumpCmDailyOps); // save the initialized value to EEPROM
  }
  EEPROM.get(30, iSumpD1DailyOps); // yesterday's count sump pump operations based on D1 (D is too noisy to be useful for this)
  if ((iSumpD1DailyOps > 100) || (iSumpD1DailyOps < 0)) { // if the value was not initialized
    iSumpD1DailyOps = 0;
    EEPROM.put(30, iSumpD1DailyOps); // save the initialized value to EEPROM
  }
  sSumpYesterdayOperations = String(iSumpCmDailyOps) + ", " + String(iSumpD1DailyOps); // number of times the sump pump has operated yesterday

  EEPROM.get(0, iSumpCmDailyOps); // count sump pump operations based on UT Cm
  if ((iSumpCmDailyOps > 100) || (iSumpCmDailyOps < 0)) { // if the value was not initialized
    iSumpCmDailyOps = 0;
    EEPROM.put(0, iSumpCmDailyOps); // save the initialized value to EEPROM
  }
  EEPROM.get(10, iSumpD1DailyOps); // count sump pump operations based on D1 (D is too noisy to be useful for this)
  if ((iSumpD1DailyOps > 100) || (iSumpD1DailyOps < 0)) { // if the value was not initialized
    iSumpD1DailyOps = 0;
    EEPROM.put(10, iSumpD1DailyOps); // save the initialized value to EEPROM
  }
  //sSumpTodayOperations = String(iSumpCmDailyOps) + ", " + String(iSumpD1DailyOps); // number of times the sump pump has operated today
  
  bCmLow = FALSE;
  bCmHigh = FALSE;
  bCmTooLow = FALSE;
  bD1Low = FALSE;
  bD1High = FALSE;
  bD1TooHigh = FALSE;
  lmsWriteFile = 0;
  fCmMedNowTooHigh = 0.0; // This will be set when the high water flag bCmTooLow is triggered
  fD1MedNowTooHigh = 0.0; // This will be set when the high water flag bD1TooHigh is triggered

  iLastDayTimeSynced = 100; // invalid vaue, to force Particle.syncTime() in UpdateDateAndTime()
  UpdateDateAndTime();
  CreateFilename();
  PrepareHeaderForFile(); // always save file data header info when first booting up
  SaveInfoToFile(); // save header to SD file
  // the following two flags are used to perform a finite 4-state machine operation
  bNewDay = FALSE; // only add header once
  bHeaderDataSaved = FALSE; // only add header once per day
  bTCPLoggingEnabled = FALSE; // disable TCP logging by default

  digitalWrite(boardLed, LOW); // turn off since initializing finished
}







// the OS runs loop() over and over again, as quickly as it can execute, typically 1000 per s
void loop() {

  if (iNewDataAvailable > 0) { // data is available from interrupt routine, typically every 1 s

    iNewDataAvailable = 0; // reset re Interrupt routine data available

    // update Median 25 filters data (MEDIANFILTERSIZE)
    fCmMedFilter.addSample(fCm); // the data will automatically get sorted when new data is added
    fCmMedNow = fCmMedFilter.getMedian();
    fD1MedFilter.addSample(fD1); // the data will automatically get sorted when new data is added
    fD1MedNow = fD1MedFilter.getMedian();

    // update sump operations counter for UT cm, as needed, and sump not operating status
    if (fCmMedNow < CMLOW) { bCmLow = TRUE; } // a low point (high water) has been reached
    if (fCmMedNow > CMHIGH) { bCmHigh = TRUE; } // presently a high point (low water)
    else { bCmHigh = FALSE; } // not presently a high point (not low water)
    if (bCmLow && bCmHigh) { // a high point after a low point, so pump must have operated
      iSumpCmDailyOps++; // record that the sump pump operated once
      EEPROM.put(0, iSumpCmDailyOps); // save the updated value to EEPROM
      bCmLow = FALSE; // reset, so can monitor for another pump operation
    }
    if (fCmMedNow < CMTOOLOW) {
      bCmTooLow = TRUE; // monitor if sump pump didn't operate
      fCmMedNowTooHigh = fCmMedNow; // save the median value that was too low (high water)
      if (!bHighWaterAlertSent) { // only send alert once, until reset by user
        sEmail = "Sump1 high water alert at " + sDisplayDate + " " + sDisplayTime + ", H = " + String(fCmMedNowTooHigh,1) + " cm"; // add the value that triggered the high water flag
        SendTCPemail(); // send email alert via Raspberry Pi, if water is too high (i.e. cm is too low)
        if (iEmailSent == 1) { // if iEmailSend is used as other than binary, then need to compare old to new value
          bHighWaterAlertSent = TRUE; // email alert was sent successfully
        }
      }
    }

    // update sump operations counter for D1, as needed, and sump not operating status
    if (fD1MedNow > D1HIGH) { bD1High = TRUE; } // a high water point has been reached
    if (fD1MedNow < D1LOW) { bD1Low = TRUE; } // presently a low water point
    else { bD1Low = FALSE; } // not presently a low water point
    if (bD1Low && bD1High) { // a low point after a high point, so pump must have operated
      iSumpD1DailyOps++; // record that the sump pump operated once
      EEPROM.put(10, iSumpD1DailyOps); // save the updated value to EEPROM
      bD1High = FALSE; // reset, so can monitor for another pump operation
    }
    if (fD1MedNow > D1TOOHIGH) {
      bD1TooHigh = TRUE; // monitor if sump pump didn't operate
      fD1MedNowTooHigh = fD1MedNow; // save the median value that was too high
      if (!bHighWaterAlertSent) { // only send alert once, until reset by user
        sEmail = "Sump1 high water alert at " + sDisplayDate + " " + sDisplayTime + ", D1 = " + String(fD1MedNow,1) + " cm"; // add the value that triggered the high water flag
        SendTCPemail(); // send email alert via Raspberry Pi, if water is too high
        if (iEmailSent == 1) { // if iEmailSend is used as other than binary, then need to compare old to new value
          bHighWaterAlertSent = TRUE; // email alert was sent successfully
        }
      }
    }

    // save data to SD file
    UpdateDateAndTime();
    CreateFilename();
    // the following two flags are used to perform a finite 4-state machine operation
    if (bNewDay) {
      if (!bHeaderDataSaved) {
        sEmail = "Sump1 daily pump operations for " + sLastDate + ": " + String(iSumpCmDailyOps) + " based on UT Cm, " + String(iSumpD1DailyOps) + " based on D1"; // add yesterday's count of sump pump operations to email alert
        PrepareHeaderForFile(); // add file data header to the daily new SD file
        SaveInfoToFile(); // save header to SD file
        bHeaderDataSaved = TRUE; // only add header once per day
        EEPROM.put(20, iSumpCmDailyOps); // save today's count to yesterday's count, based on UT Cm
        EEPROM.put(30, iSumpD1DailyOps); // save today's count to yesterday's count, based on D1
        sSumpYesterdayOperations = String(iSumpCmDailyOps) + ", " + String(iSumpD1DailyOps); // number of times the sump pump has operated yesterday
        iSumpCmDailyOps = 0; // reset counter for a new day
        EEPROM.put(0, iSumpCmDailyOps); // save the initialized value to EEPROM
        iSumpD1DailyOps = 0; // reset counter for a new day
        EEPROM.put(10, iSumpD1DailyOps); // save the initialized value to EEPROM
      }
      if (!bDailySumpOperationsSent) { // only check during bNewDay (1st 10 s of a day), else email won't get sent
        SendTCPemail(); // send email alert via Raspberry Pi, with daily sump pump operations (see above for email content)
        if (iEmailSent == 1) { // if iEmailSend is used as other than binary, then need to compare old to new value
          bDailySumpOperationsSent = TRUE; // email with daily sump pump operations was sent successfully
        }
      }
    }
    else {
      bHeaderDataSaved = FALSE;
      bDailySumpOperationsSent = FALSE;
    }
    UpdateDataForFileOutput();
    SaveInfoToFile(); // save data to SD file

    // update cloud variables
    UpdateCloudVariables();

    digitalWrite(boardLed,LOW); // pulse the board blue LED on for the duration of the data sampling AND processing time (not serial or remote TCP time)

    //PrintOutputToSerial(); // comment out when not needed for testing
    
    // send data to remote TCP
    if (bTCPLoggingEnabled) {
      client.println(cDataString);
    }

    lmsTotalLoop = millis() - lTimeLoopStart; // typically 17-70 ms (if no serial or TCP Logging)
    if (lmsTotalLoop > 1000) {
      lmsTotalLoop = 999; // cap at 999 ms (in case millis() overflows after ~49 days, or some other issue causes a really long loop time, so that it doesn't mess up the data formatting in the file and remote TCP)
    }
  }
} // if no data from interrupt routine, exit loop() so other stuff can be done (i.e. non blocking by doing this)