View source for CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

==Synopsis==
==Notes==

This was developed to test communication to the EPEVER AN Solar controller from the Arduino



==Code==
<syntaxhighlight lang="C++" line='line'>
//Arduino MEGA 2560
//MCP2515
////Pin 52 SPI clock
////Pin 50 MISO
////Pin 51 MOSI
////Pin 53 Cable Select

#include <SPI.h>
#include <mcp_can.h>
#include <LCDWIKI_GUI.h> //Core graphics library http://www.lcdwiki.com/3.5inch_Arduino_Display-UNO
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library
#include <ModbusMaster.h>

//Software constants
#define NUMPACKS                4     //Number of packs installed on line.  Must edit knownID[] array
#define NUMCELLS                8     //Hazardous to modify
#define REFRESH                 1000   //Refresh rate display
#define ALARM                   3.640    //Alarm threshold
#define LOWCELL                 3.100
#define windDown_period         600000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle
#define windUp_period           60000
#define windUpThreshold         3.550 //WindUp function will not call again until a cell reaches this voltage
#define dischargeProtect_period 600000
#define defaultPin              22 //Short pin 22 to ground to send default values in the next group to the controller

//Define the default values for your pack here, value *100, no decimal
#define def_BATT_TYPE           0000
#define def_BATT_AH             880
#define def_TEMP_COMP           300
#define def_OVERVOLT_DISC_VAL   2950
#define def_CHARGING_LIMIT_VAL  2860
#define def_OVERVOLT_RECON_VAL  2880
#define def_EQUILIBRIUM_CV_VAL  2830
#define def_BOOST_CV_VAL        2830
#define def_FLOAT_CV_VAL        2760        
#define def_BOOST_RECON_VAL     2640 
#define def_LOW_VOLT_RECON      2350
#define def_UNDERVOLT_RECOV     2440
#define def_UNDERVOLT_WARNING   2400
#define def_LOW_VOLT_DISC       2220
#define def_DISCHARGE_LIMIT     2120
#define dayLightVolt            3500  

//define some colour values
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
#define ORANGE  0xFC00
#define GREY    0x1863
#define BACKGRD 0x2965

//RS485 converter connections
#define MAX485_DE   49
#define MAX485_RE   48

// For Epever AN controller MODBUS read
#define PANEL_VOLTS     0x00
#define PANEL_AMPS      0x01
#define PANEL_POWER_L   0x02
#define PANEL_POWER_H   0x03
#define BATT_VOLTS      0x04
#define BATT_AMPS       0x05
#define BATT_POWER_L    0x06
#define BATT_POWER_H    0x07
#define OVERVOLT_DISC   0x03
#define CHARGING_LIMIT  0x04
#define OVERVOLT_RECON  0x05
#define EQUILIBRIUM_CV  0x06
#define BOOST_CV        0x07
#define FLOAT_CV        0x08
#define BOOST_RECON     0x09
#define LOW_VOLT        0x0A
#define UNDERVOLT_RECOV 0x0B
#define UNDERVOLT_WARN  0x0C
#define LOW_VOLT_DISC   0x0D
#define DISCHARGE_LIMIT 0x0E

//Touchscreen
#define YP A3  // must be an analog pin, use "An" notation!
#define XM A2  // must be an analog pin, use "An" notation!
#define YM 9   // can be a digital pin
#define XP 8   // can be a digital pin
#define MINPRESSURE 10
#define MAXPRESSURE 1000
#define TS_MINX 906
#define TS_MAXX 116
#define TS_MINY 92
#define TS_MAXY 952

//Globals
bool buzzer = LOW;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif
unsigned long currentMillis;

float voltage[NUMPACKS][NUMCELLS];
int temperature[NUMPACKS][NUMCELLS];

//Pack Parameters - you will fill this info in once you find the CAN address of your packs. Only the last two numbers will be relevant
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;
bool msg5 = LOW;
float hotCellVolt = 0;
float coldCellVolt = 0;


//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_READ;
unsigned short CHARGING_LIMIT_READ;
unsigned short OVERVOLT_RECON_READ;
unsigned short EQUILIBRIUM_CV_READ;
unsigned short BOOST_CV_READ;
unsigned short FLOAT_CV_READ;
unsigned short BOOST_RECON_READ;
unsigned short LOW_VOLT_RECON_READ;
unsigned short UNDERVOLT_RECOVERY_READ;
unsigned short UNDERVOLT_WARNING_READ;
unsigned short LOW_VOLT_DISC_READ;
unsigned short DISCHARGE_LIMIT_READ;

//Variables for holding register values from the controller
unsigned short PANEL_VOLTS_READ;
unsigned short PANEL_AMPS_READ;
unsigned short BATT_VOLTS_READ;
unsigned short BATT_AMPS_READ;

//Variables for holding values to be sent to the solar controller
unsigned short OVERVOLT_DISC_SETTO;
unsigned short CHARGING_LIMIT_SETTO;
unsigned short OVERVOLT_RECON_SETTO;
unsigned short EQUILIBRIUM_CV_SETTO;
unsigned short BOOST_CV_SETTO;
unsigned short FLOAT_CV_SETTO;
unsigned short BOOST_RECON_SETTO;
unsigned short LOW_VOLT_RECON_SETTO;
unsigned short UNDERVOLT_RECOVERY_SETTO;
unsigned short UNDERVOLT_WARNING_SETTO;
unsigned short LOW_VOLT_DISC_SETTO;
unsigned short DISCHARGE_LIMIT_SETTO;

//Variables for working with the controller
bool windDownFlag = LOW;
unsigned long unknownId = 0;

//Low failure rate timer
//const int windDown_period = 60000;
unsigned long windDown_etime = 0;
//const long windUp_period = 600000;
unsigned long windUp_etime = 0;
unsigned long dischargeProtect_etime = 0;


TouchScreen ts = TouchScreen(XP,YP, XM, YM, 300);
MCP_CAN CAN(53);

//if the IC model is known or the modules is unreadable,you can use this constructed function
LCDWIKI_KBV mylcd(ILI9486,A3,A2,A1,A0,A4); //model,cs,cd,wr,rd,reset
//if the IC model is not known and the modules is readable,you can use this constructed function
//LCDWIKI_KBV mylcd(320,480,A3,A2,A1,A0,A4);//width,height,cs,cd,wr,rd,reset

// instantiate ModbusMaster object
ModbusMaster node;

/*Function Prototypes
void BuildScreen(int);
void UpdateScreen(int);
void preTransmission();
void postTransmission();
void getControllerParams();
void windDown();
void windUp();
void dischargeProtect();
void updateController();
void defaultController();
*/

void setup()
{
long st, fn;
int q;  
  Serial.begin(115200);

  //Graphics
  mylcd.Init_LCD();
  Serial.print("My LCD ID: ");
  Serial.println(mylcd.Read_ID(), HEX);
  BuildScreen(0);

  //Pin 49 voltage alarm
  pinMode(49, OUTPUT);
  //Initialize against undefined values
  for(int i=0;i<NUMPACKS;i++)
  {
    for(int j=0;j<NUMCELLS;j++)
    {
      voltage[i][j]=0.0;
      temperature[i][j]=0;
    }
  }

  while (CAN_OK != CAN.begin(CAN_125KBPS,MCP_8MHz))
  {
    Serial.println("CAN BUS Init Failed, waiting for hardware...");
    delay(100);
  }
  Serial.println("CAN BUS  Init OK!");

  pinMode(MAX485_RE, OUTPUT);
  pinMode(MAX485_DE, OUTPUT);
  // Init in receive mode
  digitalWrite(MAX485_RE, 0);
  digitalWrite(MAX485_DE, 0);
  
  // Modbus setup at 115200 baud
  Serial1.begin(115200);

  // EPEver Device ID 1
  node.begin(1, Serial1);

  // Callbacks
  node.preTransmission(preTransmission);
  node.postTransmission(postTransmission);

  pinMode(defaultPin, INPUT_PULLUP);
  if (defaultPin == LOW)
    defaultController(); //Pin 22, shorted to ground, will default the controller to the settings defined atop
  else
  {
    Serial.println("Controller probed for default values");
    getControllerParams();
    //This will read the stores values from the non volatile memory in the controller in the event of a reset.
    OVERVOLT_DISC_SETTO = OVERVOLT_DISC_READ;
    CHARGING_LIMIT_SETTO = CHARGING_LIMIT_READ;
    OVERVOLT_RECON_SETTO = OVERVOLT_RECON_READ;
    EQUILIBRIUM_CV_SETTO = EQUILIBRIUM_CV_READ;
    BOOST_CV_SETTO = BOOST_CV_READ;
    FLOAT_CV_SETTO = FLOAT_CV_READ;
    BOOST_RECON_SETTO = BOOST_RECON_READ;
    LOW_VOLT_RECON_SETTO = LOW_VOLT_RECON_READ;
    UNDERVOLT_RECOVERY_SETTO = UNDERVOLT_RECOVERY_READ;
    UNDERVOLT_WARNING_SETTO = UNDERVOLT_WARNING_READ;
    LOW_VOLT_DISC_SETTO = LOW_VOLT_DISC_READ;
    DISCHARGE_LIMIT_SETTO = DISCHARGE_LIMIT_READ;
    Serial.println("Default values pulled from controller");
   }

}

void loop()
{
  long msgID = 0x00000FFF;
  bool skip = LOW;
  unsigned char len = 0;
  unsigned char buf[10];
  unsigned long canId = 0x00000000;

  //WARNING - Touch screen may be blocking
  digitalWrite(13, HIGH);
  TSPoint p = ts.getPoint();
  digitalWrite(13, LOW);
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);
  if (p.z > MINPRESSURE && p.z < MAXPRESSURE)
  {
    //p.x = my_lcd.Get_Display_Width()-map(p.x, TS_MINX, TS_MAXX, my_lcd.Get_Display_Width(), 0);
    //p.y = my_lcd.Get_Display_Height()-map(p.y, TS_MINY, TS_MAXY, my_lcd.Get_Display_Height(), 0);
    p.x = map(p.x, TS_MINX, TS_MAXX, mylcd.Get_Display_Width(),0);
    p.y = map(p.y, TS_MINY, TS_MAXY, mylcd.Get_Display_Height(),0);

    Serial.print("Touch detect x=");
    Serial.print(p.x);
    Serial.print(" y=");
    Serial.println(p.y);        
  }

  if(CAN_MSGAVAIL == CAN.checkReceive())
  {
    CAN.readMsgBuf(&len, buf);
    canId = CAN.getCanId();
    //Serial.print("p");//packet received

    if (canId & 0xFFFFF000 != 0x08010000)
    {
      Serial.println("Unsupported device attached!  Correct and restart monitor.");
      Serial.print("Device: 0x");
      Serial.print(canId & 0xFFFFF000,HEX);
      Serial.println(".");
      //Sound alarm
      digitalWrite(8,1);
      while(1){}
    }
    
    //detect if pack is registered
    packID = canId & 0x000000FF;
    slot = 0xFF;
    for(int i = 0; i<NUMPACKS ; i++)
    {
      if(knownID[i]==packID)
      {
        slot=i;
      }
      if(i==NUMPACKS-1 && slot==0xFF)
      {
        Serial.println("Unregistered Device attached!  Skipping!");
        Serial.print("  Device : 0x");
        Serial.print(packID,HEX);
        Serial.println(".");
        skip = HIGH;    
      }
    }
    
    //If pack is registered, collect it's data into local storage.
    if(!skip)
    {
    
      msgID = canId & 0x00000F00;
      //Interpret message 3
      if (msgID == 0x00000300)
      {        
        //Copy seven values to temperature[][]
        if(buf[0]==0)
        {
          for(int i=0;i<NUMCELLS-1;i++)
          {
            temperature[slot][i]=tempconvert(buf[i+1]); //i+1 because buf[0] is a count register
          }
        }
        //Copy one value to temperature[][0] wich is cell 1.
        if(buf[0]==1)
        {
          temperature[slot][7]=tempconvert(buf[1]);
        }
        //unknown temperature code
        if(buf[0]>1)
        {
          Serial.println("Unknown Temperature code");
        }
        //for(int i = 0; i<len; i++) {buf3[i] = buf[i];}
      }
      //Interpret message 5
      else if (msgID == 0x00000500) ;//{for(int i = 0; i<len; i++){buf5[i] = buf[i];}}
      //Interpret message A
      else if (msgID == 0x00000A00) ;//{for(int i = 0; i<len; i++){bufA[i] = buf[i];}}
      //Interpret message 0
      else if (msgID == 0x00000000) ;//{for(int i = 0; i<len; i++){buf0[i] = buf[i];}}
      //Interpret message 2
      else if (msgID == 0x00000200)
      {
        if (buf[0] == 0)
        {
          voltage[slot][7] = (buf[2] * 256 + buf[1]) / 1000.0;
          voltage[slot][6] = (buf[4] * 256 + buf[3]) / 1000.0;
          voltage[slot][5] = (buf[6] * 256 + buf[5]) / 1000.0;
          //for(int i = 0; i<len; i++){buf20[i] = buf[i];} 
        }
        if (buf[0] == 1)
        {
          voltage[slot][4] = (buf[2] * 256 + buf[1]) / 1000.0;
          voltage[slot][3] = (buf[4] * 256 + buf[3]) / 1000.0;
          voltage[slot][2] = (buf[6] * 256 + buf[5]) / 1000.0;
          //for(int i = 0; i<len; i++){buf21[i] = buf[i];}
        }
        if (buf[0] == 2)
        {
          voltage[slot][1] = (buf[2] * 256 + buf[1]) / 1000.0;
          voltage[slot][0] = (buf[4] * 256 + buf[3]) / 1000.0;
          //for(int i = 0; i<len; i++){buf22[i] = buf[i];}
        }
      }
      else 
      {
        unknownId = canId;
        Serial.println("Unexpected Message type detected!");
        Serial.println(canId & 0x00000F00, HEX);
      }
      
      hotCellVolt = voltage[0][0];
      coldCellVolt = voltage[0][0];
      for(int i=0; i<NUMPACKS;i++) //Calculate a pack sum and check for hot cells
      {
        sum[i]=0.0;
        for(int j=0;j<NUMCELLS;j++)
        {
          sum[i] += voltage[i][j];
          if (voltage[i][j] > hotCellVolt)
            hotCellVolt = voltage[i][j];
          else if (voltage[i][j] < coldCellVolt)
            coldCellVolt = voltage[i][j];
          if(hotCellVolt >= ALARM)
          {
            buzzer=HIGH;
          }
          if((coldCellVolt <= LOWCELL) && (coldCellVolt >= 1))
          {
            dischargeProtect();
          }
          
        }  
        
      }
        
      //Execute alarm condition
      currentMillis = millis();
      if(buzzer)
      {
        digitalWrite(49,1);
        windDown(); // This loop should only be executed once and then skipped for at least 1 minute
        windDown_etime = currentMillis;
        Serial.println("Buzzer Loop");
      } else digitalWrite(49,0);        
      if (windDownFlag && ((unsigned long)(currentMillis - windDown_etime) >= windDown_period))
        {
          Serial.println("post windDown windUp triggered");
          windUp();
          windUp_etime = currentMillis;
        }
      if ((PANEL_VOLTS_READ >= dayLightVolt) && (PANEL_AMPS_READ <= 1) && (hotCellVolt <= windUpThreshold) && ((unsigned long)(currentMillis - windUp_etime) >= windUp_period)) //Keep tweaking the controller to max
        {
          Serial.println("conditional windUp triggered");
          windUp();
          windUp_etime = currentMillis;
        }
        
        //Dump cell voltages to CSV
        /*
        Pack=0.0;
        for(int i=0; i<NUMPACKS;i++)
        {
          Pack=0.0;
          for(int j=0; j<NUMCELLS ; j++) 
          {

            Serial.print(voltage[i][j],3);
            Serial.print(",");


            Pack += voltage[i][j];

          }
          Serial.print(Pack,3);
          if(NUMPACKS-1!=i)
            Serial.print(',');
          else
            Serial.println();     
        }
        */
        //END Dump cell voltages to CSV
        
      if(unknownId != 0)
      {
        Serial.print("Unknown Message: ");
        Serial.print(unknownId, HEX);
        Serial.println();
      }
     }
     else skip=LOW;    
    }
    else
    {
      UpdateScreen(0);
    }
}

void BuildScreen(int ScreenMode)
{
  //Home Screen
  if(ScreenMode==0)
  {
    mylcd.Fill_Screen(BACKGRD);

    //Draw Blues
    mylcd.Set_Draw_color(32,0,255);
    mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);

    //Draw Blacks
    mylcd.Set_Draw_color(0,0,0);
    mylcd.Fill_Rectangle(10,42 , 150, 191);   //Pack 1
    mylcd.Fill_Rectangle(170,42 , 310, 191);//Pack 2
    mylcd.Fill_Rectangle(10,234 , 150, 386);//Pack 3
    mylcd.Fill_Rectangle(170, 234 , 310, 386);//Pack 4

    //Draw Lines
    mylcd.Set_Draw_color(WHITE);
    mylcd.Draw_Line(11, 62, 149, 62);//Pack 1
    mylcd.Draw_Line(171, 62, 309, 62);//Pack 2
    mylcd.Draw_Line(11, 254, 149, 254);//Pack 3
    mylcd.Draw_Line(171, 254, 309, 254);//Pack 4

    //Draw Reds 
    mylcd.Set_Draw_color(RED);
    mylcd.Fill_Rectangle(10,193 , 150, 214);//Pack 1
    mylcd.Fill_Rectangle(170,193, 310, 214);//Pack 2
    mylcd.Fill_Rectangle(10,384 , 150, 407);//Pack 3
    mylcd.Fill_Rectangle(170,384, 310, 407);//Pack 4
    //Title
    mylcd.Set_Text_colour(CYAN);
    mylcd.Set_Text_Mode(1);
    mylcd.Set_Text_Size(3);
    mylcd.Print_String("Battery Monitor", 30, 0);
    //Outline the screen
    mylcd.Set_Text_Size(2);
    mylcd.Set_Text_Back_colour(BLACK);
    mylcd.Set_Text_colour(WHITE);
    mylcd.Print_String("  x04    (-)   x20    (-)", 4, 30+16*1);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*2);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*3);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*4);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*5);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*6);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*7);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*8);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*9);
    mylcd.Print_String(" (+)       V  (+)       V", 4, 38+16*10);
    mylcd.Print_String("  x06    (-)   x22    (-)", 4, 30+16*13);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*14);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*15);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*16);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*17);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*18);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*19);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*20);
    mylcd.Print_String(" -.---V  --F  -.---V  --F", 4, 32+16*21);
    mylcd.Print_String(" (+)       V  (+)       V", 4, 38+16*22);

    //credits, statusbar
    mylcd.Set_Text_colour(CYAN);
    mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
  }
  return;
}

void UpdateScreen(int battery)
{
  
  int xc, yc;
  if(p==0 || p==1)
  {
    yc=64+(16*c);
  }
  if(p==2 || p==3)
  {
    yc=256+(16*c);
  }
  if(p==0 || p==2)
  {
    xc=14;
  }
  if(p==1 || p==3)
  {
    xc=172;
  }
  mylcd.Set_Text_Mode(0);
  mylcd.Set_Text_Back_colour(BLACK);
  mylcd.Set_Text_colour(GREEN);
  if(voltage[p][c]> 3.600 || voltage[p][c] < 3.200) mylcd.Set_Text_colour(YELLOW);
  if(voltage[p][c]> 3.645 || voltage[p][c] < 3.150) mylcd.Set_Text_colour(ORANGE);
  if(voltage[p][c]< 2.900 || voltage[p][c] > 3.650) mylcd.Set_Text_colour(RED);
  if(voltage[p][c]<= 0.0001) mylcd.Set_Text_colour(GREY);

  if(p!=4) mylcd.Print_Number_Float(voltage[p][c], 3, xc,yc, '.', 0, ' ');
  if(p!=4) mylcd.Print_Number_Int(temperature[p][c], xc+96,yc,2, ' ', 10);
  
  if(c==7)
  {
    mylcd.Set_Text_Mode(0);
    mylcd.Set_Text_colour(WHITE);
    mylcd.Set_Text_Back_colour(RED);
    mylcd.Print_Number_Float(sum[p], 3, xc+48, yc+22, '.', 0, ' ');
    mylcd.Set_Text_Back_colour(BLACK);
  }
  if(c<NUMCELLS){c++;}
  if(c==NUMCELLS){p++;c=0;}
  if(p==NUMPACKS){p=0;}
  buzzer=LOW;
  return;
}
char tempconvert(char raw) // Convert the readings from the ADC to human readable
{
  //Fahrenheit this loop will calculate it live but the look up table saves clock cycles
  //Supports Rounding
  //if( (raw*1.555)-26.0 - (int) ((raw*1.555)-26.0) >= 0.5)
  //  return (int)((raw*1.555)-25.0);
  //else
  //  return (int)((raw*1.555)-26.0);
  short static const table[256] = 
                     {-26, -24,-23,-21,-20,-18,-17,-15,-14,-12,-10,-9,-7,-6,-4,-3,-1,
                      0,2,4,5,7,8,10,11,13,14,16,18,19,21,22,24,25,27,28,30,32,33,35,
                      36,38,39,41,42,44,46,47,49,50,52,53,55,56,58,60,61,63,64,66,67,
                      69,70,72,74,75,77,78,80,81,83,84,86,88,89,91,92,94,95,97,98,100,
                      102,103,105,106,108,109,111,112,114,116,117,119,120,122,123,125,
                      126,128,130,131,133,134,136,137,139,140,142,143,145,147,148,150,
                      151,153,154,156,157,159,161,162,164,165,167,168,170,171,173,175,
                      176,178,179,181,182,184,185,187,189,190,192,193,195,196,198,199,
                      201,203,204,206,207,209,210,212,213,215,217,218,220,221,223,224,
                      226,227,229,231,232,234,235,237,238,240,241,243,245,246,248,249,
                      251,252,254,255,257,259,260,262,263,265,266,268,269,271,273,274,
                      276,277,279,280,282,283,285,287,288,290,291,293,294,296,297,299,
                      301,302,304,305,307,308,310,311,313,315,316,318,319,321,322,324,
                      325,327,329,330,332,333,335,336,338,339,341,343,344,346,347,349,
                      350,352,353,355,357,358,360,361,363,364,366,367,369,371};
  return (int)table[raw]; 
}

void preTransmission() //Put RS485 into transmit mode by bringing the transmit and receive pins high
{
  digitalWrite(MAX485_RE, 1);
  digitalWrite(MAX485_DE, 1);
}

void postTransmission() //Put the RS485 into receive mode by bringing the transmit and receive pins low
{
  digitalWrite(MAX485_RE, 0);
  digitalWrite(MAX485_DE, 0);
}
void getControllerParams() // Hit the controller with a request for information
{
uint8_t result;

  // Read input registers from the controller starting at address 0x3100)
  node.clearResponseBuffer();
  result = node.readInputRegisters(0x3100, 5);

  if (result == node.ku8MBSuccess)
  {
    PANEL_VOLTS_READ = node.getResponseBuffer(PANEL_VOLTS); //Data slot 0
    PANEL_AMPS_READ = node.getResponseBuffer(PANEL_AMPS); //Data slot 1
    BATT_VOLTS_READ = node.getResponseBuffer(BATT_VOLTS); //Data slot 4 (2,3 skipped, not needed)
    Serial.print("Panel volts: ");
    Serial.println((float)PANEL_VOLTS_READ/100.00);
    Serial.print("Panel Amps: ");
    Serial.println((float)PANEL_AMPS_READ/100.00);
    Serial.print("Battery volts: ");
    Serial.println((float)BATT_VOLTS_READ/100.00);
    Serial.println();
  } 
  else { //If there's an error send it to the console
    Serial.print("Reading controller parameters failed, error:");
    Serial.println(result);
  }
  //delay(1000);

  // Read charging parameters from the controller starting at address 0x9000)
  node.clearResponseBuffer();
  result = node.readHoldingRegisters(0x9000, 15);

  if (result == node.ku8MBSuccess)
  {
    //Some values are not collected because we will always use the defaults
    OVERVOLT_DISC_READ = node.getResponseBuffer(OVERVOLT_DISC);
    CHARGING_LIMIT_READ = node.getResponseBuffer(CHARGING_LIMIT);
    OVERVOLT_RECON_READ = node.getResponseBuffer(OVERVOLT_RECON);
    EQUILIBRIUM_CV_READ = node.getResponseBuffer(EQUILIBRIUM_CV);
    BOOST_CV_READ = node.getResponseBuffer(BOOST_CV);
    FLOAT_CV_READ = node.getResponseBuffer(FLOAT_CV);
    BOOST_RECON_READ = node.getResponseBuffer(BOOST_RECON);
    LOW_VOLT_RECON_READ = node.getResponseBuffer(LOW_VOLT);
    UNDERVOLT_RECOVERY_READ = node.getResponseBuffer(UNDERVOLT_RECOV);
    UNDERVOLT_WARNING_READ = node.getResponseBuffer(UNDERVOLT_WARN);
    LOW_VOLT_DISC_READ = node.getResponseBuffer(LOW_VOLT_DISC);
    DISCHARGE_LIMIT_READ = node.getResponseBuffer(DISCHARGE_LIMIT);
    Serial.println("Parameters received successfully");
  } 
  else {
    Serial.print("The charging parameters failed to read, error: ");
    Serial.println(result);
  }

  //delay(2000);
}


void windDown() // Bring the controller charge voltage down so the hot cell will kalm
{
  OVERVOLT_DISC_SETTO = BATT_VOLTS_READ + 50;
  CHARGING_LIMIT_SETTO = BATT_VOLTS_READ - 20;
  OVERVOLT_RECON_SETTO = BATT_VOLTS_READ - 30;
  EQUILIBRIUM_CV_SETTO = BATT_VOLTS_READ - 30;
  BOOST_CV_SETTO = BATT_VOLTS_READ - 40;
  FLOAT_CV_SETTO = BATT_VOLTS_READ - 50;
  BOOST_RECON_SETTO = BATT_VOLTS_READ - 200;
  updateController();
  windDownFlag = HIGH;
  Serial.println("Wind down has been prepared for sending");
  //Insert a timer to wind up in 2 minutes
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
  Serial.println("Windup activated");
  getControllerParams();
  unsigned short difference = int((ALARM - hotCellVolt) * 100);
  unsigned short setvolt = BATT_VOLTS_READ + difference;
  if (difference > 10)
  {
    OVERVOLT_DISC_SETTO = (setvolt + 50);
    CHARGING_LIMIT_SETTO = setvolt;
    OVERVOLT_RECON_SETTO = setvolt - 10;
    EQUILIBRIUM_CV_SETTO = setvolt - 20;
    BOOST_CV_SETTO = setvolt - 30;
    FLOAT_CV_SETTO = setvolt - 40;
    BOOST_RECON_SETTO = setvolt - 100;
    Serial.println("Wind Up has been prepared for sending");
    updateController();
    windDownFlag = LOW;
  }
  
}
void dischargeProtect()
{
  
  getControllerParams();
  currentMillis = millis();
  if (((DISCHARGE_LIMIT_READ + 60) > BATT_VOLTS_READ) && (unsigned long)(currentMillis - dischargeProtect_etime) >= dischargeProtect_period)
  {
    UNDERVOLT_RECOVERY_SETTO = BATT_VOLTS_READ + 50;
    UNDERVOLT_WARNING_SETTO = BATT_VOLTS_READ + 30;
    LOW_VOLT_RECON_SETTO = BATT_VOLTS_READ + 20;
    LOW_VOLT_DISC_SETTO = BATT_VOLTS_READ - 20;
    DISCHARGE_LIMIT_SETTO = BATT_VOLTS_READ - 50;
    Serial.println("Overdischarge protection adjustment prepared");
    updateController();
    dischargeProtect_etime = currentMillis;
  }
}
void updateController() // Send new information to the controller. Something unusual discovered with the Epever AN controller is that it will not change 9003-9007 
{
  
  node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
  node.setTransmitBuffer(0, def_BATT_TYPE);
  node.setTransmitBuffer(1, def_BATT_AH);
  node.setTransmitBuffer(2, def_TEMP_COMP);
  node.setTransmitBuffer(3, OVERVOLT_DISC_SETTO);
  node.setTransmitBuffer(4, CHARGING_LIMIT_SETTO);
  node.setTransmitBuffer(5, OVERVOLT_RECON_SETTO);
  node.setTransmitBuffer(6, EQUILIBRIUM_CV_SETTO);
  node.setTransmitBuffer(7, BOOST_CV_SETTO);
  node.setTransmitBuffer(8, FLOAT_CV_SETTO);
  node.setTransmitBuffer(9, BOOST_RECON_SETTO);
  node.setTransmitBuffer(10, LOW_VOLT_RECON_SETTO);
  node.setTransmitBuffer(11, UNDERVOLT_RECOVERY_SETTO);
  node.setTransmitBuffer(12, UNDERVOLT_WARNING_SETTO);
  node.setTransmitBuffer(13, LOW_VOLT_DISC_SETTO);
  node.setTransmitBuffer(14, DISCHARGE_LIMIT_SETTO);
  
  int result = (node.writeMultipleRegisters(0x9000,15)); //Yeet this new info to the controller
  if (result == 0) //Verify
    Serial.print("Controller parameters 9000-900F changed sucessfully"); // For Diagnostic console
  else
  {
    Serial.print("Controller parameters 9000-900F change failed, error: ");
    Serial.println(result);
  }
}
void defaultController()
{
  node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
  node.setTransmitBuffer(0, def_BATT_TYPE);
  node.setTransmitBuffer(1, def_BATT_AH);
  node.setTransmitBuffer(2, def_TEMP_COMP);
  node.setTransmitBuffer(3, def_OVERVOLT_DISC_VAL);
  node.setTransmitBuffer(4, def_CHARGING_LIMIT_VAL);
  node.setTransmitBuffer(5, def_OVERVOLT_RECON_VAL);
  node.setTransmitBuffer(6, def_EQUILIBRIUM_CV_VAL);
  node.setTransmitBuffer(7, def_BOOST_CV_VAL);
  node.setTransmitBuffer(8, def_FLOAT_CV_VAL);
  node.setTransmitBuffer(9, def_BOOST_RECON_VAL);
  node.setTransmitBuffer(10, def_LOW_VOLT_RECON);
  node.setTransmitBuffer(11, def_UNDERVOLT_RECOV);
  node.setTransmitBuffer(12, def_UNDERVOLT_WARNING);
  node.setTransmitBuffer(13, def_LOW_VOLT_DISC);
  node.setTransmitBuffer(14, def_DISCHARGE_LIMIT);
  
  int result = (node.writeMultipleRegisters(0x9000,15)); //Yeet this new info to the controller
  if (result == 0) //Verify
    Serial.print("Controller parameters 9000-900F have been set to default"); // For Diagnostic console
  else
  {
    Serial.print("Controller parameters 9000-900F default failed, error: ");
    Serial.println(result);
  }
}
</syntaxhighlight>