/*
}
}
{
"initialize":0,
"baudRate":38400,
"version":"v2.0.0",
"atmegaUptime":"00:00:00:40",
"pins":{
//"D2":0,
int0 - flowrate
"D3":0,
"D4":0,
"D5":0,
"D6":0,
"D7":0,
"D8":0,
"D9":0,
"D22":0,
"D23":0,
"D25":1,
//"D26":1,
openwire26:xx,
//"D27":1,
dht27:yy.
"D28":1,
"D29":1,
"D30":1,
"D31":1,
"D32":1,
"D33":1,
"D34":1,
"D35":0,
"D36":0,
"D37":0,
"D38":0,
"D39":0,
"D40":0,
"D41":0,
"D42":0,
"D43":0,
"D44":0,
"D45":0,
"D46":0,
"D47":0,
"D48":0,
"D49":0,
"A0":509.00,
"A1":509.00,
"A2":1023.00,
"A3":1023.00,
"A4":1023.00,
"A5":1023.00,
"A6":1023.00,
"A7":1023.00,
"A8":1023.00,
"A9":1023.00,
"A10":713.00,
"A11":533.00,
"A12":426.00,
"A13":359.00,
"A14":323.00,
"A15":290.00,
"UART1":0,
"UART2":0,
"UART3":0
}
}
*/
/* Useful Constants and macros from DateTime.h */
#include <stdio.h>
#include <string.h>
//i2c lib for miniEc
#include <Wire.h>
//We'll want to save calibration and configration information in EEPROM for miniec
#include <avr/eeprom.h>
#include <MCP3221.h>
#include <RTClib.h>
RTC_DS1307 RTC;
//EEPROM trigger check
#define ecWrite_Check 0x1234
#define phWrite_Check 0x1234
byte ecAddress = 0x4E; // MCP3221 A5 in Dec 77 A0 = 72 A7 = 79)
#define phAddress 0x4D // MCP3221 A5 in Dec 77 A0 = 72 A7 = 79)
#define I2C_TIMEOUT 5000
#define Version ("\"v2.0.0\"")
#define SECS_PER_MIN (60UL)
#define SECS_PER_HOUR (3600UL)
#define SECS_PER_DAY (SECS_PER_HOUR * 24L)
/* Useful Macros for getting elapsed time */
#define numberOfSeconds(_time_) (_time_ % SECS_PER_MIN)
#define numberOfMinutes(_time_) ((_time_ / SECS_PER_MIN) % SECS_PER_MIN)
#define numberOfHours(_time_) (( _time_% SECS_PER_DAY) / SECS_PER_HOUR)
#define elapsedDays(_time_) ( _time_ / SECS_PER_DAY)
//Our parameter, for ease of use and eeprom access lets use a struct
struct parameters_phT
{
unsigned int WriteCheck;
int pH7Cal, pH4Cal;
float pHStep;
}
phParams;
//Our parameter, for ease of use and eeprom access lets use a struct
struct parameters_ecT
{
unsigned int WriteCheck;
int eCLowCal, eCHighCal;
float eCStep;
}
ecParams;
float eC, temperatute;
const int I2CadcVRef = 4948;
const int oscV = 185; //voltage of oscillator output after voltage divider in millivolts i.e 120mV (measured AC RMS) ideal output is about 180-230mV range
const float kCell = 1.0; //set our Kcell constant basically our microsiemesn conversion 10-6 for 1 10-7 for 10 and 10-5 for .1
const float Rgain = 3000.0; //this is the measured value of the R9 resistor in ohms
float pH;
const float vRef = 4.096; //Our vRef into the ADC wont be exact
//Since you can run VCC lower than Vref its
//best to measure and adjust here
const float opampGain = 5.25; //what is our Op-Amps gain (stage 1)
MCP3221 i2cADC(ecAddress, I2CadcVRef);
//coriz co2
#include <cozir.h>
// <SoftwareSerial.h> is needed as the cozir lib uses it.
// even when only using HWserial
#include <SoftwareSerial.h>
// COZIR object
COZIR czr(&Serial1);
//uarts
const int RX1 = 19;
const int TX1 = 18;
const int RX2 = 17;
const int TX2 = 16;
const int RX3 = 15;
const int TX3 = 14;
//dio's
/*controls*/
const int RESET9331 = 24; //reset ar9331 module
/*specials*/
const int HALLSENSOR = 21; //The pin location of the sensor
const int FLOWSWITCH1 = 30; //flow switch sensor
const int D13 = 13;
/*outputs*/
const int D4 = 4;
const int D10 = 10;
const int D11 = 11;
const int D12 = 12;
/*inputs*/
const int D5 = 5;
const int D2 = 2;
const int D3 = 3;
const int D6 = 6;
const int D7 = 7;
const int D8 = 8;
const int D9 = 9;
const int D49 = 49;
const int D48 = 48;
const int D47 = 47;
const int D46 = 46;
const int D45 = 45;
const int D44 = 44;
const int D43 = 43;
const int D42 = 42;
const int D41 = 41;
const int D40 = 40;
const int D39 = 39;
const int D38 = 38;
const int D37 = 37;
const int D36 = 36;
const int D35 = 35;
const int D34 = 34;
const int D33 = 33;
const int D32 = 32;
const int D31 = 31;
const int D30 = 30; //flow switch
const int D29 = 29;
const int D28 = 28;
//const int D27 = 27;
//const int D26 = 26;
const int D25 = 25;
const int D23 = 23;
const int D22 = 22;
boolean waterIsFlowing = 0; //is water flowing
//flow rate sensor variables
volatile int NbTopsFan; //measuring the rising edges of the signal
int Calc;
int flowRate;
//analogue
/*
const int A15;
const int A14;
const int A13;
const int A12;
const int A11;
const int A10;
const int A9;
const int A8;
const int A7;
const int A6;
const int A5;
const int A4;
const int A3;
const int A2;
const int A1;
const int A0;
*/
//libraries
/*1-wire temp sensors*/
#include <OneWire.h>
#include <DallasTemperature.h>
// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS 26
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
int numberOfDevices; //number of one wire temperature devices found
DeviceAddress tempDeviceAddress, nutrientTemp, roomTemp; // We'll use this variable to store a found device address
/*humidity sensor constants*/
#include "DHT.h"
#define DHTPIN 27 // what pin we're connected to
#define DHTTYPE DHT22 // DHT 27 (AM2302)
DHT dht(DHTPIN, DHTTYPE);
// the follow variables is a long because the time, measured in miliseconds, will quickly become a bigger number than can be stored in an int.
long interval = 1000; // interval at which to blink (milliseconds)
////int measureFlowRateInterval = 10; //measure flow rate once every number of seconds.
int measureFlowRateInterval = 1; //measure flow rate once every number of seconds.
long previousMillis = 0; // will store last timer update
//FLOWSWITCH1 38
//HALLSENSOR 21
//dio pinouts
const int RELAY1 = 10;
const int RELAY2 = 11;
const int RELAY3 = 12;
const int RELAY4 = 4;
int relay1Status;
int relay2Status;
int relay3Status;
int relay4Status;
//program setup
int initialize;
//long baudRate = 115200;
long baudRate = 38400;
//This just simply applies defaults to the params incase the need to be reset or
//they have never been set before (!magicnum)
void reset_ecParams(void)
{
//Restore to default set of parameters!
ecParams.WriteCheck = ecWrite_Check;
ecParams.eCLowCal = 200; //assume ideal probe and amp conditions 1/2 of 4096
ecParams.eCHighCal = 1380; //using ideal probe slope we end up this many 12bit units away on the 4 scale
eeprom_write_block(&ecParams, (void *)0, sizeof(ecParams)); //write these settings back to eeprom
}
//This just simply applys defaults to the params incase the need to be reset or
//they have never been set before (!magicnum)
void reset_phParams(void)
{
//Restore to default set of parameters!
phParams.WriteCheck = phWrite_Check;
phParams.pH7Cal = 2048; //assume ideal probe and amp conditions 1/2 of 4096
phParams.pH4Cal = 1286; //using ideal probe slope we end up this many 12bit units away on the 4 scale
phParams.pHStep = 59.16;//ideal probe slope
eeprom_write_block(&phParams, (void *)0, sizeof(phParams)); //write these settings back to eeprom
}
//used to visual indicate program wait state when booting. wait is for preventing console kernel overrides
//int flashCounter;
int flashLed(int flashCounter) {
int ledcount = 0;
int flashDelay = 500; // milliseconds
//int flashCounter = 10;
while (ledcount < flashCounter ){ //flashCounter times
digitalWrite(D13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(flashDelay); // wait for a second
digitalWrite(D13, LOW); // turn the LED off by making the voltage LOW
delay(flashDelay); // wait for a second
ledcount ++;
}
}
/*pio hardware initialization*/
void setup() {
//delay(30000); //let 9331 boot to prevent hanging up
pinMode(D4, OUTPUT);
pinMode(D10, OUTPUT);
pinMode(D11, OUTPUT);
pinMode(D12, OUTPUT);
pinMode(D13, OUTPUT);
pinMode(RESET9331, OUTPUT); //reset wireless module module
pinMode(D4, INPUT);
pinMode(D5, INPUT);
//pinMode(D2, INPUT);
pinMode(D3, INPUT);
pinMode(D6, INPUT_PULLUP);
pinMode(D7, INPUT);
pinMode(D8, INPUT_PULLUP);
pinMode(D9, INPUT);
pinMode(D49, INPUT);
pinMode(D48, INPUT);
pinMode(D47, INPUT_PULLUP);
pinMode(D46, INPUT);
pinMode(D45, INPUT_PULLUP);
pinMode(D44, INPUT);
pinMode(D43, INPUT_PULLUP);
pinMode(D42, INPUT);
pinMode(D41, INPUT_PULLUP);
pinMode(D39, INPUT_PULLUP);
pinMode(D38, INPUT_PULLUP);
pinMode(D40, INPUT_PULLUP);
pinMode(D37, INPUT_PULLUP);
pinMode(D36, INPUT_PULLUP);
pinMode(D35, INPUT_PULLUP);
pinMode(D34, INPUT_PULLUP);
pinMode(D33, INPUT_PULLUP);
pinMode(D32, INPUT_PULLUP);
pinMode(D31, INPUT);
pinMode(D30, INPUT);
pinMode(D29, INPUT);
pinMode(D28, INPUT);
// pinMode(D27, INPUT);
// pinMode(D26, INPUT);
pinMode(D25, INPUT_PULLUP);
pinMode(D23, INPUT_PULLUP);
pinMode(D22, INPUT);
//int flashCounterTimes = 10;
flashLed(10);
//initialize serial ports
Serial.begin(baudRate); //linux
// SETUP COZIR
Serial1.begin(9600); //coriz co2
czr.init();
Serial.print("Cozir HardwareSerial: ");
Serial.println(COZIR_LIB_VERSION);
//atlas specific sensors
Serial2.begin(baudRate); //ph
Serial3.begin(baudRate); //tds
RTC.begin();
Serial2.print("\r"); //sensors require return to start
Serial3.print("\r");
// Start up one wire temp library
sensors.begin();
// sensors.reset_search();
numberOfDevices = sensors.getDeviceCount();
// report parasite power requirements
Serial.print("Parasite power is: ");
if (sensors.isParasitePowerMode()) Serial.println("ON");
else Serial.println("OFF");
if (!sensors.getAddress(nutrientTemp, 0)) Serial.println("Unable to find address for nutrient temperature");
if (!sensors.getAddress(roomTemp, 1)) Serial.println("Unable to find address for room temperature");
Wire.begin(); //connects I2C
//Lets read our Info from the eeprom and setup our params,
//if we loose power or reset we'll still remember our settings!
eeprom_read_block(&ecParams, (void *)0, sizeof(ecParams));
//if its a first time setup or our magic number in eeprom is wrong reset to default
if (ecParams.WriteCheck != ecWrite_Check){
reset_ecParams();
}
eeprom_read_block(&ecParams, (void *)0, sizeof(ecParams));
Serial.println(initialize = 1);
//if we loose power or reset we'll still remember our settings!
eeprom_read_block(&phParams, (void *)0, sizeof(phParams));
//if its a first time setup or our magic number in eeprom is wrong reset to default
if (phParams.WriteCheck != phWrite_Check){
reset_phParams();
}
}
void getD2(){
Serial.print("\t\"D2\":");
int d2 = (digitalRead(D2));
Serial.print(d2);
Serial.println(",");
}
void getD3(){
Serial.print("\t\"D3\":");
int d3 = (digitalRead(D3));
Serial.print(d3);
Serial.println(",");
}
void getD4(){
Serial.print("\t\"D4\":");
int d4 = (digitalRead(D4));
Serial.print(d4);
Serial.println(",");
}
void getD5(){
Serial.print("\t\"D5\":");
int d5 = (digitalRead(D5));
Serial.print(d5);
Serial.println(",");
}
void getD6(){
Serial.print("\t\"D6\":");
int d6 = (digitalRead(D6));
Serial.print(d6);
Serial.println(",");
}
void getD7(){
Serial.print("\t\"D7\":");
int d7 = (digitalRead(D7));
Serial.print(d7);
Serial.println(",");
}
void getD8(){
Serial.print("\t\"D8\":");
int d8 = (digitalRead(D8));
Serial.print(d8);
Serial.println(",");
}
void getD9(){
Serial.print("\t\"D9\":");
int d9 = (digitalRead(D9));
Serial.print(d9);
Serial.println(",");
}
void getD22(){
Serial.print("\t\"D22\":");
int d22 = (digitalRead(D22));
Serial.print(d22);
Serial.println(",");
}
void getD23(){
Serial.print("\t\"D23\":");
int d23 = (digitalRead(D23));
Serial.print(d23);
Serial.println(",");
}
void getD25(){
Serial.print("\t\"D25\":");
int d25 = (digitalRead(D25));
Serial.print(d25);
Serial.println(",");
}
/*
void getD26(){
Serial.print("\t\"D26\":");
int d26 = (digitalRead(D26));
Serial.print(d26);
Serial.println(",");
}
void getD27(){
Serial.print("\t\"D27\":");
int d27 = (digitalRead(D27));
Serial.print(d27);
Serial.println(",");
}
*/
void getD28(){
Serial.print("\t\"D28\":");
int d28 = (digitalRead(D28));
Serial.print(d28);
Serial.println(",");
}
void getD29(){
Serial.print("\t\"D29\":");
int d29 = (digitalRead(D29));
Serial.print(d29);
Serial.println(",");
}
void getD30(){
Serial.print("\t\"D30\":");
int d30 = (digitalRead(D30));
Serial.print(d30);
Serial.println(",");
}
void getD31(){
Serial.print("\t\"D31\":");
int d31 = (digitalRead(D31));
Serial.print(d31);
Serial.println(",");
}
void getD32(){
Serial.print("\t\"D32\":");
int d32 = (digitalRead(D32));
Serial.print(d32);
Serial.println(",");
}
void getD33(){
Serial.print("\t\"D33\":");
int d33 = (digitalRead(D33));
Serial.print(d33);
Serial.println(",");
}
void getD34(){
Serial.print("\t\"D34\":");
int d34 = (digitalRead(D34));
Serial.print(d34);
Serial.println(",");
}
void getD35(){
Serial.print("\t\"D35\":");
int d35 = (digitalRead(D35));
Serial.print(d35);
Serial.println(",");
}
void getD36(){
Serial.print("\t\"D36\":");
int d36 = (digitalRead(D36));
Serial.print(d36);
Serial.println(",");
}
void getD37(){
Serial.print("\t\"D37\":");
int d37 = (digitalRead(D37));
Serial.print(d37);
Serial.println(",");
}
void getD38(){
Serial.print("\t\"D38\":");
int d38 = (digitalRead(D38));
Serial.print(d38);
Serial.println(",");
}
void getD39(){
Serial.print("\t\"D39\":");
int d39 = (digitalRead(D39));
Serial.print(d39);
Serial.println(",");
}
void getD40(){
Serial.print("\t\"D40\":");
int d40 = (digitalRead(D40));
Serial.print(d40);
Serial.println(",");
}
void getD41(){
Serial.print("\t\"D41\":");
int d41 = (digitalRead(D41));
Serial.print(d41);
Serial.println(",");
}
void getD42(){
Serial.print("\t\"D42\":");
int d42 = (digitalRead(D42));
Serial.print(d42);
Serial.println(",");
}
void getD43(){
Serial.print("\t\"D43\":");
int d43 = (digitalRead(D43));
Serial.print(d43);
Serial.println(",");
}
void getD44(){
Serial.print("\t\"D44\":");
int d44 = (digitalRead(D44));
Serial.print(d44);
Serial.println(",");
}
void getD45(){
Serial.print("\t\"D45\":");
int d45 = (digitalRead(D45));
Serial.print(d45);
Serial.println(",");
}
void getD46(){
Serial.print("\t\"D46\":");
int d46 = (digitalRead(D46));
Serial.print(d46);
Serial.println(",");
}
void getD47(){
Serial.print("\t\"D47\":");
int d47 = (digitalRead(D47));
Serial.print(d47);
Serial.println(",");
}
void getD48(){
Serial.print("\t\"D48\":");
int d48 = (digitalRead(D48));
Serial.print(d48);
Serial.println(",");
}
void getD49(){
Serial.print("\t\"D49\":");
int d49 = (digitalRead(D49));
Serial.print(d49);
Serial.println(",");
}
//analogue
void getA0(){
Serial.print("\t\"A0\":");
float a0 = analogRead(A0); //gb level
Serial.print(a0);
Serial.println(",");
}
void getA1(){
Serial.print("\t\"A1\":");
float a1 = analogRead(A1); //gb level
Serial.print(a1);
Serial.println(",");
}
void getA2(){
Serial.print("\t\"A2\":");
float a2 = analogRead(A2); //gb level
Serial.print(a2);
Serial.println(",");
}
void getA3(){
Serial.print("\t\"A3\":");
float a3 = analogRead(A3); //gb level
Serial.print(a3);
Serial.println(",");
}
void getA4(){
Serial.print("\t\"A4\":");
float a4 = analogRead(A4); //gb level
Serial.print(a4);
Serial.println(",");
}
void getA5(){
Serial.print("\t\"A5\":");
float a5 = analogRead(A5); //gb level
Serial.print(a5);
Serial.println(",");
}
void getA6(){
Serial.print("\t\"A6\":");
float a6 = analogRead(A6); //gb level
Serial.print(a6);
Serial.println(",");
}
void getA7(){
Serial.print("\t\"A7\":");
float a7 = analogRead(A7); //gb level
Serial.print(a7);
Serial.println(",");
}
void getA8(){
Serial.print("\t\"A8\":");
float a8 = analogRead(A8); //gb level
Serial.print(a8);
Serial.println(",");
}
void getA9(){
Serial.print("\t\"A9\":");
float a9 = analogRead(A9); //gb level
Serial.print(a9);
Serial.println(",");
}
void getA10(){
Serial.print("\t\"A10\":");
float a10 = analogRead(A10); //gb level
Serial.print(a10);
Serial.println(",");
}
void getA11(){
Serial.print("\t\"A11\":");
float a11 = analogRead(A11); //gb level
Serial.print(a11);
Serial.println(",");
}
void getA12(){
Serial.print("\t\"A12\":");
float a12 = analogRead(A12); //gb level
Serial.print(a12);
Serial.println(",");
}
void getA13(){
Serial.print("\t\"A13\":");
float a13 = analogRead(A13); //gb level
Serial.print(a13);
Serial.println(",");
}
void getA14(){
Serial.print("\t\"A14\":");
float a14 = analogRead(A14); //gb level
Serial.print(a14);
Serial.println(",");
}
void getA15(){
Serial.print("\t\"A15\":");
float a15 = analogRead(A15); //gb level
Serial.print(a15);
Serial.println(",");
}
void getUART1(){
Serial.print("\t\"UART1\":");
char uart1[20];
Serial.print(0);
Serial.println(",");
}
void getUART2(){
Serial.print("\t\"UART2\":");
char uart2[20];
Serial.print(0);
Serial.println(",");
}
void getUART3(){
Serial.print("\t\"UART3\":");
char uart3[20];
Serial.print(0);
Serial.println(",");
}
int turnRelay1on(){
//turn relay1 on
digitalWrite(RELAY1, HIGH);
relay1Status = 1;
}
int turnRelay1off(){
//turn relay1 off
digitalWrite(RELAY1, LOW);
relay1Status = 0;
}
int turnRelay2on(){
//turn relay2 on
digitalWrite(RELAY2, HIGH);
relay2Status = 1;
}
int turnRelay2off(){
//turn relay2 off
digitalWrite(RELAY2, LOW);
relay2Status = 0;
}
int turnRelay3on(){
//turn relay3 on
digitalWrite(RELAY3, HIGH);
relay3Status = 1;
}
int turnRelay3off(){
//turn relay4 off
digitalWrite(RELAY3, LOW);
relay3Status = 0;
}
int turnRelay4on(){
//turn relay4 on
digitalWrite(RELAY4, HIGH);
relay4Status = 1;
}
int turnRelay4off(){
//turn relay4 off
digitalWrite(RELAY4, LOW);
relay4Status = 0;
}
void mydelay(unsigned long ms)
{
//does not use delay due to interupts
if (ms > 20) {
unsigned long start = millis();
while (millis() - start <= ms) ;
} else delayMicroseconds((unsigned int)ms * 1000);
}
void getUptime (unsigned long time) {
static unsigned char days, hours, minutes, seconds;
static char format[] = "dd:hh:mm:ss";
days = (unsigned char) elapsedDays(time);
hours = (unsigned char) numberOfHours(time);
minutes = (unsigned char) numberOfMinutes(time);
seconds = (unsigned char) numberOfSeconds(time);
format[0] = days / 10 + '0';
format[1] = days % 10 + '0';
format[3] = hours / 10 + '0';
format[4] = hours % 10 + '0';
format[6] = minutes / 10 + '0';
format[7] = minutes % 10 + '0';
format[9] = seconds / 10 + '0';
format[10] = seconds % 10 + '0';
Serial.print (format);
}
float whatIsTemperatureSensors() {
// temps for fish tank and ambient air, Grab a count of devices on the wire
// call sensors.requestTemperatures() to issue a global temperature, request to all devices on the bus
sensors.requestTemperatures(); // Send the command to get temperatures
float temp; //left to support the earlier release visualization code - this is now set to the last sensor value if multiple sensors are used
Serial.print("\t\"temperature_sensor_count\":");
Serial.print(numberOfDevices);
Serial.println(",");
for(int i=0;i<numberOfDevices; i++)
{
// Search the wire for address
if(sensors.getAddress(tempDeviceAddress, i))
{
float temperature = sensors.getTempC(roomTemp);
// Output the device ID
Serial.print("\t\"temperature_"); //"temperature_"
Serial.print(i,DEC); //
Serial.print("\":"); //"temperature_0":
float tempF = sensors.getTempF(tempDeviceAddress);
temp = tempF;
Serial.print(tempF);//"temperature_0":xx
Serial.println(","); //"temperature_0":xx,
}
//else ghost device! Check your power requirements and cabling
}
return temp;
}
float whatIsTemperature() {
// temps for fish tank and ambient air, use addresses found in setup
// call sensors.requestTemperatures() to issue a global temperature, request to all devices on the bus
// "temperature_sensor":19.91,
// "nutrientTemp_sensor":22.20,
sensors.requestTemperatures(); // Send the command to get temperatures
float nutTemperature = 0;
if (sensors.getAddress(nutrientTemp, 0)){ // Serial.println("Unable to find address for nutrient temperature");
//float nutTemperature = sensors.getTempC(nutrientTemp);
nutTemperature = sensors.getTempC(nutrientTemp);
Serial.print("\t\"nutrientTemp\":");
Serial.print(nutTemperature);
Serial.println(",");
}
if (sensors.getAddress(roomTemp, 1)) { //Serial.println("Unable to find address for room temperature");
float temperature = sensors.getTempC(roomTemp);
Serial.print("\t\"temperature\":");
Serial.print(temperature);
Serial.println(",");
}
return nutTemperature;
}
float whatIsHumidity(){
//humidity - temp reading from DHt22
// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
float humidity = 0;
float temperature = 0;
humidity = dht.readHumidity();
/*
switch (humidity)
{
case "DHTLIB_OK":
break;
case "DHTLIB_ERROR_CHECKSUM":
Serial.print("Checksum error,\t");
break;
case "DHTLIB_ERROR_TIMEOUT":
Serial.print("Time out error,\t");
break;
default:
Serial.print("Unknown error,\t");
break;
}
*/
temperature = dht.readTemperature();
// check if returns are valid, if they are NaN (not a number) then something went wrong!
if (isnan(temperature) || isnan(humidity)) {
//Serial.println("Failed to read from DHT");
Serial.println("\t\"humidity\": 0,");
Serial.println("\t\"humidity_temperature\": 0,");
} else {
Serial.print("\t\"humidity\":");
Serial.print(humidity);
Serial.println(",");
Serial.print("\t\"humidity_temperature\":");
Serial.print(temperature);
Serial.println(",");
}
}
float whatIsOldHumidity(){
//humidity - temp reading from DHt22
// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
float humidity = 0;
float temperature = 0;
humidity = dht.readHumidity();
temperature = dht.readTemperature();
// check if returns are valid, if they are NaN (not a number) then something went wrong!
if (isnan(temperature) || isnan(humidity)) {
//Serial.println("Failed to read from DHT");
Serial.print("\t\"humidity_sensor\": { \"humidity\":");
Serial.print(0);
Serial.print(",\"temperature\":");
Serial.print(0);
Serial.println("},");
} else {
Serial.print("\t\"humidity_sensor\": { \"humidity\":");
Serial.print(humidity);
Serial.print(", \"temperature\":");
Serial.print(temperature);
Serial.println("},");
}
}
void rpm () {
//This is the function that the flow rate sensor interupt calls
//interrupt routine for hall effect sensor 1 counter
NbTopsFan++; //This function measures the rising and falling edge of the hall effect sensors signal
}
int measureFlowRate () {
//measure flow rate
// Serial.println("hall(flow) sensor 1 - measuring flow rate");
attachInterrupt(0, rpm, RISING); //and the interrupt is attached
NbTopsFan = 0; //Set NbTops to 0 ready for calculations
delay (1000); //Wait 1 second
detachInterrupt(0);
Calc = (NbTopsFan * 60 / 7.5); //(Pulse frequency x 60) / 7.5Q, = flow rate in L/hour
float flowRateGalPerMin = Calc * 0.00440286754; //1 liters per hour = 0.00440286754 US gallons per minute
return Calc;
}
float whatIsFlowRate(){
waterIsFlowing = digitalRead(FLOWSWITCH1); //is water flowing
float flowRateLPerMin = measureFlowRate(); // measure flow rate in liters per min
float flowRateGalPerMin = flowRateLPerMin * 0.00440286754; //flow rate in gal per min
Serial.print("\t\"flow_rate_sensor\":");
Serial.print(flowRateGalPerMin);
Serial.println(",");
return flowRateGalPerMin;
}
//------------mini ec
//This is really the heart of the calibration process
void calceCSlope ()
{
//RefVoltage * our deltaRawpH / 12bit steps *mV in V / OP-Amp gain /pH step difference 7-4
ecParams.eCStep = ((((I2CadcVRef*(float)(ecParams.eCLowCal - ecParams.eCHighCal)) / 4095) * 1000));
}
//Lets read our raw reading while in our lower eC cal solution
void calibrateeCLow(int calnum)
{
ecParams.eCLowCal = calnum;
calceCSlope();
//write these settings back to eeprom
eeprom_write_block(&ecParams, (void *)0, sizeof(ecParams));
}
//Lets read our raw reading while in our higher eC cal solution
void calibrateeCHigh(int calnum)
{
ecParams.eCHighCal = calnum;
calceCSlope();
//write these settings back to eeprom
eeprom_write_block(&ecParams, (void *)0, sizeof(ecParams));
}
void calcEc(int raw)
{
float temp, tempmv, tempgain, Rprobe;
tempmv = (float)i2cADC.calcMillivolts(raw);
tempgain = (tempmv / (float)oscV) - 1.0; // what is our overall gain again so we can cal our probe leg portion
Rprobe = (Rgain / tempgain); // this is our actually Resistivity
temp = ((1000000) * kCell) / Rprobe; // this is where we convert to uS inversing so removed neg exponant
eC = temp / 1000.0; //convert to EC from uS
}
void whatIsMiniEc(){
//miniEc
int adcRaw = i2cADC.calcRollingAVG();
Serial.print("\t\"miniEc\":");
Serial.print(adcRaw);
...
This file has been truncated, please download it to see its full contents.
Comments