#include <EEPROM.h>
#include <DS3231.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address // In my case 0x27


//#include <LiquidCrystal.h>  
// initialize the library with the numbers of the interface pins
//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

      #define SOL_VOLTS_CHAN 0               // defining the adc channel to read solar volts
      #define ACCU_VOLTS_CHAN 2              // defining the adc channel to read Accu volts (emulation)
      #define GRID_VOLTS_CHAN 3              // defining the adc channel to read Grid volts (emulation)
      
      #define AVG_NUM 8                      // number of iterations of the adc routine to average the adc readings
      
      //Defining relay pins for indication
      #define RELAY_T1 4 //5v 30A Relay for DC swithing
      #define RELAY_T2 5 //5v 30A Relay for DC swithing
      #define RELAY_T3 6 //Solid State Relay for AC swithing
      #define RELAY_T4 7 //Solid State Relay for AC swithing
      
      #define TRUE 1
      #define FALSE 0
      #define ON TRUE
      #define OFF FALSE
      
      float sol_volts = 00.00;                   // solar volts
      float grid_volts = 00.00;                  // grid volts
      float accu_volts = 00.00;                  // accu volts
      float sol_volts_threshold = 2.046; // = 10.80;        // solar panel threshold voltage
      float accu_volts_threshold = 4.590; // = 21.60v;        // accu threshold voltage
      
      float sol_volts_prev = 00.00;         // previous reading of solar volts                         
      float grid_volts_prev = 00.00;        // previous reading of grid volts                        
      float accu_volts_prev = 00.00;        // previous reading of accu volts                        

void setup() {

        // Start the I2C interface
        Wire.begin();
        lcd.begin(20,4);
        lcd.backlight(); // finish with backlight on 
    
        Serial.begin(9600);

        //Initialize the digital pin for relays as an output.
        pinMode(RELAY_T1, OUTPUT);
        pinMode(RELAY_T2, OUTPUT);
        pinMode(RELAY_T3, OUTPUT);
        pinMode(RELAY_T4, OUTPUT);
        //Initialize Relay with NO swithcing
        digitalWrite(RELAY_T1, LOW);
        digitalWrite(RELAY_T2, LOW);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, LOW);  
        
}

void DecisionMaker(bool PV, bool Accu, bool Grid){

if (PV == false && Accu == false && Grid == false){  
	Serial.print("Mod#1");
          
        lcd.setCursor (0,0);                          // Go to the next line
        lcd.write("MODUS-1");                            // Modus-1
        lcd.setCursor (0,1);                          
        lcd.write ("Externe net-storing");                   // External error
        lcd.setCursor (0,2);
        lcd.write("EV. is onbeschikbaar");               // Power supply is unavailable
        lcd.setCursor (0,3);                          
        lcd.write ("Wachten a.u.b...");                  // Please wait..
       
        digitalWrite(RELAY_T1, LOW);
        digitalWrite(RELAY_T2, LOW);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, LOW);        
}

if (PV == false && Accu == false && Grid == true){
	Serial.print("Mod#2");

        lcd.setCursor (0,0);                          
        lcd.write("MODUS-2");                            // Modus-2
        lcd.setCursor (0,1);                          
        lcd.write ("EV. uit lichtnet");                  // Power Supply from the grid
        lcd.setCursor (0,2);
        lcd.write("Onvoldoende zon");                    // Not enough sun
        lcd.setCursor (0,3);                          
        lcd.write ("Kan accu niet laden");               // Can't load battery
     
        
        digitalWrite(RELAY_T1, HIGH);
        digitalWrite(RELAY_T2, LOW);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, LOW);        
}  
if (PV == false && Accu == true && Grid == false){  
	Serial.print("Mod#3");

        lcd.setCursor (0,0);                          
        lcd.print("MODUS-3");                            // Modus-3
        lcd.setCursor (0,1);                          
        lcd.print ("EV. uit accu");                      // Power Supply from battery
        lcd.setCursor (0,2);
        lcd.print("Onvoldoende zon");                    // Not enough sun
        lcd.setCursor (0,3);                          
        lcd.print ("Externe net-storing");               // External grid error   
        delay(100);

        digitalWrite(RELAY_T1, LOW);
        digitalWrite(RELAY_T2, LOW);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, HIGH);        
} 
if (PV == true && Accu == false && Grid == false){  
	Serial.print("Mod#4");
    
        lcd.setCursor (0,0);                          
        lcd.print("MODUS-4");                           // Modus-4
        lcd.setCursor (0,1);                          
        lcd.print ("Externe net-storing");              // Power Supply is unavaillable
        lcd.setCursor (0,2);
        lcd.print("EV. onbeschikbaar");                     // Enough sun
        lcd.setCursor (0,3);                          
        lcd.print ("Accu wordt geladen");               // Battery will be loaded
        delay(100);
      
        digitalWrite(RELAY_T1, LOW);
        digitalWrite(RELAY_T2, HIGH);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, LOW);        
} 
if (PV == true && Accu == false && Grid == true){  
	Serial.print("Mod#5");

        lcd.setCursor (0,0);                          
        lcd.print("MODUS-5");                           // Modus-5
        lcd.setCursor (0,1);                          
        lcd.print ("EV uit lichtnet");                  // Power Supply from grid
        lcd.setCursor (0,2);
        lcd.print("Voldoende zon");                     // Enough sun
        lcd.setCursor (0,3);                          
        lcd.print ("Accu wordt geladen");               // Battery will be loaded
        delay(100);

        digitalWrite(RELAY_T1, HIGH);
        digitalWrite(RELAY_T2, HIGH);
        digitalWrite(RELAY_T3, LOW);
        digitalWrite(RELAY_T4, LOW);        
} 
if (PV == true && Accu == true){  
	Serial.print("Mod#6");

        lcd.setCursor ( 0, 0 );                          
        lcd.print("MODUS-6");                           // Modus-6
        lcd.setCursor ( 0, 1 );                          
        lcd.print ("EV uit accu");                      // Power Supply from grid
        lcd.setCursor (0,2);
        lcd.print("Energieoverschot");                  // Enough sun
        lcd.setCursor ( 0, 3 );                          
        lcd.print ("Terugleveren");                     // Battery will be loaded
        delay(100);
      
      
        digitalWrite(RELAY_T1, LOW);
        digitalWrite(RELAY_T2, LOW);
        digitalWrite(RELAY_T3, HIGH);
        digitalWrite(RELAY_T4, HIGH);        
} 
        
        Serial.print("PV");
        Serial.print(PV);
        Serial.print("\n\r");
        Serial.print("ACCU");
        Serial.print(Accu);
        Serial.print("\n\r");
        Serial.print("Grid");
        Serial.print(Grid);
        Serial.print("\n\r"); 
}

      void ProcessInputs(){
      
        bool HasSolarEnergy = false;
        bool IsAccuCharged = false;
        bool HasGridEnergy = false;
        
        if (sol_volts > sol_volts_threshold){
       	HasSolarEnergy = true;
        }
      Serial.print("accu_volts:");
      Serial.print(accu_volts);
      Serial.print("\n\r");
      Serial.print("accu_volts_threshold:");
      Serial.print(accu_volts_threshold);
      Serial.print("\n\r");
        if (accu_volts >= accu_volts_threshold){ //Needs also a treshold to check if it is sufficiently charged
       	IsAccuCharged = true;
        }
        if (grid_volts > 0){
       	HasGridEnergy = true;
        } 
      
        DecisionMaker(HasSolarEnergy,IsAccuCharged,HasGridEnergy);
      }
      
      //------------------------------------------------------------------------------------------------------
      // This routine reads and averages the analog inputs for this system, solar volts, solar amps and 
      // battery volts. 
      //------------------------------------------------------------------------------------------------------
      float read_adc(int channel){
        
        int sum = 0;
        int temp;
        int i;
        
        for (i=0; i<AVG_NUM; i++) {            // loop through reading raw adc values AVG_NUM number of times  
          temp = analogRead(channel);          // read the input pin  
          sum += temp;                        // store sum for averaging
          delayMicroseconds(50);              // pauses for 50 microseconds  
        }
        return(sum / AVG_NUM);                // divide sum by AVG_NUM to get average and return it
      }
      
      //------------------------------------------------------------------------------------------------------
      // This routine reads all the analog input values for the system. Then it multiplies them by the scale
      // factor to get actual value in volts or amps. 
      //------------------------------------------------------------------------------------------------------
      void read_data(void) {
        //Arduino Analog input voltaj reading scale:
        //1024 for 5v
        //But, if there is a voltage divider which provides the voltage will cause
        //some loss of voltage. Therefore, the scale maybe different value i.e. 1057.139
        //Standard multiplication index is 0.00473 accordng to 1024 with 5v.
      
        sol_volts = read_adc(SOL_VOLTS_CHAN) * 0.0048875;   //input of solar volts 
        grid_volts = read_adc(GRID_VOLTS_CHAN);// * 0.00489;   //input of grid volts 
        accu_volts = read_adc(ACCU_VOLTS_CHAN) * 0.0048875;   //input of accu volts 
        Serial.print("SOL:");
        Serial.print('\n');
        Serial.print(read_adc(sol_volts));
        Serial.print('\n');  
        Serial.print(sol_volts);
        Serial.print('\n');  
        //Serial.print(sol_volts,DEC);
      }
      void loop() {
        read_data();                         //read data from inputs
        ProcessInputs();
        delay(500);
      }