303 lines
11 KiB
C#
303 lines
11 KiB
C#
/*-------------------------------------------------------------------------
|
|
// UNCLASSIFIED
|
|
/*-------------------------------------------------------------------------
|
|
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
|
|
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
|
|
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
|
|
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
|
|
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
|
|
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
|
|
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
|
|
COMPANY.
|
|
|
|
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
|
|
GOVERNMENT.
|
|
|
|
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
|
|
-------------------------------------------------------------------------*/
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using NLog;
|
|
using Raytheon.Instruments;
|
|
|
|
namespace ProgramLib
|
|
{
|
|
/// <summary>
|
|
/// Send Test Messages to UUT via TCP sockets
|
|
/// </summary>
|
|
internal class PerformTacticalUartCommAction : BasicAction
|
|
{
|
|
#region PrivateClassMembers
|
|
private static NLog.ILogger _logger;
|
|
|
|
private ICommDevice _serialDevice;
|
|
|
|
private List<byte> _receiveByteList = new List<byte>();
|
|
|
|
private int _expectedPbitAggregate;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public PerformTacticalUartCommAction()
|
|
{
|
|
string expectedPbitAggregate;
|
|
_logger = LogManager.GetCurrentClassLogger();
|
|
|
|
string serialDeviceInstanceName = Program.Instance().ProgramSpecificConfig.ReadValue("UART_INFO", "SERIAL_DEVICE_INSTANCE_NAME");
|
|
expectedPbitAggregate = Program.Instance().ProgramSpecificConfig.ReadValue("PBIT_INFO", "SUCCESSFUL_PBIT_AGGREGATE_VALUE");
|
|
_expectedPbitAggregate = Convert.ToInt32(expectedPbitAggregate, 16);
|
|
_serialDevice = (ICommDevice)Program.Instance().InstrumentManager.GetGenericInstrument(serialDeviceInstanceName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Run the action
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override void Run()
|
|
{
|
|
try
|
|
{
|
|
_logger?.Debug($"Entering {this.GetType().Name}::{System.Reflection.MethodBase.GetCurrentMethod().Name}() method...");
|
|
|
|
if (Program.Instance().IsUutPwrOn)
|
|
{
|
|
SendHandshakeAndGetResponse();
|
|
SendAckNackAndGetResponse();
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Cannot send message to UUT because UUT is not powered on.");
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send AckNack message and get response
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public void SendAckNackAndGetResponse()
|
|
{
|
|
UartAckNackMessage msg = new UartAckNackMessage(0x0C, 1);
|
|
List<byte> msgByteList = Util.StructToByteList(msg).ToList();
|
|
// remove checksum byte
|
|
msgByteList.RemoveAt(msgByteList.Count - 1);
|
|
msgByteList.Add(Util.GetTwosComplimentChecksum(msgByteList.ToArray()));
|
|
_serialDevice.Write(msgByteList.ToArray(), (uint)msgByteList.Count);
|
|
_logger.Info($"Raw AckNackMsg Sent: {Util.ByteArrayToHexString(msgByteList.ToArray())}");
|
|
|
|
UartPbitResultMessage pbitMsg = new UartPbitResultMessage();
|
|
List<byte> pbitMsgByteList = Util.StructToByteList(pbitMsg).ToList();
|
|
|
|
_logger.Info($"Waiting for PBIT Result from UUT");
|
|
byte[] byteArray;
|
|
DateTime startDateTime = DateTime.Now;
|
|
TimeSpan ts = DateTime.Now - startDateTime;
|
|
const int MAX_PBIT_WAIT_SEC = 7;
|
|
List<byte> pBitReceivedByteList = new List<byte>();
|
|
bool pBitMsgFound = false;
|
|
while (ts.TotalSeconds < MAX_PBIT_WAIT_SEC)
|
|
{
|
|
ts = DateTime.Now - startDateTime;
|
|
|
|
if (TacticalUartReadThread._byteQueue.Count > 0)
|
|
{
|
|
TacticalUartReadThread._byteQueue.TryDequeue(out byteArray);
|
|
_receiveByteList.AddRange(byteArray);
|
|
}
|
|
else
|
|
Thread.Sleep(100);
|
|
|
|
if (_receiveByteList.Count < pbitMsgByteList.Count)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
int index = 0;
|
|
bool needMoreData = false;
|
|
do
|
|
{
|
|
if (_receiveByteList[index] == pbitMsg.Id)
|
|
{
|
|
pBitReceivedByteList = _receiveByteList.Skip(index).Take(_receiveByteList.Count - index).ToList();
|
|
if (pBitReceivedByteList.Count < pbitMsgByteList.Count)
|
|
{
|
|
_receiveByteList = pBitReceivedByteList;
|
|
needMoreData = true;
|
|
break;
|
|
}
|
|
|
|
pBitReceivedByteList = pBitReceivedByteList.Skip(0).Take(pbitMsgByteList.Count).ToList();
|
|
if (Util.GetTwosComplimentChecksum(pBitReceivedByteList.Skip(0).Take(pbitMsgByteList.Count - 1).ToArray()) != pBitReceivedByteList[pBitReceivedByteList.Count - 1])
|
|
{
|
|
index++;
|
|
}
|
|
else
|
|
{
|
|
int numBytesToRemove = index + pBitReceivedByteList.Count;
|
|
|
|
if (numBytesToRemove == _receiveByteList.Count)
|
|
_receiveByteList.Clear();
|
|
else
|
|
_receiveByteList = _receiveByteList.Skip(numBytesToRemove).Take(_receiveByteList.Count - numBytesToRemove).ToList();
|
|
|
|
pBitMsgFound = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
index++;
|
|
|
|
if (index == _receiveByteList.Count)
|
|
{
|
|
_receiveByteList.Clear();
|
|
needMoreData = true;
|
|
break;
|
|
}
|
|
}
|
|
while (true);
|
|
|
|
if (!needMoreData)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pBitMsgFound)
|
|
{
|
|
_logger.Info($"Raw Msg Received: {Util.ByteArrayToHexString(pBitReceivedByteList.ToArray(), pbitMsgByteList.Count)}");
|
|
|
|
UartPbitResultMessage rsp = Util.ByteArrayToStruct<UartPbitResultMessage>(pBitReceivedByteList.ToArray());
|
|
_logger.Info($"PbitResult Fields: PbitFinalResult={rsp.PbitFinalResult}, PbitAggregate=0x{rsp.PbitAggregate.ToString("X4")}, GSP_Temp={rsp.GspTemp} C, Lifetime_Time={rsp.LifetimeTime} sec, Lifetime_Count={rsp.LifetimeCount}");
|
|
|
|
if (rsp.PbitAggregate != _expectedPbitAggregate)
|
|
{
|
|
_logger.Error("UUT's PBIT failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Timed out waiting for PBIT result.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send Handshake message and get response
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public void SendHandshakeAndGetResponse()
|
|
{
|
|
UartHandshakeMessage handshakeMsg = new UartHandshakeMessage(0xCCAAFFEEDDAAEEDD, 0xDDEEAADDEEFFAACC);
|
|
List<byte> handshakeMsgByteList = Util.StructToByteList(handshakeMsg).ToList();
|
|
// remove checksum byte
|
|
handshakeMsgByteList.RemoveAt(handshakeMsgByteList.Count - 1);
|
|
handshakeMsgByteList.Add(Util.GetTwosComplimentChecksum(handshakeMsgByteList.ToArray()));
|
|
_serialDevice.Write(handshakeMsgByteList.ToArray(), (uint)handshakeMsgByteList.Count);
|
|
_logger.Info($"Raw HandshakeMsg Sent: {Util.ByteArrayToHexString(handshakeMsgByteList.ToArray())}");
|
|
|
|
_logger.Info($"Waiting for HandshakeMsg from UUT");
|
|
byte[] byteArray;
|
|
DateTime startDateTime = DateTime.Now;
|
|
TimeSpan ts = DateTime.Now - startDateTime;
|
|
const int MAX_HANDSHAKE_WAIT_SEC = 7;
|
|
List<byte> handshakeReceivedByteList = new List<byte>();
|
|
bool handshakeMsgFound = false;
|
|
double secondCount = 0.0;
|
|
while (ts.TotalSeconds < MAX_HANDSHAKE_WAIT_SEC)
|
|
{
|
|
ts = DateTime.Now - startDateTime;
|
|
|
|
if (ts.TotalSeconds > secondCount)
|
|
{
|
|
_serialDevice.Write(handshakeMsgByteList.ToArray(), (uint)handshakeMsgByteList.Count);
|
|
_logger.Info($"Raw HandshakeMsg Sent: {Util.ByteArrayToHexString(handshakeMsgByteList.ToArray())}");
|
|
secondCount = ts.TotalSeconds;
|
|
}
|
|
|
|
if (TacticalUartReadThread._byteQueue.Count > 0)
|
|
{
|
|
TacticalUartReadThread._byteQueue.TryDequeue(out byteArray);
|
|
_receiveByteList.AddRange(byteArray);
|
|
}
|
|
else
|
|
Thread.Sleep(100);
|
|
|
|
if (_receiveByteList.Count < handshakeMsgByteList.Count)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
int index = 0;
|
|
bool needMoreData = false;
|
|
do
|
|
{
|
|
if (_receiveByteList[index] == handshakeMsg.Id)
|
|
{
|
|
handshakeReceivedByteList = _receiveByteList.Skip(index).Take(_receiveByteList.Count - index).ToList();
|
|
if (handshakeReceivedByteList.Count < handshakeMsgByteList.Count)
|
|
{
|
|
_receiveByteList = handshakeReceivedByteList;
|
|
needMoreData = true;
|
|
break;
|
|
}
|
|
|
|
handshakeReceivedByteList = handshakeReceivedByteList.Skip(0).Take(handshakeMsgByteList.Count).ToList();
|
|
if (Util.GetTwosComplimentChecksum(handshakeReceivedByteList.Skip(0).Take(handshakeMsgByteList.Count - 1).ToArray()) != handshakeReceivedByteList[handshakeReceivedByteList.Count - 1])
|
|
{
|
|
index++;
|
|
}
|
|
else
|
|
{
|
|
int numBytesToRemove = index + handshakeReceivedByteList.Count;
|
|
|
|
if (numBytesToRemove == _receiveByteList.Count)
|
|
_receiveByteList.Clear();
|
|
else
|
|
_receiveByteList = _receiveByteList.Skip(numBytesToRemove).Take(_receiveByteList.Count - numBytesToRemove).ToList();
|
|
|
|
handshakeMsgFound = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
index++;
|
|
|
|
if (index == _receiveByteList.Count)
|
|
{
|
|
_receiveByteList.Clear();
|
|
needMoreData = true;
|
|
break;
|
|
}
|
|
}
|
|
while (true);
|
|
|
|
if (!needMoreData)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (handshakeMsgFound)
|
|
{
|
|
_logger.Info($"Raw Msg Received: {Util.ByteArrayToHexString(handshakeReceivedByteList.ToArray(), handshakeMsgByteList.Count)}");
|
|
|
|
UartHandshakeMessage rsp = Util.ByteArrayToStruct<UartHandshakeMessage>(handshakeReceivedByteList.ToArray());
|
|
_logger.Info($"Handshake Fields: Pattern1=0x{rsp.Pattern1.ToString("X8")}, Pattern2=0x{rsp.Pattern2.ToString("X8")}");
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Timed out waiting for HandshakeMsg.");
|
|
}
|
|
}
|
|
}
|
|
}
|