protected void Send(TransmissionState state, Result result, TResponse baseResponse = null)
{
result = result ?? Result.Success;
try
{
string data;
var serialize = Result.Success;
SocketResponsePackage <TResponse, TResponseTypes> response;
// TODO: Consider other options.
if (result.Any(i => i.Level >= ResultIssueLevels.Fatal))
{
ErrorOut(result);
}
if (IsFailed ||
(response = PackResponse(result, baseResponse)) == null ||
!(serialize += PayloadSerializer.Serialize(response, out data)) ||
!state.Send(data))
{
Send(state, result + serialize);
}
}
catch (Exception e)
{
ErrorOut(result + Result.Error(e));
}
}
protected void AcceptConnection(IAsyncResult result)
{
try
{
Accepted.Set();
Socket listener, handler;
if (result == null ||
(listener = result.AsyncState as Socket) == null ||
(handler = listener.EndAccept(result)) == null)
{
return;
}
// TODO: Consider making this configurable.
const int bufferSize = 1024;
// Begin receiving.
var state = new TransmissionState(this, bufferSize, handler, ServiceValues.EoF);
state.Receive();
}
catch (ObjectDisposedException)
{
// Exit gracefully in the event of a shutdown.
}
catch (Exception e)
{
ErrorOut(e);
}
}
/// <summary>
///Provides data for UploadFileChanged event
/// </summary>
/// <param name="bytesSend">Bytes uploaded</param>
/// <param name="totalBytesToSend">Total bytes uploaded</param>
public UploadProgressChangedLibArgs(long bytesSend, long totalBytesToSend)
{
TransmissionState = TransmissionState.Uploading;
BytesSent = bytesSend;
TotalBytesToSend = totalBytesToSend;
Procent = Procent_.Get(bytesSend, totalBytesToSend);
}//constructor
}//constructor
/// <summary>
/// Provides data for UploadFileChanged event
/// </summary>
/// <param name="transmissionState">TransmissionState e.g. Uploading, CreatingDir..</param>
public UploadProgressChangedLibArgs(TransmissionState transmissionState)
{
TransmissionState = transmissionState;
BytesSent = 0;
TotalBytesToSend = 0;
Procent = 0;
} //constructor
}//constructor
/// <summary>
/// Provides data for UploadFileCompleted event
/// </summary>
/// <param name="totalBytesSend"></param>
/// <param name="transmissionState"></param>
/// <param name="exception">Upload failed => exception describes error</param>
public UploadFileCompletedEventLibArgs(long totalBytesSend, TransmissionState transmissionState, Exception exception)
{
TotalBytesSend = totalBytesSend;
TransmissionState = transmissionState;
WebException = null;
Exception = exception;
} //constructor
}//constructor
/// <summary>
/// Provides data for DownloadFileChanged event
/// </summary>
/// <param name="totalBytesReceived">TotalBytes downloaded</param>
/// <param name="transmissionState">TransmissionState</param>
/// <param name="webException">Webexception | Webexception = NULL in case of success</param>
public DownloadFileCompletedEventLibArgs(long totalBytesReceived, TransmissionState transmissionState, WebException webException)
{
TotalBytesReceived = totalBytesReceived;
TransmissionState = transmissionState;
WebException = webException;
Exception = null;
}//constructor
private void LogAndSetTxState(TransmissionState newState)
{
#if DEBUG
if (this.Cache == null)
{
this.Cache = this.CreateProtoItem(this.OutlookItem);
}
Globals.ThisAddIn.Log.Debug($"{this.GetType().Name} '{this.Cache?.Description}': transition {this.TxState} => {newState}");
#endif
this.TxState = newState;
}
private TransmissionState DoWriteParameterIntern(int pkParameter, int converterType, ref uint value)
{
byte[] array = new byte[13];
int num = GlobalData.PKParameter2ConverterParameter(pkParameter, converterType);
byte[] array2;
TransmissionState result;
try
{
array2 = ProtocolFrame.CreateBuffer((ushort)_serialNumber, 0, (ushort)num, true, false, false, value);
this.WriteData(array2, 0, array2.Length);
}
catch (TimeoutException)
{
result = TransmissionState.WriteTimeout;
return(result);
}
catch (Exception ex)
{
result = TransmissionState.Error;
return(result);
}
try
{
TransmissionState transmissionState = this.ReadFrame(13, array2, array);
if (transmissionState == TransmissionState.Ok)
{
uint num2 = (uint)(((int)array[7] << 24) + ((int)array[8] << 16) + ((int)array[9] << 8) + (int)array[10]);
if (value == num2)
{
result = TransmissionState.Ok;
}
else
{
value = num2;
result = TransmissionState.Error;
}
}
else
{
result = transmissionState;
}
}
catch (TimeoutException)
{
result = TransmissionState.ReadTimeout;
}
catch (Exception ex2)
{
result = TransmissionState.Error;
}
return(result);
}
/// <summary>
/// This Task handles all the types of Modbus Functions
/// </summary>
/// <returns>The operation.</returns>
/// <param name="functionType">Function type.</param>
/// <param name="slaveAddress">Slave address.</param>
/// <param name="nrRegisters">Nr registers.</param>
/// <param name="selectedRegisterAddress">Selected register address.</param>
/// <param name="dataToWrite">Data to write.</param>
public async Task <ReceivedData> ModbusOperation(ModbusFunctionType functionType, byte slaveAddress, byte[] nrRegisters, byte[] selectedRegisterAddress, byte[] dataToWrite)
{
frameToSend = new ModbusFrame();
if (functionType == ModbusFunctionType.WriteCoil || functionType == ModbusFunctionType.WriteHoldingRegister)
{
frameToSend = new ModbusFrame(slaveAddress, functionType, selectedRegisterAddress, null, dataToWrite);
}
else
{
frameToSend = new ModbusFrame(slaveAddress, functionType, selectedRegisterAddress, nrRegisters, null);
}
//We send the message to the Slave Device
TransmissionState b = await SendMessage(frameToSend.BytePacketToSend);
sizeOfMessage = CalculateExpectedSize();
ReceivedData responseData = new ReceivedData();
//If the message was transmitted right, then proceed with the listening
//of the response
if (b == TransmissionState.OK)
{
System.Diagnostics.Debug.WriteLine("MessageSended: " + b.ToString());
//TO-DO Implement the retry mechanism
//int retries = 3;
//responseData = await ListenMessages();
responseData = await ListenMessages();
}
else
{
responseData.state = TransmissionState.ErrorSendMessage;
}
if (responseData.state == TransmissionState.OK)
{
frameReceived = new ModbusFrame(responseData.data);
}
else
{
frameReceived = new ModbusFrame();
}
return(responseData);
}
private TransmissionState ReadFileBlock(uint uiFileIndex, byte[] values, int converterType)
{
int num = Settings.Default.ReadFileBlockRepeat;
TransmissionState transmissionState = this.ReadFileBlockIntern(values, converterType);
while (transmissionState != TransmissionState.Ok && --num >= 0)
{
uint v = uiFileIndex / 4u;
transmissionState = this.DoWriteParameterIntern(264, 0, ref v);
if (transmissionState == TransmissionState.Ok)
{
transmissionState = this.ReadFileBlockIntern(values, converterType);
}
}
return(transmissionState);
}
private TransmissionState ReadFileBlockIntern(byte[] values, int converterType)
{
byte[] array = new byte[137];
int num = GlobalData.PKParameter2ConverterParameter(270, converterType);
byte[] array2;
TransmissionState result;
try
{
array2 = ProtocolFrame.CreateBuffer((ushort)_serialNumber, 0, (ushort)num, false, true, false, 0u);
this.WriteData(array2);
}
catch (TimeoutException)
{
result = TransmissionState.WriteTimeout;
return(result);
}
catch (Exception ex)
{
result = TransmissionState.Error;
return(result);
}
try
{
TransmissionState transmissionState = this.ReadFrame(137, array2, array);
if (transmissionState == TransmissionState.Ok)
{
Array.Copy(array, 7, values, 0, 128);
result = TransmissionState.Ok;
}
else
{
result = transmissionState;
}
}
catch (TimeoutException)
{
result = TransmissionState.ReadTimeout;
}
catch (Exception ex2)
{
result = TransmissionState.Error;
}
return(result);
}
private void LogAndSetTxState(TransmissionState newState)
{
try
{
if (this.Cache == null)
{
this.Cache = this.CreateProtoItem();
}
Globals.ThisAddIn.Log.Debug(
$"{this.GetType().Name} '{this.Cache?.Description}': transition {this.TxState} => {newState}");
}
catch (InvalidComObjectException)
{
// ignore. It doesn't matter. Although TODO: I'd love to know what happens.
}
this.TxState = newState;
}
public ProtocolFrame(ushort receiver, ushort sender, ushort parameter, bool write, bool read, bool master, bool error, bool file, bool vdew, byte[] value)
{
this.Time = DateTime.Now;
this.buffer = ProtocolFrame.CreateBuffer(receiver, sender, parameter, write, read, master, error, file, vdew, value);
this.DataLength = value.Length;
this.Checksum = this.buffer[7 + this.DataLength];
this.RatedChecksum = this.Checksum;
this.Receiver = receiver;
this.Sender = sender;
this.Parameter = parameter;
this.Write = write;
this.Read = read;
this.Master = master;
this.Error = error;
this.File = file;
this.Vdew = vdew;
this.State = TransmissionState.Ok;
}
private TransmissionState DrillDownBranchRecursive(AggregationTreeNode tnUpper, MatrixManipulator manipulator)
{
var stateUpperDesignated = new TransmissionState();
if (!tnUpper.IsLeaf)
{
foreach (var tn in tnUpper.Children)
{
var aggState = DrillDownBranchRecursive(tn, manipulator);
var aggValue = manipulator.AggregationFunctionVector[tn.Level](aggState.LevelValues);
stateUpperDesignated.LevelValues.Add(aggValue); // pass to upper
stateUpperDesignated.TreeNodes.Add(tn);
manipulator.setValue(tn.Dimmension, aggValue);
}
}
else
{
stateUpperDesignated.LevelValues.Add(manipulator.getValue(tnUpper.Dimmension));
}
return(stateUpperDesignated);
}
public static bool initSampleTransmission(int count, int fx1, int fx2, int tempo)
{
if (tState != TransmissionState.NA)
return false;
/* set up for transmission */
UsbEndpointReader reader = Device.OpenEndpointReader(ReadEndpointID.Ep01);
UsbEndpointWriter writer = Device.OpenEndpointWriter(WriteEndpointID.Ep01);
int bytesWritten, bytesRead;
byte[] setupMsg = getInitTransferCmd(count, fx1, fx2, tempo);
byte[] setupReply = new byte[1];
/* update the state */
eCode = writer.Write(setupMsg, Int32.MaxValue, out bytesWritten);
if (eCode != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
reader.Read(setupReply, Int32.MaxValue, out bytesRead);
if (eCode != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
if (setupReply[0] != Constants.TRANSFER_OK) {
tState = TransmissionState.NA;
return false;
}
return true;
}
public TransmissionException(TransmissionState state) : base($"Transmission failure: {state}.")
{
}
public TransmissionException(TransmissionState state)
{
this.State = state;
}
public ReceivedData()
{
this.data = new byte[] { };
this.state = TransmissionState.NONE;
}
public ReceivedData(byte[] data, TransmissionState state)
{
this.data = data;
this.state = state;
}
public BadStateTransition(SyncState state, TransmissionState from, TransmissionState to) : base($"{state.GetType().Name}: failed transition {from} => {to}")
{
this.To = to;
this.From = from;
}
/// <summary>
/// Provides data for UploadFileChanged event
/// </summary>
/// <param name="transmissionState">TransmissionState e.g. Uploading, CreatingDir..</param>
public UploadProgressChangedLibArgs(TransmissionState transmissionState)
{
TransmissionState = transmissionState;
BytesSent = 0;
TotalBytesToSend = 0;
Procent = 0;
}
/// <summary>
/// Mijenja stanje, mice handler is prijasnjeg stanja i instalira handlere za trenutno stanje
/// </summary>
/// <param name="new_state"></param>
private void ChangeState(TransmissionState new_state)
{
this.State.UnInstallHandlers(this);
this.State = new_state;
this.State.InstallHandlers(this);
}
/// <summary>
/// Provides data for UploadFileCompleted event
/// </summary>
/// <param name="totalBytesSend"></param>
/// <param name="transmissionState"></param>
/// <param name="exception">Upload failed => exception describes error</param>
public UploadFileCompletedEventLibArgs(long totalBytesSend, TransmissionState transmissionState, Exception exception)
{
TotalBytesSend = totalBytesSend;
TransmissionState = transmissionState;
WebException = null;
Exception = exception;
}
/// <summary>
/// Provides data for DownloadFileChanged event
/// </summary>
/// <param name="totalBytesReceived">TotalBytes downloaded</param>
/// <param name="transmissionState">TransmissionState</param>
/// <param name="exception">Exception | Exception = NULL in case of success</param>
public DownloadFileCompletedEventLibArgs(long totalBytesReceived, TransmissionState transmissionState, Exception exception)
{
TotalBytesReceived = totalBytesReceived;
TransmissionState = transmissionState;
WebException = null;
Exception = exception;
}
public ProtocolFrame(byte[] data, int startIndex, int length)
{
this.Time = DateTime.Now;
if (length < 13)
{
throw new ArgumentOutOfRangeException("length", length, "must not be less then " + 13);
}
if (data[startIndex] != 2)
{
throw new ApplicationException("FrameErrorException");
}
this.State = TransmissionState.Ok;
this.Receiver = (ushort)(((int)data[startIndex + 1] << 8) + (int)data[startIndex + 2]);
this.Sender = (ushort)(((int)data[startIndex + 3] << 8) + (int)data[startIndex + 4]);
ushort num = (ushort)(((int)data[startIndex + 5] << 8) + (int)data[startIndex + 6]);
this.Parameter = (ushort)(num & 1023);
this.Write = ((num & 32768) == 32768);
this.Read = ((num & 16384) == 16384);
this.Master = ((num & 8192) == 8192);
this.Error = ((num & 4096) == 4096);
this.File = ((num & 2048) == 2048);
this.Vdew = ((num & 1024) == 1024);
int num2;
if (this.File)
{
if (length < 137)
{
throw new ApplicationException("FrameErrorException");
}
num2 = 137;
}
else
{
num2 = 13;
}
if (data[startIndex + num2 - 1] != 3)
{
throw new ApplicationException("FrameErrorException");
}
this.Checksum = data[startIndex + num2 - 2];
this.RatedChecksum = GlobalData.CalcChecksum(data, startIndex + 1, startIndex + num2 - 3);
if (this.RatedChecksum != this.Checksum)
{
this.State = TransmissionState.ChecksumError;
}
if (this.State == TransmissionState.Ok && this.Error)
{
switch (data[startIndex + 10])
{
case 1:
this.State = TransmissionState.UnknownParameter;
break;
case 2:
this.State = TransmissionState.PasswordProtected;
break;
case 3:
this.State = TransmissionState.MaxValueError;
break;
case 4:
this.State = TransmissionState.MinValueError;
break;
case 5:
this.State = TransmissionState.ParameterIsReadOnly;
break;
case 6:
this.State = TransmissionState.AccessCode1;
break;
case 7:
this.State = TransmissionState.AccessCode2;
break;
case 8:
this.State = TransmissionState.NoCommand;
break;
case 9:
this.State = TransmissionState.WrongValue;
break;
case 10:
this.State = TransmissionState.NoAnswer;
break;
case 11:
this.State = TransmissionState.NoFWFile;
break;
default:
this.State = TransmissionState.Error;
break;
}
}
if (this.File)
{
this.DataLength = 128;
this.buffer = new byte[137];
}
else
{
this.DataLength = 4;
this.buffer = new byte[13];
}
Array.Copy(data, startIndex, this.buffer, 0, this.buffer.Length);
}
private static void initSampleTransmission(int row, int col, string filepath, int mode, int loop)
{
if (tState != TransmissionState.NA)
return;
/* set up for transmission */
UsbEndpointReader reader = Device.OpenEndpointReader(ReadEndpointID.Ep01);
UsbEndpointWriter writer = Device.OpenEndpointWriter(WriteEndpointID.Ep01);
int bytesWritten, bytesRead;
byte[] setupMsg = getTransferCmd(row, col, filepath, mode, loop);
byte[] setupReply = new byte[1];
/* update the state */
tState = TransmissionState.INIT;
eCode = writer.Write(setupMsg, Int32.MaxValue, out bytesWritten);
if (eCode != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
reader.Read(setupReply, Int32.MaxValue, out bytesRead);
if (eCode != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
if (setupReply[0] != Constants.TRANSFER_OK) {
tState = TransmissionState.NA;
return;
}
tState = TransmissionState.TRANSFER;
}
public NodeCommandCompleted(byte[] payload) :
base(FrameHeader.SOF, MessageType.Request, Channel.Function.SendData)
{
CallbackID = payload[0];
TransmissionState = (TransmissionState)payload[1];
}
private TransmissionState DoReadFile(uint fileNumber, int converterType)
{
uint num = 0u;
uint num2 = 0u;
byte[] values = new byte[128];
int num3 = Settings.Default.ReadFileLengthRepeat;
int num4 = (int)fileNumber;
if (num4 <= 12)
{
if (num4 != 2)
{
if (num4 == 12)
{
this.file12Data = new byte[32768];
}
}
}
else
{
if (num4 != 18)
{
if (num4 == 28)
{
this.file28Data = new byte[32768];
}
}
else
{
this.file18Data = new byte[1480];
}
}
uint v = 0;
TransmissionState transmissionState = DoWriteParameterIntern(260, converterType, ref v);
if (transmissionState == TransmissionState.Ok)
{
transmissionState = this.DoWriteParameterIntern(260, converterType, ref fileNumber);
}
DateTime t = DateTime.Now.AddMilliseconds((double)Settings.Default.ReadFileLengthTimeout);
while (transmissionState == TransmissionState.Ok && num == 0u && num3 > 0 && t > DateTime.Now)
{
transmissionState = this.DoReadParameter(261, out num, converterType);
System.Threading.Thread.Sleep(50);
num3--;
}
num *= 4u;
uint num5 = num;
if (fileNumber == 23 || fileNumber == 24 || fileNumber == 31)
{
this.fileRawData = new byte[num];
}
if (transmissionState == TransmissionState.Ok && num == 0u)
{
transmissionState = TransmissionState.ReadTimeout;
}
if (transmissionState == TransmissionState.Ok)
{
while (transmissionState == TransmissionState.Ok)
{
if (num5 <= 0u)
{
break;
}
Thread.Sleep(50);
transmissionState = this.ReadFileBlock(num2, values, converterType);
if (num5 >= 128u)
{
FileData(values, num2, 128u, fileNumber);
num5 -= 128u;
}
else
{
FileData(values, num2, num5, fileNumber);
num5 = 0u;
}
num2 += 128u;
}
}
return(transmissionState);
}
/// <summary>
///Provides data for UploadFileChanged event
/// </summary>
/// <param name="bytesSend">Bytes uploaded</param>
/// <param name="totalBytesToSend">Total bytes uploaded</param>
public UploadProgressChangedLibArgs(long bytesSend, long totalBytesToSend)
{
TransmissionState = TransmissionState.Uploading;
BytesSent = bytesSend;
TotalBytesToSend = totalBytesToSend;
Procent = Net.Procent.Get(bytesSend, totalBytesToSend);
}
public NodeCommandCompleted(byte[] payload) :
base(FrameHeader.SOF, MessageType.Request, Channel.Function.SendData)
{
CallbackID = payload[0];
TransmissionState = (TransmissionState)payload[1];
}
public static bool transmitSample(int row, int col, string filepath, int mode, int loop, int stream)
{
try {
initSampleTransmission(row, col, filepath, mode, loop);
if (tState != TransmissionState.TRANSFER)
return false;
UsbEndpointReader reader = Device.OpenEndpointReader(ReadEndpointID.Ep01);
UsbEndpointWriter writer = Device.OpenEndpointWriter(WriteEndpointID.Ep01);
/* reset the position to the start */
Bass.BASS_ChannelSetPosition(stream, 0);
long fileSize = new FileInfo(filepath).Length;
long length = Bass.BASS_ChannelGetLength(stream);
int offset = 0, TotalbytesWritten = 0;
do {
long pos = Bass.BASS_ChannelGetPosition(stream);
int size = bufferSize, bytesWritten = 0, bytesRead = 0;
if (offset + size > fileSize) {
size = Convert.ToInt32(fileSize) - offset;
}
/* send & receive buffers */
byte[] data = new byte[size], receive = new byte[10];
Bass.BASS_ChannelGetData(stream, data, size);
/* write the data */
eCode = writer.Write(data, Int32.MaxValue, out bytesWritten);
if (eCode != ErrorCode.None) {
throw new Exception(UsbDevice.LastErrorString);
}
TotalbytesWritten += bytesWritten;
/* read and then check successful response */
eCode = reader.Read(receive, Int32.MaxValue, out bytesRead);
if (eCode != ErrorCode.None) {
throw new Exception(UsbDevice.LastErrorString);
}
offset += bytesWritten;
switch (receive[0]) {
case Constants.TRANSFER_OK:
break;
case Constants.TRANSFER_CMP:
if (offset != fileSize)
throw new Exception("Unexpected end of transmission");
break;
case Constants.TRANSFER_ERR:
default:
throw new Exception("error in transmission");
}
} while (offset < length);
} catch (Exception ex) {
throw ex;
} finally {
if (Device != null) {
if (Device.IsOpen) {
Device.Close();
}
}
Device = null;
// Free usb resources
UsbDevice.Exit();
tState = TransmissionState.NA;
}
return true;
}
public Protocol()
{
log.Debug("Protocol:ctor");
_state = TransmissionState.Idle;
_state.InstallHandlers(this);
_input = new BlockingCollection<string>();
_output = new BlockingCollection<string>();
_orders = new Dictionary<string, Message>();
_commands = new BlockingCollection<ICommand>();
_results = new BlockingCollection<Message>();
_receiveHandlerMap = new Dictionary<string, Action<ProtocolReceiverEventArgs>>();
_messageHandlerMap = new Dictionary<string, Action<MessageReceiveEventArgs>>();
_timer = new System.Timers.Timer();
_timer.AutoReset = false;
Entity = Entity.Host;
Mode = Mode.RealTime;
InitReceiveEventMap();
InitMessageEventMap();
//_task = Task.Factory.StartNew(ReceiverTask);
_task_cancel = new CancellationTokenSource();
//_command_task = Task.Factory.StartNew(CommandTask);
_command_task_cancel = new CancellationTokenSource();
_waitHandle = new AutoResetEvent(false);
}
public void Run()
{
ILogger <InverterTask> logger = ServiceFactory.CurrentServiceProvider.GetService <ILogger <InverterTask> >();
ILogger <FimerR25Inverter> loggerFimer = ServiceFactory.CurrentServiceProvider.GetService <ILogger <FimerR25Inverter> >();
IMQTTQueueService mqttService = ServiceFactory.CurrentServiceProvider.GetService <IMQTTQueueService>();
using (IInverter currentInverter = new FimerR25Inverter(loggerFimer))
{
Hashtable ht = new Hashtable
{
{ InverterCommonProperties.NET_IP_ADDRESS, "192.168.0.99" },
{ InverterCommonProperties.NET_IP_PORT, "33330" },
{ InverterCommonProperties.SERIAL_NUMBER, "18344" }
};
logger.LogDebug($"Connect to: {ht[InverterCommonProperties.NET_IP_ADDRESS]} - Port: {ht[InverterCommonProperties.NET_IP_PORT]} - Serial : {ht[InverterCommonProperties.SERIAL_NUMBER]}");
Ping p = new Ping();
PingReply pr = p.Send(IPAddress.Parse((string)ht[InverterCommonProperties.NET_IP_ADDRESS]), 5000);
if (pr.Status == IPStatus.Success)
{
logger.LogDebug("initing...");
currentInverter.Init(ht);
logger.LogDebug("connecting...");
TransmissionState ts = currentInverter.Connect();
logger.LogDebug("connected");
if (ts == TransmissionState.Ok)
{
logger.LogDebug("start reading...");
ConverterStatus?cs = currentInverter.ReadData(31);
logger.LogDebug("Reading status:" + (cs != null).ToString());
if (cs == null)
{
logger.LogDebug("Nessun dato letto");
currentInverter.Dispose();
}
ServiceFactory.CurrentServiceProvider.GetService <IPersisterFactory>().Save(currentInverter, cs);
MessageBase mb = new MessageBase
{
Command = Constants.Power.Messages.ProductionDataAcquired,
Data = new ProductionDataInfo
{
DailyValue = cs.Value.CommonStatus.EnergieTag * 1000,
CurrentValue = (ushort)cs.Value.TypeStatus.GetProperty(CommonPropertyType.ProduzioneCorrente)
}
};
var jsonSerializerSettings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
};
mqttService.Publish(Constants.Power.Queues.Production, JsonConvert.SerializeObject(mb, jsonSerializerSettings));
}
else
{
logger.LogDebug($"reading error:{ts}");
}
}
}
}
