//Dictionary<int, DateTime> lastRecordTime = new Dictionary<int, DateTime>();
//Dictionary<int, DateTime> lastRecordTime = new Dictionary<int, DateTime>();
private void ManagedClient_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
try
{
//lastTime = DateTime.Now.Add(mqttOptions.RecordInterval);
//byte[] pay_load = e.ApplicationMessage.Payload;
//byte[] new_fileArray = new byte[pay_load.Length + 8];
//Array.Copy(pay_load, new_fileArray, pay_load.Length);
//File.WriteAllBytes($"{DateTime.Now.TimeOfDay}_dump.bin", e.ApplicationMessage.Payload);
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(e.ApplicationMessage.Payload);
//if (lastRecordTime.ContainsKey(packet.sSiteId) == false)
// lastRecordTime.Add(packet.sSiteId, DateTime.MinValue);
//if (DateTime.Now < lastRecordTime[packet.sSiteId])
// return;
_logger.LogInformation($"RECEIVED DAEGUN : siteid({packet.sSiteId}) from({e.ClientId}) t({e.ApplicationMessage.Topic}) QoS({e.ApplicationMessage.QualityOfServiceLevel}) size({e.ApplicationMessage.Payload.Length})");
//nLogger.Info($"RECEIVED DAEGUN : siteid({packet.sSiteId}) from({e.ClientId}) t({e.ApplicationMessage.Topic}) QoS({e.ApplicationMessage.QualityOfServiceLevel}) size({e.ApplicationMessage.Payload.Length})");
//lastRecordTime[packet.sSiteId] = DateTime.Now.Add(mqttOptions.RecordInterval);
//packet.timestamp = DateTime.Now;
DateTime dt = DateTime.Now.Date
.AddHours(DateTime.Now.Hour)
.AddMinutes(DateTime.Now.Minute)
.AddSeconds(DateTime.Now.Second);
#if RASPIAN == false
queue.QueueBackgroundWorkItem(new DaegunPacketClass(packet, dt));
#else
NLog.LogEventInfo pcsEventInfo = LogEventMaker.CreateLogEvent(PCS_LOG, packet.Pcs);
NLog.LogEventInfo bscEventInfo = LogEventMaker.CreateLogEvent(BSC_LOG, packet.Bsc);
NLog.LogEventInfo pvEventInfo = LogEventMaker.CreateLogEvent(PV_METER_LOG, packet.Pv);
NLog.LogEventInfo essEventInfo = LogEventMaker.CreateLogEvent(BSC_METER_LOG, packet.Ess);
//NLog.Logger logger = NLog.LogManager.Configuration.LogFactory.GetLogger("record.pcs");
//NLog.LogEventInfo logEvent = LogEventMaker.CreateLogEvent("record.pcs", pcsPacket);
pcsEventInfo.Properties["SiteId"] =
bscEventInfo.Properties["SiteId"] =
pvEventInfo.Properties["SiteId"] =
essEventInfo.Properties["SiteId"] = packet.sSiteId;
pcsLogger.Log(pcsEventInfo);
bscLogger.Log(bscEventInfo);
pvMeterLogger.Log(pvEventInfo);
bscMeterLogger.Log(essEventInfo);
//logger.Log(logEvent);
#endif
//logger.LogInformation("Store Daegun Packet");
//if(lastRecordTime.ContainsKey(packet.sSiteId) == false)
//{
// lastRecordTime.Add(packet.sSiteId, DateTime.MinValue);
//}
//if (DateTime.Now > lastRecordTime[packet.sSiteId])
//{
// lastRecordTime[packet.sSiteId] = DateTime.Now.Add(mqttOptions.RecordInterval);
//}
}catch (Exception ex)
{
Console.WriteLine(ex.Message);
_logger.LogError(ex, ex.Message);
}
}
protected override Task OnMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs e)
{
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(e.ApplicationMessage.Payload);
queue.QueueBackgroundWorkItem(packet);
return(Task.CompletedTask);
}
private PcsData CreatePcsData(DaegunPacketClass _packet)
{
DaegunPacket packet = _packet.Packet;
PcsData pcs = new PcsData();
pcs.deviceId = $"DS{packet.sSiteId}_PCS{packet.Pcs.PcsNumber}";
pcs.groupId = 1;
pcs.siteId = packet.sSiteId;
pcs.groupName = "PCS_SYSTEM";
pcs.freq = packet.Pcs.Frequency;
pcs.acVltR = packet.Pcs.AC_line_voltage.R;
pcs.acVltS = packet.Pcs.AC_line_voltage.S;
pcs.acVltT = packet.Pcs.AC_line_voltage.T;
pcs.actPwrCmdLmtLowChg = 0;
pcs.actPwrCmdLmtLowDhg = 0;
pcs.actPwrCmdLmtHighChg = packet.Bsc.ChargePowerLimit;
pcs.actPwrCmdLmtHighDhg = packet.Bsc.DischargePowerLimit;
pcs.actPwr = packet.Pcs.ActivePower;
pcs.acCrtLow = 0;
pcs.acCrtHigh = packet.Bsc.DischargeCurrentLimit;
pcs.acCrtR = packet.Pcs.AC_phase_current.R;
pcs.acCrtS = packet.Pcs.AC_phase_current.S;
pcs.acCrtT = packet.Pcs.AC_phase_current.T;
pcs.rctPwr = packet.Pcs.ReactivePower;
pcs.pf = packet.Pcs.PowerFactor;
pcs.timestamp = _packet.Timestamp;
return(pcs);
}
protected async override Task ExecuteAsync(CancellationToken stoppingToken)
{
DateTime lastRecord = DateTime.MinValue;
while (!stoppingToken.IsCancellationRequested)
{
//var workItem = await TaskQueue.DequeueAsync(stoppingToken);
DaegunPacket modbusWorkItem = await TaskQueue.DequeueAsync(stoppingToken);
try
{
modbusWorkItem.timestamp = DateTime.Now;
string pcs_key = $"site_{modbusWorkItem.sSiteId}_PCS";
string bsc_key = $"site_{modbusWorkItem.sSiteId}_BSC";
string ess_key = $"site_{modbusWorkItem.sSiteId}_ESSMETER";
string pv_key = $"site_{modbusWorkItem.sSiteId}_PVMETER";
HashEntry lastUpdate = new HashEntry("timestamp", DateTime.Now.ToString());
var hashPcsMap = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Pcs);
hashPcsMap.Add(lastUpdate);
var hashbmsMap = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Bsc, lastUpdate);
var hashmeter_ess_Map = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Ess, lastUpdate);
var hashmeter_pv_Map = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Pv, lastUpdate);
await _redisDb.HashSetAsync(pcs_key, hashPcsMap.ToArray(), CommandFlags.FireAndForget);
await _redisDb.HashSetAsync(bsc_key, hashbmsMap.ToArray(), CommandFlags.FireAndForget);
await _redisDb.HashSetAsync(ess_key, hashmeter_ess_Map.ToArray(), CommandFlags.FireAndForget);
await _redisDb.HashSetAsync(pv_key, hashmeter_pv_Map.ToArray(), CommandFlags.FireAndForget);
_db = _client.GetDatabase("PEIU");
cols = _db.GetCollection <DaegunPacket>("daegun_meter");
lastRecord = DateTime.Now.Add(_mqttConfig.RecordInterval);
await cols.InsertOneAsync(modbusWorkItem);
_logger.LogInformation("Recorded packet from daegun");
//Console.WriteLine($"SAVE DB");
// if(workItem != null)
// await workItem(stoppingToken);
//if (modbusWorkItem != null)
// await modbusWorkItem.RunAsync(stoppingToken);
}
catch (Exception ex)
{
_logger.LogError(ex,
$"Error occurred executing {nameof(modbusWorkItem)}.");
}
}
_logger.LogInformation("Queued Hosted Service is stopping.");
}
private void ManagedClient_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
logger.LogInformation($"RECEIVED DAEGUN :from({e.ClientId}) t({e.ApplicationMessage.Topic}) QoS({e.ApplicationMessage.QualityOfServiceLevel}) size({e.ApplicationMessage.Payload.Length})");
byte[] pay_load = e.ApplicationMessage.Payload;
byte[] new_fileArray = new byte[pay_load.Length + 8];
Array.Copy(pay_load, new_fileArray, pay_load.Length);
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(new_fileArray);
packet.timestamp = DateTime.Now;
queue.QueueBackgroundWorkItem(packet);
logger.LogInformation("Queuying Daegun Packet");
}
private void DaegunSubscriberWorker_MessageReceived(object sender, MQTTnet.MqttApplicationMessageReceivedEventArgs e)
{
try
{
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(e.ApplicationMessage.Payload);
queue.QueueBackgroundWorkItem(packet);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
peiuPublishWorker = new PeiuPublishWorker(stoppingToken);
peiuPublishWorker.Initialize();
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
DaegunPacket pacekt = await packetQueue.DequeueAsync(stoppingToken);
await Task.Delay(100, stoppingToken);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
PeiuPublishWorker = new PeiuPublishWorker(stoppingToken);
PeiuPublishWorker.Initialize();
while (true)
{
stoppingToken.ThrowIfCancellationRequested();
if (stoppingToken.IsCancellationRequested)
{
break;
}
DaegunPacket packet = await queue.DequeueAsync(stoppingToken);
await PublishAsync(packet);
}
}
private async Task PublishAsync(DaegunPacket packet)
{
string pcs_string = null;
string bms_string = null;
string pv_string = null;
if (MqttModelConvert.ConvertPcs(packet, DateTime.Now, ref pcs_string, ref bms_string, ref pv_string))
{
//await base.p
await PeiuPublishWorker.publish(packet.sSiteId, "PCS" + packet.Pcs.PcsNumber, pcs_string);
await PeiuPublishWorker.publish(packet.sSiteId, "BMS" + packet.Bsc.PcsIndex, bms_string);
await PeiuPublishWorker.publish(packet.sSiteId, "PV" + packet.Pv.DeviceIndex, pv_string);
}
}
private BmsData CreateBmsData(DaegunPacketClass _packet)
{
DaegunPacket packet = _packet.Packet;
BmsData bmsData = new BmsData();
bmsData.deviceId = $"DS{packet.sSiteId}_BMS{packet.Bsc.PcsIndex}";
bmsData.groupId = 2;
bmsData.siteId = packet.sSiteId;
bmsData.timestamp = _packet.Timestamp;
bmsData.groupName = "PCS_BATTERY";
bmsData.soc = packet.Bsc.Soc;
bmsData.soh = packet.Bsc.Soh;
bmsData.dcPwr = packet.Pcs.Dc_battery_power;
bmsData.dcVlt = packet.Pcs.Dc_battery_voltage;
bmsData.dcCrt = packet.Pcs.Dc_battery_current;
bmsData.cellMaxTemp = packet.Bsc.ModuleTempRange.Max;
bmsData.cellMinTemp = packet.Bsc.ModuleTempRange.Min;
bmsData.cellMinVlt = packet.Bsc.CellVoltageRange.Min;
bmsData.cellMaxVlt = packet.Bsc.CellVoltageRange.Max;
return(bmsData);
}
private async Task PublishAsync(DaegunPacket packet, CancellationToken stoppingToken)
{
string pcs_string = null;
string bms_string = null;
string pv_string = null;
if (MqttModelConvert.ConvertPcs(packet, DateTime.Now, ref pcs_string, ref bms_string, ref pv_string))
{
//await base.p
await PeiuPublishWorker.publish(packet.sSiteId, DeviceTypes.PCS, packet.Pcs.PcsNumber, pcs_string);
await PeiuPublishWorker.publish(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, bms_string);
await PeiuPublishWorker.publish(packet.sSiteId, DeviceTypes.PV, packet.Pv.PmsIndex, pv_string);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.PCS, packet.Pcs.PcsNumber, 2, 27, (ushort)packet.Pcs.Faults[0], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.PCS, packet.Pcs.PcsNumber, 2, 28, (ushort)packet.Pcs.Faults[1], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.PCS, packet.Pcs.PcsNumber, 2, 29, (ushort)packet.Pcs.Faults[2], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 23, (ushort)packet.Bsc.Warning[0], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 24, (ushort)packet.Bsc.Warning[1], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 25, (ushort)packet.Bsc.Warning[2], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 26, (ushort)packet.Bsc.Warning[3], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 27, (ushort)packet.Bsc.Faults[0], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 28, (ushort)packet.Bsc.Faults[1], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 29, (ushort)packet.Bsc.Faults[2], stoppingToken);
await _worker.UpdateDigitalPoint(packet.sSiteId, DeviceTypes.BMS, packet.Bsc.PcsIndex, 2, 30, (ushort)packet.Bsc.Faults[3], stoppingToken);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
PeiuPublishWorker = new PeiuPublishWorker(stoppingToken);
PeiuPublishWorker.Initialize();
while (true)
{
try
{
stoppingToken.ThrowIfCancellationRequested();
if (stoppingToken.IsCancellationRequested)
{
break;
}
//if(PeiuPublishWorker.)
DaegunPacket packet = await queue.DequeueAsync(stoppingToken);
await PublishAsync(packet, stoppingToken);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
}
}
}
public void QueueBackgroundWorkItem(DaegunPacket workItem)
{
// DaegunPacket workItem = new DaegunPacket(client, packetStruct);
_workItems.Enqueue(workItem);
_signal.Release();
}
public static bool ConvertPcs(DaegunPacket packet, DateTime timestamp, ref string pcs_string, ref string bms_string, ref string pv_string)
{
DaegunPcsPacket pcsPacket = packet.Pcs;
DaegunBSCPacket bmsPacket = packet.Bsc;
DaegunMeterPacket bms_meter_packet = packet.Ess;
DaegunMeterPacket pv_pack = packet.Pv;
JObject obj = CreateTemporary(1, "PCS_SYSTEM", $"PCS{pcsPacket.PcsNumber}", packet.sSiteId, timestamp);
obj.Add("freq", pcsPacket.Frequency);
obj.Add("acGridVlt", 0);
obj.Add("acGridCrtLow", 0);
obj.Add("acGridCrtHigh", 0);
obj.Add("acGridPwr", 0);
obj.Add("actPwrKw", pcsPacket.ActivePower);
obj.Add("rctPwrKw", pcsPacket.ReactivePower);
obj.Add("pwrFact", pcsPacket.PowerFactor);
obj.Add("acGridVltR", pcsPacket.AC_phase_voltage.R);
obj.Add("acGridVltS", pcsPacket.AC_phase_voltage.S);
obj.Add("acGridVltT", pcsPacket.AC_phase_voltage.T);
obj.Add("acGridCrtR", pcsPacket.AC_phase_current.R);
obj.Add("acGridCrtS", pcsPacket.AC_phase_current.S);
obj.Add("acGridCrtT", pcsPacket.AC_phase_current.T);
obj.Add("actCmdLimitLowChg", 0);
obj.Add("actCmdLimitLowDhg", 0);
obj.Add("actCmdLimitHighChg", bmsPacket.ChargePowerLimit);
obj.Add("actCmdLimitHighDhg", bmsPacket.DischargePowerLimit);
pcs_string = obj.ToString();
obj = CreateTemporary(2, "PCS_BATTERY", $"BMS{bmsPacket.PcsIndex}", packet.sSiteId, timestamp);
obj.Add("bms_soc", bmsPacket.Soc);
obj.Add("bms_soh", bmsPacket.Soh);
obj.Add("dcCellPwr", packet.Pcs.Dc_battery_power);
obj.Add("dcCellVlt", packet.Pcs.Dc_battery_voltage);
obj.Add("dcCellCrt", packet.Pcs.Dc_battery_current);
obj.Add("dcCellTmpMx", packet.Bsc.ModuleTempRange.Max);
obj.Add("dcCellTmpMn", packet.Bsc.ModuleTempRange.Min);
obj.Add("dcCellVltMx", packet.Bsc.CellVoltageRange.Max);
obj.Add("dcCellVltMn", packet.Bsc.CellVoltageRange.Min);
bms_string = obj.ToString();
obj = CreateTemporary(4, "PV_SYSTEM", $"PV{pv_pack.PmsIndex}", packet.sSiteId, timestamp);
obj.Add("TotalActivePower", pv_pack.TotalActivePower);
obj.Add("TotalReactivePower", pv_pack.TotalReactivePower);
obj.Add("ReverseActivePower", pv_pack.ReverseActivePower);
obj.Add("ReverseReactivePower", pv_pack.ReverseReactivePower);
obj.Add("vltR", pv_pack.Voltage.R);
obj.Add("vltS", pv_pack.Voltage.S);
obj.Add("vltT", pv_pack.Voltage.T);
obj.Add("crtR", pv_pack.Current.R);
obj.Add("crtS", pv_pack.Current.S);
obj.Add("crtT", pv_pack.Current.T);
obj.Add("Frequency", pv_pack.Frequency);
if (pv_pack.EnergyTotalActivePower != 0)
{
}
obj.Add("EnergyTotalActivePower", pv_pack.EnergyTotalActivePower);
obj.Add("EnergyTotalReactivePower", pv_pack.EnergyTotalReactivePower);
obj.Add("EnergyTotalReverseActivePower", pv_pack.EnergyTotalReverseActivePower);
pv_string = obj.ToString();
return(true);
}
private void DaegunSubscriberWorker_MessageReceived(object sender, MQTTnet.MqttApplicationMessageReceivedEventArgs e)
{
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(e.ApplicationMessage.Payload);
queue.QueueBackgroundWorkItem(packet);
}
protected async override Task ExecuteAsync(CancellationToken stoppingToken)
{
DateTime batchTime = DateTime.MinValue;
while (!stoppingToken.IsCancellationRequested)
{
//var workItem = await TaskQueue.DequeueAsync(stoppingToken);
mre.WaitOne();
DaegunPacketClass queueItem = await TaskQueue.DequeueAsync(stoppingToken);
DaegunPacket modbusWorkItem = queueItem.Packet;
try
{
//modbusWorkItem.timestamp = DateTime.Now;
//string pcs_key = $"site_{modbusWorkItem.sSiteId}_PCS";
//string bsc_key = $"site_{modbusWorkItem.sSiteId}_BSC";
//string ess_key = $"site_{modbusWorkItem.sSiteId}_ESSMETER";
//string pv_key = $"site_{modbusWorkItem.sSiteId}_PVMETER";
//HashEntry lastUpdate = new HashEntry("timestamp", DateTime.Now.ToString());
//var hashPcsMap = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Pcs);
//hashPcsMap.Add(lastUpdate);
//var hashbmsMap = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Bsc, lastUpdate);
//var hashmeter_ess_Map = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Ess, lastUpdate);
//var hashmeter_pv_Map = RedisConnectionFactory.CreateHashEntries(modbusWorkItem.Pv, lastUpdate);
//await _redisDb.HashSetAsync(pcs_key, hashPcsMap.ToArray(), CommandFlags.FireAndForget);
//await _redisDb.HashSetAsync(bsc_key, hashbmsMap.ToArray(), CommandFlags.FireAndForget);
//await _redisDb.HashSetAsync(ess_key, hashmeter_ess_Map.ToArray(), CommandFlags.FireAndForget);
//await _redisDb.HashSetAsync(pv_key, hashmeter_pv_Map.ToArray(), CommandFlags.FireAndForget);
if (lastRecordTime.ContainsKey(modbusWorkItem.sSiteId) == false)
{
lastRecordTime.Add(modbusWorkItem.sSiteId, DateTime.MinValue);
}
insertBatchList.Add(queueItem);
//if (DateTime.Now > lastRecordTime[modbusWorkItem.sSiteId])
//{
// insertBatchList.Add(queueItem);
// //_db = _client.GetDatabase("PEIU");
// //cols = _db.GetCollection<DaegunPacket>("daegun_meter");
// ////lastRecord = DateTime.Now.Add(_mqttConfig.RecordInterval);
// //await cols.InsertOneAsync(modbusWorkItem);
// //_logger.LogInformation("Store packet from daegun");
// lastRecordTime[modbusWorkItem.sSiteId] = DateTime.Now.Add(_mqttConfig.RecordInterval);
//}
if (batchTime <= DateTime.Now)
{
StoreDb(stoppingToken);
batchTime = DateTime.Now.Add(BatchInterval);
}
//Console.WriteLine($"SAVE DB");
// if(workItem != null)
// await workItem(stoppingToken);
//if (modbusWorkItem != null)
// await modbusWorkItem.RunAsync(stoppingToken);
}
catch (Exception ex)
{
_logger.LogError(ex,
$"Error occurred executing {nameof(ex)}");
Console.WriteLine(ex);
}
}
_logger.LogInformation("Queued Hosted Service is stopping.");
}