443 lines
18 KiB
C#
443 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
|
|
using LFP_Manager.DataStructure;
|
|
|
|
namespace LFP_Manager.Utils
|
|
{
|
|
static class csUtils
|
|
{
|
|
public static readonly 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
|
|
};
|
|
|
|
public static readonly 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
|
|
};
|
|
|
|
#region CRC Calculation
|
|
/// <summary>
|
|
/// Modbus CRC-16 계산
|
|
/// </summary>
|
|
public static byte[] CalculateCRC(byte[] data, int length)
|
|
{
|
|
if (data == null || length <= 0 || length > data.Length)
|
|
throw new ArgumentException("Invalid data or length");
|
|
|
|
ushort crc = 0xFFFF;
|
|
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
crc ^= data[i];
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
if ((crc & 1) == 1)
|
|
crc = (ushort)((crc >> 1) ^ 0xA001);
|
|
else
|
|
crc >>= 1;
|
|
}
|
|
}
|
|
|
|
return new byte[] { (byte)(crc & 0xFF), (byte)(crc >> 8) };
|
|
}
|
|
#endregion
|
|
|
|
public static int GetModuleQty(CommConfig aConfig)
|
|
{
|
|
int mQty = 0;
|
|
|
|
switch (aConfig.CommType)
|
|
{
|
|
case csConstData.CommType.COMM_UART:
|
|
mQty = 1;
|
|
break;
|
|
case csConstData.CommType.COMM_RS485:
|
|
mQty = aConfig.ModuleQty;
|
|
break;
|
|
case csConstData.CommType.COMM_SNMP:
|
|
mQty = 1;
|
|
break;
|
|
default:
|
|
mQty = 0;
|
|
break;
|
|
}
|
|
return mQty;
|
|
}
|
|
|
|
public static void TypingOnlyNumber(object sender, KeyPressEventArgs e, bool includePoint, bool includeMinus)
|
|
{
|
|
bool isValidInput = false;
|
|
if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))
|
|
{
|
|
if (includePoint == true) { if (e.KeyChar == '.') isValidInput = true; }
|
|
if (includeMinus == true) { if (e.KeyChar == '-') isValidInput = true; }
|
|
|
|
if (isValidInput == false) e.Handled = true;
|
|
}
|
|
|
|
if (includePoint == true)
|
|
{
|
|
if (e.KeyChar == '.' && (string.IsNullOrEmpty((sender as DevExpress.XtraEditors.TextEdit).Text.Trim()) || (sender as DevExpress.XtraEditors.TextEdit).Text.IndexOf('.') > -1)) e.Handled = true;
|
|
}
|
|
if (includeMinus == true)
|
|
{
|
|
if (e.KeyChar == '-' && (!string.IsNullOrEmpty((sender as DevExpress.XtraEditors.TextEdit).Text.Trim()) || (sender as DevExpress.XtraEditors.TextEdit).Text.IndexOf('-') > -1)) e.Handled = true;
|
|
}
|
|
}
|
|
|
|
public static bool[] Int16ToBitArray(Int16 data)
|
|
{
|
|
bool[] result = new bool[16];
|
|
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
result[i] = (((data >> i) & 0x0001) == 0x0001) ? true : false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static byte[] GetCRC(byte[] pby, UInt16 nSize)
|
|
{
|
|
byte[] result = new byte[2];
|
|
UInt16 uIndex, i;
|
|
UInt16 crc;
|
|
byte uchCRCHi = 0xff;
|
|
byte uchCRCLo = 0xff;
|
|
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
uIndex = (UInt16)(uchCRCHi ^ pby[i]);
|
|
uchCRCHi = (byte)(uchCRCLo ^ csConstData.CRC_Data.auchCRCHi[uIndex]);
|
|
uchCRCLo = csConstData.CRC_Data.auchCRCLo[uIndex];
|
|
}
|
|
crc = (UInt16)(((UInt16)uchCRCHi << 8) | uchCRCLo);
|
|
|
|
result[1] = (byte)(crc / 256);
|
|
result[0] = (byte)(crc % 256);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static byte StrByte2toByte(byte a, byte b)
|
|
{
|
|
byte result = 0;
|
|
byte a1 = 0, b1 = 0;
|
|
|
|
if ((a >= (byte)'0')&&(a <= (byte)'9'))
|
|
{
|
|
a1 = (byte)(a - (byte)'0');
|
|
}
|
|
else if ((a >= (byte)'a')&&(a <= (byte)'f'))
|
|
{
|
|
a1 = (byte)(a - (byte)'a');
|
|
}
|
|
else if ((a >= (byte)'A')&&(a <= (byte)'F'))
|
|
{
|
|
a1 = (byte)((a - (byte)'A') + 0x0A);
|
|
}
|
|
|
|
if ((b >= (byte)'0') && (b <= (byte)'9'))
|
|
{
|
|
b1 = (byte)(b - (byte)'0');
|
|
}
|
|
else if ((b >= (byte)'a') && (b <= (byte)'f'))
|
|
{
|
|
b1 = (byte)(b - (byte)'a');
|
|
}
|
|
else if ((b >= (byte)'A') && (b <= (byte)'F'))
|
|
{
|
|
b1 = (byte)((b - (byte)'A') + 0x0A);
|
|
}
|
|
|
|
result = (byte)((b1 << 4) | a1);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static byte[] StrToByteArray(byte[] rData, int offset, int rlen)
|
|
{
|
|
int len = (rlen - 2) / 2;
|
|
byte[] result = new byte[len];
|
|
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
result[i] = StrByte2toByte(rData[(i * 2) + offset + 2], rData[(i * 2) + offset + 1]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static byte[] StringToByte(string str)
|
|
{
|
|
byte[] StrByte = Encoding.UTF8.GetBytes(str); return StrByte;
|
|
}
|
|
|
|
#region OPERATING WARNING FUCTION
|
|
|
|
public static bool BitCheck(short rData, int pos)
|
|
{
|
|
if (((rData >> pos) & 0x0001) == 0x0001)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TIMESTAMP FUNCTION
|
|
public static UInt32 CalcKKTimeStamp(DateTime tDate)
|
|
{
|
|
//Time of test and calibration. Local time in seconds since 2000.
|
|
//Ex:
|
|
//Epoch time offset (1 January 2000 00:00:00) = 946684800
|
|
//Current epoch time (1 October 2019 12:00:00) = 1569931200
|
|
//Timestamp = 1569931200 - 946684800 = 623246400
|
|
//(Used 'https://www.epochconverter.com/' for conversion)
|
|
DateTime baseDate = new DateTime(2000, 1, 1, 0, 0, 0);
|
|
|
|
int bDate = ConvertToUnixTimestamp(baseDate);
|
|
int nDate = ConvertToUnixTimestamp(tDate);
|
|
|
|
return (UInt32)(nDate - bDate);
|
|
}
|
|
|
|
public static DateTime ConvertTimeStampToDateTime(UInt32 tStamp)
|
|
{
|
|
DateTime result = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
|
|
|
|
result = result.AddSeconds(tStamp);
|
|
|
|
// DateTimeOffset.Now.ToUnixTimeSeconds() // (.NET Framework 4.6 +/.NET Core),
|
|
// older versions:
|
|
//var epoch = (DateTime.UtcNow - new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
|
|
|
|
return result;
|
|
}
|
|
|
|
public static int ConvertToUnixTimestamp(DateTime date)
|
|
{
|
|
DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0);
|
|
TimeSpan diff = date - origin;
|
|
return (int)Math.Floor(diff.TotalSeconds);
|
|
}
|
|
#endregion
|
|
|
|
#region DateTime Format Methods
|
|
/// <summary>
|
|
/// DateTime을 기본 형식으로 변환합니다. (yyyy-MM-dd HH:mm:ss)
|
|
/// </summary>
|
|
public static string FormatDateTime(DateTime dateTime)
|
|
{
|
|
return dateTime.ToString("yyyy-MM-dd HH:mm:ss");
|
|
}
|
|
#endregion
|
|
|
|
#region DATA INIT
|
|
|
|
public static void DataInit(CommConfig aConfig, ref DeviceSystemData aSystemData)
|
|
{
|
|
aSystemData.ShelfCommFail = true;
|
|
|
|
switch (aConfig.CommType)
|
|
{
|
|
case csConstData.CommType.COMM_UART:
|
|
case csConstData.CommType.COMM_RS485:
|
|
switch (aConfig.UartModelIndex)
|
|
{
|
|
case csConstData.MODEL_INDEX.LFPM_48100D:
|
|
case csConstData.MODEL_INDEX.LFPM_48150D:
|
|
case csConstData.MODEL_INDEX.LFPM_48200D:
|
|
case csConstData.MODEL_INDEX.LFPM_48250D:
|
|
case csConstData.MODEL_INDEX.LFPM_48300D:
|
|
aSystemData.cellQty = 15;
|
|
aSystemData.tempQty = 4;
|
|
break;
|
|
case csConstData.MODEL_INDEX.LFPM_124050D:
|
|
aSystemData.cellQty = csConstData.SystemInfo.MAX_MODULE_CELL_SIZE;
|
|
aSystemData.tempQty = csConstData.SystemInfo.MAX_MODULE_TEMP_SIZE;
|
|
break;
|
|
default:
|
|
aSystemData.cellQty = 15;
|
|
aSystemData.tempQty = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case csConstData.CommType.COMM_SNMP:
|
|
switch (aConfig.SnmpModelIndex)
|
|
{
|
|
case csConstData.MODEL_INDEX.LFPM_48100D:
|
|
case csConstData.MODEL_INDEX.LFPM_48150D:
|
|
case csConstData.MODEL_INDEX.LFPM_48200D:
|
|
case csConstData.MODEL_INDEX.LFPM_48250D:
|
|
case csConstData.MODEL_INDEX.LFPM_48300D:
|
|
aSystemData.cellQty = 15;
|
|
aSystemData.tempQty = 4;
|
|
break;
|
|
case csConstData.MODEL_INDEX.LFPM_124050D:
|
|
aSystemData.cellQty = csConstData.SystemInfo.MAX_MODULE_CELL_SIZE;
|
|
aSystemData.tempQty = csConstData.SystemInfo.MAX_MODULE_TEMP_SIZE;
|
|
break;
|
|
default:
|
|
aSystemData.cellQty = 15;
|
|
aSystemData.tempQty = 4;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
aSystemData.cellQty = 15;
|
|
aSystemData.tempQty = 4;
|
|
break;
|
|
}
|
|
|
|
for (int j = 0; j < aSystemData.ValueData.CellVoltage.Length; j++)
|
|
{
|
|
aSystemData.ValueData.CellVoltage[j] = 0;
|
|
}
|
|
for (int j = 0; j < aSystemData.ValueData.CellTemperature.Length; j++)
|
|
{
|
|
aSystemData.ValueData.CellTemperature[j] = 0;
|
|
}
|
|
aSystemData.ValueData.voltageOfPack = 0;
|
|
aSystemData.ValueData.current = 0;
|
|
aSystemData.ValueData.rSOC = 0;
|
|
aSystemData.AvgData.maxCellVoltage = 0;
|
|
aSystemData.AvgData.minCellVoltage = 0;
|
|
aSystemData.AvgData.avgCellVoltage = 0;
|
|
aSystemData.AvgData.maxTemp = 0;
|
|
aSystemData.AvgData.minTemp = 0;
|
|
aSystemData.AvgData.avgTemp = 0;
|
|
aSystemData.heatbeat = 0;
|
|
aSystemData.StatusData.warning = 0;
|
|
aSystemData.StatusData.protection = 0;
|
|
|
|
for (int j = 0; j < aSystemData.Information.BMS_SN.Length; j++)
|
|
{
|
|
aSystemData.Information.BMS_SN[j] = 0;
|
|
}
|
|
for (int j = 0; j < aSystemData.Information.Module_SN.Length; j++)
|
|
{
|
|
aSystemData.Information.Module_SN[j] = 0;
|
|
}
|
|
|
|
aSystemData.CalibrationData.Battery.Capacity = 0;
|
|
aSystemData.CalibrationData.Current.ChaAndDchSelect = 0;
|
|
aSystemData.CalibrationData.Current.ChgCalibration_K = 0;
|
|
aSystemData.CalibrationData.Current.DchCalibration_K = 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MAKE AVERAGE VALUE
|
|
public static void MakeMaxAvgMinCellVoltage(ref DeviceSystemData rSystemData, int cellQty)
|
|
{
|
|
int Max, Avg, Min, Sum;
|
|
int MaxNo, MinNo;
|
|
|
|
Max = Avg = Min = Sum = 0;
|
|
MaxNo = MinNo = 0;
|
|
for (int i = 0; i < cellQty; i++)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
Max = Min = rSystemData.ValueData.CellVoltage[i];
|
|
}
|
|
Sum += rSystemData.ValueData.CellVoltage[i];
|
|
|
|
if (Max < rSystemData.ValueData.CellVoltage[i])
|
|
{
|
|
Max = rSystemData.ValueData.CellVoltage[i];
|
|
MaxNo = i;
|
|
}
|
|
if (Min > rSystemData.ValueData.CellVoltage[i])
|
|
{
|
|
Min = rSystemData.ValueData.CellVoltage[i];
|
|
MinNo = i;
|
|
}
|
|
}
|
|
Avg = Sum / cellQty;
|
|
|
|
rSystemData.AvgData.avgCellVoltage = (short)Avg;
|
|
rSystemData.AvgData.maxCellVoltage = (short)Max;
|
|
rSystemData.AvgData.maxCellNum = (short)(MaxNo + 1);
|
|
rSystemData.AvgData.minCellVoltage = (short)Min;
|
|
rSystemData.AvgData.minCellNum = (short)(MinNo + 1);
|
|
rSystemData.AvgData.diffCellVoltage = (short)(Max - Min);
|
|
}
|
|
|
|
public static void MakeMaxAvgMinTemperature(ref DeviceSystemData rSystemData, int tempQty)
|
|
{
|
|
int Max, Avg, Min, Sum;
|
|
int MaxNo, MinNo;
|
|
|
|
Max = Avg = Min = Sum = 0;
|
|
MaxNo = MinNo = 0;
|
|
|
|
for (int i = 0; i < tempQty; i++)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
Max = Min = rSystemData.ValueData.CellTemperature[i];
|
|
}
|
|
Sum += rSystemData.ValueData.CellTemperature[i];
|
|
|
|
if (Max < rSystemData.ValueData.CellTemperature[i])
|
|
{
|
|
Max = rSystemData.ValueData.CellTemperature[i];
|
|
MaxNo = i;
|
|
}
|
|
if (Min > rSystemData.ValueData.CellTemperature[i])
|
|
{
|
|
Min = rSystemData.ValueData.CellTemperature[i];
|
|
MinNo = i;
|
|
}
|
|
}
|
|
Avg = Sum / tempQty;
|
|
|
|
rSystemData.AvgData.avgTemp = (short)Avg;
|
|
rSystemData.AvgData.maxTemp = (short)Max;
|
|
rSystemData.AvgData.maxTempNum = (short)(MaxNo + 1);
|
|
rSystemData.AvgData.minTemp = (short)Min;
|
|
rSystemData.AvgData.minTempNum = (short)(MinNo + 1);
|
|
rSystemData.AvgData.diffTemp = (short)(Max - Min);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|