////////////////////////////////ARDUINO PWM SOLAR CHARGE CONTROLLER V-2.02///////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------

//  Author: Debasish Dutta
//          www.opengreenenergy.com
//  This code is for an arduino based Solar PWM charge controller ( V-2.0)
//  Credit :logic of 3 stage charging taken from http://jamesoid.com/pwm_charger_project/pwm_charger.ph
//  Last updated on 14/04/2022
//----------------------------------------------------------------------------------------------------
// Arduino pins Connections----------------------------------------------------------------------------

// A0 - Voltage divider to measure solar panel voltage
// A1 - Voltage divider to measure battery voltage
// A2 - LDR input
// A3 - ACS712 to monitor solar current
// A4 - LCD+RTC SDA
// A5 - LCD+RTC SCL

// D0 - Not used
// D1 - Not used
// D2 - Control Load Relay S pin
// D3 - PWM Output to control MOSFET Q1
// D4 - Not Used
// D5 - Battery Red LED
// D6 - Battery Green LED
// D7 - Battery Blue LED
// D8 - Load Red Led
// D9 - Load Green Led
// D10- Solar Red LED
// D11- Solar Green LED
// D12- DS18B20 Temp. Sensor
// D13- Not Used

#include <Wire.h>
#include <OneWire.h>
#include "RTClib.h"
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>

#define SOL_ADC A0     // Solar panel side voltage divider is connected to pin A0
#define BAT_ADC A1     // Battery side voltage divider is connected to pin A1
#define ldr     A2
//#define LOAD_CURRENT_ADC A2  // ACS 712 current sensor is connected to pin A2 for load curremt
#define SOL_CURRENT_ADC A3  // ACS 712 current sensor is connected to pin A3 for solar current
#define AVG_NUM 10    // number of iterations of the adc routine to average the adc readings
#define BAT_MIN 10.5  // minimum battery voltage for 12V system
#define BAT_MAX 15.0  // maximum battery voltage for 12V system
#define BULK_CH_SP 14.4 // bulk charge set point for sealed lead acid battery // flooded type set it to 14.6V
#define FLOAT_CH_SP 13.6  //float charge set point for lead acid battery
#define LVD 11.5          //Low voltage disconnect setting for a 12V system
#define PWM_PIN 3         // pin-3 is used to control the charging MOSFET //the default frequency is 490.20Hz
#define LOAD_PIN 2       // pin-2 is used to control the load
#define BAT_RED_LED 5
#define BAT_GREEN_LED 6
#define BAT_BLUE_LED 7
#define LOAD_RED_LED 8
#define LOAD_GREEN_LED 9
#define SOL_RED_LED 10
#define SOL_GREEN_LED 11
#define ONE_WIRE_BUS 12 // Data wire of DS18B20 temp. sensor is connected to pin 12

//--------------------------------------------------------------------------------------------------------------------------
///////////////////////DECLARATION OF ALL BIT MAP ARRAY FOR FONTS////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------------------------------------

byte solar[8] = //icon for solar panel
{
  0b11111, 0b10101, 0b11111, 0b10101, 0b11111, 0b10101, 0b11111, 0b00000
};
byte battery[8] =  //icon for battery
{
  0b01110, 0b11011, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11111
};

byte energy[8] =  // icon for power
{
  0b00010, 0b00100, 0b01000, 0b11111, 0b00010, 0b00100, 0b01000, 0b00000
};
/*byte alarm[8] =  // icon for alarm
  {
  0b00000,0b00100,0b01110,0b01110,0b01110,0b11111,0b00000,0b00100
  };*/
byte temp[8] = //icon for termometer
{
  0b00100, 0b01010, 0b01010, 0b01110, 0b01110, 0b11111, 0b11111, 0b01110
};

byte charge[8] = // icon for battery charge
{
  0b01010, 0b11111, 0b10001, 0b10001, 0b10001, 0b01110, 0b00100, 0b00100,
};
byte not_charge[8] =
{
  0b00000, 0b10001, 0b01010, 0b00100, 0b01010, 0b10001, 0b00000, 0b00000,
};


//--------------------------------------------------------------------------------------------------------------------------
///////////////////////DECLARATION OF ALL GLOBAL VARIABLES//////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------------------------------------
float solar_volt = 0;
float bat_volt = 0;
float load_current = 0;
float solar_current = 0;
float offsetVoltage = 2.5; // for ACS712 sensor
float Sensitivity = 0.185; // 185mV/A for ACS712-5A variant
int temperature = 0;
int temp_change = 0;
float system_volt = 0;
float bulk_charge_sp = 0;
float float_charge_sp = 0;
int charge_stage = 0;
float load_status = 0;
double PWM_Duty = 0; // PWM_Duty varies from 0 to 255
float lvd;
int ldr_status = 0;

// Variables for power and energy measurements

long unsigned time = 0;
long unsigned msec = 0;
long unsigned last_msec = 0;
long unsigned elasped_msec = 0;
long unsigned elasped_time = 0;
float load_ampSecs = 0;
float load_ampHours = 0;
float load_watts = 0;
float load_wattSecs = 0;
float load_wattHours = 0;
float solar_ampSecs = 0;
float solar_ampHours = 0;
float solar_watts = 0;
float solar_wattSecs = 0;
float solar_wattHours = 0;

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 sensor
RTC_DS3231 rtc;

// Set the pins on the I2C chip used for LCD connections:
//                    addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 20, 4); // Set the LCD I2C address // In my case 0x27
//******************************************************* MAIN PROGRAM START ************************************************
void setup()
{

  Serial.begin(9600);
  rtc.begin();
  sensors.begin(); // // Start up the library
  TCCR2B = TCCR2B & B11111000 | 0x03;    // pin 3 PWM frequency of 980.39 Hz

  pinMode(ldr, INPUT);
  pinMode(SOL_RED_LED , OUTPUT);
  pinMode(SOL_GREEN_LED, OUTPUT);
  pinMode(BAT_RED_LED, OUTPUT);
  pinMode(BAT_GREEN_LED, OUTPUT);
  pinMode(BAT_BLUE_LED, OUTPUT);
  pinMode(LOAD_RED_LED , OUTPUT);
  pinMode(LOAD_GREEN_LED, OUTPUT);
  pinMode(PWM_PIN, OUTPUT);
  pinMode(LOAD_PIN, OUTPUT);
  digitalWrite(PWM_PIN, LOW); // default value of pwm duty cycle
  digitalWrite(LOAD_PIN, LOW); // default load state is OFF
  lcd.init();   // initialize the lcd for 16 chars 2 lines, turn on backlight
  lcd.backlight(); // finish with backlight on
  lcd.createChar(1, solar);
  lcd.createChar(2, battery);
  lcd.createChar(3, energy);
  //lcd.createChar(4,alarm);
  lcd.createChar(5, temp);
  lcd.createChar(6, charge);
  lcd.createChar(7, not_charge);
  lcd.clear();
  if (rtc.lostPower()) {
    Serial.println("RTC lost power, let's set the time!");
    // When time needs to be set on a new device, or after a power loss, the
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
}

void loop()
{
  read_data();             // read different sensors data from analog pin of arduino
  system_voltage();        // detect the system voltage according to battery voltage
  setpoint();      // decide the charge set point according to system voltage
  charge_cycle();         // pwm charging of battery
  power();                // calculate the load power and energy
  load_control();         //control the load
  led_indication();       // led indica
  print_data();            // print in serial monitor
  lcd_display();           // lcd display
}
//************************************************************ PROGRAM END *************************************************


//------------------------------------------------------------------------------------------------------
////////////////// READS AND AVERAGES THE ANALOG INPUTS (SOLRAR VOLTAGE,BATTERY VOLTAGE)////////////////
//------------------------------------------------------------------------------------------------------
int read_adc(int adc_parameter)
{

  int sum = 0;
  int sample ;
  for (int i = 0; i < AVG_NUM; i++)
  { // loop through reading raw adc values AVG_NUM number of times
    sample = analogRead(adc_parameter);    // read the input pin
    sum += sample;                        // 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
}
//-------------------------------------------------------------------------------------------------------------
////////////////////////////////////READ THE DATA//////////////////////////////////////////////////////////////
//-------------------------------------------------------------------------------------------------------------
void read_data(void)
{
  //5V = ADC value 1024 => 1 ADC value = (5/1024)Volt= 0.0048828Volt
  // Vout=Vin*R2/(R1+R2) => Vin = Vout*(R1+R2)/R2   R1=100 and R2=20
  ldr_status = analogRead(A0);
  solar_volt = read_adc(SOL_ADC) * 0.00488 * (120 / 20);
  bat_volt   = read_adc(BAT_ADC) * 0.00488 * (120 / 20);
  //load_current = ((read_adc(LOAD_CURRENT_ADC)*0.00488 - offsetVoltage-2.5)/Sensitivity ); // 2.4V offset when no load is connected
  solar_current = ((read_adc(SOL_CURRENT_ADC) * 0.00488 - offsetVoltage) / Sensitivity );
  // if (load_current <0)
  //{
  // load_current = 0;
  //}
  if (solar_current < 0)
  {
    solar_current = 0;
  }

  sensors.requestTemperatures();  // get temperature readings
  temperature = sensors.getTempCByIndex(0) ;    // 0 refers to the first IC on the wire

}
//------------------------------------------------------------------------------------------------------------
/////////////////////////////////POWER AND ENERGY CALCULATION //////////////////////////////////////////////
//------------------------------------------------------------------------------------------------------------
void power(void) {

  msec = millis();
  elasped_msec = msec - last_msec; //Calculate how long has past since last call of this function
  elasped_time = elasped_msec / 1000.0; // 1sec=1000 msec
  //load_watts = load_current * bat_volt; //Watts now
  solar_watts = solar_current * solar_volt; //Watts now

  //load_ampSecs = (load_current*elasped_time); //AmpSecs since last measurement
  solar_ampSecs = (solar_current * elasped_time); //AmpSecs since last measurement

  //load_wattSecs = load_ampSecs * bat_volt; //WattSecs since last measurement
  solar_wattSecs = solar_ampSecs * solar_volt; //WattSecs since last measurement

  //load_ampHours = load_ampHours + load_ampSecs/3600; // 1 hour=3600sec //Total ampHours since program started
  solar_ampHours = solar_ampHours + solar_ampSecs / 3600; // 1 hour=3600sec //Total ampHours since program started

  //load_wattHours = load_wattHours + load_wattSecs/3600; // 1 hour=3600sec //Total wattHours since program started
  solar_wattHours = solar_wattHours + solar_wattSecs / 3600; // 1 hour=3600sec //Total wattHours since program started

  last_msec = msec; //Store 'now' for next time


  /*

    last_time = current_time;
    current_time = millis();
    load_watts = load_current * bat_volt; //load Watts now
    solar_watts = solar_current * solar_volt; //solar Watts now
    load_wattHours = load_wattHours +  load_watts*(( current_time -last_time) /3600000.0) ; // calculating energy in Watt-Hour
    solar_wattHours = solar_wattHours+  solar_watts*(( current_time -last_time) /3600000.0) ; // calculating energy in Watt-Hour
  */
}

//------------------------------------------------------------------------------------------------------------
/////////////////////////////////PRINT DATA IN SERIAL MONITOR/////////////////////////////////////////////////
//------------------------------------------------------------------------------------------------------------
void print_data(void)
{
  //delay(100);
  Serial.print("        Solar Voltage: ");
  Serial.print(solar_volt);
  Serial.print("        Battery Voltage: ");
  Serial.print(bat_volt);
  Serial.print("Temp: " );
  Serial.print (temperature);
  Serial.print("        Bulk Voltage Setpoint: ");
  Serial.print(bulk_charge_sp);
  Serial.print("        Float Voltage Setpoint: ");
  Serial.print(float_charge_sp);
  Serial.print("        PWM Duty: ");
  Serial.print((PWM_Duty / 255 ) * 100); // convert a number between 0 -1024  to  0-1024 then convert float to intiger
  Serial.print("%");
  Serial.print("        Charge Stage: ");
  Serial.println(charge_stage);
  Serial.print("Solar Current: ");
  Serial.print(solar_current);
  Serial.println("A");
}
//----------------------------------------------------------------------------------------------------------------------
//////////////////////////////////SYSTEM VOLTAGE AUTO DETECT ///////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
void system_voltage(void)
{
  if ((bat_volt > BAT_MIN) && (bat_volt < BAT_MAX))
  {
    system_volt = 12;
  }
  /*
    else if  ((bat_volt > BAT_MIN*2 ) && (bat_volt < BAT_MAX*2))
    {
    system_volt=24;
    }*/
  else if ((bat_volt > BAT_MIN / 2 ) && (bat_volt < BAT_MAX / 2))
  {
    system_volt = 6;
  }

}
//---------------------------------------------------------------------------------------------------------------------------
////////////////////////////////////CHARGE SET POINT ///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------------------------------------------------------

void setpoint(void)
{
  temp_change = temperature - 25.0; // 25deg cel is taken as standard room temperature
  // temperature compensation = -5mv/degC/Cell
  // If temperature is above the room temp ;Charge set point should reduced
  // If temperature is bellow the room temp ;Charge set point should increased
  if (system_volt == 12)
  {
    bulk_charge_sp = BULK_CH_SP - (0.050 * temp_change) ;
    float_charge_sp = FLOAT_CH_SP - (0.050 * temp_change) ;
    lvd = LVD;
  }

  else if (system_volt == 6)
  {
    bulk_charge_sp = (BULK_CH_SP / 2) - (0.015 * temp_change) ;
    float_charge_sp = (FLOAT_CH_SP / 2) - (0.015 * temp_change) ;
    lvd = LVD / 2;
  }
  /*
    else if (system_volt == 24)
    {
    bulk_charge_sp = (BULK_CH_SP*2)-(0.060*temp_change) ;
    float_charge_sp= (FLOAT_CH_SP*2)-(0.060*temp_change) ;
    lvd=LVD*2;
    }
  */

}
//--------------------------------------------------------------------------------------------------------------------------------
///////////////////////////////////////////////////PWM CHARGE CYCLE @500 HZ //////////////////////////////////////////////////
//-------------------------------------------------------------------------------------------------------------------------------
void charge_cycle(void)
{
  if (solar_volt <= 10) {
    read_data();         // Reading voltage temp from the sensors
    setpoint();              // Reading temp compensated charging set point
    PWM_Duty = 0;
    analogWrite(PWM_PIN, PWM_Duty); //generate PWM from D9 @ 0% duty // Shut down the charger

  }


  //--------------------------------------------------------------------------------------------------------------------------------
  ///////////////////////////////////////////////////PWM CHARGE CYCLE @500 HZ //////////////////////////////////////////////////
  //-------------------------------------------------------------------------------------------------------------------------------

  ///////////////////////////////////  STAGE-1 (BULK CHARGING)//////////////////////////////////////////////////////
  // During this stage the MOSFET is fully on by setting the duty cycle to 100%
  // Constant Current Charging
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////



  if ((bat_volt < bulk_charge_sp) && (solar_volt > (bat_volt + .5)) && charge_stage == 1) {
    read_data();        // Reading voltage and temp from the sensors
    setpoint();               // Reading temp compensated charging set point
    PWM_Duty = 252.45;
    analogWrite(PWM_PIN, PWM_Duty); // 99 % duty cycle // rapid charging
  }
  charge_stage = 2;


  ///////////////////////////////////  STAGE-2 (TOPPING CHARGE)//////////////////////////////////////////////////////
  // During this stage the MOSFET is fully on by setting the duty cycle to 100%
  // Constant voltage
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  // 25.5 is 10 % duty cycle
  if ((PWM_Duty > 25.5 ) && (solar_volt > (bulk_charge_sp + .5)) && charge_stage == 2) {
    time = millis();
    read_data();         // Reading voltage and temp from the sensors
    setpoint();              // Reading temp compensated charging set point

    if (bat_volt >= bulk_charge_sp) { // if the battery voltage rise above the bulk charge setpoint
      PWM_Duty--;                     // Slow down the charging rate by reducing the pwm duty cycle
      if (PWM_Duty < 0) {             // if during slow down process duty cycle falls below 0% then set to 0%
        PWM_Duty = 0;
      }
      analogWrite(PWM_PIN, PWM_Duty);   //generate PWM from D3 @ 0% duty // MOSFET Q1 is OFF
    }
    if (bat_volt < bulk_charge_sp) { // if the battery voltage falls below the bulk charge setpoint, then go to stage-1
      charge_stage = 1;
    }
    else {
      analogWrite(PWM_PIN, PWM_Duty);
    }

    /* while( millis()-time > 3600000){ // Ensure the charger stay 1hour in bulk charging
      charge_stage = 3;
      }
    */

  }
  charge_stage = 3;


  ///////////////////////////////////  STAGE-3 (FLOAT CHARGING)//////////////////////////////////////////////////////
  // During this stage the MOSFET is fully on by setting the duty cycle to 100%
  // Constant Current Charging
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  if ((solar_volt > ( float_charge_sp + .5)) && charge_stage == 3) {
    read_data();         // Reading voltage and temp from the sensors
    setpoint();      // Reading temp compensated charging set point
    if (bat_volt >= float_charge_sp) { // if the battery voltage is more than float charge setpoint then shut down the charger
      PWM_Duty = 0;                    // setting duty cycle =0 to turn off the MOSFET Q1
      analogWrite(PWM_PIN, PWM_Duty); //generate PWM from D9 @ 0% duty // MOSFET Q1 is OFF
    }
    else if (bat_volt <  float_charge_sp - 0.5) { // if the battery voltage falls below the float charge setpoint then go to stage -1
      charge_stage = 1;
    }
    else {
      PWM_Duty = 252.25; // setting duty cycle = 5% for trickle charge

      analogWrite(PWM_PIN, PWM_Duty); //generate PWM from D9 @ 5% duty // Q1 is driving @ 5% duty cycle

    }

  }
}
//----------------------------------------------------------------------------------------------------------------------
/////////////////////////////////////////////LOAD CONTROL/////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------

void load_control()
{
  DateTime now = rtc.now();
  if (ldr_status < 700) {
    load_status = 1;
    digitalWrite(LOAD_PIN, HIGH); // load is ON
  }
  else {
    // 18 - 19 - 20 - 21 - 22 - 23 - 0 - 1 - 2 - 3 - 4 - 5 - 6
    if (now.hour() == 18 || now.hour() == 19 || now.hour() == 20 || now.hour() == 21 || now.hour() == 22 || now.hour() == 23 || now.hour() == 0 || now.hour() == 1 || now.hour() == 2 || now.hour() == 3 || now.hour() == 4 || now.hour() == 5 ) {
      load_status = 1;
      digitalWrite(LOAD_PIN, HIGH); // load is ON
    }
    else {
      load_status = 0;
      digitalWrite(LOAD_PIN, LOW); //load is OFF
    }
  }
}


//-------------------------------------------------------------------------------------------------
//////////////////////////LED INDICATION////////////////////////////////////
//-------------------------------------------------------------------------------------------------
void led_indication(void)
{
  solar_led();              //Solar led indication
  battery_led();           //Battery status led indication
  load_led();              //Load led indication
}
//----------------------------------------------------------------------------------------------------------------------
/////////////////////////////////////////////SOLAR LED INDICATION/////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------

void solar_led()

{
  if (solar_volt > float_charge_sp)
  {
    digitalWrite(SOL_RED_LED, LOW);
    digitalWrite(SOL_GREEN_LED, HIGH); // Sun Light is available and charger is ready for charging
  }
  else
  {
    digitalWrite(SOL_GREEN_LED, LOW);
    digitalWrite(SOL_RED_LED, HIGH); //Sun light is not available for charging

  }
}
//----------------------------------------------------------------------------------------------------------------------
/////////////////////////////////////////////BATTERY LED INDICATION/////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
void battery_led(void)
{

  if ( (bat_volt > system_volt) && ( bat_volt < bulk_charge_sp))
  {
    leds_off_all();
    digitalWrite(BAT_GREEN_LED, HIGH); // battery voltage is healthy
  }
  else if (bat_volt >= bulk_charge_sp)
  {
    leds_off_all();
    digitalWrite(BAT_BLUE_LED, HIGH); //battery is fully charged
  }
  else if (bat_volt < system_volt)
  {
    leds_off_all();
    digitalWrite(BAT_RED_LED, HIGH); // battery voltage low
  }
}
//----------------------------------------------------------------------------------------------------------------------
/////////////////////////////////////////////LOAD LED INDICATION/////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------

void load_led()

{
  if (load_status == 1)
  {
    digitalWrite(LOAD_RED_LED, LOW);
    digitalWrite(LOAD_GREEN_LED, HIGH);
  }
  else if (load_status == 0)
  {
    digitalWrite(LOAD_GREEN_LED, LOW);
    digitalWrite(LOAD_RED_LED, HIGH);
  }
}

//------------------------------------------------------------------------------------------------------
//////////////////////// TURN OFF ALL THE LED///////////////////////////////////////////////////////////
//------------------------------------------------------------------------------------------------------
void leds_off_all(void)

{

  digitalWrite(BAT_RED_LED, LOW);
  digitalWrite(BAT_GREEN_LED, LOW);
  digitalWrite(BAT_BLUE_LED, LOW);


}
//------------------------------------------------------------------------------------------------------
//////////////////////// LCD DISPLAY///////////////////////////////////////////////////////////////////
//------------------------------------------------------------------------------------------------------
void lcd_display()
{
  // Display Solar Panel Parameters
  lcd.setCursor(0, 0);
  lcd.write(1);
  lcd.setCursor(2, 0);
  lcd.print(solar_volt, 1);
  lcd.print("V");
  lcd.setCursor(8, 0);
  lcd.print(solar_current, 1);
  lcd.print("A");
  lcd.setCursor(14, 0);
  lcd.print(solar_watts, 1);
  lcd.print("W");

  // Display Battery Parameters
  lcd.setCursor(0, 1);
  lcd.write(2);
  lcd.setCursor(2, 1);
  lcd.print(bat_volt, 1);
  lcd.print("V");
  lcd.setCursor(8, 1);
  lcd.write(5);
  lcd.setCursor(9, 1);
  lcd.print(temperature);
  lcd.write(0b11011111);
  lcd.print("C");

  lcd.setCursor(14, 1);
  lcd.write(2);
  if ((charge_stage == 1) | (charge_stage == 2) | (charge_stage == 3))
  {
    lcd.write(6);
  }
  else
  {
    lcd.write(7);
  }

  // Display Load Parameters

  lcd.setCursor(0, 2);
  lcd.print("L");
  lcd.setCursor(2, 2);
  lcd.print(ldr_status, 1);
  //lcd.print("A");
  //lcd.setCursor(8, 2);
  //lcd.print(load_watts, 1);
  //lcd.print("W");
  lcd.setCursor(14, 2);
  if (load_status == 1)
  {
    lcd.print("   ");
    lcd.setCursor(14, 2);
    lcd.print("ON");
  }
  else if (load_status == 0)
  {
    lcd.print("OFF");
  }

  // Display Energy
  lcd.setCursor(0, 3);
  lcd.write(3);
  lcd.setCursor(2, 3);
  lcd.print(solar_wattHours, 1);
  lcd.print("Wh");
  //lcd.setCursor(8, 3);
  //lcd.print(load_wattHours, 1);
  //lcd.print("Wh");

}