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

13
Source/TSRealLib/MAL/Managers/BitMeasurementManager/Lib/BitMsgRxBuffer.cs
View File

@@ -16,9 +16,9 @@ UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Threading;
using System.Collections.Generic;
using Raytheon.Common;
using System.Threading;
using NLog;
namespace BitMeasurementManagerLib
{
@@ -34,6 +34,7 @@ namespace BitMeasurementManagerLib
private BitMessageIDs _messageIds;
private Dictionary<uint, List<BitConfigurableMessage>> _msgList;
private Dictionary<uint, AutoResetEvent> _receivedMsgEvents;
private readonly ILogger _logger;
#endregion
#region PrivateFuctions
@@ -43,6 +44,8 @@ namespace BitMeasurementManagerLib
/// </summary>
private BitMsgRxBuffer(BitMessageIDs messageIds)
{
_logger = LogManager.GetCurrentClassLogger();
_messageIds = messageIds;
_msgList = new Dictionary<uint, List<BitConfigurableMessage>>();
@@ -88,17 +91,17 @@ namespace BitMeasurementManagerLib
if (shouldWeDeleteOthers == true)
{
ErrorLogger.Instance().Write("BitMsgRxBuffer::AddMsg() - clearing list for " + msgId.ToString(), ErrorLogger.LogLevel.INFO);
_logger.Debug("clearing list for " + msgId.ToString());
ClearList(msgId);
}
if (_msgList.ContainsKey(msgId) == false)
{
ErrorLogger.Instance().Write("BitMsgRxBuffer::AddMsg() - creating new list for " + msgId.ToString(), ErrorLogger.LogLevel.INFO);
_logger.Debug("creating new list for " + msgId.ToString());
_msgList[msgId] = new List<BitConfigurableMessage>();
}
ErrorLogger.Instance().Write("BitMsgRxBuffer::AddMsg() - Adding " + msgId.ToString() + " to the list", ErrorLogger.LogLevel.INFO);
_logger.Debug("Adding " + msgId.ToString() + " to the list");
_msgList[msgId].Add(msg);
_receivedMsgEvents[msgId].Set();

621
Source/TSRealLib/MAL/Managers/BitMeasurementManager/Lib/BitSimCommDeviceNode.cs
View File

@@ -15,402 +15,331 @@ GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using Raytheon.Instruments;
using Raytheon.Common;
using System;
using System.Runtime.InteropServices;
using System.Threading;
using NLog;
using Raytheon.Common;
using Raytheon.Instruments;
namespace BitMeasurementManagerLib
{
/// <summary>
/// An interface to sending/receiving data over TCP sockets
/// </summary>
internal class BitSimCommDeviceNode : ICommDevice, IDisposable
{
#region PrivateClassMembers
private ICommDevice _commDevice;
private BitMessageIDs _messageIds;
private IWorkerInterface _socketReadWorker;
private Thread _socketReadThread;
private readonly string _name;
private SelfTestResult _selfTestResult;
private State _state;
#endregion
/// <summary>
/// An interface to sending/receiving data over TCP sockets
/// </summary>
internal class BitSimCommDeviceNode : ICommDevice, IDisposable
{
#region PrivateClassMembers
private ICommDevice _commDevice;
private BitMessageIDs _messageIds;
private IWorkerInterface _socketReadWorker;
private Thread _socketReadThread;
private readonly string _name;
private SelfTestResult _selfTestResult;
private State _state;
private readonly ILogger _logger;
#endregion
#region PrivateFunctions
/// <summary>
/// The finalizer. Necessary for quitting the read thread
/// </summary>
~BitSimCommDeviceNode()
{
Dispose(false);
}
#region PrivateFunctions
/// <summary>
/// The finalizer. Necessary for quitting the read thread
/// </summary>
~BitSimCommDeviceNode()
{
Dispose(false);
}
/// <summary>
/// Quit the threads associated with the node
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
State initialState = _state;
/// <summary>
/// Quit the threads associated with the node
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
State initialState = _state;
// close the socket and threads
try
{
if (initialState == State.Ready)
{
Shutdown();
// close the socket and threads
if (initialState == State.Ready)
{
Shutdown();
_commDevice.Shutdown();
}
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
_commDevice.Shutdown();
}
// dispose of the resources
try
{
if (initialState == State.Ready)
{
_socketReadWorker.Dispose();
_state = State.Uninitialized;
}
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
}
}
// dispose of the resources
if (initialState == State.Ready)
{
_socketReadWorker.Dispose();
_state = State.Uninitialized;
}
}
}
#endregion
#endregion
#region PublicFuctions
#region PublicFuctions
/// <summary>
///
/// </summary>
/// <param name="name">The name of this instance</param>
/// <param name="messageIds"></param>
/// <param name="msgHandler"></param>
/// <param name="commReadWorkerBufferSize"></param>
/// <param name="readWorkerRestTimeInMs"></param>
public BitSimCommDeviceNode(string name, ICommDevice commDevice, BitMessageIDs messageIds, MsgDevice msgHandler, uint commReadWorkerBufferSize = 100000, uint readWorkerRestTimeInMs = 10)
{
_name = name;
/// <summary>
///
/// </summary>
/// <param name="name">The name of this instance</param>
/// <param name="messageIds"></param>
/// <param name="msgHandler"></param>
/// <param name="commReadWorkerBufferSize"></param>
/// <param name="readWorkerRestTimeInMs"></param>
public BitSimCommDeviceNode(string name, ICommDevice commDevice, BitMessageIDs messageIds, MsgDevice msgHandler, uint commReadWorkerBufferSize = 100000, uint readWorkerRestTimeInMs = 10)
{
_logger = LogManager.GetCurrentClassLogger();
_commDevice = commDevice;
_name = name;
_messageIds = messageIds;
_commDevice = commDevice;
_socketReadWorker = new CommReadWorker(this, msgHandler, commReadWorkerBufferSize, readWorkerRestTimeInMs);
_socketReadThread = new Thread(_socketReadWorker.DoWork);
_messageIds = messageIds;
// start the read thread
_socketReadThread.Start();
_socketReadWorker = new CommReadWorker(this, msgHandler, commReadWorkerBufferSize, readWorkerRestTimeInMs);
_socketReadThread = new Thread(_socketReadWorker.DoWork);
_selfTestResult = SelfTestResult.Unknown;
// start the read thread
_socketReadThread.Start();
_state = State.Uninitialized;
}
_selfTestResult = SelfTestResult.Unknown;
public void Open()
{
}
_state = State.Uninitialized;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool ClearErrors()
{
return true;
}
public void Open()
{
}
/// <summary>
///
/// </summary>
public bool DisplayEnabled
{
get
{
return false;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool ClearErrors()
{
return true;
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public bool DisplayEnabled
{
get
{
return false;
}
/// <summary>
///
/// </summary>
public string DetailedStatus
{
get
{
return "This is a BIT Comm Sim Device Node " + _name;
}
}
set
{
throw new NotImplementedException();
}
}
public void Close()
{
Dispose();
}
/// <summary>
///
/// </summary>
public string DetailedStatus
{
get
{
return "This is a BIT Comm Sim Device Node " + _name;
}
}
/// <summary>
/// Close the device
/// </summary>
/*public void Close()
{
const int THREAD_QUIT_TIMEOUT_MS = 3000;
public void Close()
{
Dispose();
}
// tell the thread to quit
_socketReadWorker.QuitWork();
/// <summary>
///
/// </summary>
public void Dispose()
{
Dispose(true);
// close the socket which the thread might be blocked on
_commDevice.Close();
GC.SuppressFinalize(this);
}
if (_socketReadThread.IsAlive)
{
bool didThreadQuit = _socketReadThread.Join(THREAD_QUIT_TIMEOUT_MS);
/// <summary>
///
/// </summary>
public bool FrontPanelEnabled
{
get
{
throw new NotImplementedException();
}
if (didThreadQuit == false)
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread did not quit as expected, aborting it");
_socketReadThread.Abort();
}
else
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread quit successfully after join", ErrorLogger.LogLevel.INFO);
}
}
else
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread quit successfully", ErrorLogger.LogLevel.INFO);
}
}*/
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public void Dispose()
{
try
{
Dispose(true);
/// <summary>
///
/// </summary>
public InstrumentMetadata Info
{
get
{
throw new NotImplementedException();
}
}
GC.SuppressFinalize(this);
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
}
/// <summary>
///
/// </summary>
public void Initialize()
{
_commDevice.Initialize();
_state = State.Ready;
}
/// <summary>
///
/// </summary>
public bool FrontPanelEnabled
{
get
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
public string Name
{
get
{
return _name;
}
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public SelfTestResult PerformSelfTest()
{
return _commDevice.SelfTestResult;
}
/// <summary>
///
/// </summary>
public InstrumentMetadata Info
{
get
{
throw new NotImplementedException();
}
}
/// <summary>
/// Read data from the socket
/// </summary>
/// <param name="dataRead">The data that was read</param>
/// <returns>the number of bytes read</returns>
public uint Read(ref byte[] dataRead)
{
return 0;
}
/// <summary>
///
/// </summary>
public void Initialize()
{
_commDevice.Initialize();
_state = State.Ready;
}
/// <summary>
/// </summary>
public void Reset()
{
Close();
/// <summary>
///
/// </summary>
public string Name
{
get
{
return _name;
}
}
Initialize();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public SelfTestResult PerformSelfTest()
{
return _commDevice.SelfTestResult;
}
/// <summary>
///
/// </summary>
/// <param name="readTimeout"></param>
public void SetReadTimeout(uint readTimeout)
{
}
/// <summary>
/// Read data from the socket
/// </summary>
/// <param name="dataRead">The data that was read</param>
/// <returns>the number of bytes read</returns>
public uint Read(ref byte[] dataRead)
{
return 0;
}
/// <summary>
///
/// </summary>
public SelfTestResult SelfTestResult
{
get
{
return _selfTestResult;
}
}
/// <summary>
/// </summary>
public void Reset()
{
Close();
/// <summary>
///
/// </summary>
public State Status
{
get
{
return _state;
}
}
Initialize();
}
/// <summary>
///
/// </summary>
public void Shutdown()
{
const int THREAD_QUIT_TIMEOUT_MS = 3000;
/// <summary>
///
/// </summary>
/// <param name="readTimeout"></param>
public void SetReadTimeout(uint readTimeout)
{
}
if (_state == State.Ready)
{
// tell the thread to quit
_socketReadWorker.QuitWork();
/// <summary>
///
/// </summary>
public SelfTestResult SelfTestResult
{
get
{
return _selfTestResult;
}
}
// close the socket which the thread might be blocked on
_commDevice.Shutdown();
/// <summary>
///
/// </summary>
public State Status
{
get
{
return _state;
}
}
if (_socketReadThread.IsAlive)
{
bool didThreadQuit = _socketReadThread.Join(THREAD_QUIT_TIMEOUT_MS);
/// <summary>
///
/// </summary>
public void Shutdown()
{
const int THREAD_QUIT_TIMEOUT_MS = 3000;
if (didThreadQuit == false)
{
_logger.Debug("Logging Thread did not quit as expected, aborting it");
_socketReadThread.Abort();
}
else
{
_logger.Debug("Logging Thread quit successfully after join");
}
}
else
{
_logger.Debug("Logging Thread quit successfully");
}
}
if (_state == State.Ready)
{
// tell the thread to quit
_socketReadWorker.QuitWork();
_state = State.Uninitialized;
}
// close the socket which the thread might be blocked on
_commDevice.Shutdown();
/// <summary>
/// Send data on the socket
/// </summary>
/// <param name="dataToSend">The data to send</param>
/// <param name="numBytesToWrite">The number of bytes to write from the dataToSend buffer</param>
/// <returns>The number of bytes sent</returns>
public uint Write(byte[] dataToSend, uint numBytesToWrite)
{
// determine the id and get create the rsp message
IntPtr pDataPtr = Marshal.AllocHGlobal(dataToSend.Length);
Marshal.Copy(dataToSend, 0, pDataPtr, dataToSend.Length);
uint commandId = BitConfigurableMessageHeader.GetMessageId(pDataPtr, (uint)dataToSend.Length);
Marshal.FreeHGlobal(pDataPtr);
if (_socketReadThread.IsAlive)
{
bool didThreadQuit = _socketReadThread.Join(THREAD_QUIT_TIMEOUT_MS);
bool isThereAResponse = _messageIds.IsThereAResponseMessage(commandId);
if (didThreadQuit == false)
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread did not quit as expected, aborting it");
_socketReadThread.Abort();
}
else
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread quit successfully after join", ErrorLogger.LogLevel.INFO);
}
}
else
{
ErrorLogger.Instance().Write("BitSimCommDeviceNode::Close() - Logging Thread quit successfully", ErrorLogger.LogLevel.INFO);
}
}
// if there is a rsp msg, create a dummy msg
if (isThereAResponse == true)
{
uint rspId = _messageIds.GetResponseId(commandId);
BitConfigurableMessage rspMessage = BitConfigurableMessageFactory.Instance().RetreiveMessage(rspId);
BitMsgRxBuffer.Instance().AddMsg(rspMessage);
//uint msgLen = rspMessage.GetEntireMsgLength();
//byte[] simData = new byte[msgLen];
//_msgHandler.AddData();
}
else
{
}
_state = State.Uninitialized;
}
return (uint)dataToSend.Length;
}
/// <summary>
/// Send data on the socket
/// </summary>
/// <param name="dataToSend">The data to send</param>
/// <param name="numBytesToWrite">The number of bytes to write from the dataToSend buffer</param>
/// <returns>The number of bytes sent</returns>
public uint Write(byte[] dataToSend, uint numBytesToWrite)
{
// determine the id and get create the rsp message
IntPtr pDataPtr = Marshal.AllocHGlobal(dataToSend.Length);
Marshal.Copy(dataToSend, 0, pDataPtr, dataToSend.Length);
uint commandId = BitConfigurableMessageHeader.GetMessageId(pDataPtr, (uint)dataToSend.Length);
Marshal.FreeHGlobal(pDataPtr);
bool isThereAResponse = _messageIds.IsThereAResponseMessage(commandId);
// if there is a rsp msg, create a dummy msg
if (isThereAResponse == true)
{
uint rspId = _messageIds.GetResponseId(commandId);
BitConfigurableMessage rspMessage = BitConfigurableMessageFactory.Instance().RetreiveMessage(rspId);
BitMsgRxBuffer.Instance().AddMsg(rspMessage);
//uint msgLen = rspMessage.GetEntireMsgLength();
//byte[] simData = new byte[msgLen];
//_msgHandler.AddData();
}
else
{
}
return (uint)dataToSend.Length;
}
#endregion
}
#endregion
}
}

577
Source/TSRealLib/MAL/Managers/BitMeasurementManager/Lib/CommDeviceNode.cs
View File

@@ -15,357 +15,316 @@ GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using Raytheon.Common;
using System;
using System.Threading;
using NLog;
using Raytheon.Common;
namespace Raytheon.Instruments
{
/// <summary>
/// An interface to sending/receiving data over comm devices
/// </summary>
internal class CommDeviceNode : ICommDevice, IDisposable
{
#region PrivateClassMembers
private ICommDevice _commDevice;
private IWorkerInterface _socketReadWorker;
private Thread _socketReadThread;
private readonly string _name;
private SelfTestResult _selfTestResult;
private State _state;
/// <summary>
/// An interface to sending/receiving data over comm devices
/// </summary>
internal class CommDeviceNode : ICommDevice, IDisposable
{
#region PrivateClassMembers
private ICommDevice _commDevice;
private IWorkerInterface _socketReadWorker;
private Thread _socketReadThread;
private readonly string _name;
private SelfTestResult _selfTestResult;
private State _state;
private uint _commReadWorkerBufferSize;
private uint _readWorkerRestTimeInMs;
private MsgDevice _msgHandler;
private uint _commReadWorkerBufferSize;
private uint _readWorkerRestTimeInMs;
private MsgDevice _msgHandler;
private readonly ILogger _logger;
#endregion
#endregion
#region PrivateFuctions
/// <summary>
/// The finalizer. Necessary for quitting the read thread
/// </summary>
~CommDeviceNode()
{
Dispose(false);
}
#region PrivateFuctions
/// <summary>
/// The finalizer. Necessary for quitting the read thread
/// </summary>
~CommDeviceNode()
{
Dispose(false);
}
/// <summary>
/// Quit the threads associated with the node
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
State initialState = _state;
/// <summary>
/// Quit the threads associated with the node
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
State initialState = _state;
// close the socket and threads
try
{
if (initialState == State.Ready)
{
Shutdown();
_commDevice.Shutdown();
}
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
// close the socket and threads
if (initialState == State.Ready)
{
Shutdown();
_commDevice.Shutdown();
}
// dispose of the resources
try
{
if (initialState == State.Ready)
{
_socketReadWorker.Dispose();
_state = State.Uninitialized;
}
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
}
}
// dispose of the resources
if (initialState == State.Ready)
{
_socketReadWorker.Dispose();
_state = State.Uninitialized;
}
}
}
#endregion
#endregion
#region PublicFuctions
#region PublicFuctions
/// <summary>
/// The constructor
/// </summary>
/// <param name="name">The name of this instance</param>
/// <param name="commDevice">The communication device</param>
/// <param name="msgHandler">The message handler for this interface</param>
/// <param name="commReadWorkerBufferSize">The number of bytes for the buffer internal to this class. Each individual read will read upto this buffer size (or until the timeout happens)</param>
/// <param name="readWorkerRestTimeInMs">Number of ms to reset between read calls on the comm interface</param>
public CommDeviceNode(string name, ICommDevice commDevice, MsgDevice msgHandler, uint commReadWorkerBufferSize = 100000, uint readWorkerRestTimeInMs = 10)
{
_name = name;
_commDevice = commDevice;
_commReadWorkerBufferSize = commReadWorkerBufferSize;
_readWorkerRestTimeInMs = readWorkerRestTimeInMs;
_msgHandler = msgHandler;
/// <summary>
/// The constructor
/// </summary>
/// <param name="name">The name of this instance</param>
/// <param name="commDevice">The communication device</param>
/// <param name="msgHandler">The message handler for this interface</param>
/// <param name="commReadWorkerBufferSize">The number of bytes for the buffer internal to this class. Each individual read will read upto this buffer size (or until the timeout happens)</param>
/// <param name="readWorkerRestTimeInMs">Number of ms to reset between read calls on the comm interface</param>
public CommDeviceNode(string name, ICommDevice commDevice, MsgDevice msgHandler, uint commReadWorkerBufferSize = 100000, uint readWorkerRestTimeInMs = 10)
{
_logger = LogManager.GetCurrentClassLogger();
_name = name;
_commDevice = commDevice;
Open();
}
_commReadWorkerBufferSize = commReadWorkerBufferSize;
_readWorkerRestTimeInMs = readWorkerRestTimeInMs;
_msgHandler = msgHandler;
/// <summary>
/// Starts communication thread
/// </summary>
public void Open()
{
_socketReadWorker = new CommReadWorker(this, _msgHandler, _commReadWorkerBufferSize, _readWorkerRestTimeInMs);
_socketReadThread = new Thread(_socketReadWorker.DoWork);
Open();
}
// start the read thread
_socketReadThread.Start();
/// <summary>
/// Starts communication thread
/// </summary>
public void Open()
{
_socketReadWorker = new CommReadWorker(this, _msgHandler, _commReadWorkerBufferSize, _readWorkerRestTimeInMs);
_socketReadThread = new Thread(_socketReadWorker.DoWork);
_selfTestResult = SelfTestResult.Unknown;
_state = State.Uninitialized;
}
// start the read thread
_socketReadThread.Start();
_selfTestResult = SelfTestResult.Unknown;
_state = State.Uninitialized;
}
/// <summary>
/// there is no error msg repository
/// </summary>
/// <returns></returns>
public bool ClearErrors()
{
return false;
}
/// <summary>
/// there is no error msg repository
/// </summary>
/// <returns></returns>
public bool ClearErrors()
{
return false;
}
/// <summary>
///
/// </summary>
public bool DisplayEnabled
{
get
{
return false;
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public bool DisplayEnabled
{
get
{
return false;
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public string DetailedStatus
{
get
{
return "This is a Comm Sim Device Node " + _name;
}
}
/// <summary>
///
/// </summary>
public string DetailedStatus
{
get
{
return "This is a Comm Sim Device Node " + _name;
}
}
/// <summary>
///
/// </summary>
public void Dispose()
{
try
{
Dispose(true);
/// <summary>
///
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
}
GC.SuppressFinalize(this);
}
/// <summary>
///
/// </summary>
public bool FrontPanelEnabled
{
get
{
return false;
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public bool FrontPanelEnabled
{
get
{
return false;
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public InstrumentMetadata Info
{
get
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public InstrumentMetadata Info
{
get
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
public void Initialize()
{
_commDevice.Initialize();
_state = State.Ready;
}
/// <summary>
///
/// </summary>
public void Initialize()
{
_commDevice.Initialize();
_state = State.Ready;
}
/// <summary>
///
/// </summary>
public string Name
{
get
{
return _name;
}
}
/// <summary>
///
/// </summary>
public string Name
{
get
{
return _name;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public SelfTestResult PerformSelfTest()
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public SelfTestResult PerformSelfTest()
{
throw new NotImplementedException();
}
/// <summary>
/// Read data from the socket
/// </summary>
/// <param name="dataRead">The data that was read</param>
/// <returns>the number of bytes read</returns>
public uint Read(ref byte[] dataRead)
{
return _commDevice.Read(ref dataRead);
}
/// <summary>
/// Read data from the socket
/// </summary>
/// <param name="dataRead">The data that was read</param>
/// <returns>the number of bytes read</returns>
public uint Read(ref byte[] dataRead)
{
return _commDevice.Read(ref dataRead);
}
/// <summary>
/// Resets communications
/// </summary>
public void Reset()
{
Close();
Open();
}
/// <summary>
/// Resets communications
/// </summary>
public void Reset()
{
Close();
Open();
}
/// <summary>
///
/// </summary>
/// <param name="readTimeout"></param>
public void SetReadTimeout(uint readTimeout)
{
_commDevice.SetReadTimeout(readTimeout);
}
/// <summary>
///
/// </summary>
/// <param name="readTimeout"></param>
public void SetReadTimeout(uint readTimeout)
{
_commDevice.SetReadTimeout(readTimeout);
}
/// <summary>
///
/// </summary>
public SelfTestResult SelfTestResult
{
get
{
return _selfTestResult;
}
}
/// <summary>
///
/// </summary>
public SelfTestResult SelfTestResult
{
get
{
return _selfTestResult;
}
}
/// <summary>
///
/// </summary>
public State Status
{
get
{
return _state;
}
}
/// <summary>
///
/// </summary>
public State Status
{
get
{
return _state;
}
}
/// <summary>
/// Close communications
/// </summary>
public void Close()
{
Shutdown();
}
/// <summary>
/// Close communications
/// </summary>
public void Close()
{
Shutdown();
}
/// <summary>
/// Close communications
/// </summary>
public void Shutdown()
{
if (_state == State.Ready)
{
const int THREAD_QUIT_TIMEOUT_MS = 3000;
/// <summary>
/// Close communications
/// </summary>
public void Shutdown()
{
if (_state == State.Ready)
{
const int THREAD_QUIT_TIMEOUT_MS = 3000;
// tell the thread to quit
_socketReadWorker.QuitWork();
// tell the thread to quit
_socketReadWorker.QuitWork();
// close the socket which the thread might be blocked on
_commDevice.Shutdown();
// close the socket which the thread might be blocked on
_commDevice.Shutdown();
if (_socketReadThread.IsAlive)
{
bool didThreadQuit = _socketReadThread.Join(THREAD_QUIT_TIMEOUT_MS);
if (_socketReadThread.IsAlive)
{
bool didThreadQuit = _socketReadThread.Join(THREAD_QUIT_TIMEOUT_MS);
if (didThreadQuit == false)
{
ErrorLogger.Instance().Write("CommDeviceNode::Close() - Logging Thread did not quit as expected, aborting it");
_socketReadThread.Abort();
}
else
{
ErrorLogger.Instance().Write("CommDeviceNode::Close() - Logging Thread quit successfully after join", ErrorLogger.LogLevel.INFO);
}
}
else
{
ErrorLogger.Instance().Write("CommDeviceNode::Close() - Logging Thread quit successfully", ErrorLogger.LogLevel.INFO);
}
}
if (didThreadQuit == false)
{
_socketReadThread.Abort();
}
else
{
_logger.Debug("Logging Thread quit successfully after join");
}
}
else
{
_logger.Debug("Logging Thread quit successfully");
}
}
_state = State.Uninitialized;
}
_state = State.Uninitialized;
}
/// <summary>
/// Send data on the socket
/// </summary>
/// <param name="dataToSend">The data to send</param>
/// <param name="numBytesToWrite">The number of bytes to write from the dataToSend buffer</param>
/// <returns>The number of bytes sent</returns>
public uint Write(byte[] dataToSend, uint numBytesToWrite)
{
return _commDevice.Write(dataToSend, numBytesToWrite);
}
/// <summary>
/// Send data on the socket
/// </summary>
/// <param name="dataToSend">The data to send</param>
/// <param name="numBytesToWrite">The number of bytes to write from the dataToSend buffer</param>
/// <returns>The number of bytes sent</returns>
public uint Write(byte[] dataToSend, uint numBytesToWrite)
{
return _commDevice.Write(dataToSend, numBytesToWrite);
}
#endregion
}
#endregion
}
}

66
Source/TSRealLib/MAL/Managers/BitMeasurementManager/Lib/CommReadWorker.cs
View File

@@ -17,8 +17,7 @@ UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
using System;
using System.Threading;
using System.Net.Sockets;
using Raytheon.Instruments;
using NLog;
using Raytheon.Common;
namespace Raytheon.Instruments
@@ -35,6 +34,7 @@ namespace Raytheon.Instruments
private AutoResetEvent _quitEvent;
private byte[] _dataRead;
private readonly uint _timeToRestBetweenReadsInMs;
private readonly ILogger _logger;
#endregion
#region PublicFuctions
@@ -48,6 +48,7 @@ namespace Raytheon.Instruments
/// <param name="timeToRestBetweenReadsInMs">Number of ms to rest after a read call</param>
public CommReadWorker(ICommDevice commNode, MsgDevice msghandler, uint bufferSize, uint timeToRestBetweenReadsInMs)
{
_logger = LogManager.GetCurrentClassLogger();
_commNode = commNode;
_threadQuitControl = false;
_msgHandler = msghandler;
@@ -69,23 +70,9 @@ namespace Raytheon.Instruments
/// </summary>
public void Dispose()
{
try
{
Dispose(true);
Dispose(true);
GC.SuppressFinalize(this);
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
}
GC.SuppressFinalize(this);
}
/// <summary>
@@ -110,33 +97,14 @@ namespace Raytheon.Instruments
// not using timeToRestBetweenReadsInMs. Just going to wait 1 ms and get back to the read
if (_quitEvent.WaitOne(1))
{
ErrorLogger.Instance().Write("CommReadWorker::DoWork() - received signal to quit", ErrorLogger.LogLevel.INFO);
_logger.Debug("received signal to quit");
_threadQuitControl = true;
}
}
catch (SocketException e)
{
if (e.SocketErrorCode == SocketError.TimedOut)
{
//expected
}
else
{
ErrorLogger.Instance().Write("CommReadWorker::DoWork() - " + e.Message, ErrorLogger.LogLevel.ERROR);
}
}
catch (Exception e)
{
ErrorLogger.Instance().Write("CommReadWorker::DoWork() - " + e.Message, ErrorLogger.LogLevel.ERROR);
}
catch (Exception) { }
}
ErrorLogger.Instance().Write("CommReadWorker::DoWork() - exiting", ErrorLogger.LogLevel.INFO);
}
catch (Exception err)
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception) { }
}
/// <summary>
@@ -154,23 +122,9 @@ namespace Raytheon.Instruments
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
try
if (disposing)
{
if (disposing)
{
_quitEvent.Dispose();
}
}
catch (Exception err)
{
try
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
}
catch (Exception)
{
//Do not rethrow. Exception from error logger that has already been garbage collected
}
_quitEvent.Dispose();
}
}
#endregion

8
Source/TSRealLib/MAL/Managers/BitMeasurementManager/Messages/BitConfigurableMessageHeader.cs
View File

@@ -15,8 +15,8 @@ GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using Raytheon.Common;
using System;
using Raytheon.Common;
namespace BitMeasurementManagerLib
{
@@ -71,8 +71,7 @@ namespace BitMeasurementManagerLib
// is there enough data?
if (numBytesInPdata <= headerDef.secondaryMsgIdByteLocation + headerDef.secondaryMsgIdDataLen)
{
ErrorLogger.Instance().Write("BitConfigurableMessageHeader::GetSecondaryCmdMessageId() - not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.secondaryMsgIdByteLocation + headerDef.secondaryMsgIdDataLen).ToString() + " for a header", ErrorLogger.LogLevel.INFO);
throw new Exception("BitConfigurableMessageHeader::GetSecondaryCmdMessageId() - not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.secondaryMsgIdByteLocation + headerDef.secondaryMsgIdDataLen).ToString() + " for a header");
throw new Exception("Not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.secondaryMsgIdByteLocation + headerDef.secondaryMsgIdDataLen).ToString() + " for a header");
}
if (headerDef.secondaryMsgIdByteLocation == 0)
@@ -141,8 +140,7 @@ namespace BitMeasurementManagerLib
// is there enough data?
if (numBytesInPdata <= headerDef.msgIdByteLocation + headerDef.msgIdDataLen)
{
ErrorLogger.Instance().Write("BitConfigurableMessageHeader::GetCmdMessageId() - not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.msgIdByteLocation + headerDef.msgIdDataLen).ToString() + " for a header", ErrorLogger.LogLevel.INFO);
throw new Exception("BitConfigurableMessageHeader::GetCmdMessageId() - not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.msgIdByteLocation + headerDef.msgIdDataLen).ToString() + " for a header");
throw new Exception("Not enough data form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + (headerDef.msgIdByteLocation + headerDef.msgIdDataLen).ToString() + " for a header");
}
uint cmdId = 0;

52
Source/TSRealLib/MAL/Managers/BitMeasurementManager/MsgHandler/BitMsgHandler.cs
View File

@@ -16,9 +16,10 @@ UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using Raytheon.Common;
using System.IO;
using System.Collections.Generic;
using System.IO;
using NLog;
using Raytheon.Common;
namespace BitMeasurementManagerLib
{
@@ -48,6 +49,7 @@ namespace BitMeasurementManagerLib
private readonly bool _shallWeLogIncomingAsciiData;
private readonly uint _bitmask;
private readonly string _crcFieldName;
private readonly ILogger _logger;
#endregion
#region PublicFuctions
@@ -66,6 +68,7 @@ namespace BitMeasurementManagerLib
unsafe public BitMsgHandler(BitMessageIDs messageIds, MeasurementManagerLib.BitMeasurementManager.MessageReceivedDelegate callback, uint bufferSize, string binLogFileName, string asciiLogFileName, bool shallWeLogOutgoingBinData, bool shallWeLogOutgoingAsciiData, bool shallWeLogIncomingBinData, bool shallWeLogIncomingAsciiData, uint crcBitmask, string crcFieldName, bool shallWePerformVerboseParserLogging)
: base(new BitMsgParser(messageIds, shallWePerformVerboseParserLogging), bufferSize)
{
_logger = LogManager.GetCurrentClassLogger();
_messageIds = messageIds;
// hold onto the callback
@@ -166,7 +169,7 @@ namespace BitMeasurementManagerLib
{
if (_messageIds.ContainsId(msgId) == false)
{
ErrorLogger.Instance().Write("BitMsgHandler::OnCompleteMessage() - detected unknown msg id: " + msgId.ToString());
_logger.Warn("BitMsgHandler::OnCompleteMessage() - detected unknown msg id: " + msgId.ToString());
}
else
{
@@ -184,7 +187,7 @@ namespace BitMeasurementManagerLib
if (maskedStatus != 0)
{
ErrorLogger.Instance().Write($"Message Status register indicates that a CRC error may have occurred. Raw status read: 0x{rawStatus:X8}. Masked status value: 0x{maskedStatus:X8}");
_logger.Warn($"Message Status register indicates that a CRC error may have occurred. Raw status read: 0x{rawStatus:X8}. Masked status value: 0x{maskedStatus:X8}");
callbackValue = -1;
}
}
@@ -207,14 +210,10 @@ namespace BitMeasurementManagerLib
}
// some debugging
ErrorLogger.Instance().Write("BitMsgHandler::HandleMsg() - added message " + msgId.ToString("X8") + " to buffer ", ErrorLogger.LogLevel.INFO);
_logger.Debug("added message " + msgId.ToString("X8") + " to buffer ");
}
}
catch (Exception err)
{
//@@@ need to flow error to the host
ErrorLogger.Instance().Write("BitMsgHandler::HandleMsg() - caught an error: " + err.Message, ErrorLogger.LogLevel.ERROR);
}
catch { }
}
/// <summary>
@@ -271,7 +270,7 @@ namespace BitMeasurementManagerLib
{
if (_binWriter == null && _shallWeLogIncomingBinData == true)
{
throw new Exception("BitMsgHandler::WriteIncomingDataToLog() - Trying to log bin data before the log file is open");
throw new Exception("Trying to log bin data before the log file is open");
}
else if (_shallWeLogIncomingBinData == true)
{
@@ -292,7 +291,7 @@ namespace BitMeasurementManagerLib
{
if (_asciiWriter == null && _shallWeLogIncomingAsciiData == true)
{
throw new Exception("BitMsgHandler::WriteIncomingDataToLog() - Trying to log ascii data before the log file is open");
throw new Exception("Trying to log ascii data before the log file is open");
}
else if (_shallWeLogIncomingAsciiData == true)
{
@@ -318,7 +317,7 @@ namespace BitMeasurementManagerLib
{
if (_binWriter == null && _shallWeLogOutgoingBinData == true)
{
throw new Exception("BitMsgHandler::WriteOutgoingDataToLog() - Trying to log bin data before the log file is open");
throw new Exception("Trying to log bin data before the log file is open");
}
else if (_shallWeLogOutgoingBinData == true)
{
@@ -339,7 +338,7 @@ namespace BitMeasurementManagerLib
{
if (_asciiWriter == null && _shallWeLogOutgoingAsciiData == true)
{
throw new Exception("BitMsgHandler::WriteOutgoingDataToLog() - Trying to log ascii data before the log file is open");
throw new Exception("Trying to log ascii data before the log file is open");
}
else if (_shallWeLogOutgoingAsciiData == true)
{
@@ -362,25 +361,18 @@ namespace BitMeasurementManagerLib
{
if (disposing)
{
try
// call the parent dispose first
base.Dispose(disposing);
// now dispose of our resources
if (_binWriter != null)
{
// call the parent dispose first
base.Dispose(disposing);
// now dispose of our resources
if (_binWriter != null)
{
_binWriter.Dispose();
}
if (_asciiWriter != null)
{
_asciiWriter.Dispose();
}
_binWriter.Dispose();
}
catch (Exception err)
if (_asciiWriter != null)
{
ErrorLogger.Instance().Write(err.Message + "\r\n" + err.StackTrace);
_asciiWriter.Dispose();
}
}
}

29
Source/TSRealLib/MAL/Managers/BitMeasurementManager/MsgHandler/BitMsgParser.cs
View File

@@ -15,8 +15,9 @@ GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using Raytheon.Common;
using System;
using NLog;
using Raytheon.Common;
namespace BitMeasurementManagerLib
{
@@ -34,6 +35,7 @@ namespace BitMeasurementManagerLib
private readonly BitMessageIDs _messageIdToSizeMap;
private BitMsgEndianControl.HeaderDef _headerDef;
private readonly bool _shallWePerformVerboseParserLogging;
private readonly ILogger _logger;
#endregion
#region PrivateFuctions
@@ -54,7 +56,7 @@ namespace BitMeasurementManagerLib
if (numBytesInPdata < payloadHeaderSize)
{
ErrorLogger.Instance().Write("BitMsgParser::HandleData() - not enough data in the buffer to form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + payloadHeaderSize.ToString() + " for a header", ErrorLogger.LogLevel.INFO);
_logger.Debug("not enough data in the buffer to form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + payloadHeaderSize.ToString() + " for a header");
bytesToRemove = 0;
return false;
}
@@ -67,8 +69,8 @@ namespace BitMeasurementManagerLib
if (_messageIdToSizeMap.ContainsId(id) == false)
{
uint numBytesToRemove = Resync(pData, numBytesInPdata);
string msg = "BitMsgParser::HandleData() - unknown id received: " + id.ToString("X8") + " When resyncing threw away " + numBytesToRemove.ToString() + " Bytes";
ErrorLogger.Instance().Write(msg, ErrorLogger.LogLevel.ERROR);
string msg = "unknown id received: " + id.ToString("X8") + " When resyncing threw away " + numBytesToRemove.ToString() + " Bytes";
_logger.Warn(msg);
bytesToRemove = numBytesToRemove;
return false;
}
@@ -79,8 +81,8 @@ namespace BitMeasurementManagerLib
if (secondaryId != _headerDef.secondaryMsgIdExpectedValue)
{
uint numBytesToRemove = Resync(pData, numBytesInPdata);
string msg = "BitMsgParser::HandleData() - detected seondary ID: " + secondaryId.ToString("X8") + " was not as expected: " + _headerDef.secondaryMsgIdExpectedValue.ToString("X8") + " When resyncing threw away " + numBytesToRemove.ToString() + " Bytes";
ErrorLogger.Instance().Write(msg, ErrorLogger.LogLevel.ERROR);
string msg = "detected seondary ID: " + secondaryId.ToString("X8") + " was not as expected: " + _headerDef.secondaryMsgIdExpectedValue.ToString("X8") + " When resyncing threw away " + numBytesToRemove.ToString() + " Bytes";
_logger.Warn(msg);
bytesToRemove = numBytesToRemove;
return false;
}
@@ -91,7 +93,7 @@ namespace BitMeasurementManagerLib
// do we have enough data to make the complete message
if (numBytesInPdata < msgSize)
{
ErrorLogger.Instance().Write("BitMsgParser::HandleData() - not enough data in the buffer to form a entire message. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, expected msg size is: " + msgSize.ToString(), ErrorLogger.LogLevel.INFO);
_logger.Debug("not enough data in the buffer to form a entire message. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, expected msg size is: " + msgSize.ToString());
// need to wait for more data
bytesToRemove = 0;
return false;
@@ -102,7 +104,7 @@ namespace BitMeasurementManagerLib
if (_shallWePerformVerboseParserLogging == true)
{
ErrorLogger.Instance().Write("BitMsgParser::HandleData() - found msg: " + id.ToString() + " which has " + msgSize.ToString() + " bytes", ErrorLogger.LogLevel.INFO);
_logger.Debug("found msg: " + id.ToString() + " which has " + msgSize.ToString() + " bytes");
}
messageId = id;
@@ -118,7 +120,7 @@ namespace BitMeasurementManagerLib
/// <returns>The number of bytes to remove from the buffer</returns>
private uint Resync(IntPtr pData, uint numBytesInPdata)
{
ErrorLogger.Instance().Write("BitMsgParser::Resync() - Begin", ErrorLogger.LogLevel.INFO);
_logger.Debug("Begin");
// increment pData by 1
pData = IntPtr.Add(pData, 1);
@@ -138,7 +140,7 @@ namespace BitMeasurementManagerLib
if (numBytesInPdata < payloadHeaderSize)
{
ErrorLogger.Instance().Write("BitMsgParser::Resync() - not enough data in the buffer to form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + payloadHeaderSize.ToString() + " for a header. Removing " + bytesToRemove.ToString() + " bytes", ErrorLogger.LogLevel.INFO);
_logger.Debug("not enough data in the buffer to form a header. Buffer contained " + Convert.ToString(numBytesInPdata) + " bytes, needed " + payloadHeaderSize.ToString() + " for a header. Removing " + bytesToRemove.ToString() + " bytes");
break;
}
@@ -179,20 +181,20 @@ namespace BitMeasurementManagerLib
else
{
didWeFindMsg = true;
ErrorLogger.Instance().Write("BitMsgParser::Resync() - Detected message ID: " + id.ToString("X8") + ". Detected Secondary ID: " + secondaryId.ToString("X8") + " Resync complete. Removing " + bytesToRemove.ToString() + " Bytes", ErrorLogger.LogLevel.INFO);
_logger.Debug("Detected message ID: " + id.ToString("X8") + ". Detected Secondary ID: " + secondaryId.ToString("X8") + " Resync complete. Removing " + bytesToRemove.ToString() + " Bytes");
break;
}
}
else
{
didWeFindMsg = true;
ErrorLogger.Instance().Write("BitMsgParser::Resync() - Detected message ID: " + id.ToString("X8") + ". Resync complete. Removing " + bytesToRemove.ToString() + " Bytes", ErrorLogger.LogLevel.INFO);
_logger.Debug("Detected message ID: " + id.ToString("X8") + ". Resync complete. Removing " + bytesToRemove.ToString() + " Bytes");
break;
}
}
}
ErrorLogger.Instance().Write("BitMsgParser::Resync() - returning " + bytesToRemove.ToString(), ErrorLogger.LogLevel.INFO);
_logger.Debug("returning " + bytesToRemove.ToString());
return bytesToRemove;
@@ -208,6 +210,7 @@ namespace BitMeasurementManagerLib
/// <param name="shallWePerformVerboseParserLogging"></param>
public BitMsgParser(BitMessageIDs messageIds, bool shallWePerformVerboseParserLogging)
{
_logger = LogManager.GetCurrentClassLogger();
// Using it to hold onto valid message ids and the size
_messageIdToSizeMap = messageIds;
_shallWePerformVerboseParserLogging = shallWePerformVerboseParserLogging;