362 lines
14 KiB
C
362 lines
14 KiB
C
/**
|
|
******************************************************************************
|
|
* File Name : modbus_lcd.c
|
|
* Description : This file provides code for the configuration
|
|
* of modbus for lcd comm.
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
|
|
* All rights reserved.</center></h2>
|
|
*
|
|
* This software component is licensed by ST under Ultimate Liberty license
|
|
* SLA0044, the "License"; You may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at:
|
|
* www.st.com/SLA0044
|
|
*
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include <includes.h>
|
|
#include "modbus.h"
|
|
#include "device_param.h"
|
|
#include "malloc.h"
|
|
#include "temp.h"
|
|
#include "asutil.h"
|
|
#include "brtc.h"
|
|
#include "can_comm.h"
|
|
#include "dflash_sf1.h"
|
|
#include "date_calc.h"
|
|
#include "io.h"
|
|
|
|
/* Defines -------------------------------------------------------------------*/
|
|
/* Type declarations ---------------------------------------------------------*/
|
|
/* Exported macro ------------------------------------------------------------*/
|
|
/* Private variables ---------------------------------------------------------*/
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
s16 GetPackRegisterToLcd(u16 reg_addr, u8 dno);
|
|
|
|
/* Private functions ---------------------------------------------------------*/
|
|
|
|
s16 GetRegisterToLcd(u16 reg_addr)
|
|
{
|
|
s16 result = 0;
|
|
|
|
if (reg_addr >= 0xA000) {
|
|
// Pack 10 data
|
|
result = GetPackRegisterToLcd(reg_addr, 9);
|
|
} else if (reg_addr >= 0x9000) {
|
|
// Pack 9 data
|
|
result = GetPackRegisterToLcd(reg_addr, 8);
|
|
} else if (reg_addr >= 0x8000) {
|
|
// Pack 8 data
|
|
result = GetPackRegisterToLcd(reg_addr, 7);
|
|
} else if (reg_addr >= 0x7000) {
|
|
// Pack 7 data
|
|
result = GetPackRegisterToLcd(reg_addr, 6);
|
|
} else if (reg_addr >= 0x6000) {
|
|
// Pack 6 data
|
|
result = GetPackRegisterToLcd(reg_addr, 5);
|
|
} else if (reg_addr >= 0x5000) {
|
|
// Pack 5 data
|
|
result = GetPackRegisterToLcd(reg_addr, 4);
|
|
} else if (reg_addr >= 0x4000) {
|
|
// Pack 4 data
|
|
result = GetPackRegisterToLcd(reg_addr, 3);
|
|
} else if (reg_addr >= 0x3000) {
|
|
// Pack 3 data
|
|
result = GetPackRegisterToLcd(reg_addr, 2);
|
|
} else if (reg_addr >= 0x2000) {
|
|
// Pack 2 data
|
|
result = GetPackRegisterToLcd(reg_addr, 1);
|
|
} else if (reg_addr >= 0x1000) {
|
|
// Pack 1 data
|
|
result = GetPackRegisterToLcd(reg_addr, 0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
s16 FindMaxTemp(void)
|
|
{
|
|
u16 i;
|
|
s16 result = 0;
|
|
|
|
for (i = 0; i < DEVICE_MAX_TEMP; i++)
|
|
{
|
|
if (i == 0) result = device_value.Temp.temperature[i];
|
|
else
|
|
{
|
|
if (result < device_value.Temp.temperature[i])
|
|
result = device_value.Temp.temperature[i];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 GetMaxTemperature(void)
|
|
{
|
|
u16 i;
|
|
s16 result = 0;
|
|
|
|
for (i = 0; i < DEVICE_MAX_TEMP; i++)
|
|
{
|
|
if (i == 0) result = device_value.Temp.temperature[i];
|
|
else
|
|
{
|
|
if (result < device_value.Temp.temperature[i])
|
|
result = device_value.Temp.temperature[i];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 GetMinTemperature(void)
|
|
{
|
|
u16 i;
|
|
s16 result = 0;
|
|
|
|
for (i = 0; i < DEVICE_MAX_TEMP; i++) {
|
|
if (i == 0) result = device_value.Temp.temperature[i];
|
|
else {
|
|
if (result > device_value.Temp.temperature[i])
|
|
result = device_value.Temp.temperature[i];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 GetAvgTemperature(void)
|
|
{
|
|
u16 i;
|
|
s32 sum = 0;
|
|
s16 result = 0;
|
|
|
|
for (i = 0; i < DEVICE_MAX_TEMP; i++) {
|
|
sum += device_value.Temp.temperature[i];
|
|
}
|
|
|
|
result = (s16)(sum / DEVICE_MAX_TEMP);
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 GetPackRegisterToLcd(u16 reg_addr, u8 dno)
|
|
{
|
|
s16 result = 0;
|
|
|
|
if (dno >= DEVICE_MAX_CELL)
|
|
return result;
|
|
|
|
switch (reg_addr & 0x0FFF) {
|
|
case 0: result = (s16)device_value.BatVoltage; break; // 0000 0.00V
|
|
case 1: result = (s16)(device_value.Current); break; // 0001 0.1A
|
|
case 3: // 0003 CELL #1 mV
|
|
case 4: // 0004 CELL #2 mV
|
|
case 5: // 0005 CELL #3 mV
|
|
case 6: // 0006 CELL #4 mV
|
|
case 7: // 0007 CELL #5 mV
|
|
case 8: // 0008 CELL #6 mV
|
|
case 9: // 0009 CELL #7 mV
|
|
case 10: // 0010 CELL #8 mV
|
|
case 11: // 0011 CELL #9 mV
|
|
case 12: // 0012 CELL #10 mV
|
|
case 13: // 0013 CELL #11 mV
|
|
case 14: // 0014 CELL #12 mV
|
|
case 15: // 0015 CELL #13 mV
|
|
case 16: // 0016 CELL #14 mV
|
|
case 17: result = (s16)device_value.Cell.voltage[(reg_addr & 0x0FFF) - 3]; // 0017 CELL #15
|
|
break;
|
|
case 18: // 0018 TEMP #1 0.1C
|
|
case 19: // 0019 TEMP #2 0.1C
|
|
case 20: // 0020 TEMP #3 0.1C
|
|
case 21: // 0021 TEMP #4 0.1C
|
|
case 22: // 0022 TEMP #5 0.1C
|
|
case 23: result = (s16)device_value.Temp.temperature[(reg_addr & 0x0FFF) - 18]; // 0023 TEMP #6 0.1C
|
|
break;
|
|
// case 24: result = (s16)device_value.Temp.status[6].temp; break; // 0024
|
|
// case 25: result = (s16)device_value.Temp.status[7].temp; break; // 0025
|
|
|
|
case 26: result = (s16)device_value.RelativeStateOfCharge; break; // 0026
|
|
case 32: result = (s16)device_param.sbs.data.Full_Charge_Capacity; break; // 32 : Design Capacity
|
|
|
|
case 37: result = (s16)device_value.Cell.avg.Max.value; break;
|
|
case 38: result = (s16)device_value.Cell.avg.Min.value; break;
|
|
case 39: result = (s16)device_value.Cell.avg.avg; break;
|
|
case 40: result = (s16)device_value.Cell.avg.avg; break;
|
|
|
|
case 41: result = device_status.alarm_status; break; // 41 : Alarm Status
|
|
case 42: result = device_status.warning.value; break; // 42 : Warning
|
|
case 43: result = device_status.protection.value; break; // 43 : Protection
|
|
case 44: result = device_status.op_status; break; // 44 : Operating Status
|
|
case 45: result = GetCanCommState(); break; // 45 : Commfail
|
|
|
|
case 46: result = device_status.cellbalance.value; break; // 46 : cell balance status
|
|
|
|
// case 50: result = (s16)((UnixTimeStamp >> 16) & 0x0000FFFF);break; // 0050 : UnixTimeStamp MSB
|
|
// case 51: result = (s16)((UnixTimeStamp >> 0) & 0x0000FFFF);break; // 0051 : UnixTimeStamp LSB
|
|
|
|
case 52: result = device_value.Cell.avg.Max.num; break; // 0052 : Max Cell Number
|
|
case 53: result = device_value.Cell.avg.Min.num; break; // 0053 : Min Cell Number
|
|
|
|
case 54: result = device_value.Temp.avg.Max.value; break; // 0054 : Max Temp
|
|
case 55: result = device_value.Temp.avg.Min.value; break; // 0055 : Min Temp
|
|
|
|
case 56: result = device_value.Temp.avg.Max.num; break; // 0056 : Max Temp Number
|
|
case 57: result = device_value.Temp.avg.Min.num; break; // 0057 : Min Temp Number
|
|
case 58: result = device_value.Temp.avg.avg; break; // 0058 : Average Temperature Number
|
|
|
|
case 60: result = (s16)device_param.safety.voltage.CUV_Threshold; break; // 0061 : Low cell voltage protection data
|
|
case 61: result = (s16)device_param.safety.voltage.CUV_Warning; break; // 0060 : Low cell voltage warning data
|
|
case 62: result = (s16)device_param.safety.voltage.CUV_Recovery; break; // 0062 : Low cell voltage recovery data
|
|
case 63: result = (s16)device_param.safety.voltage.SUV_Threshold; break; // 0064 : Low voltage protection data
|
|
case 64: result = (s16)device_param.safety.voltage.SUV_Warning; break; // 0063 : Low voltage warning data
|
|
case 65: result = (s16)device_param.safety.voltage.SUV_Recovery; break; // 0065 : Low voltage recovery data
|
|
case 66: result = (s16)device_param.safety.voltage.COV_Threshold; break; // 0067 : Over cell voltage protection data
|
|
case 67: result = (s16)device_param.safety.voltage.COV_Warning; break; // 0066 : Over cell voltage warning data
|
|
case 68: result = (s16)device_param.safety.voltage.COV_Recovery; break; // 0068 : Over cell voltage recovery data
|
|
case 69: result = (s16)device_param.safety.voltage.SOV_Threshold; break; // 0070 : Over voltage protection data
|
|
case 70: result = (s16)device_param.safety.voltage.SOV_Warning; break; // 0069 : Over voltage warning data
|
|
case 71: result = (s16)device_param.safety.voltage.SOV_Recovery; break; // 0071 : Over voltage recovery data
|
|
|
|
case 72: result = (s16)device_param.safety.current.OC_Chg_Threshold; break; // 0072 : Charge over current threshold
|
|
case 73: result = (s16)device_param.safety.current.OC_Chg_Warning; break; // 0073 : Charge over current warning
|
|
case 74: result = (s16)device_param.safety.current.OC_Chg_Recovery; break; // 0074 : Charge Over current recovery
|
|
case 76: result = (s16)device_param.safety.current.OC_Dsg_Threshold; break; // 0076 : Discharge over current threshold
|
|
case 77: result = (s16)device_param.safety.current.OC_Dsg_Warning; break; // 0077 : Discharge over current warning
|
|
case 78: result = (s16)device_param.safety.current.OC_Dsg_Recovery; break; // 0078 : Discharge Over current recovery
|
|
|
|
case 80: result = (s16)device_param.safety.temperature.OT_Chg_Threshold; break; // 0080 : Charge high temperature threshold
|
|
case 81: result = (s16)device_param.safety.temperature.OT_Chg_Warning; break; // 0081 : Charge high temperature warning
|
|
case 82: result = (s16)device_param.safety.temperature.OT_Chg_Recovery; break; // 0082 : Charge high temperature recovery
|
|
case 84: result = (s16)device_param.safety.temperature.OT_Dsg_Threshold; break; // 0084 : Discharge high temperature threshold
|
|
case 85: result = (s16)device_param.safety.temperature.OT_Dsg_Warning; break; // 0085 : Discharge high temperature warning
|
|
case 86: result = (s16)device_param.safety.temperature.OT_Dsg_Recovery; break; // 0086 : Discharge high temperature recovery
|
|
|
|
case 88: result = (s16)device_param.safety.soc.Low_Soc_Warning; break; // 0088 : Low SOC Warning
|
|
case 89: result = (s16)device_param.safety.soc.Low_Soc_Recovery; break; // 0089 : Low SOC Recovery
|
|
|
|
}
|
|
return result;
|
|
}
|
|
|
|
s16 SetMainRegisterLCD(u16 reg_addr, s16 reg_value)
|
|
{
|
|
s16 result = 0;
|
|
|
|
switch (reg_addr) {
|
|
case 60: device_param.safety.voltage.CUV_Threshold = reg_value; break; // 60 : Low cell voltage protection data
|
|
case 61: device_param.safety.voltage.CUV_Warning = reg_value; break; // 61 : Low cell voltage warning data
|
|
case 62: device_param.safety.voltage.CUV_Recovery = reg_value; break; // 62 : Low cell voltage recovery data
|
|
case 63: device_param.safety.voltage.SUV_Threshold = reg_value; break; // 63 : Low voltage protection data
|
|
case 64: device_param.safety.voltage.SUV_Warning = reg_value; break; // 64 : Low voltage warning data
|
|
case 65: device_param.safety.voltage.SUV_Recovery = reg_value; break; // 65 : Low voltage recovery data
|
|
case 66: device_param.safety.voltage.COV_Threshold = reg_value; break; // 66 : Over cell voltage protection data
|
|
case 67: device_param.safety.voltage.COV_Warning = reg_value; break; // 67 : Over cell voltage warning data
|
|
case 68: device_param.safety.voltage.COV_Recovery = reg_value; break; // 68 : Over cell voltage recovery data
|
|
case 69: device_param.safety.voltage.SOV_Threshold = reg_value; break; // 69 : Over voltage protection data
|
|
case 70: device_param.safety.voltage.SOV_Warning = reg_value; break; // 70 : Over voltage warning data
|
|
case 71: device_param.safety.voltage.SOV_Recovery = reg_value; break; // 71 : Over voltage recovery data
|
|
|
|
case 72: device_param.safety.current.OC_Chg_Threshold = reg_value; break; // 72 : Charge over current threshold
|
|
case 73: device_param.safety.current.OC_Chg_Warning = reg_value; break; // 73 : Charge over current warning
|
|
case 74: device_param.safety.current.OC_Chg_Recovery = reg_value; break; // 74 : Charge Over current recovery
|
|
case 76: device_param.safety.current.OC_Dsg_Threshold = reg_value; break; // 76 : Discharge over current threshold
|
|
case 77: device_param.safety.current.OC_Dsg_Warning = reg_value; break; // 77 : Discharge over current warning
|
|
case 78: device_param.safety.current.OC_Dsg_Recovery = reg_value; break; // 78 : Discharge Over current recovery
|
|
|
|
case 80: device_param.safety.temperature.OT_Chg_Threshold = reg_value; break; // 80 : Charge high temperature threshold
|
|
case 81: device_param.safety.temperature.OT_Chg_Warning = reg_value; break; // 81 : Charge high temperature warning
|
|
case 82: device_param.safety.temperature.OT_Chg_Recovery = reg_value; break; // 82 : Charge high temperature recovery
|
|
case 84: device_param.safety.temperature.OT_Dsg_Threshold = reg_value; break; // 84 : Discharge high temperature threshold
|
|
case 85: device_param.safety.temperature.OT_Dsg_Warning = reg_value; break; // 85 : Discharge high temperature warning
|
|
case 86: device_param.safety.temperature.OT_Dsg_Recovery = reg_value; break; // 86 : Discharge high temperature recovery
|
|
|
|
case 88: device_param.safety.soc.Low_Soc_Warning = reg_value; break;
|
|
case 89: device_param.safety.soc.Low_Soc_Warning = reg_value; break;
|
|
|
|
case 200: SetTime.year = reg_value; break; // _TTIME
|
|
case 201: SetTime.month = reg_value; break; // _TTIME
|
|
case 202: SetTime.date = reg_value; break; // _TTIME
|
|
case 203: SetTime.hour = reg_value; break; // _TTIME
|
|
case 204: SetTime.min = reg_value; break; // _TTIME
|
|
case 205: SetTime.sec = reg_value;
|
|
RTC_TimeSet(&SetTime);
|
|
break;
|
|
|
|
case 50: // TimeStamp MSB Set
|
|
SetUpTimeStamp(reg_value, 1);
|
|
break;
|
|
case 51: // TimeStamp LSB Set
|
|
SetUpTimeStamp(reg_value, 0);
|
|
break;
|
|
case 0x4000: // Buzzer Hold
|
|
Alarm_Buzzer_Update();
|
|
break;
|
|
case 0x4001:
|
|
SF1_InitData();
|
|
break;
|
|
case 0x9000: // Reset
|
|
Sys_Soft_Reset();
|
|
while(1);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 SetPackRegisterLCD(u16 reg_addr, s16 reg_value, u8 tno)
|
|
{
|
|
s16 result = 0;
|
|
|
|
switch (reg_addr) {
|
|
case 50: // TimeStamp MSB Set
|
|
SetUpTimeStamp(reg_value, 1);
|
|
break;
|
|
case 51: // TimeStamp LSB Set
|
|
SetUpTimeStamp(reg_value, 0);
|
|
break;
|
|
case 0x4000: // Buzzer Hold
|
|
// Alarm_Buzzer_Update();
|
|
break;
|
|
case 0x9000: // Reset
|
|
Sys_Soft_Reset();
|
|
while(1);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
s16 SetRegisterLCD(u16 reg_addr, s16 reg_value)
|
|
{
|
|
s16 result = 0;
|
|
|
|
if (reg_addr < 0x1000)
|
|
{
|
|
result = SetMainRegisterLCD(reg_addr, reg_value);
|
|
}
|
|
else if (reg_addr < 0x2000)
|
|
{
|
|
result = SetPackRegisterLCD(reg_addr, reg_value, 0);
|
|
}
|
|
else if (reg_addr < 0x3000)
|
|
{
|
|
result = SetPackRegisterLCD(reg_addr, reg_value, 1);
|
|
}
|
|
else if (reg_addr < 0x4000)
|
|
{
|
|
result = SetPackRegisterLCD(reg_addr, reg_value, 2);
|
|
}
|
|
else
|
|
{
|
|
result = SetMainRegisterLCD(reg_addr, reg_value);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|