private void AppBinWriteGpio()
{
if (CheckStartStatus() != true)
{
return;
}
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.WriteGpio,
Arguments = new List <object>()
{
(byte)1,
(byte)1
}
};
binMsg.Header.device_id = 1;
binMsg.Header.flag1.sequence_num = _hostSimul.GetNextSeqNum();
IFlMessage message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
_hostSimul.ResponseReceived = false;
_hostSimul.SendPacket(message.Buffer);
WaitForResponse();
}
private FlBinMessageResponse GetResponse(FlBinMessageCommand command)
{
FlBinMessageResponse response = null;
int count = 0;
int i;
lock (_generalLock)
{
count = _responseQ.Count;
}
if (count > 0)
{
Console.WriteLine($"Response count : {count}");
}
for (i = 0; i < count; i++)
{
if ((_responseQ[i].MessageId == command.MessageId) &&
(_responseQ[i].Header.flag1.sequence_num == command.Header.flag1.sequence_num))
{
lock (_generalLock)
{
response = _responseQ[i];
_responseQ.RemoveAt(i);
}
break;
}
}
return(response);
}
private void AppHwVer()
{
IFlMessage message = null;
if (_flMsgMgr.MessageType == FwMessageType.Text)
{
message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadHardwareVersion,
Arguments = new List <object>()
{
_deviceId.ToString() // DeviceID
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref message);
}
else if (_flMsgMgr.MessageType == FwMessageType.Binary)
{
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadHardwareVersion
};
binMsg.Header.device_id = _deviceId;
binMsg.Header.flag1.sequence_num = GetNextSeqNum();
message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
}
_flMsgMgr.EnqueueCommand(message);
}
private IFlMessage ProcessCommand(FlBinMessageCommand command)
{
TimeSpan timeSpan;
bool waitTimeExpired;
IFlMessage response = null;
IFlMessage message = (IFlMessage)command;
FlBinPacketBuilder.BuildMessagePacket(ref message);
lock (_generalLock)
{
_commandQ.Add(command);
}
for (int i = 0; i < command.MaxTryCount; i++)
{
_serialPort.Write(command.Buffer, 0, command.Buffer.Length);
if (command.SendTimeHistory == null)
{
command.SendTimeHistory = new List <DateTime>();
}
command.SendTimeHistory.Add(DateTime.UtcNow);
waitTimeExpired = false;
while (true)
{
response = GetResponse(command);
if (response != null)
{
break;
}
timeSpan = DateTime.UtcNow - command.SendTimeHistory[i];
if (timeSpan.TotalMilliseconds > command.ResponseWaitTimeout)
{
waitTimeExpired = true;
Console.WriteLine($"Response wait time expired");
break;
}
}
if (response != null)
{
break;
}
if ((waitTimeExpired == true) &&
(command.TryInterval > 0))
{
Thread.Sleep(command.TryInterval);
}
}
lock (_generalLock)
{
_commandQ.RemoveAt(0);
}
return(response);
}
private void AppBinFwVer()
{
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion
};
binMsg.Header.device_id = 1;
binMsg.Header.flag1.sequence_num = _hostSimul.GetNextSeqNum();
IFlMessage message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
_hostSimul.ResponseReceived = false;
_hostSimul.SendPacket(message.Buffer);
WaitForResponse();
}
private void OnBinCommandResultReady(FwCommandMessageResult cmdResult)
{
FlBinMessageCommand command = (FlBinMessageCommand)cmdResult.Command;
int i;
TimeSpan spanTime;
Console.WriteLine($"Command : {command.MessageId}");
Console.WriteLine($"Try count : {command.TryCount}");
if (command.TryCount > 1)
{
for (i = 0; i < command.TryCount; i++)
{
if ((i + 1) < command.TryCount)
{
spanTime = command.SendTimeHistory[i + 1] - command.SendTimeHistory[i];
Console.WriteLine($"Try interval : {spanTime.TotalMilliseconds}");
}
}
}
if (command.TryCount > 0)
{
spanTime = cmdResult.CreatedDate - command.SendTimeHistory[0];
Console.WriteLine($"Total processing time : {spanTime.TotalMilliseconds}");
}
if (cmdResult.Response != null)
{
if (cmdResult.Response.Arguments?.Count > 0)
{
foreach (var item in cmdResult.Response.Arguments)
{
Console.WriteLine($"{item}");
}
}
}
else
{
Console.WriteLine("No response");
}
}
private void AppWriteGpio()
{
IFlMessage message = null;
if (_flMsgMgr.MessageType == FwMessageType.Text)
{
message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.WriteGpio,
Arguments = new List <object>()
{
_deviceId.ToString(), // DeviceID
"3", // GPIO number
"1" // GPIO value
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref message);
}
else if (_flMsgMgr.MessageType == FwMessageType.Binary)
{
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.WriteGpio,
Arguments = new List <object>()
{
(byte)3,
(byte)1
}
};
binMsg.Header.device_id = _deviceId;
binMsg.Header.flag1.sequence_num = GetNextSeqNum();
message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
}
_flMsgMgr.EnqueueCommand(message);
}
private void AppBinHwVer()
{
if (CheckStartStatus() != true)
{
return;
}
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadHardwareVersion
};
binMsg.Header.device_id = 1;
binMsg.Header.flag1.sequence_num = _hostSimul.GetNextSeqNum();
IFlMessage message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
_hostSimul.ResponseReceived = false;
_hostSimul.SendPacket(message.Buffer);
WaitForResponse();
}
private void AppBootBmode()
{
IFlMessage message = null;
if (_flMsgMgr.MessageType == FwMessageType.Text)
{
message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.BootMode,
Arguments = new List <object>()
{
_deviceId.ToString(), // DeviceID
FlConstant.FL_BMODE_BOOTLOADER.ToString() // Bootloader
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref message);
}
else if (_flMsgMgr.MessageType == FwMessageType.Binary)
{
IFlBinMessage binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.BootMode,
Arguments = new List <object>()
{
(byte)FlConstant.FL_BMODE_BOOTLOADER
}
};
binMsg.Header.device_id = _deviceId;
binMsg.Header.flag1.sequence_num = GetNextSeqNum();
message = binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref message);
}
_flMsgMgr.EnqueueCommand(message);
}
private void ReadTempAndHum(uint deviceId, byte sensorNum)
{
IFlMessage command = null;
if (_currentParserType == ParserType.Binary)
{
command = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadTempAndHum,
Arguments = new List <object>()
{
sensorNum
}
};
((FlBinMessageCommand)command).Header.device_id = deviceId;
((FlBinMessageCommand)command).Header.flag1.sequence_num = _sequenceNumber;
}
else if (_currentParserType == ParserType.Text)
{
command = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadTempAndHum,
Arguments = new List <object>()
{
deviceId.ToString(),
sensorNum.ToString()
}
};
}
if (command != null)
{
CommandResult result = _msgManager.ReadTemperatureAndHumidity(command);
LbMessageHistory.Items.Add($"S : ReadTemperature");
string response = string.Empty;
if (result != null)
{
if (result.Response != null)
{
if (_currentParserType == ParserType.Binary)
{
FlBinMessageResponse resp = (FlBinMessageResponse)result.Response;
if (resp.Header.flag2.error == FlConstant.FL_OK)
{
if (result.Response.Arguments?.Count == 3)
{
response = string.Format("R : {0},{1:0.##}.{2:0.##}",
(byte)result.Response.Arguments[0],
(double)result.Response.Arguments[1],
(double)result.Response.Arguments[1]
);
}
else
{
response = "R : Invalid response(invalid argument count)";
}
}
else
{
response = "R : Error";
}
}
else if (_currentParserType == ParserType.Text)
{
if (result.Response.Arguments?.Count == 5)
{
if ((string)result.Response.Arguments[1] == FlConstant.FL_OK.ToString())
{
response = $"R : OK, {(string)result.Response.Arguments[2]}, {(string)result.Response.Arguments[3]}, {(string)result.Response.Arguments[4]}";
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = "R : Invalid parser type";
}
}
else
{
response = "R : No response";
}
}
else
{
response = "R : Command fail";
}
LbMessageHistory.Items.Add(response);
}
}
private void ReadGpio(uint deviceId, byte gpioNum)
{
IFlMessage command = null;
if (_currentParserType == ParserType.Binary)
{
command = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadGpio,
Arguments = new List <object>()
{
gpioNum
}
};
((FlBinMessageCommand)command).Header.device_id = deviceId;
((FlBinMessageCommand)command).Header.flag1.sequence_num = _sequenceNumber;
}
else if (_currentParserType == ParserType.Text)
{
command = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadGpio,
Arguments = new List <object>()
{
deviceId.ToString(),
gpioNum.ToString()
}
};
}
if (command != null)
{
CommandResult result = _msgManager.ReadGpio(command);
LbMessageHistory.Items.Add($"S : ReadGpio");
string response = string.Empty;
if (result != null)
{
if (result.Response != null)
{
if (_currentParserType == ParserType.Binary)
{
FlBinMessageResponse resp = (FlBinMessageResponse)result.Response;
if (resp.Header.flag2.error == FlConstant.FL_OK)
{
if (result.Response.Arguments?.Count == 2)
{
response = $"R : {(byte)result.Response.Arguments[0]},{(byte)result.Response.Arguments[1]}";
}
else
{
response = "R : Invalid response(invalid argument count)";
}
}
else
{
response = "R : Error";
}
}
else if (_currentParserType == ParserType.Text)
{
if (result.Response.Arguments?.Count == 4)
{
if ((string)result.Response.Arguments[1] == FlConstant.FL_OK.ToString())
{
response = $"R : OK, {(string)result.Response.Arguments[2]}, {(string)result.Response.Arguments[3]}";
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = "R : Invalid parser type";
}
}
else
{
response = "R : No response";
}
}
else
{
response = "R : Command fail";
}
LbMessageHistory.Items.Add(response);
}
}
private void ReadFirmwareVersion(uint deviceId)
{
IFlMessage command = null;
if (_currentParserType == ParserType.Binary)
{
command = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion
};
((FlBinMessageCommand)command).Header.device_id = deviceId;
((FlBinMessageCommand)command).Header.flag1.sequence_num = _sequenceNumber;
}
else if (_currentParserType == ParserType.Text)
{
command = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion,
Arguments = new List <object>()
{
deviceId.ToString()
}
};
}
if (command != null)
{
CommandResult result = _msgManager.ReadFirmwareVersion(command);
LbMessageHistory.Items.Add($"S : ReadFirmwareVersion");
string response = string.Empty;
if (result != null)
{
if (result.Response != null)
{
if (_currentParserType == ParserType.Binary)
{
if (((FlBinMessageResponse)(result.Response)).Header.flag2.error == FlConstant.FL_OK)
{
if (result.Response.Arguments?.Count == 1)
{
response = $"R : {(string)result.Response.Arguments[0]}";
}
else
{
response = "R : Invalid response(invalid version format)";
}
}
else
{
response = "R : Error";
}
}
else if (_currentParserType == ParserType.Text)
{
if (result.Response.Arguments?.Count == 3)
{
if ((string)result.Response.Arguments[1] == FlConstant.FL_OK.ToString())
{
response = $"R : OK, {(string)result.Response.Arguments[2]}";
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = "R : Invalid parser type";
}
}
else
{
response = "R : No response";
}
}
else
{
response = "R : Command fail";
}
LbMessageHistory.Items.Add(response);
}
}
private void BootMode(uint deviceId, byte bootMode)
{
IFlMessage command = null;
if (_currentParserType == ParserType.Binary)
{
command = new FlBinMessageCommand()
{
MessageId = FlMessageId.BootMode
};
((FlBinMessageCommand)command).Header.device_id = deviceId;
((FlBinMessageCommand)command).Header.flag1.sequence_num = _sequenceNumber;
command.Arguments = new List <object>()
{
bootMode
};
}
else if (_currentParserType == ParserType.Text)
{
command = new FlTxtMessageCommand()
{
MessageId = FlMessageId.BootMode,
Arguments = new List <object>()
{
deviceId.ToString(),
bootMode.ToString()
}
};
}
if (command != null)
{
CommandResult result = _msgManager.BootMode(command);
LbMessageHistory.Items.Add($"S : Boot mode");
string response = string.Empty;
if (result != null)
{
if (result.Response != null)
{
if (_currentParserType == ParserType.Binary)
{
if (((FlBinMessageResponse)(result.Response)).Header.flag2.error == FlConstant.FL_OK)
{
response = $"R : OK";
}
else
{
response = "R : Error";
}
}
else if (_currentParserType == ParserType.Text)
{
if (result.Response.Arguments?.Count == 2)
{
if ((string)result.Response.Arguments[1] == FlConstant.FL_OK.ToString())
{
response = $"R : OK";
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = $"R : {GetArgumentString(result.Response.Arguments)}";
}
}
else
{
response = "R : Invalid parser type";
}
}
else
{
response = "R : No response";
}
}
else
{
response = "R : Command fail";
}
LbMessageHistory.Items.Add(response);
}
}
private unsafe bool MakeCommandObject(ref IFlMessage message)
{
bool ret = false;
int crcDataLen = _bufPos - 4;
int crcStartIndex = _bufPos - 3;
List <object> arguments = null;
FlMessageId messageId = FlMessageId.Unknown;
ushort receivedCrc = 0;
FlBinMsgFullStruct fullMsg = Marshal.PtrToStructure <FlBinMsgFullStruct>(_bufPtr);
messageId = (FlMessageId)fullMsg.header.message_id;
switch (messageId)
{
case FlMessageId.ReadHardwareVersion:
case FlMessageId.ReadFirmwareVersion:
case FlMessageId.Reset:
{
_crc16 = FlUtil.CRC16(_buf, 1, crcDataLen);
receivedCrc = BitConverter.ToUInt16(_buf, crcStartIndex);
if ((CompareCrc(_crc16, receivedCrc) == true) &&
(FlConstant.FL_BIN_MSG_ETX == _buf[_bufPos - 1]))
{
ret = true;
}
}
break;
case FlMessageId.ReadGpio:
{
_crc16 = FlUtil.CRC16(_buf, 1, crcDataLen);
receivedCrc = BitConverter.ToUInt16(_buf, crcStartIndex);
if ((CompareCrc(_crc16, receivedCrc) == true) &&
(FlConstant.FL_BIN_MSG_ETX == _buf[_bufPos - 1]))
{
arguments = new List <object>
{
fullMsg.payload[0] // GPIO number
};
ret = true;
}
}
break;
case FlMessageId.WriteGpio:
{
_crc16 = FlUtil.CRC16(_buf, 1, crcDataLen);
receivedCrc = BitConverter.ToUInt16(_buf, crcStartIndex);
if ((CompareCrc(_crc16, receivedCrc) == true) &&
(FlConstant.FL_BIN_MSG_ETX == _buf[_bufPos - 1]))
{
arguments = new List <object>
{
fullMsg.payload[0], // GPIO number
fullMsg.payload[1] // GPIO value
};
ret = true;
}
}
break;
case FlMessageId.ReadTemperature:
case FlMessageId.ReadHumidity:
case FlMessageId.ReadTempAndHum:
{
_crc16 = FlUtil.CRC16(_buf, 1, crcDataLen);
receivedCrc = BitConverter.ToUInt16(_buf, crcStartIndex);
if ((CompareCrc(_crc16, receivedCrc) == true) &&
(FlConstant.FL_BIN_MSG_ETX == _buf[_bufPos - 1]))
{
arguments = new List <object>
{
fullMsg.payload[0] // Sensor number
};
ret = true;
}
}
break;
case FlMessageId.BootMode:
{
_crc16 = FlUtil.CRC16(_buf, 1, crcDataLen);
receivedCrc = BitConverter.ToUInt16(_buf, crcStartIndex);
if ((CompareCrc(_crc16, receivedCrc) == true) &&
(FlConstant.FL_BIN_MSG_ETX == _buf[_bufPos - 1]))
{
arguments = new List <object>
{
fullMsg.payload[0] // Boot mode
};
ret = true;
}
}
break;
}
if (ret == true)
{
FlBinMessageCommand command = new FlBinMessageCommand
{
Arguments = arguments
};
command.Header.device_id = fullMsg.header.device_id;
command.Header.length = fullMsg.header.length;
command.Header.message_id = (FlMessageId)fullMsg.header.message_id;
command.Header.flag1 = fullMsg.header.flag1;
command.Header.flag2 = fullMsg.header.flag2;
message = command;
}
return(ret);
}
