DotNetFrameworkDev/GenericTeProgramLibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Major upgrade

Browse Source
This commit is contained in:
Duc
2025-10-24 15:18:11 -07:00
parent fd85735c93
commit ce583d1664
478 changed files with 237518 additions and 47610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
Source/Program/Actions/PerformTacticalUartCommAction.cs Normal file
View File

@@ -0,0 +1,302 @@
/*-------------------------------------------------------------------------
// 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.");
}
}
}
}