UNO_serial

/*

   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 =600; //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 =2; //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= A1;
int ECGround=A2;
int ECPower =A4;

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

#define ONE_WIRE_BUS 13              // Data wire For Temp Probe is plugged into pin 10 on the Arduino
const int TempProbePossitive =13;  //Temp Probe power connected to pin 9
const int TempProbeNegative=12;    //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("Hydrobot  ");
lcd.setCursor(0,1);
delay(1000);
lcd.setCursor(0,1);
lcd.print("MadLab  ");
delay(1000);
lcd.setCursor(0,1);
lcd.print("Hydrobot  ");
delay(1000);
lcd.setCursor(0,1);
lcd.print("MadLab  ");
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]
komunikasi();

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

if(NutesAdded==0) LogEC();
delay(50);

}

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

//void main program

//void reques trigger
void komunikasi()
{
//baca request dari MCU
String minta = "";
//baca reques dari MCU
while(Serial.available()>0)
{
  minta += char(Serial.read());
}
//buang spasi data
minta.trim();
//Uji variable minta
if(minta == "Ya")
{
  //kirim data
  kirimdata();
}
//kosongkan var minta
minta = "";
delay(1000);
}

//void kirimdata
void kirimdata()
{
  //variable data kirim ke mcu
String datakirim = String(ppm) + "#" + String(Temperature) + "#" + String(PumECRate);
//kirim data ke MCU
Serial.println(datakirim);
}
// End of void kirimdata


//*******************************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("Hydrobot 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 < 60)   button =1;
else if (adc_key_in < 200)  button =2;
else  if (adc_key_in < 400)  button =3;
else if (adc_key_in < 600)  button =4;
else if (adc_key_in < 800)  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;



};