899 lines
37 KiB
C#
899 lines
37 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Data.SqlServerCe;
|
|
using System.Runtime.InteropServices;
|
|
|
|
using BMS_D1000H.BMSConstData;
|
|
using BMS_D1000H.DataStructs;
|
|
using BMS_D1000H.Utils.Functions;
|
|
|
|
namespace BMS_D1000H.Utils.Functions
|
|
{
|
|
public class AlarmFile
|
|
{
|
|
public string BMS_PASSWORD;
|
|
TAlarmList AlarmList;
|
|
DeviceDataSystem bMainData;
|
|
DeviceDataTray[] bTrayData;
|
|
|
|
static readonly string AlarmFilePath = PathHelper.GetFullPath("alarmlist.sdf");
|
|
static readonly string AlarmHistPath = PathHelper.GetFullPath("AlarmHistory.db");
|
|
static readonly string AlarmHistCsvPath = PathHelper.GetFullPath(@"Alarm\");
|
|
|
|
static readonly string PasswordFilePath = PathHelper.GetFullPath("password.db");
|
|
static readonly string LoggingFilePath = PathHelper.GetFullPath(@"Log\");
|
|
//static readonly string SdCardPath = @"SD Card\";
|
|
//static readonly string SdLoggingFilePath = @"SD Card\Run\Log\";
|
|
|
|
//public static void SystemDataLog(int RackID, CommConfig sConfig, DeviceSystemData sData, DateTime aTime, string AppPath)
|
|
//{
|
|
// SYSTEMLOG_FILE_DIR = String.Format("{0}\\SHELF{1}\\{2}", "\\log\\systemlog", RackID, String.Format("{0:yyyyMM}", aTime));
|
|
|
|
// FileStream logFile = null;
|
|
// string path = System.IO.Path.GetDirectoryName(AppPath);
|
|
// string FileName = String.Format(path + SYSTEMLOG_FILE_DIR + "\\SHELF{0}_LOG_{1}.csv", RackID, String.Format("{0:yyMMdd}", aTime));
|
|
// byte[] logData;
|
|
|
|
// if (Directory.Exists(path + SYSTEMLOG_FILE_DIR) == false)
|
|
// Directory.CreateDirectory(path + SYSTEMLOG_FILE_DIR);
|
|
|
|
// if (File.Exists(FileName) == false)
|
|
// {
|
|
// logFile = new FileStream(FileName, FileMode.CreateNew, FileAccess.ReadWrite);
|
|
// logData = WriteDataHeader(aTime);
|
|
// logFile.Write(logData, 0, logData.Length);
|
|
// logFile.Close();
|
|
// }
|
|
|
|
// logFile = null;
|
|
// //logFile = new FileStream(FileName, FileMode.Open, FileAccess.ReadWrite);
|
|
// logFile = new FileStream(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
|
|
|
|
// if (logFile != null)
|
|
// {
|
|
// logFile.Seek(0, SeekOrigin.End);
|
|
// logData = WriteData(aTime, sConfig, sData);
|
|
// logFile.Write(logData, 0, logData.Length);
|
|
// logFile.Close();
|
|
// }
|
|
//}
|
|
|
|
public AlarmFile()
|
|
{
|
|
bTrayData = new DeviceDataTray[SystemID.MAX_MODULE_SIZE];
|
|
|
|
AlarmList = new TAlarmList();
|
|
AlarmList.aData = new TAlarm[1000];
|
|
|
|
AlarmList.front = 0;
|
|
AlarmList.rear = 0;
|
|
AlarmList.count = 0;
|
|
|
|
LoadAlarmData();
|
|
LoadPasswordData();
|
|
}
|
|
|
|
#region WriteDataHeader
|
|
|
|
private byte[] WriteDataHeader(DeviceDataSystem sData)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append("DATETIME,OPERATING,ALARM,SYSTEM VOLTAGE,SYSTEM CURRENT,SYSTEM SOC,TRIP,WARNING,");
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("VOLTAGE_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("CURRENT_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("SOC_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("MAX_TEMP_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("MIN_TEMP_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("MAX_CVOLT_{0:00},", i + 1);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("MIN_CVOLT_{0:00},", i + 1);
|
|
}
|
|
sb.Append("\r\n");
|
|
|
|
return new UTF8Encoding(true).GetBytes(sb.ToString());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region WriteData
|
|
|
|
private byte[] WriteData(DeviceDataSystem sData, DeviceDataTray[] tData)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
DateTime aLog = DateTime.Now;
|
|
|
|
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss},{1},{2},{3:#0.0},{4:#0.0},{5:#0.0},"
|
|
, aLog
|
|
, StatusStr.operating[sData.OpStatus]
|
|
, StatusStr.alarm[sData.AlarmStatus]
|
|
, Convert.ToDouble(sData.BatVoltage) / 100
|
|
, Convert.ToDouble(sData.Current) / 10
|
|
, Convert.ToDouble(sData.RelativeStateOfCharge) / 10
|
|
);
|
|
|
|
sb.AppendFormat("0x{0:X4},", sData.Protection);
|
|
sb.AppendFormat("0x{0:X4},", sData.Warning);
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].BatVoltage) / 100);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].Current) / 10);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0},", Convert.ToDouble(tData[i].RelativeStateOfCharge) / 10);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].MaxTemp) / 10);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].MinTemp) / 10);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.000},", Convert.ToDouble(tData[i].MaxCellVoltage) / 1000);
|
|
}
|
|
|
|
for (int i = 0; i < sData.ModuleQuantity; i++)
|
|
{
|
|
sb.AppendFormat("{0:#0.000},", Convert.ToDouble(tData[i].MinCellVoltage) / 1000);
|
|
}
|
|
sb.Append("\r\n");
|
|
|
|
return new UTF8Encoding(true).GetBytes(sb.ToString());
|
|
}
|
|
#endregion
|
|
|
|
public void LoggingData(DeviceDataSystem sData, DeviceDataTray[] tData)
|
|
{
|
|
DateTime aLog = DateTime.Now;
|
|
string filename = String.Format("{0}log{1}.csv", LoggingFilePath, aLog.ToString("yyyyMMdd"));
|
|
string path = System.IO.Path.GetDirectoryName(filename);
|
|
|
|
try
|
|
{
|
|
if (Directory.Exists(path) == false)
|
|
Directory.CreateDirectory(path);
|
|
|
|
bool fileExists = File.Exists(filename);
|
|
FileMode mode = fileExists ? FileMode.Open : FileMode.CreateNew;
|
|
|
|
using (FileStream fStream = new FileStream(filename, mode, FileAccess.ReadWrite))
|
|
{
|
|
fStream.Seek(0, SeekOrigin.End);
|
|
if (!fileExists)
|
|
{
|
|
byte[] logHeader = WriteDataHeader(sData);
|
|
fStream.Write(logHeader, 0, logHeader.Length);
|
|
}
|
|
byte[] logData = WriteData(sData, tData);
|
|
fStream.Write(logData, 0, logData.Length);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
public void InitPasswordData()
|
|
{
|
|
string filepath = PasswordFilePath;
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
|
|
{
|
|
BMS_PASSWORD = "0000";
|
|
byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);
|
|
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, bData.Length);
|
|
}
|
|
}
|
|
|
|
public void SaveNewPasswordData(string new_password)
|
|
{
|
|
string filepath = PasswordFilePath;
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
|
|
{
|
|
BMS_PASSWORD = new_password;
|
|
byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);
|
|
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, bData.Length);
|
|
}
|
|
}
|
|
|
|
private void LoadPasswordData()
|
|
{
|
|
string filepath = PasswordFilePath;
|
|
|
|
if (File.Exists(filepath))
|
|
{
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
long fsize = fStream.Length;
|
|
byte[] bData = new byte[fsize];
|
|
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Read(bData, 0, Convert.ToInt32(fsize));
|
|
|
|
BMS_PASSWORD = Encoding.ASCII.GetString(bData, 0, Convert.ToInt32(fsize));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
|
|
{
|
|
BMS_PASSWORD = "0000";
|
|
byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);
|
|
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, bData.Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadAlarmData()
|
|
{
|
|
string filepath = AlarmHistPath;
|
|
byte[] bData = new byte[Marshal.SizeOf(AlarmList)];
|
|
|
|
if (File.Exists(AlarmHistPath))
|
|
{
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
|
|
{
|
|
long fsize = fStream.Length;
|
|
|
|
if (Marshal.SizeOf(AlarmList) != fsize)
|
|
{
|
|
fStream.Close();
|
|
File.Delete(filepath);
|
|
|
|
using (FileStream newStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
|
|
{
|
|
newStream.SetLength(Marshal.SizeOf(AlarmList));
|
|
newStream.Seek(0, SeekOrigin.Begin);
|
|
newStream.Write(bData, 0, Marshal.SizeOf(AlarmList));
|
|
|
|
newStream.Seek(0, SeekOrigin.Begin);
|
|
newStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
|
|
AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
|
|
AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
|
|
{
|
|
fStream.SetLength(Marshal.SizeOf(AlarmList));
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, Marshal.SizeOf(AlarmList));
|
|
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
|
|
AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
|
|
}
|
|
}
|
|
Make_Run_History(EventID.EVENT_INFO, AlarmID.POWER_ON_RESET, 0, 0, 0);
|
|
}
|
|
|
|
private void SaveAlarmData()
|
|
{
|
|
long fsize = Marshal.SizeOf(AlarmList);
|
|
string filepath = AlarmHistPath;
|
|
byte[] bData = ConvertTo.StructureToByte(AlarmList);
|
|
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
|
|
{
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, Convert.ToInt32(fsize));
|
|
}
|
|
}
|
|
|
|
public void DeleteAlarmData()
|
|
{
|
|
long fsize = Marshal.SizeOf(AlarmList);
|
|
string filepath = AlarmHistPath;
|
|
byte[] bData = new byte[fsize];
|
|
|
|
System.Array.Clear(bData, 0, Convert.ToInt32(fsize));
|
|
|
|
using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
|
|
{
|
|
fStream.Seek(0, SeekOrigin.Begin);
|
|
fStream.Write(bData, 0, Convert.ToInt32(fsize));
|
|
|
|
AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
|
|
}
|
|
|
|
Make_Run_History(EventID.EVENT_INFO, AlarmID.HIST_DELETE, 0, 0, 0); // History Delete
|
|
}
|
|
|
|
public long GetFileSize(string FilePath)
|
|
{
|
|
long fsize = 0;
|
|
|
|
if (File.Exists(FilePath))
|
|
{
|
|
using (FileStream fStream = new FileStream(FilePath, FileMode.Open, FileAccess.ReadWrite))
|
|
{
|
|
fsize = fStream.Length;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (FileStream fStream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
|
|
{
|
|
fsize = fStream.Length;
|
|
}
|
|
}
|
|
|
|
return fsize;
|
|
}
|
|
|
|
public void CreateDatabase()
|
|
{
|
|
if (File.Exists(AlarmFilePath))
|
|
File.Delete(AlarmFilePath);
|
|
|
|
string connstr = @String.Format("Data Source = '{0}'; LCID=1033; Password='1111'; Encrypt = TRUE;", AlarmFilePath);
|
|
|
|
SqlCeEngine engine = new SqlCeEngine(connstr);
|
|
engine.CreateDatabase();
|
|
engine.Dispose();
|
|
|
|
SqlCeConnection conn = null;
|
|
|
|
|
|
try
|
|
{
|
|
conn = new SqlCeConnection(connstr);
|
|
conn.Open();
|
|
|
|
SqlCeCommand cmd = conn.CreateCommand();
|
|
cmd.CommandText = "CREATE TABLE AlarmList(col1 int, con2 ntext)";
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
finally
|
|
{
|
|
conn.Close();
|
|
}
|
|
}
|
|
|
|
public bool TableExists(SqlCeConnection connection, string tableName)
|
|
{
|
|
using (var command = new SqlCeCommand())
|
|
{
|
|
command.Connection = connection;
|
|
var sql = String.Format("SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{0}'", tableName);
|
|
command.CommandText = sql;
|
|
var count = Convert.ToInt32(command.ExecuteScalar());
|
|
|
|
return (count > 0);
|
|
}
|
|
}
|
|
|
|
public int GetAlarmCount()
|
|
{
|
|
return AlarmList.count;
|
|
}
|
|
|
|
public TAlarmList GetAlarmList()
|
|
{
|
|
return AlarmList;
|
|
}
|
|
|
|
public void Save_History(TAlarm hdata)
|
|
{
|
|
int nFront = AlarmList.front;
|
|
int nRear = AlarmList.rear;
|
|
int nCount = AlarmList.count;
|
|
|
|
Save_HistoryCsv(hdata); // History Save - CSV type
|
|
|
|
AlarmList.aData[nFront] = hdata;
|
|
|
|
nCount++;
|
|
|
|
nFront++;
|
|
nFront %= AlarmID.MAX_ALARM_COUNT;
|
|
|
|
if (nFront == nRear)
|
|
{
|
|
nRear++;
|
|
nRear %= AlarmID.MAX_ALARM_COUNT;
|
|
|
|
nCount = AlarmID.MAX_ALARM_COUNT;
|
|
}
|
|
if (nCount > AlarmID.MAX_ALARM_COUNT)
|
|
nCount = AlarmID.MAX_ALARM_COUNT;
|
|
|
|
AlarmList.front = nFront;
|
|
AlarmList.rear = nRear;
|
|
AlarmList.count = nCount;
|
|
|
|
SaveAlarmData();
|
|
}
|
|
|
|
public byte[] MakeHistoryCsvHeader()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("DateTime,Event,Alarm Name,Position,Parameter,\r\n");
|
|
return new UTF8Encoding(true).GetBytes(sb.ToString());
|
|
}
|
|
|
|
public void Save_HistoryCsv(TAlarm hdata)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss},", hdata.aTime);
|
|
sb.AppendFormat("{0},", EventID.event_name[hdata.aFlag]);
|
|
sb.AppendFormat("{0},", AlarmID.name[hdata.aNameNo]);
|
|
|
|
switch (hdata.aNameNo)
|
|
{
|
|
case AlarmID.COV_PROTECTION:
|
|
case AlarmID.COV_WARNING:
|
|
case AlarmID.CUV_PROTECTION:
|
|
case AlarmID.CUV_WARNING:
|
|
sb.AppendFormat("'{0}-{1},", PosID.pos[hdata.aPos], hdata.ctno);
|
|
sb.AppendFormat("{0:#0.000},", Convert.ToDouble(hdata.aParam) / 1000);
|
|
break;
|
|
case AlarmID.OTC_PROTECTION:
|
|
case AlarmID.OTC_WARNING:
|
|
case AlarmID.OTD_PROTECTION:
|
|
case AlarmID.OTD_WARNING:
|
|
sb.AppendFormat("'{0}-{1},", PosID.pos[hdata.aPos], hdata.ctno);
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 10);
|
|
break;
|
|
case AlarmID.SOV_PROTECTION:
|
|
case AlarmID.SOV_WARNING:
|
|
case AlarmID.SUV_PROTECTION:
|
|
case AlarmID.SUV_WARNING:
|
|
sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 100);
|
|
break;
|
|
case AlarmID.OCC_PROTECTION:
|
|
case AlarmID.OCC_WARNING:
|
|
case AlarmID.OCD_PROTECTION:
|
|
case AlarmID.OCD_WARNING:
|
|
sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
|
|
sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 10);
|
|
break;
|
|
default:
|
|
sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
|
|
sb.Append(",");
|
|
break;
|
|
}
|
|
sb.Append("\r\n");
|
|
|
|
byte[] bAlm = new UTF8Encoding(true).GetBytes(sb.ToString());
|
|
|
|
string filename = String.Format("{0}Alm_{1}.csv", AlarmHistCsvPath, DateTime.Now.ToString("yyyyMMdd"));
|
|
string path = System.IO.Path.GetDirectoryName(filename);
|
|
|
|
try
|
|
{
|
|
if (Directory.Exists(path) == false)
|
|
Directory.CreateDirectory(path);
|
|
|
|
bool fileExists = File.Exists(filename);
|
|
FileMode mode = fileExists ? FileMode.Open : FileMode.CreateNew;
|
|
|
|
using (FileStream fStream = new FileStream(filename, mode, FileAccess.ReadWrite))
|
|
{
|
|
fStream.Seek(0, SeekOrigin.End);
|
|
if (!fileExists)
|
|
{
|
|
byte[] hdr = MakeHistoryCsvHeader();
|
|
fStream.Write(hdr, 0, hdr.Length);
|
|
}
|
|
fStream.Write(bAlm, 0, bAlm.Length);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
public void Make_Run_History(int status // Alarm Status (0 = Normal, 1 = Alarm)
|
|
, int name_id // Alarm Name
|
|
, int pos // Tray Number
|
|
, int cno // Temp Number or Cell Number
|
|
, int param // Alarm Value
|
|
)
|
|
{
|
|
TAlarm his;
|
|
|
|
his.aFlag = Convert.ToByte(status);
|
|
his.aTime = DateTime.Now;
|
|
his.aNameNo = Convert.ToByte(name_id);
|
|
his.aPos = Convert.ToByte(pos);
|
|
his.ctno = Convert.ToByte(cno);
|
|
his.aParam = param;
|
|
|
|
Save_History(his);
|
|
}
|
|
|
|
#region Check Main Alarm History
|
|
public void CheckAlarmHistory(DeviceDataSystem nSys)
|
|
{
|
|
// BMCU Communication Fail Alarm
|
|
if (bMainData.MainCommState != nSys.MainCommState)
|
|
{
|
|
if (nSys.MainCommState != 0)
|
|
// Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMS_COMM_FAIL, 0, 0, 0);
|
|
else
|
|
// Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMS_COMM_FAIL, 0, 0, 0);
|
|
|
|
bMainData.MainCommState = nSys.MainCommState;
|
|
}
|
|
|
|
//if (ConvertTo.GetBit(bMainData.TrayCommState, 0) != ConvertTo.GetBit(nSys.TrayCommState, 0))
|
|
//{
|
|
// if (ConvertTo.GetBit(nSys.TrayCommState, 0))
|
|
// // Alarm
|
|
// Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 1, 0, 0);
|
|
// else
|
|
// // Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 1, 0, 0);
|
|
|
|
//}
|
|
//if (ConvertTo.GetBit(bMainData.TrayCommState, 1) != ConvertTo.GetBit(nSys.TrayCommState, 1))
|
|
//{
|
|
// if (ConvertTo.GetBit(nSys.TrayCommState, 1))
|
|
// // Alarm
|
|
// Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 2, 0, 0);
|
|
// else
|
|
// // Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 2, 0, 0);
|
|
|
|
//}
|
|
//if (ConvertTo.GetBit(bMainData.TrayCommState, 2) != ConvertTo.GetBit(nSys.TrayCommState, 2))
|
|
//{
|
|
// if (ConvertTo.GetBit(nSys.TrayCommState, 2))
|
|
// // Alarm
|
|
// Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 3, 0, 0);
|
|
// else
|
|
// // Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 3, 0, 0);
|
|
|
|
//}
|
|
bMainData.TrayCommState = nSys.TrayCommState;
|
|
|
|
CheckStatusHistory(nSys);
|
|
}
|
|
#endregion
|
|
|
|
#region Check Status History
|
|
public void CheckStatusHistory(DeviceDataSystem nSys)
|
|
{
|
|
if (bMainData.OpStatus != nSys.OpStatus)
|
|
{
|
|
switch (nSys.OpStatus)
|
|
{
|
|
case 0: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_STAND_BY, 0, 0, 0); break; // Status Stand by
|
|
case 1: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_CHARGING, 0, 0, 0); break; // Status Charging
|
|
case 2: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_DISCHARGING, 0, 0, 0); break; // Status Stand by
|
|
case 3: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_FLOATING, 0, 0, 0); break; // Status Stand by
|
|
}
|
|
bMainData.OpStatus = nSys.OpStatus;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public void CheckAlarmHistory(DeviceDataTray nTray, int tno)
|
|
{
|
|
CheckAlarmWarningHistory(nTray, tno);
|
|
CheckAlarmProtectionHistory(nTray, tno);
|
|
}
|
|
|
|
#region Check Alarm Warning History
|
|
public void CheckAlarmWarningHistory(DeviceDataTray nTray, int tno)
|
|
{
|
|
int bit_no;
|
|
|
|
// Module Commfail Alarm
|
|
if (ConvertTo.GetBit(bTrayData[tno].Commfail, 0) != ConvertTo.GetBit(nTray.Commfail, 0))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Commfail, 0))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, tno + 1, 0, 0);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, tno + 1, 0, 0);
|
|
|
|
bTrayData[tno].Commfail = nTray.Commfail;
|
|
}
|
|
|
|
// System Over Voltage Warning Check
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, 0) != ConvertTo.GetBit(nTray.Warning, 0))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, 0))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.SOV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
}
|
|
// Cell Over Voltage Warning Check
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, 1) != ConvertTo.GetBit(nTray.Warning, 1))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, 1))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
|
|
}
|
|
// System Under Voltage Warning Check
|
|
bit_no = 2;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
}
|
|
// Cell Under Voltage Warning Check
|
|
bit_no = 3;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
|
|
}
|
|
// Charge Over Current Warning Check
|
|
bit_no = 4;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
|
|
}
|
|
// Discharge Over Current Warning Check
|
|
bit_no = 5;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
|
|
}
|
|
// Charge Over Temperature Warning Check
|
|
bit_no = 8;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
}
|
|
// Discharge Over Temperature Warning Check
|
|
bit_no = 9;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
}
|
|
// Charge Low Temperature Warning Check
|
|
bit_no = 10;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
}
|
|
// Discharge Low Temperature Warning Check
|
|
bit_no = 11;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
}
|
|
// SOC Low Warning Check
|
|
bit_no = 12;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Warning, bit_no))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_WARNING, AlarmID.SOC_WARNING, tno + 1, 0, nTray.RelativeStateOfCharge);
|
|
else
|
|
// Warning Recovery
|
|
Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOC_WARNING, tno + 1, 0, nTray.RelativeStateOfCharge);
|
|
}
|
|
bTrayData[tno].Warning = nTray.Warning;
|
|
}
|
|
#endregion
|
|
|
|
#region Check Alarm Protection History
|
|
public void CheckAlarmProtectionHistory(DeviceDataTray nTray, int tno)
|
|
{
|
|
int bit_no;
|
|
|
|
// System Over Voltage Protection Check
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, 0) != ConvertTo.GetBit(nTray.Protection, 0))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, 0))
|
|
// Warning Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.SOV_PROTECTION, tno + 1, 0, nTray.BatVoltage);
|
|
//else
|
|
// // Warning Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOV_PROTECTION, tno + 1, 0, nTray.BatVoltage);
|
|
}
|
|
// Cell Over Voltage Warning Check
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, 1) != ConvertTo.GetBit(nTray.Protection, 1))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, 1))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
|
|
}
|
|
// System Under Voltage Protection Check
|
|
bit_no = 2;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
|
|
}
|
|
// Cell Under Voltage Protection Check
|
|
bit_no = 3;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
|
|
}
|
|
// Charge Over Current Protection Check
|
|
bit_no = 4;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
|
|
}
|
|
// Discharge Over Current Protection Check
|
|
bit_no = 5;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCD_WARNING, tno + 1, 0, bTrayData[tno].Current);
|
|
}
|
|
// Charge Over Temperature Protection Check
|
|
bit_no = 8;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
}
|
|
// Discharge Over Temperature Protection Check
|
|
bit_no = 9;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
|
|
}
|
|
// Charge Low Temperature Protection Check
|
|
bit_no = 10;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
}
|
|
// Discharge Low Temperature Protection Check
|
|
bit_no = 11;
|
|
if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
{
|
|
if (ConvertTo.GetBit(nTray.Protection, bit_no))
|
|
// Protection Alarm
|
|
Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
//else
|
|
// // Protection Recovery
|
|
// Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
|
|
}
|
|
bTrayData[tno].Protection = nTray.Protection;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|