Public Wiki - User contributions [en]

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2021-02-19T04:49:14Z

Falgsc-al: /* Code */ BMS units changed due to suspected failure.

==Synopsis==
==Notes==

This version trimmed off several bytes of RAM and provides additional speedup (approx 1ms per update)
Fixed voltage sum bug.
[[LCDWIKI Libraries]]

==Code==
<syntaxhighlight lang="C++" line='line'>

#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library

//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.660 //Alarm threshold
//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

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0001 1000 0110 0011 = 0x01863

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

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

float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000018, 0x00000020, 0x00000006, 0x00000012};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;
bool msg5 = LOW;

//unsigned char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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

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

//Graphics
mylcd.Init_LCD();
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!");

}

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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
sum[i]=0.0;
for(int j=0;j<NUMCELLS;j++)
{
sum[i] += voltage[i][j];
if(voltage[i][j]>=ALARM) buzzer=HIGH;
}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;

//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

mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);

mylcd.Set_Text_Size(2);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x18 (-) 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 (-) x12 (-)", 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+60, 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)
{
//Fahrenheit
//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];
}
</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-10T21:55:57Z

Falgsc-al: /* Code */ Default mode created by shorting pin 22 to ground during boot, bug fixes

==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>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-10T20:27:39Z

Falgsc-al:

==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 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;

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);
getControllerParams();

}

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)
{
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+60, 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);
}
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
{
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 + 50) < 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);
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-10T20:22:35Z

Falgsc-al: /* Code */ Epever integration has not been tested yet

==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 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;

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);
getControllerParams();

}

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)
{
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+60, 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);
}
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
{
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_SETTO + 50) > 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);
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-10T04:40:19Z

Falgsc-al: /* Code */ Values can be read from controller but not yet written properly

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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 windUpDelay 300000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle
#define windUpThreshold 3.550 //WindUp function will not call again until a cell reaches this voltage

//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;

//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;

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

//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;

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);
getControllerParams();

}

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 = 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];
if(hotCellVolt >= ALARM)
{
buzzer=HIGH;
}

}

}

//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+60, 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 8 registers starting at 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 15 registers starting at 0x9000)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9000, 15);

if (result == node.ku8MBSuccess)
{
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);
}
else {
Serial.print("The charging parameters failed to read, error: ");
Serial.println(result);
}

//delay(2000);
}

void windDown() // Quickly bring the controller charge voltage down so the hot cell will kalm
{
getControllerParams();
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("The controller is in wind down, settings will be readjusted in 5 minutes");
//Insert a timer to wind up in 2 minutes
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
getControllerParams();
unsigned short difference = int((ALARM - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
windDownFlag = LOW;
Serial.println("The controller has been adjusted up");
}
void updateController() // Send new information to the controller
{

node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);

int result = (node.writeMultipleRegisters(0x9003,7)); //Yeet this new info to the controller
if (result == 0) //Verify
Serial.print("Controller parameters changed sucessfully"); // For Diagnostic console
else
{
Serial.print("Controller parameter change failed, error: ");
Serial.println(result);
Serial.print("OVERVOLT_DISC_SETTO=");
Serial.println(OVERVOLT_DISC_SETTO,HEX);
Serial.print("CHARGING_LIMIT_SETTO=");
Serial.println(CHARGING_LIMIT_SETTO,HEX);
Serial.print("OVERVOLT_RECON_SETTO=");
Serial.println(OVERVOLT_RECON_SETTO,HEX);
Serial.print("EQUILIBRIUM_CV_SETTO=");
Serial.println(EQUILIBRIUM_CV_SETTO,HEX);
Serial.print("BOOST_CV_SETTO=");
Serial.println(BOOST_CV_SETTO,HEX);
Serial.print("FLOAT_CV_SETTO=");
Serial.println(FLOAT_CV_SETTO,HEX);
Serial.print("BOOST_RECON_SETTO=");
Serial.println(BOOST_RECON_SETTO,HEX);

}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T20:14:53Z

Falgsc-al: /* Code */ New timer method implemented which should be failsafe

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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 windUpDelay 300000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle
#define windUpThreshold 3.550 //WindUp function will not call again until a cell reaches this voltage

//Define the default values for your pack here, value *100, no decimal
#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 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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

//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 = HIGH;
#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;
unsigned short hotCellVolt = 0;

//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_CURRENT;
unsigned short CHARGING_LIMIT_CURRENT;
unsigned short OVERVOLT_RECON_CURRENT;
unsigned short EQUILIBRIUM_CV_CURRENT;
unsigned short BOOST_CV_CURRENT;
unsigned short FLOAT_CV_CURRENT;
unsigned short BOOST_RECON_CURRENT;
bool is_Controller_default;

//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;

//Variables for working with the controller
bool windDownFlag = LOW;
//unsigned char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=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;

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

//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;

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

//Graphics
mylcd.Init_LCD();
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);
getControllerParams();

}

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 = 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];
if(voltage[i][j]>=ALARM)
{
buzzer=HIGH;
}
}
}

//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
} else digitalWrite(49,0);
if (windDownFlag && ((unsigned long)(currentMillis - windDown_etime) >= windDown_period))
windUp();
if ((PANEL_VOLTS_READ >= dayLightVolt) && (PANEL_AMPS_READ <= 1) && (hotCellVolt <= windUpThreshold) && ((unsigned long)(currentMillis - windUp_etime) >= windUp_period)) //Keep tweaking the controller to max
windUp();

//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+60, 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 8 registers starting at 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)
}
else { //If there's an error send it to the console
Serial.print("Reading controller parameters failed, error:");
Serial.println(result);
}
//delay(1000);

// Read 7 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
OVERVOLT_DISC_CURRENT = node.getResponseBuffer(OVERVOLT_DISC);
CHARGING_LIMIT_CURRENT = node.getResponseBuffer(CHARGING_LIMIT);
OVERVOLT_RECON_CURRENT = node.getResponseBuffer(OVERVOLT_RECON);
EQUILIBRIUM_CV_CURRENT = node.getResponseBuffer(EQUILIBRIUM_CV);
BOOST_CV_CURRENT = node.getResponseBuffer(BOOST_CV);
FLOAT_CV_CURRENT = node.getResponseBuffer(FLOAT_CV);
BOOST_RECON_CURRENT = node.getResponseBuffer(BOOST_RECON);
}
else {
Serial.print("The charging parameters failed to read, error: ");
Serial.println(result);
}

//delay(2000);
}

void windDown() // Quickly bring the controller charge voltage down so the hot cell will kalm
{
getControllerParams();
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("The controller is in wind down, settings will be readjusted in 5 minutes");
//Insert a timer to wind up in 2 minutes
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
getControllerParams();
unsigned short difference = int((ALARM - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
windDownFlag = LOW;
Serial.println("The controller has been adjusted up");
}
void updateController() // Send new information to the controller
{
node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);
int result = (node.writeMultipleRegisters(9003,7)); //Yeet this new info to the controller
if (result == 0) //Verify
Serial.print("Controller parameters changed sucessfully"); // For Diagnostic console
else
{
Serial.print("Controller parameter change failed, error: ");
Serial.println(result);
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T18:50:13Z

Falgsc-al: /* Code */ Last edit did not paste properly

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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 windUpDelay 300000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle
#define windUpThreshold 3.550 //WindUp function will not call again until a cell reaches this voltage

//Define the default values for your pack here, value *100, no decimal
#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 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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

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;
unsigned short hotCellVolt = 0;

//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_CURRENT;
unsigned short CHARGING_LIMIT_CURRENT;
unsigned short OVERVOLT_RECON_CURRENT;
unsigned short EQUILIBRIUM_CV_CURRENT;
unsigned short BOOST_CV_CURRENT;
unsigned short FLOAT_CV_CURRENT;
unsigned short BOOST_RECON_CURRENT;
bool is_Controller_default;

//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;

//Variables for working with the controller
bool windDownFlag = LOW;
//unsigned char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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;

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

//Graphics
mylcd.Init_LCD();
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);
getControllerParams();

}

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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
hotCellVolt = 0;
for(int i=0; i<NUMPACKS;i++)
{
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];
if(voltage[i][j]>=ALARM)
{
buzzer=HIGH;
}
}
}

//Execute alarm condition
if(buzzer)
{
digitalWrite(49,1);
windDown(); // This loop should only be executed once and then skipped for at least 1 minute
}

else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;;
if (windDownFlag /*&& 5 minutes have passed*/)
windUp();
if ((PANEL_VOLTS_READ >= dayLightVolt) && (PANEL_AMPS_READ == 0) && (hotCellVolt <= windUpThreshold) /*&& (timer > 1 hour from windup)*/) //Keep tweaking the controller to max
windUp();

//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+60, 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 8 registers starting at 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)
}
else { //If there's an error send it to the console
Serial.print("Reading controller parameters failed, error:");
Serial.println(result);
}
//delay(1000);

// Read 7 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
OVERVOLT_DISC_CURRENT = node.getResponseBuffer(OVERVOLT_DISC);
CHARGING_LIMIT_CURRENT = node.getResponseBuffer(CHARGING_LIMIT);
OVERVOLT_RECON_CURRENT = node.getResponseBuffer(OVERVOLT_RECON);
EQUILIBRIUM_CV_CURRENT = node.getResponseBuffer(EQUILIBRIUM_CV);
BOOST_CV_CURRENT = node.getResponseBuffer(BOOST_CV);
FLOAT_CV_CURRENT = node.getResponseBuffer(FLOAT_CV);
BOOST_RECON_CURRENT = node.getResponseBuffer(BOOST_RECON);
}
else {
Serial.print("The charging parameters failed to read, error: ");
Serial.println(result);
}

//delay(2000);
}

void windDown() // Quickly bring the controller charge voltage down so the hot cell will kalm
{
getControllerParams();
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("The controller is in wind down, settings will be readjusted in 5 minutes");
//Insert a timer to wind up in 2 minutes
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
getControllerParams();
unsigned short difference = int((ALARM - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
windDownFlag = LOW;
Serial.println("The controller has been adjusted up");
}
void updateController() // Send new information to the controller
{
node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);
int result = (node.writeMultipleRegisters(9003,7)); //Yeet this new info to the controller
if (result == 0) //Verify
Serial.print("Controller parameters changed sucessfully"); // For Diagnostic console
else
{
Serial.print("Controller parameter change failed, error: ");
Serial.println(result);
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T18:43:48Z

Falgsc-al: /* Code */

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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 windUpDelay 300000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle
#define windUpThreshold 3.550 //WindUp function will not call again until a cell reaches this voltage

//Define the default values for your pack here, value *100, no decimal
#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 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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

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;
unsigned short hotCellVolt = 0;

//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_CURRENT;
unsigned short CHARGING_LIMIT_CURRENT;
unsigned short OVERVOLT_RECON_CURRENT;
unsigned short EQUILIBRIUM_CV_CURRENT;
unsigned short BOOST_CV_CURRENT;
unsigned short FLOAT_CV_CURRENT;
unsigned short BOOST_RECON_CURRENT;
bool is_Controller_default;

//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;

//Variables for working with the controller
bool windDownFlag = LOW;
//unsigned char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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;

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

//Graphics
mylcd.Init_LCD();
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);
getControllerParams();

}

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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
hotCellVolt = 0;
for(int i=0; i<NUMPACKS;i++)
{
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];
if(voltage[i][j]>=ALARM)
{
buzzer=HIGH;
}
}
}

//Execute alarm condition
if(buzzer)
{
digitalWrite(49,1);
windDown(); // This loop should only be executed once and then skipped for at least 1 minute
}

else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;;
if (windDownFlag /*&& 5 minutes have passed*/)
windUp();
if ((PANEL_VOLTS_READ >= dayLightVolt) && (PANEL_AMPS_READ == 0) && (hotCellVolt <= windUpThreshold) /*&& (timer > 1 hour from windup)*/) //Keep tweaking the controller to max
windUp();

//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+60, 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 8 registers starting at 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)
}
else { //If there's an error send it to the console
Serial.print("Reading controller parameters failed, error:");
Serial.println(result);
}
//delay(1000);

// Read 7 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
OVERVOLT_DISC_CURRENT = node.getResponseBuffer(OVERVOLT_DISC);
CHARGING_LIMIT_CURRENT = node.getResponseBuffer(CHARGING_LIMIT);
OVERVOLT_RECON_CURRENT = node.getResponseBuffer(OVERVOLT_RECON);
EQUILIBRIUM_CV_CURRENT = node.getResponseBuffer(EQUILIBRIUM_CV);
BOOST_CV_CURRENT = node.getResponseBuffer(BOOST_CV);
FLOAT_CV_CURRENT = node.getResponseBuffer(FLOAT_CV);
BOOST_RECON_CURRENT = node.getResponseBuffer(BOOST_RECON);
}
else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}

//delay(2000);
}

void windDown() // Quickly bring the controller charge voltage down so the hot cell will kalm
{
getControllerParams();
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("The controller is in wind down, settings will be readjusted in 5 minutes");
//Insert a timer to wind up in 2 minutes
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
getControllerParams();
unsigned short difference = int((ALARM - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
windDownFlag = LOW;
Serial.println("The controller has been adjusted up");
}
void updateController() // Send new information to the controller
{
node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);
int result = (node.writeMultipleRegisters(9003,7)); //Yeet this new info to the controller
if (result == 0) //Verify
Serial.print("Controller parameters changed sucessfully"); // For Diagnostic console
else
{
Serial.print("Controller parameter change failed, error: ");
Serial.println(result);
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T17:39:10Z

Falgsc-al: /* Code */

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
#define ARDUINO_MEGA2560
//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 windUpDelay 300000 //Delay before controller attempts to increase the charge voltage, giving cells time to settle

//Define the default values for your pack here, value *100, no decimal
#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 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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

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;
unsigned short hotCellVolt = 0;

//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_CURRENT;
unsigned short CHARGING_LIMIT_CURRENT;
unsigned short OVERVOLT_RECON_CURRENT;
unsigned short EQUILIBRIUM_CV_CURRENT;
unsigned short BOOST_CV_CURRENT;
unsigned short FLOAT_CV_CURRENT;
unsigned short BOOST_RECON_CURRENT;
bool is_Controller_default;

//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 char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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;

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

//Graphics
mylcd.Init_LCD();
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);

}

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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
hotCellVolt = 0;
for(int i=0; i<NUMPACKS;i++)
{
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];
if(voltage[i][j]>=ALARM)
{
buzzer=HIGH;
}
}
}

//Execute alarm condition
if(buzzer)
{
digitalWrite(49,1);
windDown();
}

else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;

//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+60, 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 8 registers starting at 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)
}
else { //If there's an error send it to the console
Serial.print("Miss read, ret val:");
Serial.println(result);
}
//delay(1000);

// Read 7 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
OVERVOLT_DISC_CURRENT = node.getResponseBuffer(OVERVOLT_DISC);
CHARGING_LIMIT_CURRENT = node.getResponseBuffer(CHARGING_LIMIT);
OVERVOLT_RECON_CURRENT = node.getResponseBuffer(OVERVOLT_RECON);
EQUILIBRIUM_CV_CURRENT = node.getResponseBuffer(EQUILIBRIUM_CV);
BOOST_CV_CURRENT = node.getResponseBuffer(BOOST_CV);
FLOAT_CV_CURRENT = node.getResponseBuffer(FLOAT_CV);
BOOST_RECON_CURRENT = node.getResponseBuffer(BOOST_RECON);
}
else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}

//delay(2000);
}

void windDown() // Quickly bring the controller charge voltage down so the hot cell will kalm
{
getControllerParams();
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();
}
void windUp() // Bring the controller charge voltage as close to max as possible
{
getControllerParams();
unsigned short difference = int((ALARM - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
}
void updateController() // Send new information to the controller
{
node.clearTransmitBuffer(); //Prepare the buffer with new data, clear and fill
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);
unsigned short result = (node.writeMultipleRegisters(9003,7)); //Yeet!
if (result == 0) //Verify
Serial.print("Controller parameters changed sucessfully");
else
{
Serial.print("Controller parameter change failed, error: ");
Serial.println(result);;
}
}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T05:00:56Z

Falgsc-al: MODBUS integration partially done but not tested and not yet commented.

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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 the default values for your pack here, value *100, no decimal
#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 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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

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;
unsigned short hotCellVolt = 0;

//Variables for holding the solar controller's set values
unsigned short OVERVOLT_DISC_CURRENT;
unsigned short CHARGING_LIMIT_CURRENT;
unsigned short OVERVOLT_RECON_CURRENT;
unsigned short EQUILIBRIUM_CV_CURRENT;
unsigned short BOOST_CV_CURRENT;
unsigned short FLOAT_CV_CURRENT;
unsigned short BOOST_RECON_CURRENT;
bool is_Controller_default;

//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 char bufA[10];
//unsigned char buf0[10];
//unsigned char buf3[10];
//unsigned char buf5[10];
//unsigned char buf20[10];
//unsigned char buf21[10];
//unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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;

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

//Graphics
mylcd.Init_LCD();
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);

}

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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
hotCellVolt = 0;
for(int i=0; i<NUMPACKS;i++)
{
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];
if(voltage[i][j]>=ALARM)
{
buzzer=HIGH;
}
}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;

//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

mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);

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+60, 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)
{
//Fahrenheit
//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()
{
digitalWrite(MAX485_RE, 1);
digitalWrite(MAX485_DE, 1);
}

void postTransmission()
{
digitalWrite(MAX485_RE, 0);
digitalWrite(MAX485_DE, 0);
}
void getControllerParams()
{
uint8_t result;

// Read 8 registers starting at 0x3100)
node.clearResponseBuffer();
result = node.readInputRegisters(0x3100, 5);

if (result == node.ku8MBSuccess)
{
PANEL_VOLTS_READ = node.getResponseBuffer(PANEL_VOLTS);
PANEL_AMPS_READ = node.getResponseBuffer(PANEL_AMPS);
BATT_VOLTS_READ = node.getResponseBuffer(BATT_VOLTS);
}
else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}
//delay(1000);

// Read 7 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
OVERVOLT_DISC_CURRENT = node.getResponseBuffer(OVERVOLT_DISC);
CHARGING_LIMIT_CURRENT = node.getResponseBuffer(CHARGING_LIMIT);
OVERVOLT_RECON_CURRENT = node.getResponseBuffer(OVERVOLT_RECON);
EQUILIBRIUM_CV_CURRENT = node.getResponseBuffer(EQUILIBRIUM_CV);
BOOST_CV_CURRENT = node.getResponseBuffer(BOOST_CV);
FLOAT_CV_CURRENT = node.getResponseBuffer(FLOAT_CV);
BOOST_RECON_CURRENT = node.getResponseBuffer(BOOST_RECON);
}
else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}

//delay(2000);
}

void windDown()
{
getControllerParams();
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();
}
void windUp()
{
getControllerParams();
unsigned short difference = int((3.65 - hotCellVolt) * 100);
unsigned short setvolt = BATT_VOLTS_READ + difference;
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 - 200;
updateController();
}
void updateController()
{
node.clearTransmitBuffer();
node.setTransmitBuffer(0, OVERVOLT_DISC_SETTO);
node.setTransmitBuffer(1, CHARGING_LIMIT_SETTO);
node.setTransmitBuffer(2, OVERVOLT_RECON_SETTO);
node.setTransmitBuffer(3, EQUILIBRIUM_CV_SETTO);
node.setTransmitBuffer(4, BOOST_CV_SETTO);
node.setTransmitBuffer(5, FLOAT_CV_SETTO);
node.setTransmitBuffer(6, BOOST_RECON_SETTO);
node.writeMultipleRegisters(9003,7);

}

</syntaxhighlight>

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T01:55:05Z

Falgsc-al: Added stored variables from controller registers

Arduino Projects

2020-12-09T01:41:06Z

Falgsc-al:

[[CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560]]

[[CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560]]

[[EPEVER Solar Controller RS485 MODBUS test]]

[[Can bus battery monitor with OLED]]

[[Can bus battery monitor]]

[[OLED Display]]

[[OLED Display SSD1306 i2c 128x64 demo]]

[[LCD demo]]

[[RS485 Master Example]]

[[EPEVER 485]]

[[Vector Clock]]

[[DS1302 RTC Test]]

[[QR Code generation with 3.5" TFT Touch screen on Arudino MEGA2560]]

File:Mcp2515 lib.tar.gz

2020-12-09T01:40:40Z

Falgsc-al: MCP2515 library used in BYD BMS project

== Summary ==
MCP2515 library used in BYD BMS project

Arduino Projects

2020-12-09T01:37:45Z

Falgsc-al:

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T01:04:21Z

Falgsc-al: Added preTransmission and postTransmission loops

CAN Battery Monitor with Epever Controller Integration + 3.5TFT Mega2560

2020-12-09T00:57:24Z

Falgsc-al: First upload

Arduino Projects

2020-12-09T00:56:23Z

Falgsc-al: Added new section for Epever integration

EPEVER Solar Controller RS485 MODBUS test

2020-12-08T23:55:02Z

Falgsc-al: First Upload

==Synopsis==
==Notes==

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

==Code==
<syntaxhighlight lang="C++" line='line'>
//Power is not currently working for battery or panel

#include <ModbusMaster.h>

#define MAX485_DE 49
#define MAX485_RE 48

#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 0x00
#define CHARGING_LIMIT 0x01
#define OVERVOLT_RECON 0x02
#define EQUILIBRIUM_CV 0x03
#define BOOST_CV 0x04
#define FLOAT_CV 0x05
#define BOOST_RECON 0x06

// instantiate ModbusMaster object
ModbusMaster node;

//#include <SoftwareSerial.h>

//SoftwareSerial mySerial(10, 11); // RX, TX

void setup()
{
Serial.begin(115200);
while (!Serial) {
;
}
Serial.println("Moooooo!");

pinMode(MAX485_RE, OUTPUT);
pinMode(MAX485_DE, OUTPUT);
// Init in receive mode
digitalWrite(MAX485_RE, 0);
digitalWrite(MAX485_DE, 0);

// Modbus at 115200 baud
Serial1.begin(115200);

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

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

void loop()
{
uint8_t result;

// Read 8 registers starting at 0x3100)
node.clearResponseBuffer();
result = node.readInputRegisters(0x3100, 8);

if (result == node.ku8MBSuccess)
{
Serial.print("VPanel: ");
Serial.println(node.getResponseBuffer(PANEL_VOLTS)/100.0f);
Serial.print("IPanel: ");
Serial.println(node.getResponseBuffer(PANEL_AMPS)/100.0f);
Serial.print("PPanel: ");
Serial.println((node.getResponseBuffer(PANEL_POWER_L) +
node.getResponseBuffer(PANEL_POWER_H) << 16)/100.0f);

Serial.print("VBatt: ");
Serial.println(node.getResponseBuffer(BATT_VOLTS)/100.0f);
Serial.print("Ibatt: ");
Serial.println(node.getResponseBuffer(BATT_AMPS)/100.0f);
Serial.print("PBatt: ");
Serial.println((node.getResponseBuffer(BATT_POWER_L) +
node.getResponseBuffer(BATT_POWER_H) << 16)/100.0f);
Serial.println();
Serial.println();
} else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}
//delay(1000);

// Read 6 registers starting at 0x9003)
node.clearResponseBuffer();
result = node.readHoldingRegisters(0x9003, 7);

if (result == node.ku8MBSuccess)
{
Serial.print("Overvolt Disconnect Voltage: ");
Serial.println(node.getResponseBuffer(OVERVOLT_DISC)/100.0f);
Serial.print("Charging Limit Voltage: ");
Serial.println(node.getResponseBuffer(CHARGING_LIMIT)/100.0f);
Serial.print("Overvolt Disconnect Voltage: ");
Serial.println(node.getResponseBuffer(OVERVOLT_DISC)/100.0f);
Serial.print("Overvolt Reconnect Voltage: ");
Serial.println(node.getResponseBuffer(OVERVOLT_RECON)/100.0f);
Serial.print("Equilibrium Charge Voltage: ");
Serial.println(node.getResponseBuffer(EQUILIBRIUM_CV)/100.0f);
Serial.print("Boost Charging Voltage: ");
Serial.println(node.getResponseBuffer(BOOST_CV)/100.0f);
Serial.print("Float Charging Voltage: ");
Serial.println(node.getResponseBuffer(FLOAT_CV)/100.0f);
Serial.print("Boost Reconnect Voltage: ");
Serial.println(node.getResponseBuffer(BOOST_RECON)/100.0f);

Serial.println();
Serial.println();
} else {
Serial.print("Miss read, ret val:");
Serial.println(result);
}

delay(2000);
}

void preTransmission()
{
digitalWrite(MAX485_RE, 1);
digitalWrite(MAX485_DE, 1);
}

void postTransmission()
{
digitalWrite(MAX485_RE, 0);
digitalWrite(MAX485_DE, 0);
}

</syntaxhighlight>

Arduino Projects

2020-12-08T23:52:28Z

Falgsc-al: Re-arrange and add Epever RS485 test

[[CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560]]

[[EPEVER Solar Controller RS485 MODBUS test]]

[[Can bus battery monitor with OLED]]

[[Can bus battery monitor]]

[[OLED Display]]

[[OLED Display SSD1306 i2c 128x64 demo]]

[[LCD demo]]

[[RS485 Master Example]]

[[EPEVER 485]]

[[Vector Clock]]

[[DS1302 RTC Test]]

[[QR Code generation with 3.5" TFT Touch screen on Arudino MEGA2560]]

EPEVER 485

2020-11-19T06:05:40Z

Falgsc-al:

==Synopsis==
Issues 485 request and display result
==Notes==
===9000-9100 Registers===

0xFFFF9000 : 0x00
0xFFFF9001 : 0x70
0xFFFF9002 : 0x00
0xFFFF9003 : 0x86
0xFFFF9004 : 0x68
0xFFFF9005 : 0x5E
0xFFFF9006 : 0x54
0xFFFF9007 : 0x54
0xFFFF9008 : 0xC8
0xFFFF9009 : 0x50
0xFFFF900A : 0x00
0xFFFF900B : 0x00
0xFFFF900C : 0x60
0xFFFF900D : 0xAC
0xFFFF900E : 0x48
0xFFFF900F : 0x00
0xFFFF9010 : 0x64
0xFFFF9011 : 0x00
0xFFFF9012 : Error 0x02
0xFFFF9013 : 0x27
0xFFFF9014 : 0x15
0xFFFF9015 : 0x0B
0xFFFF9016 : 0x1E
0xFFFF9017 : 0x4C
0xFFFF9018 : 0x00
0xFFFF9019 : 0x1C
0xFFFF901A : 0x40
0xFFFF901B : 0x34
0xFFFF901C : 0x4C
0xFFFF901D : 0x02
0xFFFF901E : 0xE8
0xFFFF901F : 0x0A
0xFFFF9020 : 0xB0
0xFFFF9021 : 0x0A
0xFFFF9022 : Error 0x02
0xFFFF9023 : Error 0x02
0xFFFF9024 : Error 0x02
0xFFFF9025 : Error 0x02
0xFFFF9026 : Error 0x02
0xFFFF9027 : Error 0x02
0xFFFF9028 : Error 0x02
0xFFFF9029 : Error 0x02
0xFFFF902A : Error 0x02
0xFFFF902B : Error 0x02
0xFFFF902C : Error 0x02
0xFFFF902D : Error 0x02
0xFFFF902E : Error 0x02
0xFFFF902F : Error 0x02
0xFFFF9030 : Error 0x02
0xFFFF9031 : Error 0x02
0xFFFF9032 : Error 0x02
0xFFFF9033 : Error 0x02
0xFFFF9034 : Error 0x02
0xFFFF9035 : Error 0x02
0xFFFF9036 : Error 0x02
0xFFFF9037 : Error 0x02
0xFFFF9038 : Error 0x02
0xFFFF9039 : Error 0x02
0xFFFF903A : Error 0x02
0xFFFF903B : Error 0x02
0xFFFF903C : Error 0x02
0xFFFF903D : 0x00
0xFFFF903E : 0x00
0xFFFF903F : 0x00
0xFFFF9040 : Error 0x02
0xFFFF9041 : Error 0x02
0xFFFF9042 : 0x00
0xFFFF9043 : 0x00
0xFFFF9044 : 0x13
0xFFFF9045 : 0x00
0xFFFF9046 : 0x00
0xFFFF9047 : 0x06
0xFFFF9048 : 0x00
0xFFFF9049 : 0x00
0xFFFF904A : 0x13
0xFFFF904B : 0x00
0xFFFF904C : 0x00
0xFFFF904D : 0x06
0xFFFF904E : Error 0x02
0xFFFF904F : Error 0x02
0xFFFF9050 : Error 0x02
0xFFFF9051 : Error 0x02
0xFFFF9052 : Error 0x02
0xFFFF9053 : Error 0x02
0xFFFF9054 : Error 0x02
0xFFFF9055 : Error 0x02
0xFFFF9056 : Error 0x02
0xFFFF9057 : Error 0x02
0xFFFF9058 : Error 0x02
0xFFFF9059 : Error 0x02
0xFFFF905A : Error 0x02
0xFFFF905B : Error 0x02
0xFFFF905C : Error 0x02
0xFFFF905D : Error 0x02
0xFFFF905E : Error 0x02
0xFFFF905F : Error 0x02
0xFFFF9060 : Error 0x02
0xFFFF9061 : Error 0x02
0xFFFF9062 : Error 0x02
0xFFFF9063 : 0x1E
0xFFFF9064 : 0x02
0xFFFF9065 : 0x00
0xFFFF9066 : Error 0x02
0xFFFF9067 : 0x02
0xFFFF9068 : Error 0x02
0xFFFF9069 : 0x00
0xFFFF906A : 0x00
0xFFFF906B : 0x78
0xFFFF906C : 0x50
0xFFFF906D : 0x1E
0xFFFF906E : 0x50
0xFFFF906F : 0x28
0xFFFF9070 : 0x00
0xFFFF9071 : Error 0x02
0xFFFF9072 : Error 0x02
0xFFFF9073 : Error 0x02
0xFFFF9074 : Error 0x02
0xFFFF9075 : Error 0x02
0xFFFF9076 : Error 0x02
0xFFFF9077 : Error 0x02
0xFFFF9078 : Error 0x02
0xFFFF9079 : Error 0x02
0xFFFF907A : Error 0x02
0xFFFF907B : Error 0x02
0xFFFF907C : Error 0x02
0xFFFF907D : Error 0x02
0xFFFF907E : Error 0x02
0xFFFF907F : Error 0x02
0xFFFF9080 : Error 0x02
0xFFFF9081 : Error 0x02
0xFFFF9082 : Error 0x02
0xFFFF9083 : Error 0x02
0xFFFF9084 : Error 0x02
0xFFFF9085 : Error 0x02
0xFFFF9086 : Error 0x02
0xFFFF9087 : Error 0x02
0xFFFF9088 : Error 0x02
0xFFFF9089 : Error 0x02
0xFFFF908A : Error 0x02
0xFFFF908B : Error 0x02
0xFFFF908C : Error 0x02
0xFFFF908D : Error 0x02
0xFFFF908E : Error 0x02
0xFFFF908F : Error 0x02
0xFFFF9090 : 0x00
0xFFFF9091 : 0x00
0xFFFF9092 : 0x00
0xFFFF9093 : 0x00
0xFFFF9094 : 0x57
0xFFFF9095 : 0x00
0xFFFF9096 : 0x00
0xFFFF9097 : 0x38
0xFFFF9098 : 0xEE
0xFFFF9099 : Error 0x02
0xFFFF909A : Error 0x02
0xFFFF909B : Error 0x02
0xFFFF909C : Error 0x02
0xFFFF909D : Error 0x02
0xFFFF909E : Error 0x02
0xFFFF909F : Error 0x02
0xFFFF90A0 : 0x00
0xFFFF90A1 : 0x00
0xFFFF90A2 : 0x00
0xFFFF90A3 : 0x00
0xFFFF90A4 : 0x00
0xFFFF90A5 : Error 0x02
0xFFFF90A6 : Error 0x02
0xFFFF90A7 : Error 0x02
0xFFFF90A8 : Error 0x02
0xFFFF90A9 : Error 0x02
0xFFFF90AA : Error 0x02
0xFFFF90AB : Error 0x02
0xFFFF90AC : Error 0x02
0xFFFF90AD : Error 0x02
0xFFFF90AE : Error 0x02
0xFFFF90AF : Error 0x02
0xFFFF90B0 : 0xD2
0xFFFF90B1 : 0x60
0xFFFF90B2 : 0x13
0xFFFF90B3 : 0x7A
0xFFFF90B4 : 0x00
0xFFFF90B5 : 0xA7
0xFFFF90B6 : 0x89
0xFFFF90B7 : 0x35
0xFFFF90B8 : 0x75
0xFFFF90B9 : 0x87
0xFFFF90BA : 0x00
0xFFFF90BB : 0x00
0xFFFF90BC : Error 0x02
0xFFFF90BD : 0x00
0xFFFF90BE : 0x00
0xFFFF90BF : 0xE0
0xFFFF90C0 : Error 0x02
0xFFFF90C1 : Error 0x02
0xFFFF90C2 : Error 0x02
0xFFFF90C3 : Error 0x02
0xFFFF90C4 : Error 0x02
0xFFFF90C5 : Error 0x02
0xFFFF90C6 : Error 0x02
0xFFFF90C7 : Error 0x02
0xFFFF90C8 : Error 0x02
0xFFFF90C9 : Error 0x02
0xFFFF90CA : Error 0x02
0xFFFF90CB : Error 0x02
0xFFFF90CC : Error 0x02
0xFFFF90CD : Error 0x02
0xFFFF90CE : Error 0x02
0xFFFF90CF : Error 0x02
0xFFFF90D0 : Error 0x02
0xFFFF90D1 : Error 0x02
0xFFFF90D2 : Error 0x02
0xFFFF90D3 : Error 0x02
0xFFFF90D4 : Error 0x02
0xFFFF90D5 : Error 0x02
0xFFFF90D6 : Error 0x02
0xFFFF90D7 : Error 0x02
0xFFFF90D8 : Error 0x02
0xFFFF90D9 : Error 0x02
0xFFFF90DA : Error 0x02
0xFFFF90DB : Error 0x02
0xFFFF90DC : Error 0x02
0xFFFF90DD : Error 0x02
0xFFFF90DE : Error 0x02
0xFFFF90DF : Error 0x02
0xFFFF90E0 : Error 0x02
0xFFFF90E1 : Error 0x02
0xFFFF90E2 : Error 0x02
0xFFFF90E3 : Error 0x02
0xFFFF90E4 : Error 0x02
0xFFFF90E5 : Error 0x02
0xFFFF90E6 : Error 0x02
0xFFFF90E7 : Error 0x02
0xFFFF90E8 : Error 0x02
0xFFFF90E9 : Error 0x02
0xFFFF90EA : Error 0x02
0xFFFF90EB : Error 0x02
0xFFFF90EC : Error 0x02
0xFFFF90ED : Error 0x02
0xFFFF90EE : Error 0x02
0xFFFF90EF : Error 0x02
0xFFFF90F0 : Error 0x02
0xFFFF90F1 : Error 0x02
0xFFFF90F2 : Error 0x02
0xFFFF90F3 : Error 0x02
0xFFFF90F4 : Error 0x02
0xFFFF90F5 : Error 0x02
0xFFFF90F6 : Error 0x02
0xFFFF90F7 : Error 0x02
0xFFFF90F8 : Error 0x02
0xFFFF90F9 : Error 0x02
0xFFFF90FA : Error 0x02
0xFFFF90FB : Error 0x02
0xFFFF90FC : Error 0x02
0xFFFF90FD : Error 0x02
0xFFFF90FE : Error 0x02
0xFFFF90FF : Error 0x02

==Code==
<syntaxhighlight lang="C++" line='line'>

//#include <SoftwareSerial.h>
//const int SSERIAL_RX_PIN = 10; //Soft Serial Receive pin
//const int SSERIAL_TX_PIN = 11; //Soft Serial Transmit pin

// Create Soft Serial Port object and define pins to use
//SoftwareSerial RS485Serial(SSERIAL_RX_PIN, SSERIAL_TX_PIN); // RX, TX

#define DEVICE 0x01
#define BUFS 64 //Buffer size
short crc;
byte arry[6] = {0x00, 0x02, 0x02, 0x00, 0x02, 0x00};
byte Response[BUFS];
byte Response_size;
byte countdown = 2;
//===============================================================================
// Initialization
//===============================================================================
void setup()
{
Serial.begin(115200); // Start the built-in serial port
Serial1.begin(115200); // Start the RS485 soft serial port
delay(1000);
Serial.println();

Response_size=zeroone(Response,0x0002,0x0001 ); //number must be [1-0x07d0]

Serial.print("Size Redad Respponse is : ");
Serial.println(Response_size);

Serial.print("Response Read Response string is : ");
for(byte i=0;i<Response_size;i++)
{
Serial.print("0x");
if(Response[i]<16) Serial.print("0");
Serial.print(Response[i],HEX);
Serial.print(" ");
}
Serial.println();
/*
// for(int k = 0; k < 10; k++)
// {
Response_size=zerofive(Response,0x0002, HIGH);
Serial.print("Size 05 is : ");
Serial.println(Response_size);

Serial.print("Response 05string is : ");
for(byte i=0;i<Response_size;i++)
{
Serial.print("0x");
if(Response[i]<16) Serial.print("0");
Serial.print(Response[i],HEX);
Serial.print(" ");
}
Serial.println();
delay(500);
/*
Response_size=zerofive(Response,0x0002, LOW);
Serial.print("Size is : ");
Serial.println(Response_size);

Serial.print("Response string is : ");
for(byte i=0;i<Response_size;i++)
{
Serial.print("0x");
if(Response[i]<16) Serial.print("0");
Serial.print(Response[i],HEX);
Serial.print(" ");
}
*/
Serial.println();
delay(500);
// }

}

//===============================================================================
// Main
//===============================================================================
void loop()
{
Response_size=zerofive(Response,0x0002, HIGH);
Response_size=zeroone(Response,0x0002,0x0001 ); //number must be [1-0x07d0]
if(Response[3]>0) Serial.println("Device is ON.");
delay(10000);
Response_size=zerofive(Response,0x0002, LOW);
Response_size=zeroone(Response,0x0002,0x0001 ); //number must be [1-0x07d0]
if(Response[3]==0) Serial.println("Device is OFF.");
delay(10000);

}
// Read coils zeroone - Read up to 2000 coils in a call.
// Requires:
// byte rs[] : Respose[]
// int start : starting address
// int num : Number of coils between 1..0x07D0
//
byte zeroone(byte rs[],int start, int num)
{
byte rq[8]; //Always 8 bytes for 0x01
short c; //CRC value
byte i, j,sz; //Counters, size

//If there are no parameters selected or too many, then error, quit.
if(num==0 || num>0x07d0)
{
Serial.println("Illegal quantity of inputs");
return 0;
}

rq[0]=DEVICE; //Global device IO
rq[1]=0x01;
rq[3]=byte(start&0x00FF); //starting LSB address
rq[2]=byte((start&0xFF00)>>8);//starting MSB address
rq[5]=byte(num&0x00FF); //number of coils LSB
rq[4]=byte((num&0xFF00)>>8); //number of coils MSB

c = CRC16(rq,6); //Calculate CRC

rq[7]=0x00FF & c; //CRC LSB
rq[6]=c>>8; //CRC MSB

//Transmit the Request array onto bus.
for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}

//Because the number of coils is in bits and they are returned as bytes, modulo artithmetic
//is needed to ensure a fractional byte always rounds upwards to an additioanl byte
sz=5+num/8;
if(num%8>0) sz++;

if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x01. Recompile with BUFS to a higher value");
return 0;
}
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5; //Error packet is much shorter, always 5.
i++;
}
}
if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}
c=CRC16(rs,sz-2);
if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 'Read Coils' function 0x01");
return 0;
}
return sz;
}

// Read discretes zerotwo - Read up to 2000 discrete inputs in a call.
// Requires:
// byte rs[] : Respose[]
// int start : starting address
// int num : Number of inputs between 1..0x07D0
//
byte zerotwo(byte rs[], int start, int num)
{
byte rq[8]; //Always 8 bytes
short c; //CRC value
byte i, j,sz; //Counters, size

rq[0]=DEVICE; //Global device IO
rq[1]=0x02;
rq[3]=byte(start&0x00FF); //Starting address LSB
rq[2]=byte((start&0xFF00)>>8); //Starting address MSB
rq[5]=byte(num&0x00FF); //Number of bits LSB
rq[4]=byte((num&0xFF00)>>8); //Number of bits MSB

c = CRC16(rq,6);
rq[7]=0x00FF & c; //CRC LSB written
rq[6]=c>>8; //CRC MSB written

//Deliver request to device
for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}

//Because the number of coils is in bits and they are returned as bytes, modulo artithmetic
//is needed to ensure a fractional byte always rounds upwards to an additional byte
sz=5+num/8;
if(num%8>0) sz++;

if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x02. Recompile with BUFS to a higher value");
return 0;
}

//Listen for response
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5; //Error packet is much shorter, always 5.
i++;
}
}
if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}

//Verify CRC code
c=CRC16(rs,sz-2);
if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 0x02");
return 0;
}
return sz;
}

// Read Holding Registers zerothree - Read up to 125 registers in a call.
// Requires:
// byte rs[] : Response[]
// int start : starting address
// int num : Number of inputs between 1..0x0007D
//
// Note: Even though the number of inputs will never exceed 8 bits,
// the standard requires a 16-bit type cast.
byte zerothree(byte rs[],int start, int num)
{
byte rq[8];
short c; //CRC value
byte i, j,sz; //Counters, size

if(num==0 || num>0x007d)
{
Serial.println("Illegal quantity of inputs");
return 0;
}

rq[0]=DEVICE; //Global device IO
rq[1]=0x03;
rq[3]=byte(start&0x00FF);
rq[2]=byte((start&0xFF00)>>8);
rq[5]=byte(num&0x00FF);
rq[4]=0x00; //The number of registers MSB is always zero

//Calculate and store CRC
c = CRC16(rq,6);
rq[7]=0x00FF & c;
rq[6]=c>>8;

//Deliver request to device
for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}
sz = 5+num*2;
if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x03. Recompile with BUFS to a higher value");
return 0;
}
//Listen for Response
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5;
i++;
}
}
if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}
c=CRC16(rs,sz-2);
if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 0x03");
return 0;
}

return sz;
}

// Read Input Registers zerofour - Read up to 125 registers in a call.
// Requires:
// byte rs[] : Response[]
// int start : starting address
// int num : Number of inputs between 1..0x0007D

byte zerofour(byte rs[],int start, int num)
{
byte rq[8]; //Always 8 bytes
//int addr;
//int len;
short c; //CRC value
byte i, j,sz; //Counters, size

if(num==0 || num>0x007d)
{
Serial.println("Illegal quantity of inputs");
return 0;
}

rq[0]=DEVICE; //Global device IO
rq[1]=0x04;
rq[3]=byte(start&0x00FF); //LSB of starting register
rq[2]=byte((start&0xFF00)>>8); //MSB of starting register
rq[5]=byte(num&0x00FF);
rq[4]=0x00; //This is always zero for this function

c = CRC16(rq,6); //Generate CRC
rq[7]=0x00FF & c; //Write LSB of CRC
rq[6]=c>>8; //Write MSB of CRC

//Deliver request to device
for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}
sz = 5+num*2;
if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x04. Recompile with BUFS to a higher value");
return 0;
}
//Listen for Response
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5;
i++;
}
}

if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}
c=CRC16(rs,sz-2);
if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 0x04");
return 0;
}

return sz;
}

// Write Single Coil zerofive - Write a coild 0xFF00 or 0x0000.
// Requires:
// byte rs[] : Response[]
// int start : starting address
// bool set : State of coil LOW or HIGH
byte zerofive(byte rs[],int addr, bool set)
{
byte rq[8]; //Always 8 bytes
short c; //CRC value
byte i, j,sz; //Counters, size

rq[0]=DEVICE; //Global device IO
rq[1]=0x05;
rq[3]=byte(addr&0x00FF);
rq[2]=byte((addr&0xFF00)>>8);
rq[5]=0x00; //Always zero
if(set) rq[4]=0xFF;
else rq[4]=0x00;

c = CRC16(rq,6);
rq[7]=0x00FF & c;
rq[6]=c>>8;

//Deliver request to device
for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}
sz = 8; //Always 8 for this function
if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x03. Recompile with BUFS to a higher value");
return 0;
}

//Listen for Response
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5;
i++;
}
}
if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}

c=CRC16(rs,sz-2);

if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 0x05");
return 0;
}
}

// Write multiple registers onezero - Read up to 123 registers in a call.
// Requires:
// byte rs[] : Response[]
// int start : starting address
// int num : Number of inputs between 1..0x0007B
// byte arr[]: Array containing registers being written
byte onezero(byte rs[],int start, int num, byte arr[])
{
byte rq[255];
short c; //CRC value
byte i, j,sz; //Counters, size

if(num==0 || num>0x7B)
{
Serial.println("Invalid number of registers being written in 0x10.");
return 0;
}
rq[0]=DEVICE; //Global device IO
rq[1]=0x10;
rq[3]=byte(start&0x00FF);
rq[2]=byte((start&0xFF00)>>8);
rq[5]=byte(num&0x00FF);
rq[4]=0x00; //always zero
rq[6]=num<<1; //num*2

for(int i=0;i<(num<<1);i++)
{
rq[7+i]=arr[i];
}

c = CRC16(rq,7+(num<<1));
rq[8+(num<<1)]=0x00FF & c;
rq[7+(num<<1)]=c>>8;

for(i=0;i<9+(num<<1);i++)
{
Serial1.write(rq[i]);
}

sz = 9+(num<<1); //9 byzes + 2*num
if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x04. Recompile with BUFS to a higher value");
return 0;
}

sz=8; //This response is always 8 bytes long
//Listen for Response
for(i=0;i<sz;)
{
if (Serial1.available()) //Data from the Slave is available
{
rs[i]=Serial1.read();
if(i==1 && rs[i]==0x83) sz=5;
i++;
}
}

if (rs[1]==0x83)
{
Serial.println("Remote system threw an error.");
return 0;
}

c=CRC16(rs,sz-2);
if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
{
Serial.println("CRC error in 0x04");
return 0;
}
return sz;
}

short CRC16(byte array[],byte s)
{
static const byte auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40} ;

static const byte auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2,
0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6,
0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE,
0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA,
0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62,
0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE,
0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76,
0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A,
0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86,
0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40} ;

byte uchCRCHi = 0xFF;
byte uchCRCLo = 0xFF;
byte uIndex;

while(s--)
{
uIndex = uchCRCHi ^ *array++ ;
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
uchCRCLo = auchCRCLo[uIndex] ;
}
return short(uchCRCHi << 8 | uchCRCLo);
}

</syntaxhighlight>

RS485 Master Example

2020-11-16T17:44:58Z

Falgsc-al: Created page with "<syntaxhighlight lang="C++"> //#include <SoftwareSerial.h> //const int SSERIAL_RX_PIN = 10; //Soft Serial Receive pin //const int SSERIAL_TX_PIN = 11; //Soft Serial Transmit..."

<syntaxhighlight lang="C++">
//#include <SoftwareSerial.h>
//const int SSERIAL_RX_PIN = 10; //Soft Serial Receive pin
//const int SSERIAL_TX_PIN = 11; //Soft Serial Transmit pin

// Create Soft Serial Port object and define pins to use
//SoftwareSerial RS485Serial(SSERIAL_RX_PIN, SSERIAL_TX_PIN); // RX, TX

int byteReceived;
//===============================================================================
// Initialization
//===============================================================================
void setup()
{
Serial.begin(115200); // Start the built-in serial port
Serial.println("Master Device");
Serial.println("Type in upper window, press ENTER");

Serial1.begin(115200); // Start the RS485 soft serial port
}
//===============================================================================
// Main
//===============================================================================
void loop()
{
if (Serial.available()) // A char(byte) has been entered in the Serial Monitor
{
byteReceived = Serial.read(); // Read the byte
Serial1.write(byteReceived); // Send byte to Remote Arduino
}

if (Serial1.available()) //Data from the Slave is available
{
byteReceived = Serial1.read(); // Read received byte
//coomented for diagnostics
//Serial.write(byteReceived); // Show on Serial Monitor
Serial.print(micros());
Serial.print(' ');
Serial.println(byteReceived,HEX);
}
}
</syntaxhighlight>

Arduino Projects

2020-11-16T17:44:12Z

Falgsc-al: added rs485 code

[[QR Code generation with 3.5" TFT Touch screen on Arudino MEGA2560]]

[[CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560]]

[[Can bus battery monitor with OLED]]

[[Can bus battery monitor]]

[[OLED Display]]

[[OLED Display SSD1306 i2c 128x64 demo]]

[[LCD demo]]

[[RS485 Master Example]]

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-05T00:37:07Z

Falgsc-al: /* Code */ adjusted LCD, Vsum positions

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>

#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float temp[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int tempdisplay[NUMPACKS][NUMCELLS];
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;
bool msg5 = LOW;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
temp[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!");

}

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();
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 temp[][]
if(buf[0]==0)
{
for(int i=0;i<NUMCELLS-1;i++)
{
temp[slot][i]=tempconvert(buf[i+1]); //i+1 because buf[0] is a count register
}
}
//Copy one value to temp[][0] wich is cell 1.
if(buf[0]==1)
{
temp[slot][7]=tempconvert(buf[1]);
}
//unknown temp code
if(buf[0]>1)
{
Serial.println("Unknown Temp 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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
/*
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();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,384 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,384, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-)", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) V (+) V", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-)", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) V (+) V", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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(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+60, yc+22, '.', 0, ' ');
mylcd.Set_Text_Back_colour(BLACK);
}
tempdisplay[p][c] = (int) temp[p][c];
if(p!=4) mylcd.Print_Number_Int(tempdisplay[p][c], xc+98,yc,2, ' ', 10);

if(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;
return;
}
char tempconvert(char raw)
{
//Fahrenheit
return (raw*1.555)-26.0;
}

void TestTemp(void)
{
int i,j;
Serial.println("Temperatures");
for(i=0;i<NUMPACKS;i++)
{
Serial.print("Pack ");
Serial.print(i+1);
Serial.print(" : ( ");
for(j=0;j<NUMCELLS;j++)
{
Serial.print(temp[i][j]);
Serial.print(" , ");
}
Serial.println(" )");
}
}
</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-05T00:33:38Z

Falgsc-al: /* Code */ Voltage array printed in but has issue filling with values

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>

#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float temp[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int tempdisplay[NUMPACKS][NUMCELLS];
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;
bool msg5 = LOW;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
temp[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!");

}

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();
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 temp[][]
if(buf[0]==0)
{
for(int i=0;i<NUMCELLS-1;i++)
{
temp[slot][i]=tempconvert(buf[i+1]); //i+1 because buf[0] is a count register
}
}
//Copy one value to temp[][0] wich is cell 1.
if(buf[0]==1)
{
temp[slot][7]=tempconvert(buf[1]);
}
//unknown temp code
if(buf[0]>1)
{
Serial.println("Unknown Temp 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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
/*
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();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,384 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,384, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-)", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-)", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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(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+40, yc+22, '.', 0, ' ');
mylcd.Set_Text_Back_colour(BLACK);
}
tempdisplay[p][c] = (int) temp[p][c];
if(p!=4) mylcd.Print_Number_Int(tempdisplay[p][c], xc+98,yc,2, ' ', 10);

if(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;
return;
}
char tempconvert(char raw)
{
//Fahrenheit
return (raw*1.555)-26.0;
}

void TestTemp(void)
{
int i,j;
Serial.println("Temperatures");
for(i=0;i<NUMPACKS;i++)
{
Serial.print("Pack ");
Serial.print(i+1);
Serial.print(" : ( ");
for(j=0;j<NUMCELLS;j++)
{
Serial.print(temp[i][j]);
Serial.print(" , ");
}
Serial.println(" )");
}
}
</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T23:46:01Z

Falgsc-al: /* Code */

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>

#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float temp[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int tempdisplay[NUMPACKS][NUMCELLS];
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;
bool msg5 = LOW;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
temp[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!");

}

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();
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 temp[][]
if(buf[0]==0)
{
for(int i=0;i<NUMCELLS-1;i++)
{
temp[slot][i]=tempconvert(buf[i+1]); //i+1 because buf[0] is a count register
}
}
//Copy one value to temp[][0] wich is cell 1.
if(buf[0]==1)
{
temp[slot][7]=tempconvert(buf[1]);
}
//unknown temp code
if(buf[0]>1)
{
Serial.println("Unknown Temp 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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
//TestTemp();
//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
/*
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();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,388 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,388, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-) ", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-) ", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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, ' ');
tempdisplay[p][c] = (int) temp[p][c];
if(p!=4) mylcd.Print_Number_Int(tempdisplay[p][c], xc+96,yc,2, ' ', 10);

if(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;
return;
}
char tempconvert(char raw)
{
//Fahrenheit
return (raw*1.555)-26.0;
}

void TestTemp(void)
{
int i,j;
Serial.println("Temperatures");
for(i=0;i<NUMPACKS;i++)
{
Serial.print("Pack ");
Serial.print(i+1);
Serial.print(" : ( ");
for(j=0;j<NUMCELLS;j++)
{
Serial.print(temp[i][j]);
Serial.print(" , ");
}
Serial.println(" )");
}
}

</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T22:38:33Z

Falgsc-al: /* Code */ Added temperature display

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <TouchScreen.h> //touch library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//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 = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float temp[NUMPACKS][NUMCELLS];
int tempdisplay[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

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

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
temp[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!");

}

void loop()
{
long msgID = 0x00000FFF;
bool msg05temp_enable = LOW;
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();
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 temp[][]
if(buf[0]==0)
{
for(int i=0;i<NUMCELLS-2;i++)
{
temp[slot][i]=tempconvert(buf[i+1]); //i+1 because buf[0] is a count register
}
}
//Copy one value to temp[][0] wich is cell 1.
if(buf[0]==1)
{
msg05temp_enable = HIGH;
}
//unknown temp code
if(buf[0]>1)
{
Serial.println("Unknown Temp code");
}

for(int i = 0; i<len; i++)
{
buf3[i] = buf[i];
}
}
//Interpret message 5
else if (msgID == 0x00000500)
{
//This event prevents 0 from being written to screen
if(msg05temp_enable)
{
temp[slot][7]=tempconvert(buf[1]);
}
msg05temp_enable = LOW;
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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{
TestTemp();
//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
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();
}

if(unknownId != 0)
{
Serial.print("Unknown Message: ");
Serial.print(unknownId, HEX);
Serial.println();
}

}

}
else skip=LOW;
}
else
{
UpdateScreen();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,388 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,388, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-) ", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) . (+) ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-) ", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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, ' ');
tempdisplay[p][c] = (int) temp[p][c];
if(p!=4) mylcd.Print_Number_Int(tempdisplay[p][c], xc+96,yc,2, ' ', 10);

if(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;
return;
}
char tempconvert(char raw)
{
//Fahrenheit
return (raw*1.555)-26.0;
}

void TestTemp(void)
{
int i,j;
Serial.println("Temperatures");
for(i=0;i<NUMPACKS;i++)
{
Serial.print("Pack ");
Serial.print(i+1);
Serial.print(" : ( ");
for(j=0;j<NUMCELLS;j++)
{
Serial.print(temp[i][j]);
Serial.print(" , ");
}
Serial.println(" )");
}
}

</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T20:04:22Z

Falgsc-al: /* Code */ Text positions were moved to accommodate temperature readings

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//Globals
bool buzzer = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

MCP_CAN CAN(spiCSPin);

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
}
}

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!");

}

void loop()
{

long msgID = 0x00000FFF;
bool skip = LOW;
unsigned char len = 0;
unsigned char buf[10];
unsigned long canId = 0x00000000;

if(CAN_MSGAVAIL == CAN.checkReceive())
{

CAN.readMsgBuf(&len, buf);
canId = CAN.getCanId();
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)
{
for(int i = 0; i<len; i++)
{
buf3[i] = buf[i];
}
}
//Interpret message 3
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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{

//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
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();
}

if(unknownId != 0)
{
Serial.print("Unknown Message: ");
Serial.print(unknownId, HEX);
Serial.println();
}

}

}
else skip=LOW;
}
else
{
UpdateScreen();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,388 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(170, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(171, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(170,388, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-) ", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) . (+) ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-) ", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
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.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) (+) ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;

return;
}

</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T06:20:01Z

Falgsc-al: /* Code */ removed arithmetic to save clock cycles

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//Globals
bool buzzer = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

MCP_CAN CAN(spiCSPin);

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
}
}

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!");

}

void loop()
{

long msgID = 0x00000FFF;
bool skip = LOW;
unsigned char len = 0;
unsigned char buf[10];
unsigned long canId = 0x00000000;

if(CAN_MSGAVAIL == CAN.checkReceive())
{

CAN.readMsgBuf(&len, buf);
canId = CAN.getCanId();
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)
{
for(int i = 0; i<len; i++)
{
buf3[i] = buf[i];
}
}
//Interpret message 3
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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{

//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
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();
}

if(unknownId != 0)
{
Serial.print("Unknown Message: ");
Serial.print(unknownId, HEX);
Serial.println();
}

}

}
else skip=LOW;
}
else
{
UpdateScreen();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(180,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(181, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(180,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,388 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(180, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(181, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(180,388, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-) ", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" 1 -.---V 1 -.---V ", 4, 32+16*2);
mylcd.Print_String(" 2 -.---V 2 -.---V ", 4, 32+16*3);
mylcd.Print_String(" 3 -.---V 3 -.---V ", 4, 32+16*4);
mylcd.Print_String(" 4 -.---V 4 -.---V ", 4, 32+16*5);
mylcd.Print_String(" 5 -.---V 5 -.---V ", 4, 32+16*6);
mylcd.Print_String(" 6 -.---V 6 -.---V ", 4, 32+16*7);
mylcd.Print_String(" 7 -.---V 7 -.---V ", 4, 32+16*8);
mylcd.Print_String(" 8 -.---V 8 -.---V ", 4, 32+16*9);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) --C (+) --C ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-) ", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" 1 -.---V 1 -.---V ", 4, 32+16*14);
mylcd.Print_String(" 2 -.---V 2 -.---V ", 4, 32+16*15);
mylcd.Print_String(" 3 -.---V 3 -.---V ", 4, 32+16*16);
mylcd.Print_String(" 4 -.---V 4 -.---V ", 4, 32+16*17);
mylcd.Print_String(" 5 -.---V 5 -.---V ", 4, 32+16*18);
mylcd.Print_String(" 6 -.---V 6 -.---V ", 4, 32+16*19);
mylcd.Print_String(" 7 -.---V 7 -.---V ", 4, 32+16*20);
mylcd.Print_String(" 8 -.---V 8 -.---V ", 4, 32+16*21);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) --C (+) --C ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
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=40;
}
if(p==1 || p==3)
{
xc=208;
}
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(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;

return;
}

</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T06:12:05Z

Falgsc-al: /* Code */ Added outlines of packs, decorated, refreshed look, place holders for max temp once implemented

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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.660 //Alarm threshold
//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 0x0821
#define BACKGRD 0x2965

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//Globals
bool buzzer = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

MCP_CAN CAN(spiCSPin);

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
//mylcd.Fill_Screen(BLACK);
//mylcd.Set_Text_Mode(0);
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;
}
}

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!");

}

void loop()
{

long msgID = 0x00000FFF;
bool skip = LOW;
unsigned char len = 0;
unsigned char buf[10];
unsigned long canId = 0x00000000;

if(CAN_MSGAVAIL == CAN.checkReceive())
{

CAN.readMsgBuf(&len, buf);
canId = CAN.getCanId();
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)
{
for(int i = 0; i<len; i++)
{
buf3[i] = buf[i];
}
}
//Interpret message 3
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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{

//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
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();
}

if(unknownId != 0)
{
Serial.print("Unknown Message: ");
Serial.print(unknownId, HEX);
Serial.println();
}

}

}
else skip=LOW;
}
else
{
UpdateScreen();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(BACKGRD);
mylcd.Set_Draw_color(32,0,255);
mylcd.Fill_Rectangle(0, 0, mylcd.Get_Display_Width()-1, 26);
//Draw Packs
//Pack 1
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,42 , 150, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 62, 149, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,193 , 150, 214);
//Pack 2
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(180,42 , 310, 191);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(181, 62, 309, 62);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(180,193, 310, 214);
//Pack 3
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(10,234 , 150, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(11, 254, 149, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(10,388 , 150, 407);
//Pack 4
mylcd.Set_Draw_color(0,0,0);
mylcd.Fill_Rectangle(180, 234 , 310, 386);
mylcd.Set_Draw_color(WHITE);
mylcd.Draw_Line(181, 254, 309, 254);
mylcd.Set_Draw_color(RED);
mylcd.Fill_Rectangle(180,388, 310, 407);
//Fill Text
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Mode(1);
//mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
//mylcd.Draw_Fast_HLine(0,24,320);
//mylcd.Draw_Fast_HLine(0,25,320);
//mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
//mylcd.Set_Text_Mode(1);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x04 (-) x20 (-) ", 4, 30+16*1);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" 1 -.---V 1 -.---V ", 4, 32+16*2);
mylcd.Print_String(" 2 -.---V 2 -.---V ", 4, 32+16*3);
mylcd.Print_String(" 3 -.---V 3 -.---V ", 4, 32+16*4);
mylcd.Print_String(" 4 -.---V 4 -.---V ", 4, 32+16*5);
mylcd.Print_String(" 5 -.---V 5 -.---V ", 4, 32+16*6);
mylcd.Print_String(" 6 -.---V 6 -.---V ", 4, 32+16*7);
mylcd.Print_String(" 7 -.---V 7 -.---V ", 4, 32+16*8);
mylcd.Print_String(" 8 -.---V 8 -.---V ", 4, 32+16*9);
mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) --C (+) --C ", 4, 38+16*10);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" ", 4, 32+16*12);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" x06 (-) x22 (-) ", 4, 30+16*13);
//mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" 1 -.---V 1 -.---V ", 4, 32+16*14);
mylcd.Print_String(" 2 -.---V 2 -.---V ", 4, 32+16*15);
mylcd.Print_String(" 3 -.---V 3 -.---V ", 4, 32+16*16);
mylcd.Print_String(" 4 -.---V 4 -.---V ", 4, 32+16*17);
mylcd.Print_String(" 5 -.---V 5 -.---V ", 4, 32+16*18);
mylcd.Print_String(" 6 -.---V 6 -.---V ", 4, 32+16*19);
mylcd.Print_String(" 7 -.---V 7 -.---V ", 4, 32+16*20);
mylcd.Print_String(" 8 -.---V 8 -.---V ", 4, 32+16*21);
//mylcd.Set_Text_colour(WHITE);
mylcd.Print_String(" (+) --C (+) --C ", 4, 38+16*22);
mylcd.Set_Text_colour(CYAN);
mylcd.Print_String(" ", 4, 32+16*23);
mylcd.Print_String(" ", 4, 32+16*24);
mylcd.Print_String(" ", 4, 32+16*25);
mylcd.Print_String(" ", 4, 32+16*26);
mylcd.Print_String("Caleb Box and Timothy Legg", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
int xc, yc;
if(p==0 || p==1)
{
yc=32+16*2+(16*c);
}
if(p==2 || p==3)
{
yc=32+16*3+(16*c)+16*11;
}
if(p==0 || p==2)
{
xc=4+12*3;
}
if(p==1 || p==3)
{
xc=4+12*7 + 120;
}
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(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;

return;
}
</syntaxhighlight>

CAN bus battery monitor with 3.5" TFT Touch screen on Arudino MEGA2560

2020-11-04T01:16:18Z

Falgsc-al: /* Code */ Fixed buzzer issue, updated text on screen to change color depending on cell voltage

==Synopsis==
==Notes==
Only Displays Packs 0-3. Does not autodetect modules. Snake Game easter egg not yet inmplemented

==Code==
<syntaxhighlight lang="C++" line='line'>
#define ARDUINO_MEGA2560
//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
#include <LCDWIKI_KBV.h> //Hardware-specific library

//Software constants
#define NUMPACKS 5 //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.655 //Alarm threshold
//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

//RED 1111 1000 0000 0000
//BLU 0000 0000 0001 1111
//GRE 0000 0111 1110 0000
//GRY 0000 1000 0010 0001 = 0x0821

//Globals
bool buzzer = HIGH;
#ifdef ARDUINO_MEGA2560
const int spiCSPin = 53;
#endif

boolean ledON = 1;
float voltage[NUMPACKS][NUMCELLS];
float sum[NUMPACKS];
long knownID[NUMPACKS] = {0x00000021, 0x00000004, 0x00000020, 0x00000006, 0x00000022};
long packID;
int slot;
int c= 0;
int p= 0;
float Pack = 0.0;

unsigned char bufA[10];
unsigned char buf0[10];
unsigned char buf3[10];
unsigned char buf5[10];
unsigned char buf20[10];
unsigned char buf21[10];
unsigned char buf22[10];

unsigned long time;
unsigned long TriggerTime = 0;
unsigned long unknownId = 0;
int count=0;

MCP_CAN CAN(spiCSPin);

//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

void setup()
{
Serial.begin(115200);

//Graphics
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
mylcd.Fill_Screen(BLACK);
mylcd.Set_Text_Mode(0);
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;
}
}

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!");

}

void loop()
{

long msgID = 0x00000FFF;
bool skip = LOW;
unsigned char len = 0;
unsigned char buf[10];
unsigned long canId = 0x00000000;

if(CAN_MSGAVAIL == CAN.checkReceive())
{

CAN.readMsgBuf(&len, buf);
canId = CAN.getCanId();
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)
{
for(int i = 0; i<len; i++)
{
buf3[i] = buf[i];
}
}
//Interpret message 3
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)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][7] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][6] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][5] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf20[i] = buf[i];
}
}
if (buf[0] == 1)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][4] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][3] = Cell / 1000.0;
Cell = buf[6] * 256 + buf[5];
voltage[slot][2] = Cell / 1000.0;

for(int i = 0; i<len; i++)
{
buf21[i] = buf[i];
}
}
if (buf[0] == 2)
{
unsigned int Cell = buf[2] * 256 + buf[1];
voltage[slot][1] = Cell / 1000.0;
Cell = buf[4] * 256 + buf[3];
voltage[slot][0] = Cell / 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);
}

//Run every REFRESHms
time = millis();
if (time >= TriggerTime)
{

//Detect for alarm condition
for(int i=0; i<NUMPACKS;i++)
{
for(int j=0;j<NUMCELLS;j++)
{

if(voltage[i][j]>=ALARM) //KILLER LINE
//digitalWrite(49,1);
buzzer=HIGH;

}
}

//Execute alarm condition
if(buzzer)
digitalWrite(49,1);
else
digitalWrite(49,0);
TriggerTime = TriggerTime + REFRESH;
Pack=0.0;

//Dump cell voltages to CSV
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();
}

if(unknownId != 0)
{
Serial.print("Unknown Message: ");
Serial.print(unknownId, HEX);
Serial.println();
}

}

}
else skip=LOW;
}
else
{
UpdateScreen();
}
}

void BuildScreen(int ScreenMode)
{
//Home Screen
if(ScreenMode=1)
{

//display 1 times string
mylcd.Fill_Screen(0x0000);
mylcd.Set_Text_colour(CYAN);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 30, 0);
mylcd.Draw_Fast_HLine(0,24,320);
mylcd.Draw_Fast_HLine(0,25,320);
mylcd.Draw_Fast_HLine(0,26,320);
mylcd.Set_Text_Size(2);
mylcd.Print_String(" ", 4, 32+16*0);
mylcd.Print_String(" ", 4, 32+16*1);
mylcd.Print_String(" ", 4, 32+16*2);
mylcd.Print_String(" 1 = -.--- 1 = -.--- ", 4, 32+16*3);
mylcd.Print_String(" 2 = -.--- 2 = -.--- ", 4, 32+16*4);
mylcd.Print_String(" 3 = -.--- 3 = -.--- ", 4, 32+16*5);
mylcd.Print_String(" 4 = -.--- 4 = -.--- ", 4, 32+16*6);
mylcd.Print_String(" 5 = -.--- 5 = -.--- ", 4, 32+16*7);
mylcd.Print_String(" 6 = -.--- 6 = -.--- ", 4, 32+16*8);
mylcd.Print_String(" 7 = -.--- 7 = -.--- ", 4, 32+16*9);
mylcd.Print_String(" 8 = -.--- 8 = -.--- ", 4, 32+16*10);
mylcd.Print_String(" ", 4, 32+16*11);
mylcd.Print_String(" 1 = -.--- 1 = -.--- ", 4, 32+16*12);
mylcd.Print_String(" 2 = -.--- 2 = -.--- ", 4, 32+16*13);
mylcd.Print_String(" 3 = -.--- 3 = -.--- ", 4, 32+16*14);
mylcd.Print_String(" 4 = -.--- 4 = -.--- ", 4, 32+16*15);
mylcd.Print_String(" 5 = -.--- 5 = -.--- ", 4, 32+16*16);
mylcd.Print_String(" 6 = -.--- 6 = -.--- ", 4, 32+16*17);
mylcd.Print_String(" 7 = -.--- 7 = -.--- ", 4, 32+16*18);
mylcd.Print_String(" 8 = -.--- 8 = -.--- ", 4, 32+16*19);
mylcd.Print_String(" ", 4, 32+16*20);
mylcd.Print_String("xxxxxxxxxxxxxxxxxxxxxxxxxx", 4, 32+16*21);
mylcd.Print_String("Cell1 = 3.78|Cell2 = 3.321", 4, 32+16*22);
mylcd.Print_String("Cell1 = 3.33|Cell2 = 3.321", 4, 32+16*23);
mylcd.Print_String("Cell1 = 3.78|Cell2 = 3.321", 4, 32+16*24);
mylcd.Print_String("Cell1 = 3.33|Cell2 = 3.321", 4, 32+16*24);
mylcd.Print_String("xxxxxxxxxxxxxxxxxxxxxxxxxx", 4, 32+16*25);
mylcd.Print_String("xxxxxxxxxxxxxxxxxxxxxxxxxx", 4, 32+16*26);
mylcd.Print_String("xxxxxxxxxxxxxxxxxxxxxxxxxx", 4, 32+16*27);
}
return;
}

void UpdateScreen(void)
{
// float voltage_[5][8]={{1.001,2.001,3.001,4.001,5.001,6.001,7.001,8.001},{1.002,2.002,3.002,4.002,5.002,6.002,7.002,8.002},{1.003,2.003,3.003,4.003,5.003,6.003,7.003,8.003},{1.004,2.004,3.004,4.004,5.004,6.004,7.004,8.004},{1.005,2.005,3.005,4.005,5.005,6.005,7.005,8.005}};
long st, fn;
int xc, yc;
if(p==0 || p==1)
{
yc=32+16*3+(16*c);
}
if(p==2 || p==3)
{
yc=32+16*3+(16*c)+16*9;
}
if(p==0 || p==2)
{
xc=4+12*7;
}
if(p==1 || p==3)
{
xc=4+12*7 + 120;
}
mylcd.Set_Text_colour(GREEN);
if(voltage[p][c]< 2.200 || voltage[p][c] > 3.650) mylcd.Set_Text_colour(RED);
if(voltage[p][c]> 3.600) mylcd.Set_Text_colour(YELLOW);
if(voltage[p][c]> 3.645) mylcd.Set_Text_colour(ORANGE);
if(voltage[p][c]<= 0.0001) mylcd.Set_Text_colour(0x0821);

if(p!=4) mylcd.Print_Number_Float(voltage[p][c], 3, xc,yc, '.', 0, ' ');

if(c<NUMCELLS){c++;}
if(c==NUMCELLS){p++;c=0;}
if(p==NUMPACKS){p=0;}
buzzer=LOW;

return;
}

</syntaxhighlight>

LCD demo

2020-11-02T21:09:24Z

Falgsc-al:

<syntaxhighlight lang="C++">
/***********************************************************************************
*This program is a demo of displaying string
*This demo was made for LCD modules with 8bit or 16bit data port.
*This program requires the the LCDKIWI library.

* File : display_string.ino
* Hardware Environment: Arduino UNO&Mega2560
* Build Environment : Arduino

*Set the pins to the correct ones for your development shield or breakout board.
*This demo use the BREAKOUT BOARD only and use these 8bit data lines to the LCD,
*pin usage as follow:
* LCD_CS LCD_CD LCD_WR LCD_RD LCD_RST SD_SS SD_DI SD_DO SD_SCK
* Arduino Uno A3 A2 A1 A0 A4 10 11 12 13
*Arduino Mega2560 A3 A2 A1 A0 A4 10 11 12 13

* LCD_D0 LCD_D1 LCD_D2 LCD_D3 LCD_D4 LCD_D5 LCD_D6 LCD_D7
* Arduino Uno 8 9 2 3 4 5 6 7
*Arduino Mega2560 8 9 2 3 4 5 6 7

*Remember to set the pins to suit your display module!
*
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, QD electronic SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
**********************************************************************************/

#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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

//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

void setup()
{
Serial.begin(9600);
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
mylcd.Fill_Screen(BLACK);
}

void loop()
{
mylcd.Set_Text_Mode(0);
//display 1 times string
mylcd.Fill_Screen(0x0000);
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 0, 0);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 8, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 16, 0, ' ',16);
//mylcd.Print_String("DEADBEF", 0, 16);

//display 2 times string
mylcd.Set_Text_colour(GREEN);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Made by Caleb\nand Tim", 0, 40);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 56, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 72, 0, ' ',16);
//mylcd.Print_String("DEADBEEF", 0, 72);

//display 3 times string
mylcd.Set_Text_colour(BLUE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 1", 0, 100);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 128, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 152, 0, ' ',16);
// mylcd.Print_String("DEADBEEF", 0, 152);

//display 4 times string
mylcd.Set_Text_colour(WHITE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 2", 0, 140);

//display 5 times string
mylcd.Set_Text_colour(YELLOW);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 3", 0, 180);

//display 6 times string
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 4", 0, 220);

delay(3000);
}
</syntaxhighlight>

LCD demo

2020-11-02T20:26:43Z

Falgsc-al:

<syntaxhighlight lang="C++" line='line'>
/***********************************************************************************
*This program is a demo of displaying string
*This demo was made for LCD modules with 8bit or 16bit data port.
*This program requires the the LCDKIWI library.

* File : display_string.ino
* Hardware Environment: Arduino UNO&Mega2560
* Build Environment : Arduino

*Set the pins to the correct ones for your development shield or breakout board.
*This demo use the BREAKOUT BOARD only and use these 8bit data lines to the LCD,
*pin usage as follow:
* LCD_CS LCD_CD LCD_WR LCD_RD LCD_RST SD_SS SD_DI SD_DO SD_SCK
* Arduino Uno A3 A2 A1 A0 A4 10 11 12 13
*Arduino Mega2560 A3 A2 A1 A0 A4 10 11 12 13

* LCD_D0 LCD_D1 LCD_D2 LCD_D3 LCD_D4 LCD_D5 LCD_D6 LCD_D7
* Arduino Uno 8 9 2 3 4 5 6 7
*Arduino Mega2560 8 9 2 3 4 5 6 7

*Remember to set the pins to suit your display module!
*
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, QD electronic SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
**********************************************************************************/

#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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

//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

void setup()
{
Serial.begin(9600);
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
mylcd.Fill_Screen(BLACK);
}

void loop()
{
mylcd.Set_Text_Mode(0);
//display 1 times string
mylcd.Fill_Screen(0x0000);
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 0, 0);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 8, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 16, 0, ' ',16);
//mylcd.Print_String("DEADBEF", 0, 16);

//display 2 times string
mylcd.Set_Text_colour(GREEN);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Made by Caleb\nand Tim", 0, 40);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 56, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 72, 0, ' ',16);
//mylcd.Print_String("DEADBEEF", 0, 72);

//display 3 times string
mylcd.Set_Text_colour(BLUE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 1", 0, 100);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 128, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 152, 0, ' ',16);
// mylcd.Print_String("DEADBEEF", 0, 152);

//display 4 times string
mylcd.Set_Text_colour(WHITE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 2", 0, 140);

//display 5 times string
mylcd.Set_Text_colour(YELLOW);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 3", 0, 180);

//display 6 times string
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 4", 0, 220);

delay(3000);
</syntaxhighlight>

LCD demo

2020-11-02T20:23:14Z

Falgsc-al: This page is a modified demo that came with the new LCD board.

/***********************************************************************************
*This program is a demo of displaying string
*This demo was made for LCD modules with 8bit or 16bit data port.
*This program requires the the LCDKIWI library.

* File : display_string.ino
* Hardware Environment: Arduino UNO&Mega2560
* Build Environment : Arduino

*Set the pins to the correct ones for your development shield or breakout board.
*This demo use the BREAKOUT BOARD only and use these 8bit data lines to the LCD,
*pin usage as follow:
* LCD_CS LCD_CD LCD_WR LCD_RD LCD_RST SD_SS SD_DI SD_DO SD_SCK
* Arduino Uno A3 A2 A1 A0 A4 10 11 12 13
*Arduino Mega2560 A3 A2 A1 A0 A4 10 11 12 13

* LCD_D0 LCD_D1 LCD_D2 LCD_D3 LCD_D4 LCD_D5 LCD_D6 LCD_D7
* Arduino Uno 8 9 2 3 4 5 6 7
*Arduino Mega2560 8 9 2 3 4 5 6 7

*Remember to set the pins to suit your display module!
*
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, QD electronic SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
**********************************************************************************/

#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_KBV.h> //Hardware-specific library

//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

//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

void setup()
{
Serial.begin(9600);
mylcd.Init_LCD();
Serial.println(mylcd.Read_ID(), HEX);
mylcd.Fill_Screen(BLACK);
}

void loop()
{
mylcd.Set_Text_Mode(0);
//display 1 times string
mylcd.Fill_Screen(0x0000);
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Back_colour(BLACK);
mylcd.Set_Text_Size(3);
mylcd.Print_String("Battery Monitor", 0, 0);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 8, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 16, 0, ' ',16);
//mylcd.Print_String("DEADBEF", 0, 16);

//display 2 times string
mylcd.Set_Text_colour(GREEN);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Made by Caleb\nand Tim", 0, 40);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 56, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 72, 0, ' ',16);
//mylcd.Print_String("DEADBEEF", 0, 72);

//display 3 times string
mylcd.Set_Text_colour(BLUE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 1", 0, 100);
//mylcd.Print_Number_Float(01234.56789, 2, 0, 128, '.', 0, ' ');
//mylcd.Print_Number_Int(0xDEADBEF, 0, 152, 0, ' ',16);
// mylcd.Print_String("DEADBEEF", 0, 152);

//display 4 times string
mylcd.Set_Text_colour(WHITE);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 2", 0, 140);

//display 5 times string
mylcd.Set_Text_colour(YELLOW);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 3", 0, 180);

//display 6 times string
mylcd.Set_Text_colour(RED);
mylcd.Set_Text_Size(2);
mylcd.Print_String("Battery 4", 0, 220);

delay(3000);

Arduino Projects

2020-11-02T20:22:36Z

Falgsc-al:

[[Can bus battery monitor with OLED]]

[[Can bus battery monitor]]

[[OLED Display]]

[[OLED Display SSD1306 i2c 128x64 demo]]

[[LCD demo]]