/*

   ElCheapo Arduino EC-PPM measurments and Nutrient Doser Script

   This scrip uses a common USA two prong plug and a 1Kohm Resistor to measure the EC/PPM of a Aquaponics/Hydroponics Sytem.

   Then It Increases the Nutrient content until the set point is reached

   It Also Estimates the EC of the nutrient Source [For when you are using Urine/ unknown Nutrient EC]

   28/8/2015  Michael Ratcliffe  Mike@MichaelRatcliffe.com

          This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Parts:

    -Arduino - Uno/Mega

    -Standard American two prong plug

    -1 kohm resistor

    -DS18B20 Waterproof Temperature Sensor

    -FluidPump [Smaller is better];

    Limitations:

    -Cell Constant [K] and ECSetpoint must be less than 5.0 or it will Mess with the way we save values in EEPROM

    -A reset will change your set point and kell constant slightly, but not to a great extent

    -EEPROM seems to survive a reflash, so changing values in the code will not change them in the flashed software. you will need to do it via the LCD

    See www.MichaelRatcliffe.com/Projects for a Pinout and user guide or consult the Zip you got this code from

*/

//************************** Libraries Needed To Compile The Script [See Read me In Download] ***************//

// Both below Library are custom ones [ SEE READ ME In Downloaded Zip If You Dont Know how To install] Use them or add a pull up resistor to the temp probe

#include <OneWire.h>

#include <DallasTemperature.h>

#include <LiquidCrystal.h> //Standard LCD Lbrary

#include <EEPROM.h> //Standard EEPROM Library

//************************* User Defined Variables ******************************************************//

// Rememebr to ad .0 after any float definition or it will return to an initiger, ie 1.0 not 1

//********************** System Information *************************************//

float TankSize =10; //SystemVolume  in Liters

float PumpRate=0.; //Flow rate of dosing pump in L per min

long DosingInterval =60; //How often you want to dose the tank in minutes, hour intervals will be fine for most systems

long MixingTime =30; //The time for mixing of nutrients in minutes [I have a lot of water flow so 60 seonds is fine for me, if in doubt increase it to half a hour]

int Pump =14; //Pin Controlling relay for nutrient Pump

int OFF =0;

int ON=1;

//****************************** System EC Value *******************************//

//Changes for what plants you are growing, sun intensity and temperature

//###If you are using urine in a system and have not yet got a established Bacteria bed set this to ECSetpoint=0.7 for a week to let the bacteria become established##

float ECSetpoint =1.0; // How Strong you want the water system to be nutrient wise

//******************** Nut Tank EC *********************************************//

//the code will optimise this number after every dosing, so we are selecting the highest end and allowing the arduino to work the rest out its self

//You are using a nutrient that states the NPK and not a overpriced one that used the words "Boost" "flower" "Super" but hides the important NPK ratios?

//If not Save yourself a fortune and switch to a cheap one that is honest about its NPK

//We need to put in a estimated start point for the controller to start with

//For an estimate take the EC Estimate= (N*20) + (P*8.8) +(K*16)

float ECFluidEstimate =100.0; //if you dont know the value stick with 1000, it will sort itself out

//***********************************EC Meter **********************************//

//##################################################################################

//-----------  Do not Replace R1 with a resistor lower than 300 ohms    ------------

//##################################################################################

int R1= 1000; //The resitor we placed in voltage divider

int Ra=25; //Resistance of Arduino Digital Pins

//float Rp=0; //Resistance of figure 8 connector

int ECPin= A8;

int ECGround=A9;

int ECPower =A12;

//************ Temp Probe Related *********************************************//

#define ONE_WIRE_BUS 26           // Data wire For Temp Probe is plugged into pin 10 on the Arduino

const int TempProbePossitive =22;  //Temp Probe power connected to pin 9

const int TempProbeNegative=24;    //Temp Probe Negative connected to pin 8

//************************* User Defined Variables ********************************************************//

float CalibrationEC=1.380; //EC value of Calibration solution is s/cm

//*********** Converting to ppm [Learn to use EC it is much better**************//

// Hana      [USA]         PPMconverion:   0.5

// Eutech    [EU]          PPMconversion:  0.64

//Tranchen   [Australia]   PPMconversion:  0.7

// Why didnt anyone standardise this?

float PPMconversion=0.5;

//********************** Cell Constant For Ec Measurements *********************//

//Mine was around 2.9 , with plugs being a standard size they should all be the same

//I Recommend Calibrating your probe but if that is not an option at this time the following cell constants [K] will give a good estimated readout:

//EU plug: K= 1.76

//US Plug K= 2.88

float K=2.88;

//*************Compensating for temperature ************************************//

//The value below will change depending on what chemical solution we are measuring

//0.019 is generaly considered the standard for plant nutrients [google "Temperature compensation EC" for more info

float TemperatureCoef = 0.02; //this changes depending on what chemical we are measuring

//***************************** END Of Recomended User Inputs *****************************************************************//

//********************************************************//

// select the pins used on the LCD panel

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// define some values used by the panel and buttons

int lcd_key     = 0;

int adc_key_in  = 0;

int button =0;

#define btnRIGHT  1

#define btnUP     2

#define btnDOWN   3

#define btnLEFT   4

#define btnSELECT 5

#define btnNONE   6

int Screen =1;

OneWire oneWire(ONE_WIRE_BUS);// Setup a oneWire instance to communicate with any OneWire devices

DallasTemperature sensors(&oneWire);// Pass our oneWire reference to Dallas Temperature.

float Temperature=10;

float EC=0;

float EC25 =0;

int ppm =0;

float raw= 0;

float Vin= 5;

float Vdrop= 0;

float Rc= 0;

float PumpTime=0; //Variable for pumping duration

long MixingInterval=0; //variable for when to check new EC

float PostDocingEC=0;

float PreDosingEC =0;

long StartDosingMillis =0;

int NutesAdded=0;

long time=0;

//********************** Some Variables For Loging Min/Max Values ********************************//

float MinEC=100;

float MaxEC=0;

float MinT=100;

float MaxT=0;

//************************** Just Some basic Definitions used for the Up Time LOgger ************//

long Day=0;

int Hour =0;

int Minute=0;

int Second=0;

int HighMillis=0;

int Rollover=0;

//**************************Some Stuff For Calibration ******************************************//

float TemperatureFinish=0;

float TemperatureStart=0;

int i=0;

float buffer=0;

float Kt=0;

//***********************Some Stuff for Self Learning and Errors********************************//

float LastGoodEstimate= 0;

float PumECRateStart=0;

float PumECRate=0;

int error=6; // 6 means no error

long Doses=0;

long LastRun=0;

int ECHold=0;

//*********************** EPROM Stuff [So SetPoint and Cal Survive a reboot] ******************//

int value;

int addresSetpoint=10;

int addresCalibration=0;

//*********************************Setup - runs Once and sets pins etc ******************************************************//

void setup()

{

  Serial.begin(9600);

  pinMode(TempProbeNegative , OUTPUT ); //seting ground pin as output for tmp probe

  digitalWrite(TempProbeNegative , LOW );//Seting it to ground so it can sink current

  pinMode(TempProbePossitive , OUTPUT );//ditto but for positive

  digitalWrite(TempProbePossitive , HIGH );

  pinMode(ECPin,INPUT);

  pinMode(ECPower,OUTPUT);//Setting pin for sourcing current

  pinMode(ECGround,OUTPUT);//setting pin for sinking current

  pinMode(Pump,OUTPUT);//setting pin for sinking current

  digitalWrite(Pump,OFF); //makes sure we are starting from a stop

  digitalWrite(ECGround,LOW);//We can leave the ground connected permanantly

  delay(100);// gives sensor time to settle

  sensors.begin();  

  //****************Converting to milli seconds********************//

   DosingInterval =DosingInterval*60000; //Coveerting to milliseconds

   MixingTime =MixingTime*60000;       // Converting to milliseconds

   MixingInterval=DosingInterval+MixingTime;

   PumpRate=PumpRate/60.0; //converting to L.Second-1

  //***************Converting to MCU related units ****************//

   PumECRate=ECFluidEstimate*(PumpRate/TankSize);    //   EC.Second-1

   PumECRate=PumECRate*2.0;//Just incase people overestimated some values

   LastGoodEstimate=PumECRate;

   PumECRateStart=PumECRate;

   //************** Restart Protection Stuff ********************//

   //Setpoint

   value = EEPROM.read(addresSetpoint);

   if (value <=254) ECSetpoint=value*0.02;

   //Calibration

   value = EEPROM.read(addresCalibration);

   if (value <=254) K=value*0.02;

R1=(R1+Ra); //Taking into acount Digital Pin Resitance

lcd.begin(16, 2);              // start the library

lcd.setCursor(0,0);

delay(1000);

lcd.print("Nutrient Doser");

lcd.setCursor(0,1);

delay(1000);

lcd.print("Mike Ratcliffe");

lcd.setCursor(0,1);

delay(1000);

lcd.setCursor(0,1);

lcd.print("Free Software   ");

delay(1000);

lcd.setCursor(0,1);

lcd.print("Mike Ratcliffe");

delay(1000);

lcd.setCursor(0,1);

lcd.print("Free Software   ");

delay(1000);

lcd.setCursor(0,0);

lcd.print("To Calibrate      ");

  lcd.setCursor(0,1);

lcd.print("Hold Select       ");

delay(3000);

  lcd.setCursor(0,0);

lcd.print("To Navigate         ");

  lcd.setCursor(0,1);

lcd.print("Use Up-Down     ");

delay(3000);

GetEC(); //gets first reading for LCD and then resets max/min

MinEC=100.0;

MaxEC=0.0;

MinT=100.0;

MaxT=0.0;

};

//******************************************* End of Setup **********************************************************************//

//************************************* Main Loop - Runs Forever ***************************************************************//

//Moved Heavy Work To subroutines so you can call them from main loop without cluttering the main loop

//Dont Measure the EC more than once every five second "GetEC()" or you will get bad readings and wear your probe out

void loop()

{

//*********Takes care of millis rolover**************//

if(millis()<=5000){

  NutesAdded=0;

  digitalWrite(Pump,OFF);

    delay(5000);

};

//*********Check if it is time to dose the system, we wont dose it if the probe is broken or if we are colse to the setppoint ********//

if( (button==1 || millis()%DosingInterval<=1000) && (error>=4 && EC25<=(ECSetpoint-0.1) && NutesAdded==0) ){

NutrientAddition();

NutesAdded=1;

Doses++;

};

//********This fine tunes for the perticular system **************//

if((millis()>=(PumpTime+MixingTime+StartDosingMillis)) && NutesAdded==1){   

EstimateEC();                                         // Goes to the script to estimate the nutrient source EC

NutesAdded=0;

};

//********** Runs the Function to estimate the EC of the hydroponics system **********//

if (millis()%5000<=1000 && ECHold==0){

GetEC();

ECHold=1;

};

if (millis()%5000>=1000){

ECHold=0;

};

//**************** Turns the pump off at the end of the pumping time********************//

if (millis()>=StartDosingMillis+PumpTime){   //Still need to take care of millis rollover!?

digitalWrite(Pump,OFF);

};

read_LCD_buttons();

Calibration();

ChangeECSetpoint();

Error();

PrintReadings();   // Cals Print routine [below main loop]

//************* Stopinf Funky Readings From unmixed solution**********//

if(NutesAdded==0) LogEC();

delay(50);

}

//************************************** End Of Main Loop **********************************************************************//

//*******************************Turns on Pump To Dose System *********************************//

                  void NutrientAddition(){

                  PreDosingEC =EC25; //Makes note of the initial EC

                  PumpTime=1000*((ECSetpoint-PreDosingEC)/PumECRate);

                  StartDosingMillis=millis();

                  digitalWrite(Pump,ON);

                  };

//******************************** System Automatd Learning ************************************//

                //This Function optimises the dosing volume for the main tank volume and Strength of Nutrient tank

                void EstimateEC(){

                PostDocingEC=EC25;  //Makes Note of the EC at the end of the addition

                //*********Rapidly change EC Estimation on startup************//                           

                if(PostDocingEC>=(PreDosingEC+0.05)){

                 PumECRate =(1000.0*((PostDocingEC-PreDosingEC)/PumpTime));

                 LastGoodEstimate=PumECRate;   

                } 

                else  PumECRate=PumECRate/2.0;                            

                };

//************ This Loop Is called From Main Loop************************//

void GetEC(){

//*********Reading Temperature Of Solution *******************//

sensors.requestTemperatures();// Send the command to get temperatures

Temperature=sensors.getTempCByIndex(0); //Stores Value in Variable

raw= analogRead(ECPin);

//************Estimates Resistance of Liquid ****************//

digitalWrite(ECPower,HIGH);

//raw= analogRead(ECPin);

raw= analogRead(ECPin);// This is not a mistake, First reading will be low beause if charged a capacitor

digitalWrite(ECPower,LOW);

//***************** Converts to EC **************************//

Vdrop= (Vin*raw)/1024.0;

Rc=(Vdrop*R1)/(Vin-Vdrop);

Rc=Rc-Ra;

EC = 1000/(Rc*K);

LogEC();

//*************Compensating For Temperaure********************//

EC25   =  EC/ (1.0+ TemperatureCoef*(Temperature-25.0));

ppm=(EC25)*(PPMconversion*1000);

;}

//***********This Loop Is called From  Else Where- Prints to serial usefull info **************//

                void PrintReadings(){

                Serial.print("EC: "); 

                Serial.print(EC25);

                Serial.print(" Simens  "); 

                Serial.print(ppm);

                Serial.print(" ppm  "); 

                Serial.print(Temperature);

                Serial.print(" *C  ");

                Serial.print("PumpRate EC/s: "); 

                Serial.println( PumECRate);

                                      //** First Screen Shows Temp and EC **//

                                      if(Screen==1){

                                      lcd.setCursor(0,0);

                                      lcd.print("Arduino EC-PPM   ");

                                      lcd.setCursor(0,1);

                                      lcd.print("EC:               ");

                                      lcd.setCursor(3,1);

                                      lcd.print(EC25);

                                      lcd.setCursor(9,1);

                                      lcd.print(Temperature);

                                      lcd.print("'C");

                                      }

                                       //** Second Screen Shows PPM **//

                                      else if(Screen==2){

                                      lcd.setCursor(0,0);

                                      lcd.print("Arduino EC-PPM   ");

                                      lcd.setCursor(0,1);

                                      lcd.print("PPM:         ");

                                      lcd.setCursor(4,1);

                                      lcd.print(ppm);

                                      lcd.setCursor(9,1);

                                      lcd.print(Temperature);

                                      lcd.print("'C"); 

                                       }

                                       //**Third Screen Shows Min and Max **//

                                       else if(Screen==3){

                                      lcd.setCursor(0,0);

                                      lcd.print("Min:              ");

                                       lcd.setCursor(4,0);

                                       lcd.print(MinEC);

                                       lcd.setCursor(9,0);

                                      lcd.print(MinT);

                                      lcd.print("'C");

                                      lcd.setCursor(0,1);

                                      lcd.print("Max:               ");

                                      lcd.setCursor(4,1);

                                      lcd.print(MaxEC);

                                      lcd.setCursor(9,1);

                                      lcd.print(MaxT);

                                      lcd.print("'C");

                                      }

                                      else if(Screen==4){

                                      lcd.setCursor(0,0);

                                      lcd.print("Uptime Counter:              ");

                                      lcd.setCursor(0,1);

                                      lcd.print("                                     ");//Clearing LCD

                                      lcd.setCursor(0,1);

                                      lcd.print(Day);

                                      lcd.setCursor(3,1);

                                      lcd.print("Day");

                                      lcd.setCursor(8,1);

                                      lcd.print(Hour);

                                      lcd.setCursor(10,1);

                                      lcd.print(":");

                                      lcd.setCursor(11,1);

                                      lcd.print(Minute);

                                      lcd.setCursor(13,1);

                                      lcd.print(":");

                                      lcd.setCursor(14,1);

                                      lcd.print(Second);

                                       }

                                      else if(Screen==5){

                                      lcd.setCursor(0,0);

                                      lcd.print("Factors          ");

                                      lcd.setCursor(8,0);

                                      lcd.print("PPMC:");

                                      lcd.setCursor(13,0);

                                      lcd.print(PPMconversion);

                                      lcd.setCursor(0,1);

                                      lcd.print("K:               ");

                                      lcd.setCursor(2,1);

                                      lcd.print(K);

                                      lcd.setCursor(9,1);

                                      lcd.print("a:");

                                      lcd.setCursor(11,1);

                                      lcd.print(TemperatureCoef);

                                      }

                                      else if(Screen==6){

                                      lcd.setCursor(0,0);

                                      lcd.print("EC.Sec-1:                  ");

                                      lcd.setCursor(10,0);

                                      lcd.print(PumECRate,5);

                                      lcd.setCursor(0,1);

                                      lcd.print("Doses:                          ");

                                      lcd.setCursor(10,1);

                                      lcd.print(Doses);

                                      }

                                      else if(Screen==7){

                                      lcd.setCursor(0,0);

                                      lcd.print("EC Setpoint:        ");

                                      lcd.setCursor(12,0);

                                      lcd.print(ECSetpoint,3);

                                      lcd.setCursor(0,1);

                                      lcd.print("Hold Select Change                         ");

                                      }   

               if((millis()%6000)<=3000){

                //************************* Printing any errors we have ***********//

                 if  (error==1) {lcd.setCursor(0,0);

                                      lcd.print("Error:          ");

                                      lcd.setCursor(8,0);

                                      lcd.print(error);

                                      lcd.setCursor(0,1);

                                      lcd.print("Probe Problem               "); }

                 else if (error==2) {lcd.setCursor(0,0);

                                      lcd.print("Error:          ");

                                      lcd.setCursor(8,0);

                                      lcd.print(error);

                                      lcd.setCursor(0,1);

                                      lcd.print("Large Overshoot              "); }

                 else if (error==3) {lcd.setCursor(0,0);

                                      lcd.print("Error:          ");

                                      lcd.setCursor(8,0);

                                      lcd.print(error);

                                      lcd.setCursor(0,1);

                                      lcd.print("Temp Problem               "); }

                 else if (error==4) {lcd.setCursor(0,0);

                                      lcd.print("Error:          ");

                                      lcd.setCursor(8,0);

                                      lcd.print(error);

                                      lcd.setCursor(0,1);

                                      lcd.print("Pump Problem               "); }

                 else if (error==5  ) {lcd.setCursor(0,0);

                                      lcd.print("Error:          ");

                                      lcd.setCursor(8,0);

                                      lcd.print(error);

                                      lcd.setCursor(0,1);

                                      lcd.print("System Learning               "); }

                 else;

               };

                /*

                //********** Usued for Debugging ************

                Serial.print("Vdrop: ");

                Serial.println(Vdrop);

                Serial.print("Rc: ");

                Serial.println(Rc);

                Serial.print(EC);

                Serial.println("Siemens");

                //********** end of Debugging Prints *********

                */

};

void read_LCD_buttons(){

  adc_key_in = analogRead(0);      // read the value from the sensor

// my buttons when read are centered at these valies: 0, 144, 329, 504, 741

// we add approx 50 to those values and check to see if we are close

if (adc_key_in > 1000)  button =0;

else if (adc_key_in < 50)   button =1;

else if (adc_key_in < 250)  button =2;

else  if (adc_key_in < 450)  button =3;

else if (adc_key_in < 650)  button =4;

else if (adc_key_in < 850)  button =5;

if(button==2){

Screen++;

}

else if (button==3){

Screen--;

};

if (Screen>=7) Screen=7;

if(Screen<=1) Screen=1;

};

//******************************* LOGS Min/MAX Values and Uptime Counter*******************************//

                          void LogEC(){

                            //**********So We dont Get First Few Readings**********//

                                                                if( Doses==5){

                                                                  MinEC=100.0;

                                                                  MaxEC=0.0;

                                                                  MinT=100.0;

                                                                  MaxT=0.0;

                                                                };

                            if(EC25>=MaxEC)  MaxEC=EC25;

                            if(EC25<=MinEC)  MinEC=EC25;

                            if(Temperature>=MaxT) MaxT=Temperature;

                            if(Temperature<=MinT) MinT=Temperature;

                          //** Making Note of an expected rollover *****// 

                          if(millis()>=3000000000){

                          HighMillis=1;

                          }

                          //** Making note of actual rollover **//

                          if(millis()<=100000&&HighMillis==1){

                          Rollover++;

                          HighMillis=0;

                          }

                          long secsUp = millis()/1000;

                          Second = secsUp%60;

                          Minute = (secsUp/60)%60;

                          Hour = (secsUp/(60*60))%24;

                          Day = (Rollover*50)+(secsUp/(60*60*24));  //First portion takes care of a rollover [around 50 days]

                          };

//******************************* Checks if Select button is held down and enters Calibration routine if it is ************************************//

void Calibration(){

if(Screen!=5) return;

if(button!=5) return;

else delay(1000);

read_LCD_buttons();

if(button!=5) return;

while(1){

read_LCD_buttons();

lcd.setCursor(0,0);

lcd.print("Set Calibration EC  ");

lcd.setCursor(0,1);

lcd.print("EC:                 ");

lcd.setCursor(3,1);

lcd.print(CalibrationEC); 

if (button==2) CalibrationEC=CalibrationEC+0.01 ;

if(button==3)  CalibrationEC=CalibrationEC-0.01;

if(button==1) break;

delay(100);

       };

lcd.setCursor(0,0);

lcd.print("Calibrating         ");

lcd.setCursor(0,1);

lcd.print("EC:                 ");

lcd.setCursor(3,1);

lcd.print(CalibrationEC); 

i=1;

buffer=0;

sensors.requestTemperatures();// Send the command to get temperatures

TemperatureStart=sensors.getTempCByIndex(0); //Stores Value in Variable

//************Estimates Resistance of Liquid ****************//

            while(i<=10){

            digitalWrite(ECPower,HIGH);

            raw= analogRead(ECPin);

            digitalWrite(ECPower,LOW);

            buffer=buffer+raw;

            i++;

            delay(5000);

            };

raw=(buffer/10.0);

sensors.requestTemperatures();// Send the command to get temperatures

TemperatureFinish=sensors.getTempCByIndex(0); //Stores Value in Variable

//*************Compensating For Temperaure********************//

EC =CalibrationEC*(1+(TemperatureCoef*(TemperatureFinish-25.0))) ;

//***************** Calculates R relating to Calibration fluid **************************//

Vdrop= (((Vin)*(raw))/1024.0);

Rc=(Vdrop*R1)/(Vin-Vdrop);

Rc=Rc-Ra; //Taking into account pin resistance

Kt= 1000/(Rc*EC);

                    if (TemperatureStart==TemperatureFinish ){

                      Serial.println("   Results are Trustworthy");

                      Serial.print("Calibration Fluid EC: "); 

                      Serial.print(CalibrationEC);

                      Serial.print(" S  ");  //add units here

                      Serial.print("Cell Constant K");

                      Serial.print(K);

                      lcd.setCursor(0,0);

                      lcd.print("GoodResults         ");

                      lcd.setCursor(0,1);

                      lcd.print("EC:                    ");

                      lcd.setCursor(3,1);

                      lcd.print(CalibrationEC);

                      lcd.setCursor(9,1);

                      lcd.print("K:");

                      lcd.setCursor(11,1);

                      lcd.print(Kt);

                              while (1) { // wee need to keep this function running until user opts out with return function

                              read_LCD_buttons();

                              if(button==4) return; //exits the loop without saving becauser user asked so

                              if (button==5){

                              K=Kt; //saving the new cell constant

                          //******8*Saving the new value to EEprom**********//  

                            value=K/0.02;

                            EEPROM.write(addresCalibration, value);

                              lcd.setCursor(0,0);

                              lcd.print("Saved Calibration        ");

                              lcd.setCursor(0,1);

                              lcd.print("K:                        ");

                              lcd.setCursor(3,1);

                              lcd.print(Kt);

                              delay(2000);

                              return;

                              }

                              if(millis()%4000>=2000){

                              lcd.setCursor(0,0);

                              lcd.print("GoodResults         ");

                              lcd.setCursor(0,1);

                              lcd.print("EC:                  ");

                              lcd.setCursor(2,1);

                              lcd.print(CalibrationEC);

                              lcd.setCursor(9,1);

                              lcd.print("K:");

                              lcd.setCursor(11,1);

                              lcd.print(Kt);

                              }

                              else{

                              lcd.setCursor(0,0);

                              lcd.print("Select To Save       ");

                              lcd.setCursor(0,1);

                              lcd.print("Down to Exit           ");

                              };

                              }

                      }

                              else{

                               Serial.println("   Error Wait For Temperature To settle");

                                        while (1) {

                                        read_LCD_buttons();

                                        if(button==2) Calibration();

                                        if(button==3) return;

                                        lcd.setCursor(0,0);

                                        lcd.print("Bad Results         ");

                                         lcd.setCursor(0,1);

                                        lcd.print("Press DWN Exit           ");

                                  }

                            }

};

//**************************************** End OF CALIBRATION ROUTINE ******************************//

//**************************************Start OF Function To Change EC Setpoint*********************//

void ChangeECSetpoint(){

if(Screen!=7) return;

if(button!=5) return;

else delay(1000);

read_LCD_buttons();

if(button!=5) return;

while(1){

read_LCD_buttons();

lcd.setCursor(0,0);

lcd.print("Set EC SetPoint  ");

lcd.setCursor(0,1);

lcd.print("R:exit EC:                 ");

lcd.setCursor(11,1);

lcd.print(ECSetpoint); 

if (button==2) ECSetpoint=ECSetpoint+0.01 ;

if(button==3)  ECSetpoint=ECSetpoint-0.01;

if(button==1) {

  value=ECSetpoint/0.02;

  EEPROM.write(addresSetpoint, value);

break;

}

delay(100);

       };

}; 

//*******************************End OF Change EC Setpoint *********************************************//

//*********************************Function to Check for any errors**************************************//

void Error(){

error=6; //For Some Reason the Errors are not refreshing like they shoud, this fixes it

//*********Checking if the Probe is in the Solution********//

  if(EC25<=0.05){

   Serial.println("Probe Problem: Check it is in the liquid and not shorted ");

   error=1;

  }

//***********Checking if we seriosly overshot the setpoint**//

  else if((EC25>=(ECSetpoint*1.3))&& NutesAdded==0){

  Serial.println("Dosing Problem: We overshot the setpoint, Will attempt to fix its self ");

   error=2;

  }

//******** Checking Temp Probe is In range ****************//

else if((Temperature>=50.0) || (Temperature<=0.5)){

  Serial.println("Temperature Problem: Check Wiring [Also Check Probe has pull up] ");

  error=3;

}

//****** Checking Dosing Pump Is working******************//

else if( (PostDocingEC<=(PreDosingEC+0.05) ) && (NutesAdded==0 && EC25<=ECSetpoint-0.2) ){

Serial.println("Dosing Problem: Check Nute Tank is full and pump is not broken ");

              if(Doses<=10){

              //Still Geting a good estimate for the EC

              //error=5;

              };

              if(Doses>=11) {

              //Proberbly a pump problem

                error=4;

              };

                                }

else error=6;

};