1114 lines
41 KiB
C#
1114 lines
41 KiB
C#
// **********************************************************************************************************
|
|
// BITCOEDeviceInstrument.cs
|
|
// 6/21/2022
|
|
// NGI - Next Generation Interceptor
|
|
//
|
|
// Contract No. HQ0856-21-C-0003/1022000209
|
|
//
|
|
// THIS DOCUMENT DOES NOT CONTAIN TECHNOLOGY OR TECHNICAL DATA CONTROLLED UNDER EITHER THE U.S.
|
|
// INTERNATIONAL TRAFFIC IN ARMS REGULATIONS OR THE U.S. EXPORT ADMINISTRATION REGULATIONS.
|
|
//
|
|
// 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.
|
|
//
|
|
// UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
|
|
//
|
|
// DESTRUCTION NOTICE: FOR CLASSIFIED DOCUMENTS FOLLOW THE PROCEDURES IN DOD 5220.22-M,
|
|
// NATIONAL INDUSTRIAL SECURITY PROGRAM OPERATING MANUAL, FEBRUARY 2006,
|
|
// INCORPORATING CHANGE 1, MARCH 28, 2013, CHAPTER 5, SECTION 7, OR DODM 5200.01-VOLUME 3,
|
|
// DOD INFORMATION SECURITY PROGRAM: PROTECTION OF CLASSIFIED INFORMATION, ENCLOSURE 3,
|
|
// SECTION 17. FOR CONTROLLED UNCLASSIFIED INFORMATION FOLLOW THE PROCEDURES IN DODM 5200.01-VOLUME 4,
|
|
// INFORMATION SECURITY PROGRAM: CONTROLLED UNCLASSIFIED INFORMATION.
|
|
//
|
|
// CONTROLLED BY: MISSILE DEFENSE AGENCY
|
|
// CONTROLLED BY: GROUND-BASED MIDCOURSE DEFENSE PROGRAM OFFICE
|
|
// CUI CATEGORY: CTI
|
|
// DISTRIBUTION/DISSEMINATION CONTROL: F
|
|
// POC: Alex Kravchenko (1118268)
|
|
// **********************************************************************************************************
|
|
using System;
|
|
using Raytheon.Instruments.MessagingUtilities;
|
|
using System.Xml.XPath;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using Raytheon.Common;
|
|
using Raytheon.Instruments.coeCSharp;
|
|
using Raytheon.Instruments.Exceptions;
|
|
using System.Collections.Concurrent;
|
|
using static Raytheon.Instruments.MessagingUtilities.Message;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Globalization;
|
|
using System.Runtime.CompilerServices;
|
|
using NLog;
|
|
|
|
[assembly: InternalsVisibleTo("BITCOEDeviceNode.Tests")]
|
|
namespace Raytheon.Instruments
|
|
{
|
|
/// <summary>
|
|
/// This device supports different ways of communicating with other COE nodes
|
|
/// TCP
|
|
/// UDP
|
|
/// Serial
|
|
/// </summary>
|
|
public enum DriverType
|
|
{
|
|
Undefined,
|
|
TCP,
|
|
UDP,
|
|
Serial
|
|
};
|
|
|
|
/// <summary>
|
|
/// Implementation of the IBit interface
|
|
/// </summary>
|
|
public class BITCOEDeviceInstrument : IBit
|
|
{
|
|
/// <summary>
|
|
/// Nlog logger
|
|
/// </summary>
|
|
private readonly ILogger _logger;
|
|
|
|
/// <summary>
|
|
/// Raytheon configuration
|
|
/// </summary>
|
|
private readonly IConfigurationManager _configurationManager;
|
|
private readonly IConfiguration _configuration;
|
|
|
|
/// <summary>
|
|
/// reference to the main wrapper class for Common Operating Environment
|
|
/// </summary>
|
|
private readonly coe _coe;
|
|
|
|
/// <summary>
|
|
/// COE endpoint
|
|
/// </summary>
|
|
private coeEndpoint _endpoint;
|
|
|
|
/// <summary>
|
|
/// cancellation token for stopping reading thread
|
|
/// </summary>
|
|
private CancellationTokenSource _cancellationTokenSource = null;
|
|
|
|
/// <summary>
|
|
/// collection of the messages received
|
|
/// </summary>
|
|
private readonly Dictionary<string, ConcurrentQueue<Tuple<DateTime, OeMessage>>> _messages;
|
|
|
|
/// <summary>
|
|
/// UDP, TCP, Serial or Undefined
|
|
/// </summary>
|
|
private DriverType _driverType;
|
|
|
|
/// <summary>
|
|
/// dictionary of options when initializing COE endpoint and router
|
|
/// </summary>
|
|
private readonly Dictionary<string, List<KeyValuePair<string, string>>> _options = new Dictionary<string, List<KeyValuePair<string, string>>>();
|
|
|
|
/// <summary>
|
|
/// used for initialization of the endpoint
|
|
/// </summary>
|
|
private uint _maxMessageSize;
|
|
private uint _epQueueDepth;
|
|
|
|
/// <summary>
|
|
/// Number of milliseconds to wake up and check the message when receiving
|
|
/// </summary>
|
|
private int _checkForMessageIntervalMs;
|
|
|
|
/// <summary>
|
|
/// collection of all labels with message names per every XML file
|
|
/// </summary>
|
|
private readonly Dictionary<string, Dictionary<uint, string>> _icds = new Dictionary<string, Dictionary<uint, string>>();
|
|
|
|
/// <summary>
|
|
/// collection of response labels or messages that COE endpoint should be registered for
|
|
/// </summary>
|
|
private readonly List<uint> _responseLabels = new List<uint>();
|
|
|
|
/// <summary>
|
|
/// collection of message XML documents (processed XML files) used in COE communications
|
|
/// </summary>
|
|
private readonly Dictionary<string, MessageXmlDocument> _xmlDocs = new Dictionary<string, MessageXmlDocument>();
|
|
|
|
/// <summary>
|
|
/// when set to true the instrument will check every value and if empty
|
|
/// will populate it with the default value
|
|
/// </summary>
|
|
private bool _alwaysSendDefaults;
|
|
|
|
/// <summary>
|
|
/// instrument constructor
|
|
/// </summary>
|
|
public BITCOEDeviceInstrument(string name, IConfigurationManager configurationManager, DriverType driverType = DriverType.Undefined, ILogger logger = null)
|
|
{
|
|
Info = new InstrumentMetadata
|
|
{
|
|
ModelNumber = "COECommDevice"
|
|
};
|
|
|
|
if (logger == null)
|
|
logger = LogManager.GetCurrentClassLogger();
|
|
|
|
_logger = logger;
|
|
|
|
Status = State.Uninitialized;
|
|
DetailedStatus = "COE Uninitialized";
|
|
|
|
Name = name;
|
|
|
|
if (LogManager.Configuration == null)
|
|
{
|
|
var assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
|
|
LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration(assemblyFolder + "\\nlog.config");
|
|
}
|
|
|
|
if (configurationManager == null)
|
|
{
|
|
_logger.Error($"Cannot create {Name} without a configuration manager");
|
|
return;
|
|
}
|
|
|
|
_configurationManager = configurationManager;
|
|
_configuration = _configurationManager.GetConfiguration(Name);
|
|
|
|
_messages = new Dictionary<string, ConcurrentQueue<Tuple<DateTime, OeMessage>>>();
|
|
|
|
_driverType = driverType;
|
|
|
|
_coe = new coe();
|
|
}
|
|
|
|
public string DetailedStatus { get; protected set; }
|
|
|
|
public bool DisplayEnabled { get => false; set => throw new NotImplementedException(); }
|
|
public bool FrontPanelEnabled { get => false; set => throw new NotImplementedException(); }
|
|
|
|
public InstrumentMetadata Info { get; set; }
|
|
|
|
public string Name { get; protected set; }
|
|
|
|
public SelfTestResult SelfTestResult => PerformSelfTest();
|
|
|
|
public State Status { get; set; }
|
|
|
|
public bool ClearErrors()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes COE instrument
|
|
/// </summary>
|
|
public void Initialize()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Initializing...");
|
|
|
|
if (_driverType == DriverType.Undefined)
|
|
_driverType = _configuration.GetConfigurationValue<DriverType>("Parameters", "DriverType", "TCP");
|
|
|
|
_alwaysSendDefaults = _configuration.GetConfigurationValue("Parameters", "AlwaysSendDefaults", false);
|
|
|
|
_options.Clear();
|
|
_options.Add("ROUTER_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("NODE_ID", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "NODE_ID", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_STATE", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_STATE", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_LABEL_MESSAGE", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_LABEL_MESSAGE", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_BRIDGE_REGISTRATION", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_BRIDGE_REGISTRATION", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_ROUTER_DATABASE", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_ROUTER_DATABASE", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "DISPLAY_DEBUG_RECV", "0")) },
|
|
{ new KeyValuePair<string, string>("BUFFER_SIZE", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "BUFFER_SIZE", "256")) },
|
|
{ new KeyValuePair<string, string>("ENABLE_REGISTRATION_MESSAGES", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "ENABLE_REGISTRATION_MESSAGES", "1")) },
|
|
{ new KeyValuePair<string, string>("THREAD_STACK_SIZE", _configuration.GetConfigurationValue<string>("ROUTER_CONFIG", "THREAD_STACK_SIZE", "16384")) },
|
|
});
|
|
|
|
_options.Add("ROUTER_PROTOCOL_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("ROUTER_PROTOCOL_CONFIG", "DISPLAY_DEBUG_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("ROUTER_PROTOCOL_CONFIG", "DISPLAY_DEBUG_RECV", "0")) },
|
|
{ new KeyValuePair<string, string>("THREAD_STACK_SIZE", _configuration.GetConfigurationValue<string>("ROUTER_PROTOCOL_CONFIG", "THREAD_STACK_SIZE", "16384")) },
|
|
});
|
|
|
|
var poolEntry = _configuration.GetConfigurationValue<string>("ROUTER_BUFFER_POOLS", "POOL_ENTRY", "100,32|50,128|100,384|150,1536|10,65535");
|
|
if (!string.IsNullOrEmpty(poolEntry))
|
|
{
|
|
var poolEntries = poolEntry.Split('|');
|
|
if (poolEntries.Any())
|
|
{
|
|
var entries = new List<KeyValuePair<string, string>>();
|
|
foreach (var entry in poolEntries)
|
|
{
|
|
entries.Add(new KeyValuePair<string, string>("POOL_ENTRY", entry));
|
|
}
|
|
_options.Add("ROUTER_BUFFER_POOLS", entries);
|
|
}
|
|
}
|
|
|
|
_options.Add("BASIC_REGISTRATION_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND_BUFFER", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_SEND_BUFFER", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_RECV", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV_BUFFER", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_RECV_BUFFER", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_STATE", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_STATE", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_PING_SEND", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_PING_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_PING_RECV", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "DISPLAY_DEBUG_PING_RECV", "0")) },
|
|
{ new KeyValuePair<string, string>("THREAD_STACK_SIZE", _configuration.GetConfigurationValue<string>("BASIC_REGISTRATION_CONFIG", "THREAD_STACK_SIZE", "16384")) },
|
|
});
|
|
|
|
switch (_driverType)
|
|
{
|
|
case DriverType.UDP:
|
|
_options.Add("UDP_MEDIA_BINDING_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("LOCAL_IP_ADDRESS", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "LOCAL_IP_ADDRESS", "127.0.0.1")) },
|
|
{ new KeyValuePair<string, string>("REMOTE_IP_ADDRESS", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "REMOTE_IP_ADDRESS", "127.0.0.1")) },
|
|
{ new KeyValuePair<string, string>("LOCAL_SEND_PORT", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "LOCAL_SEND_PORT", "32010")) },
|
|
{ new KeyValuePair<string, string>("LOCAL_RECV_PORT", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "LOCAL_RECV_PORT", "32020")) },
|
|
{ new KeyValuePair<string, string>("REMOTE_SEND_PORT", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "REMOTE_SEND_PORT", "32011")) },
|
|
{ new KeyValuePair<string, string>("REMOTE_RECV_PORT", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "REMOTE_RECV_PORT", "32021")) },
|
|
{ new KeyValuePair<string, string>("RECV_TIMEOUT", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "RECV_TIMEOUT", "200")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_RECV", "0")) },
|
|
{ new KeyValuePair<string, string>("MTU_SIZE", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "MTU_SIZE", "1472")) },
|
|
{ new KeyValuePair<string, string>("THREAD_STACK_SIZE", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "THREAD_STACK_SIZE", "16384")) },
|
|
{ new KeyValuePair<string, string>("THREAD_NAME", _configuration.GetConfigurationValue<string>("UDP_MEDIA_BINDING_CONFIG", "THREAD_NAME", "UDP_MB_RCV")) },
|
|
});
|
|
break;
|
|
|
|
case DriverType.TCP:
|
|
_options.Add("TCP_MEDIA_BINDING_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("LOCAL_PORT", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "LOCAL_PORT", "9990")) },
|
|
{ new KeyValuePair<string, string>("NUM_PORTS", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "NUM_PORTS", "32")) },
|
|
{ new KeyValuePair<string, string>("NUM_DYNAMIC_NODES", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "NUM_DYNAMIC_NODES", "32")) },
|
|
{ new KeyValuePair<string, string>("SERVER_ADDRESS", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "SERVER_ADDRESS", "127.0.0.1:9990")) },
|
|
{ new KeyValuePair<string, string>("UDP_TX_BUFFER_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "UDP_TX_BUFFER_SIZE", "5000")) },
|
|
{ new KeyValuePair<string, string>("UDP_RX_BUFFER_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "UDP_RX_BUFFER_SIZE", "32768")) },
|
|
{ new KeyValuePair<string, string>("TCP_TX_BUFFER_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "TCP_TX_BUFFER_SIZE", "5000")) },
|
|
{ new KeyValuePair<string, string>("TCP_RX_BUFFER_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "TCP_RX_BUFFER_SIZE", "4096")) },
|
|
{ new KeyValuePair<string, string>("PACKET_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "PACKET_SIZE", "5128")) },
|
|
{ new KeyValuePair<string, string>("TCP_SELECT_VALUE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "TCP_SELECT_VALUE", "1")) },
|
|
{ new KeyValuePair<string, string>("DISABLE_NAG_DELAY", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISABLE_NAG_DELAY", "1")) },
|
|
{ new KeyValuePair<string, string>("TIMER_RATE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "TIMER_RATE", "1000")) },
|
|
{ new KeyValuePair<string, string>("CONNECT_KA_RATE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "CONNECT_KA_RATE", "1")) },
|
|
{ new KeyValuePair<string, string>("RECV_KA_RATE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "RECV_KA_RATE", "1")) },
|
|
{ new KeyValuePair<string, string>("SERVER_CONNECT_RATE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "SERVER_CONNECT_RATE", "1")) },
|
|
{ new KeyValuePair<string, string>("RECV_THREAD_STACK_SIZE", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "RECV_THREAD_STACK_SIZE", "4096")) },
|
|
{ new KeyValuePair<string, string>("RECV_THREAD_PRIORITY", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "RECV_THREAD_PRIORITY", "0")) },
|
|
{ new KeyValuePair<string, string>("RECV_THREAD_AFFINITY", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "RECV_THREAD_AFFINITY", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_SEND", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND_BUFFER", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_SEND_BUFFER", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_UDP_RECV", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_UDP_RECV", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_UDP_RECV_BUFFER", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_UDP_RECV_BUFFER", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_TCP_RECV", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_TCP_RECV", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_TCP_RECV_BUFFER", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_TCP_RECV_BUFFER", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_RECV", "1")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV_BUFFER", _configuration.GetConfigurationValue<string>("TCP_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_RECV_BUFFER", "1")) },
|
|
});
|
|
break;
|
|
|
|
case DriverType.Serial:
|
|
_options.Add("SERIAL_MEDIA_BINDING_CONFIG", new List<KeyValuePair<string, string>>
|
|
{
|
|
{ new KeyValuePair<string, string>("DEVICE_NAME", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "DEVICE_NAME", "\\\\.\\COM1")) },
|
|
{ new KeyValuePair<string, string>("BAUD_RATE", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "BAUD_RATE", "9600")) },
|
|
{ new KeyValuePair<string, string>("DATA_BITS", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "DATA_BITS", "8")) },
|
|
{ new KeyValuePair<string, string>("STOP_BITS", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "STOP_BITS", "1")) },
|
|
{ new KeyValuePair<string, string>("PARITY", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "PARITY", "0")) },
|
|
{ new KeyValuePair<string, string>("FLOW_CONTROL", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "FLOW_CONTROL", "0")) },
|
|
{ new KeyValuePair<string, string>("MTU_SIZE", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "MTU_SIZE", "256")) },
|
|
{ new KeyValuePair<string, string>("RECV_PROCESSING_DELAY", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "RECV_PROCESSING_DELAY", "100")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_SEND", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_SEND", "0")) },
|
|
{ new KeyValuePair<string, string>("DISPLAY_DEBUG_RECV", _configuration.GetConfigurationValue<string>("SERIAL_MEDIA_BINDING_CONFIG", "DISPLAY_DEBUG_RECV", "0")) },
|
|
});
|
|
break;
|
|
|
|
default:
|
|
_logger.Error($"{Name}({_driverType}) Configured driver type not valid");
|
|
break;
|
|
}
|
|
|
|
_maxMessageSize = _configuration.GetConfigurationValue<uint>("Parameters", "MaxMessageSize", "5000");
|
|
_epQueueDepth = _configuration.GetConfigurationValue<uint>("Parameters", "EPQueueDepth", "5000");
|
|
_checkForMessageIntervalMs = _configuration.GetConfigurationValue<int>("Parameters", "CheckForMessageIntervalMs", "100");
|
|
|
|
var responseLabels = _configuration.GetConfigurationListValue("ResponseMessageIds", "ResponseLabel", new List<string> { "1", "2" });
|
|
|
|
var bitFilePaths = _configuration.GetConfigurationListValue("BitFilePaths", "FilePath", new List<string> { "File1", "File2" });
|
|
|
|
_xmlDocs.Clear();
|
|
foreach (var path in bitFilePaths)
|
|
{
|
|
_xmlDocs.Add(path, new MessageXmlDocument(path, _logger));
|
|
}
|
|
|
|
_icds.Clear();
|
|
foreach (var path in bitFilePaths)
|
|
{
|
|
_icds.Add(path, ProcessFileForNamesAndLabels(path));
|
|
}
|
|
|
|
foreach (var strLabel in responseLabels)
|
|
{
|
|
uint label = GetLabelFromMessageId(strLabel);
|
|
if (label > 0)
|
|
_responseLabels.Add(label);
|
|
}
|
|
|
|
DetailedStatus = "COE Initialized";
|
|
Status = State.Ready;
|
|
}
|
|
|
|
/// <summary>
|
|
/// performs self-test
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public SelfTestResult PerformSelfTest()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Performing Self Test...");
|
|
|
|
// TODO implement method
|
|
return SelfTestResult.Pass;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets COE device comms
|
|
/// </summary>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public void Reset()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Resetting...");
|
|
|
|
Close();
|
|
|
|
Open();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shuts down COE device
|
|
/// </summary>
|
|
public void Shutdown()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Shutting Down...");
|
|
try
|
|
{
|
|
Close();
|
|
//coe.UnloadImportedDll("coeWindows-shared.dll");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error(ex, $"{Name}({_driverType}) Error while closing");
|
|
}
|
|
}
|
|
|
|
#region IBit functions
|
|
/// <summary>
|
|
/// Opens COE connection
|
|
/// </summary>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public void Open()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Opening...");
|
|
|
|
try
|
|
{
|
|
switch (_driverType)
|
|
{
|
|
case DriverType.TCP:
|
|
|
|
if (_coe.tcp_media_binding_configure(_options, _logger) != coe.Status.SUCCESS)
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) COE TCP media binding initialization failure.\nTry checking your connection configuration.\nYou could have a port collision.");
|
|
Status = State.CommunicationFailure;
|
|
throw new BitNotConnectedException($"{Name}({_driverType}) COE TCP media binding initialization failure");
|
|
}
|
|
_logger.Trace($"{Name}({_driverType}) COE TCP media binding initialization, {_coe.ProtocolCmitName}");
|
|
break;
|
|
case DriverType.UDP:
|
|
if (_coe.udp_media_binding_configure(_options, _logger) != coe.Status.SUCCESS)
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) COE UDP media binding initialization failure.\nTry checking your connection configuration.\nYou could have a port collision.");
|
|
Status = State.CommunicationFailure;
|
|
throw new BitNotConnectedException($"{Name}({_driverType}) COE UDP media binding initialization failure");
|
|
}
|
|
_logger.Trace($"{Name}({_driverType}) COE UDP media binding initialization, Local: {_coe.ProtocolCmitName} Remote: {_coe.ProtocolName}");
|
|
break;
|
|
case DriverType.Serial:
|
|
if (_coe.serial_media_binding_configure(_options, _logger) != coe.Status.SUCCESS)
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) COE Serial media binding initialization failure.\nTry checking your connection configuration.\nYou could have a port collision.");
|
|
Status = State.CommunicationFailure;
|
|
throw new BitNotConnectedException($"{Name}({_driverType}) COE Serial media binding initialization failure");
|
|
}
|
|
_logger.Trace($"{Name}({_driverType}) COE Serial media binding initialization, {_coe.ProtocolCmitName}");
|
|
break;
|
|
default:
|
|
_logger.Error($"{Name}({_driverType}) Configured driver type not valid");
|
|
throw new BitNotConnectedException($"{Name}({_driverType}) Configured driver type not valid");
|
|
}
|
|
|
|
foreach (var item in _options)
|
|
{
|
|
_logger.Trace($"{item.Key}:");
|
|
foreach (var pair in item.Value)
|
|
{
|
|
_logger.Trace(string.Format("{0,-50} {1, -40}", pair.Key, pair.Value));
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error(ex);
|
|
Status = State.CommunicationFailure;
|
|
DetailedStatus = "Unable to Open";
|
|
throw;
|
|
}
|
|
|
|
try
|
|
{
|
|
_coe.SetConnected(true);
|
|
|
|
//_endpoint = new coeEndpoint(_maxMessageSize, _epQueueDepth, _coe.Router);
|
|
_endpoint = new coeEndpoint(_maxMessageSize, _epQueueDepth);
|
|
|
|
_logger.Info($"{Name}({_driverType}) Endpoint Created, Max Message Size: {_maxMessageSize}, Queue Depth: {_epQueueDepth}");
|
|
|
|
foreach (var item in _responseLabels)
|
|
{
|
|
var fileName = WhichFileContainsTheLabel(item);
|
|
if (!string.IsNullOrEmpty(fileName))
|
|
{
|
|
var msgName = _icds[fileName][item];
|
|
if (!string.IsNullOrEmpty(msgName))
|
|
{
|
|
_endpoint.Register(item);
|
|
_logger.Debug($"{Name}({_driverType}) Registering new message with the endpoint, {item}: {msgName}");
|
|
}
|
|
else
|
|
{
|
|
_logger.Warn($"{Name}({_driverType}) Message with label {item} is not located in file {fileName}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.Warn($"{Name}({_driverType}) Unable to locate label {item} in any of the XML files registered for COE device");
|
|
}
|
|
}
|
|
|
|
_cancellationTokenSource = new CancellationTokenSource();
|
|
Task.Run(() => ReadMessages(_cancellationTokenSource.Token));
|
|
|
|
Status = State.Ready;
|
|
DetailedStatus = "Opened";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Status = State.CommunicationFailure;
|
|
DetailedStatus = "Unable to Open";
|
|
_logger.Error(ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Close COE endpoint
|
|
/// </summary>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public void Close()
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Closing ...");
|
|
|
|
Status = State.Uninitialized;
|
|
|
|
_cancellationTokenSource?.Cancel();
|
|
|
|
Thread.Sleep(1000);
|
|
|
|
if (_messages.Any())
|
|
{
|
|
foreach (var queue in _messages)
|
|
{
|
|
while (queue.Value.TryDequeue(out Tuple<DateTime, OeMessage> throwAway))
|
|
{
|
|
_logger.Warn($"Message {throwAway.Item2.Label} ({throwAway.Item2.XmlMessage.Name}) received at {throwAway.Item1:hh.mm.ss.fff} was unclaimed");
|
|
}
|
|
}
|
|
}
|
|
|
|
_messages.Clear();
|
|
|
|
_coe.SetConnected(false);
|
|
var status = _driverType == DriverType.TCP ?
|
|
_coe.TCP_media_binding_shutdown(_logger) : _driverType == DriverType.UDP ?
|
|
_coe.UDP_media_binding_shutdown(_logger) : _coe.SERIAL_media_binding_shutdown(_logger);
|
|
|
|
if (status != coe.Status.SUCCESS)
|
|
{
|
|
_logger.Error($"{_driverType} media binding shutdown failure, status {status}");
|
|
}
|
|
else
|
|
{
|
|
_logger.Debug($"{_driverType} shutdown was successful");
|
|
}
|
|
|
|
_endpoint?.Dispose();
|
|
|
|
_cancellationTokenSource?.Dispose();
|
|
_cancellationTokenSource = null;
|
|
|
|
DetailedStatus = "Closed";
|
|
}
|
|
|
|
/// <summary>
|
|
/// runs single BIT test request, no waiting for response
|
|
/// expecting user to run
|
|
/// </summary>
|
|
/// <param name="messageId"></param>
|
|
/// <param name="timeoutInMs"></param>
|
|
/// <param name="messageParams"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public bool RunBIT(string messageId, uint timeoutInMs, IEnumerable<KeyValuePair<string, string>> messageParams)
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Running BIT for {messageId} with timeout {timeoutInMs} ...");
|
|
|
|
if (!_coe.IsConnected)
|
|
{
|
|
_logger.Error("Error sending COE message, COE not connected");
|
|
throw new BitNotConnectedException();
|
|
}
|
|
if (Status != State.Ready)
|
|
{
|
|
_logger.Warn("Exiting RunBIT due to status");
|
|
throw new BitNotConnectedException();
|
|
}
|
|
|
|
var label = GetLabelFromMessageId(messageId);
|
|
|
|
var path = WhichFileContainsTheLabel(label);
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
var msg = $"Message Id {messageId} not found in any of the BIT files";
|
|
_logger.Error(msg);
|
|
throw new BitParseException(msg);
|
|
}
|
|
|
|
try
|
|
{
|
|
var message = GetOeMessageWithParameters(label, messageParams, path);
|
|
|
|
_logger.Info("Sending ...");
|
|
message.XmlMessage.SendToLog(EnumerationType.EXPANDED_FIELDS, MessageDirection.Out);
|
|
|
|
var status = _endpoint.Send(message);
|
|
|
|
if (status != coe.Status.SUCCESS)
|
|
{
|
|
_logger.Error($"Error sending COE message, error code: {status}");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runs a BIT and expects a result
|
|
/// </summary>
|
|
/// <param name="messageIdOut"></param>
|
|
/// <param name="messageIdIn"></param>
|
|
/// <param name="timeoutInMs"></param>
|
|
/// <param name="messageParams"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public BitTestResults RunBITWaitForResults(string messageIdOut, string messageIdIn, uint timeoutInMs, IEnumerable<KeyValuePair<string, string>> messageParams)
|
|
{
|
|
_logger.Trace($"{Name}({_driverType}) Running BIT for {messageIdOut} and waiting for result {messageIdIn} with timeout {timeoutInMs}...");
|
|
|
|
if (!_coe.IsConnected)
|
|
{
|
|
_logger.Error("Error sending COE message, COE not connected");
|
|
throw new BitNotConnectedException();
|
|
}
|
|
|
|
if (Status != State.Ready)
|
|
{
|
|
_logger.Warn("Exiting RunBITWaitForResults due to status");
|
|
throw new BitNotConnectedException();
|
|
}
|
|
|
|
if (RunBIT(messageIdOut, timeoutInMs, messageParams))
|
|
{
|
|
if (string.IsNullOrEmpty(messageIdIn))
|
|
{
|
|
messageIdIn = "0";
|
|
}
|
|
|
|
string[] multipleIds = messageIdIn.Split(',');
|
|
|
|
var totalWaitTimeMs = 0;
|
|
|
|
BitTestResults results = null;
|
|
do
|
|
{
|
|
foreach (var id in multipleIds)
|
|
{
|
|
results = GetBITResults(id);
|
|
|
|
if (results != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (results != null || Status != State.Ready)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Thread.Sleep(_checkForMessageIntervalMs);
|
|
totalWaitTimeMs += _checkForMessageIntervalMs;
|
|
}
|
|
|
|
} while (results == null && totalWaitTimeMs < timeoutInMs);
|
|
|
|
if (results != null)
|
|
{
|
|
_logger.Debug($"-- Successfully retrieved result message, totalWaitTimeMs = {totalWaitTimeMs}");
|
|
return results;
|
|
}
|
|
else
|
|
throw new BitTimeoutException();
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads BIT results
|
|
/// </summary>
|
|
/// <param name="messageId"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public BitTestResults GetBITResults(string messageId)
|
|
{
|
|
if (!_coe.IsConnected)
|
|
{
|
|
_logger.Error("Error reading COE message, COE not connected");
|
|
throw new BitNotConnectedException();
|
|
}
|
|
|
|
uint label = 0;
|
|
// empty string or zero means first available message from the top
|
|
if (!string.IsNullOrEmpty(messageId) && messageId != "0")
|
|
{
|
|
label = GetLabelFromMessageId(messageId);
|
|
if (label == 0)
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) Unable to match message {messageId} with anything in the dictionary. Check your configuration");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
string strLabel = label.ToString();
|
|
|
|
ConcurrentQueue<Tuple<DateTime, OeMessage>> queue;
|
|
|
|
lock (this)
|
|
{
|
|
queue = label == 0 ?
|
|
_messages.Any() ? _messages.FirstOrDefault().Value : null :
|
|
_messages.ContainsKey(strLabel) ? _messages[strLabel] : null;
|
|
}
|
|
|
|
if (queue != null && queue.TryDequeue(out Tuple<DateTime, OeMessage> message))
|
|
{
|
|
var oeMessage = message.Item2;
|
|
|
|
if (queue.IsEmpty)
|
|
{
|
|
lock (this)
|
|
{
|
|
_messages.Remove(oeMessage.Label);
|
|
}
|
|
}
|
|
|
|
// make a copy of the buffer
|
|
var xmlMessage = oeMessage.XmlMessage;
|
|
if (xmlMessage != null)
|
|
{
|
|
var results = new BitTestResults
|
|
{
|
|
Label = oeMessage.Label,
|
|
Time = message.Item1,
|
|
|
|
// parse message result into list of results
|
|
Results = FromXmlToBitTestResults(xmlMessage)
|
|
};
|
|
|
|
return results;
|
|
}
|
|
else
|
|
{
|
|
var msg = $"Found a message with label {label}, but the Buffer is empty";
|
|
_logger.Error(msg);
|
|
throw new BitParseException(msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// message not found
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Functions
|
|
|
|
/// <summary>
|
|
/// keep reading messages and stash them in _messages dictionary with label and timestamp as a key
|
|
/// </summary>
|
|
/// <param name="cancellationToken"></param>
|
|
/// <returns></returns>
|
|
private void ReadMessages(CancellationToken cancellationToken)
|
|
{
|
|
_logger.Debug($"{Name}({_driverType}) Starting to read messages.");
|
|
|
|
try
|
|
{
|
|
while (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
//_logger.Debug($"{Name}({_driverType}) Checking for messages...");
|
|
var status = _endpoint.Wait(1000);
|
|
|
|
if (status == coe.Status.SUCCESS)
|
|
{
|
|
_logger.Debug("Message Received...");
|
|
|
|
while (_endpoint.Peek(out uint label, out uint size, out int priority) == coe.Status.SUCCESS)
|
|
{
|
|
var hexLabel = $"0x{label:X}";
|
|
_logger.Debug($"{Name}({_driverType}) Identified message by peeking... {label} ({hexLabel})");
|
|
|
|
var xmlDoc = WhichFileContainsTheLabel(label);
|
|
|
|
var message = new OeMessage((int)size + 1)
|
|
{
|
|
XmlMessage = new Message(_xmlDocs[xmlDoc], label.ToString())
|
|
};
|
|
|
|
status = _endpoint.Receive(message);
|
|
|
|
if (status == coe.Status.SUCCESS)
|
|
{
|
|
_logger.Debug($"{Name}({_driverType}) Successfully read message... Label: {hexLabel} ({message.XmlMessage?.Name})");
|
|
|
|
message.XmlMessage.SendToLog(EnumerationType.EXPANDED_FIELDS, MessageDirection.In);
|
|
|
|
ConcurrentQueue<Tuple<DateTime, OeMessage>> queue;
|
|
|
|
lock (this)
|
|
{
|
|
if (!_messages.ContainsKey(message.Label))
|
|
{
|
|
_messages.Add(message.Label, new ConcurrentQueue<Tuple<DateTime, OeMessage>>());
|
|
}
|
|
queue = _messages[message.Label];
|
|
}
|
|
|
|
queue.Enqueue(new Tuple<DateTime, OeMessage>(DateTime.Now, message));
|
|
}
|
|
else
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) Endpoint Receive Failed. Status = {status}");
|
|
}
|
|
}
|
|
}
|
|
// If not timeout and no cancellation requested
|
|
else if (status != coe.Status.FAILED_TIMEOUT && !cancellationToken.IsCancellationRequested)
|
|
{
|
|
_logger.Error($"{Name}({_driverType}) Event Flag Wait Failed. Status = {status}");
|
|
}
|
|
}
|
|
_logger.Debug($"{Name}({_driverType}) Stopping to read messages. Cancellation was requested.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error(ex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// if message id can be converted to uint returns the value
|
|
/// otherwise returns the related label from the message id by dictionary lookup
|
|
/// </summary>
|
|
/// <param name="label"></param>
|
|
/// <returns></returns>
|
|
private uint GetLabelFromMessageId(string messageId)
|
|
{
|
|
uint labelId = FromStringToUint(messageId);
|
|
|
|
if (labelId == 0)
|
|
{
|
|
foreach (var file in _icds)
|
|
{
|
|
var item = file.Value.FirstOrDefault(l => l.Value == messageId);
|
|
if (!string.IsNullOrEmpty(item.Value))
|
|
return item.Key;
|
|
}
|
|
}
|
|
|
|
return labelId;
|
|
}
|
|
/// <summary>
|
|
/// return file path for the file that contains the label
|
|
/// </summary>
|
|
/// <param name="label"></param>
|
|
/// <returns></returns>
|
|
private string WhichFileContainsTheLabel(uint label)
|
|
{
|
|
foreach (var item in _icds)
|
|
{
|
|
if (item.Value.Keys.Contains(label))
|
|
{
|
|
return item.Key;
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// convert from Message to list of BItTestResult fields
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <returns></returns>
|
|
private IList<BitTestResult> FromXmlToBitTestResults(Message message)
|
|
{
|
|
if (message == null)
|
|
return null;
|
|
|
|
var result = FromMessageArrayToBitResult(message.MessageDataArray);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// recursive function for getting results out
|
|
/// </summary>
|
|
/// <param name="messages"></param>
|
|
/// <returns></returns>
|
|
private IList<BitTestResult> FromMessageArrayToBitResult(MessageData[] messages)
|
|
{
|
|
if (messages == null || messages.Length == 0)
|
|
return null;
|
|
|
|
var result = new List<BitTestResult>();
|
|
|
|
foreach (var item in messages)
|
|
{
|
|
result.Add(FromMessageDataToBitTestResult(item));
|
|
|
|
if (item.MessageArray != null && item.MessageArray.Length > 0)
|
|
{
|
|
var moreResults = FromMessageArrayToBitResult(item.MessageArray);
|
|
result.AddRange(moreResults);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// copy message data fields to BitTestResult
|
|
/// </summary>
|
|
/// <param name="from"></param>
|
|
/// <returns></returns>
|
|
private static BitTestResult FromMessageDataToBitTestResult(MessageData from)
|
|
{
|
|
if (from == null)
|
|
return null;
|
|
|
|
return new BitTestResult
|
|
{
|
|
FieldArrayValue = from.FieldArrayValue,
|
|
FieldBitValue = from.FieldBitValue,
|
|
FieldDefaultValue = from.FieldDefaultValue,
|
|
FieldInstruType = from.FieldInstruType,
|
|
FieldMaxValue = from.FieldMaxValue,
|
|
FieldMinValue = from.FieldMinValue,
|
|
FieldName = from.FieldName,
|
|
FieldType = from.FieldType,
|
|
FieldValue = from.FieldValue,
|
|
Variable = from.Variable,
|
|
MaxOffset = from.MaxOffset,
|
|
MinOffset = from.MinOffset,
|
|
VerifyType = from.VerifyType,
|
|
IsSelected = from.isSelected,
|
|
IsArray = from.isArray,
|
|
IsStructure = from.isStructure,
|
|
IsArrayOfStructures = from.isArrayOfStructures,
|
|
IsEnum = from.isEnum,
|
|
UsesRegister = from.usesRegister,
|
|
IsValid = from.isValid,
|
|
UseRange = from.useRange,
|
|
ArrayLength = from.arrayLength,
|
|
ImageWidth = from.imageWidth,
|
|
ImageHeight = from.imageHeight,
|
|
ImagePixelSize = from.imagePixelSize,
|
|
BitMask = from.bitMask,
|
|
Expanded = from.expanded,
|
|
Depth = from.depth,
|
|
ImageBuffer = from.imageBuffer?.ToArray(),
|
|
ImageBufferSize = from.imageBufferSize,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Build OeMessage from messageId and provided parameters
|
|
/// </summary>
|
|
/// <param name="messageId"></param>
|
|
/// <param name="messageParams"></param>
|
|
/// <returns></returns>
|
|
private OeMessage GetOeMessageWithParameters(uint messageId, IEnumerable<KeyValuePair<string, string>> messageParams, string bitFilePath)
|
|
{
|
|
var messageName = _icds[bitFilePath][messageId];
|
|
var message = new OeMessage(new Message(messageName, new MessageXmlDocument(bitFilePath, _logger)));
|
|
|
|
if (messageParams != null)
|
|
{
|
|
message.XmlMessage.MessageDataArray = PopulateParameters(message.XmlMessage.MessageDataArray, 0, messageParams);
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
/// <summary>
|
|
/// recursive function to populate parameters
|
|
/// </summary>
|
|
/// <param name="data">message data array</param>
|
|
/// <param name="level">indicates how deep in the tree we are populating parameters</param>
|
|
/// <param name="messageParams">message parameters</param>
|
|
/// <returns></returns>
|
|
internal MessageData[] PopulateParameters(MessageData[] data, int level, IEnumerable<KeyValuePair<string, string>> messageParams)
|
|
{
|
|
// only get parameters from the same level
|
|
var levelParams = messageParams.Where(m => m.Key.Where(c => c == '.' || c == ']').Count() == level);
|
|
|
|
foreach (var item in data)
|
|
{
|
|
if (item.FieldName.StartsWith("$"))
|
|
continue;
|
|
|
|
var messageParam = levelParams.FirstOrDefault(m => m.Key.EndsWith(item.FieldName));
|
|
if (!string.IsNullOrEmpty(messageParam.Key) && !string.IsNullOrEmpty(messageParam.Value))
|
|
{
|
|
item.FieldValue = messageParam.Value;
|
|
}
|
|
// always send defaults means that even if parameter was not provided use the default value to populate field value
|
|
else if (_alwaysSendDefaults)
|
|
{
|
|
item.FieldValue = item.FieldDefaultValue;
|
|
}
|
|
|
|
// if there are more levels, update recursively
|
|
if (item.MessageArray != null && item.MessageArray.Length > 0)
|
|
item.MessageArray = PopulateParameters(item.MessageArray, level + 1, messageParams);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/// <summary>
|
|
/// reads xml file and extracts all message names with associated labels
|
|
/// </summary>
|
|
/// <param name="filePath"></param>
|
|
/// <returns></returns>
|
|
private Dictionary<uint, string> ProcessFileForNamesAndLabels(string filePath)
|
|
{
|
|
var doc = new XPathDocument(filePath);
|
|
|
|
XPathNavigator node = doc.CreateNavigator();
|
|
XPathNodeIterator nodeset = node.Select("interface/message");
|
|
|
|
var result = new Dictionary<uint, string>();
|
|
|
|
while (nodeset.MoveNext())
|
|
{
|
|
var children = nodeset.Current.SelectChildren(XPathNodeType.Element);
|
|
if (children.Count > 0)
|
|
{
|
|
string strName = string.Empty;
|
|
string strLabel = string.Empty;
|
|
|
|
while (children.MoveNext())
|
|
{
|
|
if (children.Current.Name == "name")
|
|
{
|
|
strName = children.Current.Value;
|
|
if (!string.IsNullOrEmpty(strName))
|
|
strName = strName.Trim();
|
|
}
|
|
else if (children.Current.Name == "label")
|
|
{
|
|
strLabel = children.Current.Value;
|
|
if (!string.IsNullOrEmpty(strLabel))
|
|
strLabel = strLabel.Trim();
|
|
}
|
|
}
|
|
|
|
uint iLabel = FromStringToUint(strLabel);
|
|
|
|
if (!string.IsNullOrEmpty(strName) && iLabel > 0)
|
|
{
|
|
result.Add(iLabel, strName);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// converts from string representation of a label to uint value
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
private uint FromStringToUint(string data)
|
|
{
|
|
if (!string.IsNullOrEmpty(data))
|
|
{
|
|
if (data.StartsWith("0x", StringComparison.CurrentCultureIgnoreCase) || data.StartsWith("&H", StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
if (uint.TryParse(data.Substring(2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out uint uiValue))
|
|
return uiValue;
|
|
}
|
|
else
|
|
{
|
|
if (uint.TryParse(data, out uint uiValuel))
|
|
return uiValuel;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|