private FlTxtMessageResponse GetResponse(FlTxtMessageCommand command)
{
FlTxtMessageResponse 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)
{
lock (_generalLock)
{
response = _responseQ[i];
_responseQ.RemoveAt(i);
}
break;
}
}
return(response);
}
private void AppTxtWriteGpio()
{
if (CheckStartStatus() != true)
{
return;
}
IFlMessage message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.WriteGpio,
Arguments = new List <object>()
{
"1", // DeviceID
"1", // GPIO number
"1" // GPIO value
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref message);
_hostSimul.ResponseReceived = false;
_hostSimul.SendPacket(message.Buffer);
WaitForResponse();
}
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(FlTxtMessageCommand command)
{
TimeSpan timeSpan;
bool waitTimeExpired;
IFlMessage response = null;
IFlMessage message = (IFlMessage)command;
FlTxtPacketBuilder.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 OnTxtCommandResultReady(FwCommandMessageResult cmdResult)
{
FlTxtMessageCommand command = (FlTxtMessageCommand)cmdResult.Command;
int i;
TimeSpan spanTime;
DateTime now = DateTime.UtcNow;
TxtCommandResult txtCmdResult = new TxtCommandResult()
{
Command = command,
Response = (FlTxtMessageResponse)cmdResult.Response,
CreatedDate = cmdResult.CreatedDate,
LogName = $"{now.Year}{now.Month.ToString("00")}{now.Day.ToString("00")} {now.Hour.ToString("00")}:{now.Minute.ToString("00")}:{now.Second.ToString("00")}.{now.Millisecond.ToString("000")}"
};
col.Insert(txtCmdResult);
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 AppTxtFwVer()
{
if (CheckStartStatus() != true)
{
return;
}
IFlMessage message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion,
Arguments = new List <object>()
{
"1" // DeviceID
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref message);
_hostSimul.ResponseReceived = false;
_hostSimul.SendPacket(message.Buffer);
WaitForResponse();
}
private void AppTxtBootBmode()
{
if (CheckStartStatus() != true)
{
return;
}
IFlMessage message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.BootMode,
Arguments = new List <object>()
{
"1", // DeviceID
"1" // Bootloader
}
};
FlTxtPacketBuilder.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);
}
public FlParseState ParseCommand(byte data, out IFlMessage message)
{
FlParseState ret = FlParseState.Parsing;
message = null;
if (_fullPacketLength < FlConstant.FL_TXT_MSG_MAX_LENGTH)
{
_fullPacket[_fullPacketLength++] = data;
}
switch (_receiveState)
{
case ReceiveState.MessageId:
if (IsMsgIdChar(data) == true)
{
_buf[_bufPos++] = data;
if (_bufPos > FlConstant.TXT_MSG_ID_MAX_LEN)
{
ret = FlParseState.ParseFail;
}
}
else if (data == FlConstant.FL_TXT_MSG_ID_DEVICE_ID_DELIMITER)
{
_msgId = GetMessageId();
if (_msgId != FlMessageId.Unknown)
{
_receiveState = ReceiveState.DeviceId;
ClearReceiveBuffer();
}
else
{
ret = FlParseState.ParseFail;
}
}
else
{
ret = FlParseState.ParseFail;
}
break;
case ReceiveState.DeviceId:
if (IsDeviceIdChar(data) == true)
{
_buf[_bufPos++] = data;
if (_bufPos > FlConstant.TXT_DEVICE_ID_MAX_LEN)
{
ret = FlParseState.ParseFail;
}
}
else if (data == FlConstant.FL_TXT_MSG_ARG_DELIMITER)
{
if (ProcessCommandData() == true)
{
if (IsCommandWithArgument(_msgId) == true)
{
_receiveState = ReceiveState.Data;
ClearReceiveBuffer();
}
else
{
ret = FlParseState.ParseFail;
}
}
else
{
ret = FlParseState.ParseFail;
}
}
else if (IsTail(data) == true)
{
if (ProcessCommandData() == true)
{
_receiveState = ReceiveState.Tail;
ret = FlParseState.ParseOk;
}
else
{
ret = FlParseState.ParseFail;
}
}
else
{
ret = FlParseState.ParseFail;
}
break;
case ReceiveState.Data:
if (IsTail(data) != true)
{
if (data != FlConstant.FL_TXT_MSG_ARG_DELIMITER)
{
_buf[_bufPos++] = data;
if (_bufPos >= FlConstant.FL_TXT_MSG_MAX_LENGTH)
{
ret = FlParseState.ParseFail;
}
}
else
{
if (ProcessCommandData() == true)
{
ClearReceiveBuffer();
}
else
{
ret = FlParseState.ParseFail;
}
}
}
else
{
if (ProcessCommandData() == true)
{
_receiveState = ReceiveState.Tail;
ClearReceiveBuffer();
ret = FlParseState.ParseOk;
}
else
{
ret = FlParseState.ParseFail;
}
}
break;
default:
ret = FlParseState.ParseFail;
break;
}
if (ret != FlParseState.Parsing)
{
if (ret == FlParseState.ParseOk)
{
if (OnParseDone != null)
{
OnParseDone?.Invoke(this, null);
}
else
{
message = new FlTxtMessageCommand()
{
MessageId = _msgId,
Arguments = new List <object>()
};
while (_arguments.Count > 0)
{
message.Arguments.Add(_arguments[0]);
_arguments.RemoveAt(0);
}
}
}
Clear();
}
return(ret);
}
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);
}
}
