public void TestReadFirmwareVersionCommandParse()
{
_binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 2;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Device;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)2, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.ReadFirmwareVersion, _parsedBinMsg.MessageId);
}
public void TestReadFirmwareVersionCommandParse()
{
_message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadFirmwareVersion,
Arguments = new List <object>()
{
"1" // DeviceID
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseCommand(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.ReadFirmwareVersion, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(1, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
}
public unsafe void TestResetOkResponseMessageBuild()
{
_binMsg = new FlBinMessageResponse()
{
MessageId = FlMessageId.Reset,
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 2;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Host;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)2, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.Reset, _parsedBinMsg.MessageId);
Assert.AreEqual((byte)0, _parsedBinMsg.Header.flag2.error);
}
public void TestReadHardwareVersionResponseParse()
{
_binMsg = new FlBinMessageResponse()
{
MessageId = FlMessageId.ReadHardwareVersion,
Arguments = new List <object>()
{
"a.1.2.3" // Hardware version
}
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 1;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Host;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)1, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.ReadHardwareVersion, _parsedBinMsg.MessageId);
Assert.AreEqual(1, _parsedBinMsg.Arguments.Count);
Assert.AreEqual("a.1.2.3", (string)_parsedBinMsg.Arguments[0]);
}
public void TestBootModeCommandMessageBuild()
{
_binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.BootMode,
Arguments = new List <object>()
{
(byte)1 // Boot mode(Bootloader)
}
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 1;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Device;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)1, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.BootMode, _parsedBinMsg.MessageId);
Assert.AreEqual(1, _parsedBinMsg.Arguments.Count);
Assert.AreEqual(1, (byte)_parsedBinMsg.Arguments[0]);
}
public void TestReadTemperatureHumidityCommandMessageBuild()
{
_binMsg = new FlBinMessageCommand()
{
MessageId = FlMessageId.ReadTempAndHum,
Arguments = new List <object>()
{
(byte)3 // Sensor number
}
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 7;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Device;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)7, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.ReadTempAndHum, _parsedBinMsg.MessageId);
Assert.AreEqual(1, _parsedBinMsg.Arguments.Count);
Assert.AreEqual(3, (byte)_parsedBinMsg.Arguments[0]);
}
public void TestReadHumidityOkResponseMessageBuild()
{
_binMsg = new FlBinMessageResponse()
{
MessageId = FlMessageId.ReadHumidity,
Arguments = new List <object>()
{
(byte)2, // Sensor number
(double)23.4 // Humidity
}
};
_binMsg.Header.device_id = 1;
_binMsg.Header.flag1.sequence_num = 6;
_message = _binMsg;
FlBinPacketBuilder.BuildMessagePacket(ref _message);
_parser.Role = FlParserRole.Host;
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.Parse(_message.Buffer[_i], out _parsedMessage);
}
_parsedBinMsg = (IFlBinMessage)_parsedMessage;
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Binary, _parsedBinMsg.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedBinMsg.MessageCategory);
Assert.AreEqual((uint)1, _parsedBinMsg.Header.device_id);
Assert.AreEqual((byte)6, _parsedBinMsg.Header.flag1.sequence_num);
Assert.AreEqual(FlMessageId.ReadHumidity, _parsedBinMsg.MessageId);
Assert.AreEqual(2, _parsedBinMsg.Arguments.Count);
Assert.AreEqual(2, (byte)_parsedBinMsg.Arguments[0]);
Assert.AreEqual(23.4, (double)_parsedBinMsg.Arguments[1]);
}
public void TestWriteGpioCommandParse()
{
_message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.WriteGpio,
Arguments = new List <object>()
{
"1", // DeviceID
"3", // GPIO number
"1" // GPIO value
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseCommand(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.WriteGpio, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(3, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
Assert.AreEqual("3", (string)_parsedMessage.Arguments[1]);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[2]);
}
public void TestResetResponseParse()
{
_message = new FlTxtMessageResponse()
{
MessageId = FlMessageId.Reset,
Arguments = new List <object>()
{
1, // DeviceID,
0 // Error
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseResponseEvent(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.Reset, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(2, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
Assert.AreEqual("0", (string)_parsedMessage.Arguments[1]);
}
private void OnEventMessageReceived(object sender, IFlMessage evt)
{
lock (_lock)
{
_eventQ.Add(evt);
}
}
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);
}
public void InitializeBeforeEveryTest()
{
_parseResult = FlParseState.Parsing;
_parsedMessage = null;
_parser.Clear();
}
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();
}
public void TestReadTempemperatureAndHumidityCommandParse()
{
_message = new FlTxtMessageCommand()
{
MessageId = FlMessageId.ReadTempAndHum,
Arguments = new List <object>()
{
"1", // DeviceID
"3" // Sensor number
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseCommand(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Command, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.ReadTempAndHum, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(2, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
Assert.AreEqual("3", (string)_parsedMessage.Arguments[1]);
}
public void TestReadTempemperatureAndHumidityResponseParse()
{
_message = new FlTxtMessageResponse()
{
MessageId = FlMessageId.ReadTempAndHum,
Arguments = new List <object>()
{
1, // DeviceID,
0, // Error
3, // Sensor number
$"{23.4:0.00}", // Temperature value
$"{56.7:0.00}" // Humidity value
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseResponseEvent(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.ReadTempAndHum, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(5, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
Assert.AreEqual("0", (string)_parsedMessage.Arguments[1]);
Assert.AreEqual("3", (string)_parsedMessage.Arguments[2]);
Assert.AreEqual("23.40", (string)_parsedMessage.Arguments[3]);
Assert.AreEqual("56.70", (string)_parsedMessage.Arguments[4]);
}
public void TestReadHardwareVersionResponseParse()
{
_message = new FlTxtMessageResponse()
{
MessageId = FlMessageId.ReadHardwareVersion,
Arguments = new List <object>()
{
1, // DeviceID(string or uint32),
0, // Error(string or uint8)
"a.1.2.3" // Hardware version
}
};
FlTxtPacketBuilder.BuildMessagePacket(ref _message);
for (_i = 0; _i < _message.Buffer.Length; _i++)
{
_parseResult = _parser.ParseResponseEvent(_message.Buffer[_i], out _parsedMessage);
}
Assert.AreEqual(FlParseState.ParseOk, _parseResult);
Assert.AreEqual(FlMessageType.Text, _parsedMessage.MessageType);
Assert.AreEqual(FlMessageCategory.Response, _parsedMessage.MessageCategory);
Assert.AreEqual(FlMessageId.ReadHardwareVersion, _parsedMessage.MessageId);
Assert.IsNotNull(_parsedMessage.Arguments);
Assert.AreEqual(3, _parsedMessage.Arguments.Count);
Assert.AreEqual("1", (string)_parsedMessage.Arguments[0]);
Assert.AreEqual("0", (string)_parsedMessage.Arguments[1]);
Assert.AreEqual("a.1.2.3", (string)_parsedMessage.Arguments[2]);
}
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);
}
public static void BuildMessagePacket(ref IFlMessage binMessage)
{
List <byte> packet = new List <byte>();
Type type;
byte length = BASE_LENGTH;
UInt16 crc;
IFlBinMessage binMsg = (IFlBinMessage)binMessage;
// TODO : Check message type(text).
// TODO : Check message category.
// TODO : Check DeviceID
// STX.
packet.Add(FlConstant.FL_BIN_MSG_STX);
// Device ID.
type = binMsg.Header.device_id.GetType();
packet.AddRange(InternalProtoUtil.BuildBinPacketForPrimitiveArgument(binMsg.Header.device_id, Type.GetTypeCode(type)));
// Length
packet.Add(length);
// Message ID.
packet.Add((byte)binMsg.Header.message_id);
// Flag1
packet.Add(binMsg.Header.flag1.BitField1);
// Flag2
packet.Add(binMsg.Header.flag2.BitField1);
// Arguments
if (binMessage.Arguments?.Count > 0)
{
foreach (object arg in binMessage.Arguments)
{
type = arg.GetType();
packet.AddRange(InternalProtoUtil.BuildBinPacketForPrimitiveArgument(arg, Type.GetTypeCode(type)));
}
}
// Length value = ( current packet length + CRC(2 byte) + ETX(1 byte) )
// - ( STX(1 byte) + Device ID(4 byte) + Length(1 byte))
// => current packet length - 3
packet[LENGTH_FIELD_INDEX] = (byte)(packet.Count - 3);
// CRC16
crc = FlUtil.CRC16(packet, 1, packet.Count - 1);
packet.AddRange(InternalProtoUtil.BuildBinPacketForPrimitiveArgument(crc, crc.GetTypeCode()));
// ETX
packet.Add(FlConstant.FL_BIN_MSG_ETX);
binMsg.Buffer = packet.ToArray();
}
private void ProcessAppTxtResetResponse(IFlMessage response)
{
if (response.Arguments?.Count == 2)
{
Log.Information($"Reset result : {(string)response.Arguments[1]}");
}
else
{
Log.Warning("Reset failed");
}
}
private void ProcessAppTxtReadTempAndHumResponse(IFlMessage response)
{
if (response.Arguments?.Count == 5)
{
Log.Information($"Sensor number : {(string)response.Arguments[2]}, Temperature : {(string)response.Arguments[3]}, Humidity : {(string)response.Arguments[4]}");
}
else
{
Log.Warning("Read temperature and humidity failed");
}
}
private void ProcessAppTxtReadGpioResponse(IFlMessage response)
{
if (response.Arguments?.Count == 4)
{
Log.Information($"GPIO number : {(string)response.Arguments[2]}, GPIO value : {(string)response.Arguments[3]}");
}
else
{
Log.Warning("Read GPIO failed");
}
}
private void ProcessAppTxtReadHumidityResponse(IFlMessage response)
{
if (response.Arguments?.Count == 4)
{
Log.Information($"Sensor number : {(string)response.Arguments[2]}, Humidity : {(string)response.Arguments[3]}");
}
else
{
Log.Warning("Read humidity failed");
}
}
private void ProcessAppTxtButtonEvent(IFlMessage evt)
{
if (evt.Arguments?.Count == 3)
{
Log.Information($"Button : {evt.Arguments[1]}, State : {evt.Arguments[2]}");
}
else
{
Log.Warning("Invalid button event");
}
}
private void ProcessAppTxtFwVerResponse(IFlMessage response)
{
if (response.Arguments?.Count == 3)
{
Log.Information($"FW version : {(string)response.Arguments[2]}");
}
else
{
Log.Warning("Read firmware version failed");
}
}
// TODO : ReadFirmwareVersion arguments.
public CommandResult ReadFirmwareVersion(IFlMessage command)
{
CommandResult result = new CommandResult()
{
Command = command
};
IFlMessage response = ProcessCommand((FlBinMessageCommand)command);
result.Response = (FlBinMessageResponse)response;
return(result);
}
public CommandResult BootMode(IFlMessage command)
{
CommandResult result = new CommandResult()
{
Command = command
};
IFlMessage response = ProcessCommand((FlBinMessageCommand)command);
result.Response = (FlBinMessageResponse)response;
return(result);
}
public CommandResult ReadTemperatureAndHumidity(IFlMessage command)
{
CommandResult result = new CommandResult()
{
Command = command
};
IFlMessage response = ProcessCommand((FlTxtMessageCommand)command);
result.Response = (FlTxtMessageResponse)response;
return(result);
}
public CommandResult Reset(IFlMessage command)
{
CommandResult result = new CommandResult()
{
Command = command
};
IFlMessage response = ProcessCommand((FlTxtMessageCommand)command);
result.Response = (FlTxtMessageResponse)response;
return(result);
}
private bool MakeResponseEventObject(ref IFlMessage message)
{
FlBinMsgFullStruct fullMsg = Marshal.PtrToStructure <FlBinMsgFullStruct>(_bufPtr);
switch (fullMsg.header.flag1.message_type)
{
case (byte)FlMessageCategory.Response:
return(MakeResponseObject(fullMsg, ref message));
case (byte)FlMessageCategory.Event:
return(MakeEventObject(fullMsg, ref message));
}
return(false);
}
private unsafe bool MakeEventObject(FlBinMsgFullStruct fullMsg, ref IFlMessage message)
{
bool ret = false;
ushort receivedCrc = 0;
int crcDataLen = _bufPos - 4;
int crcStartIndex = _bufPos - 3;
List <object> arguments = null;
FlMessageId messageId = (FlMessageId)fullMsg.header.message_id;
switch (messageId)
{
case FlMessageId.ButtonEvent:
{
_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], // Button number
fullMsg.payload[1] // Button value
};
ret = true;
}
}
break;
}
if (ret == true)
{
FlBinMessageEvent evt = new FlBinMessageEvent()
{
Arguments = arguments,
ReceiveTime = DateTime.UtcNow
};
evt.Header.device_id = fullMsg.header.device_id;
evt.Header.length = fullMsg.header.length;
evt.Header.message_id = (FlMessageId)fullMsg.header.message_id;
evt.Header.flag1 = fullMsg.header.flag1;
evt.Header.flag2 = fullMsg.header.flag2;
message = evt;
}
return(ret);
}
