Big changes

Source/TSRealLib/HAL/Implementations/ELoad/ELoadSim/ELoadSim.cs

@@ -0,0 +1,388 @@
+//                           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.Threading;
+using NLog;
+using Raytheon.Common;
+using Raytheon.Units;
+
+namespace Raytheon.Instruments
+{
+	/// <summary>
+	/// A simulated eload
+	/// </summary>
+	public class EloadSim : IEload
+	{
+		#region PrivateClassMembers
+		private readonly double _overCurrentProtection;
+		private readonly double _overVoltageProtection;
+		private double _setpointVal;
+		private double _ini_setpointval;
+		private double _voltage;
+		private readonly int _channelNumber;
+		private bool _isOn;
+		private EloadModuleMode _mode;
+		private EloadModuleMode _originalMode;
+
+		/// <summary>
+		/// NLog logger
+		/// </summary>
+		private readonly ILogger _logger;
+		/// <summary>
+		/// Raytheon configuration
+		/// </summary>
+		private readonly IConfigurationManager _configurationManager;
+		private readonly IConfiguration _configuration;
+
+		public string DetailedStatus { get; protected set; }
+
+		public bool DisplayEnabled { get; set; }
+		public bool FrontPanelEnabled { get; set; }
+
+		public InstrumentMetadata Info { get; set; }
+
+		public string Name { get; protected set; }
+
+		public SelfTestResult SelfTestResult => PerformSelfTest();
+
+		public State Status { get; set; }
+		#endregion
+
+		#region PublicFuctions
+
+		/// <summary>
+		/// FlowMeterOmegaDPF20 factory constructor
+		/// </summary>
+		/// <param name="deviceName"></param>
+		/// <param name="configurationManager"></param>
+		public EloadSim(string deviceName, IConfigurationManager configurationManager, ILogger logger)
+		{
+			const double SETPOINT_VOLTAGE = 28.0;
+
+			Name = deviceName;
+
+			_logger = logger;
+
+			_configurationManager = configurationManager;
+			_configuration = _configurationManager.GetConfiguration(Name);
+
+			_channelNumber = _configuration.GetConfigurationValue("EloadSim", "ChannelNumber", 0);
+			_mode = _configuration.GetConfigurationValue("EloadSim", "Mode", EloadModuleMode.CURRENT);
+			_setpointVal = _configuration.GetConfigurationValue("EloadSim", "SetpointVal", 0.0);
+			_ini_setpointval = _configuration.GetConfigurationValue("EloadSim", "IniSetpointVal", 0.0);
+			_overCurrentProtection = _configuration.GetConfigurationValue("EloadSim", "OverCurrentProtection", 0.0);
+			_overVoltageProtection = _configuration.GetConfigurationValue("EloadSim", "OverVoltageProtection", 0.0);
+			_voltage = SETPOINT_VOLTAGE;
+			_originalMode = _mode;
+			// make sure it is off
+			Disable();
+		}
+
+		/// <summary>
+		/// The constructor for an Eload (Simulation).
+		/// </summary>
+		/// <param name="channelNumber">The channel number for the Eload.</param>
+		/// <param name="mode">The operation mode of the channel. Modes: Resistance, Voltage, Current.</param>
+		/// <param name="setpointVal">The operation point of the load. This can be a voltage, current, or resistance.</param>
+		/// <param name="overCurrentProtection">Overcurrent setpoint that will turn off the channel if exceeded.</param>
+		/// <param name="overVoltageProtection">Overvoltage setpoint that will turn off channel if exceeded (double check).</param>
+		public EloadSim(int channelNumber, EloadModuleMode mode, double setpointVal, double overCurrentProtection, double overVoltageProtection)
+		{
+			const double SETPOINT_VOLTAGE = 28.0;
+			_logger = LogManager.GetCurrentClassLogger();
+
+			_channelNumber = channelNumber;
+			_setpointVal = setpointVal;
+			_ini_setpointval = setpointVal;
+			_overCurrentProtection = overCurrentProtection;
+			_overVoltageProtection = overVoltageProtection;
+			_voltage = SETPOINT_VOLTAGE;
+			_mode = mode;
+			_originalMode = mode;
+			Disable();
+		}
+
+		/// <summary>
+		/// The finalizer.
+		/// </summary>
+		~EloadSim()
+		{
+			Dispose(false);
+		}
+
+		/// <summary>
+		/// Dispose of this object's resources.
+		/// </summary>
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		/// <summary>
+		/// Send a SCPI Command to the instrument and get a response.
+		/// </summary>
+		/// <param name="commandString">The command to send.</param>
+		/// <returns>THe instrument response.</returns>
+		public string IOQuery(string commandString)
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+			return "IOQuery Sim Response";
+		}
+
+		/// <summary>
+		/// Send a SCPI Command to the instrument.
+		/// </summary>
+		/// <param name="commandString">The command to be send.</param>
+		public void IOWrite(string commandString)
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+		}
+
+		/// <summary>
+		/// Query if the Eload input is on (simulated).
+		/// </summary>
+		/// <returns>Status of Eload (simulated). True = On, False = Off.</returns>
+		public bool IsInputOn()
+		{
+			return _isOn;
+		}
+
+		/// <summary>
+		/// Turns the Eload off (simulated).
+		/// </summary>
+		public void Enable()
+		{
+			_isOn = false;
+		}
+
+		/// <summary>
+		/// Turns the Eload on (simulated).
+		/// </summary>
+		public void Disable()
+		{
+			_isOn = true;
+		}
+
+		/// <summary>
+		/// Reads the current of the Eload.
+		/// </summary>
+		/// <returns>The current (simulated).</returns>
+		public Current ReadCurrent()
+		{
+			const double MIN_CURRENT = 1.0;
+
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			double currentToReturn = 0.0;
+
+			if (_isOn)
+			{
+				double maxCurrent = _overCurrentProtection;
+
+				Random rnd = new Random();
+
+				double seed = rnd.NextDouble();
+
+				currentToReturn = (seed * (maxCurrent - MIN_CURRENT)) + MIN_CURRENT;
+			}
+
+			return Current.FromAmps(currentToReturn);
+		}
+
+		/// <summary>
+		/// Reads the mode of the Eload.
+		/// </summary>
+		/// <returns>The mode (simulated).</returns>
+		public EloadModuleMode ReadMode()
+		{
+			return _mode;
+		}
+
+		/// <summary>
+		/// Reads the overcurrent setting from an Eload.
+		/// </summary>
+		/// <returns>Overcurrent setting (simulated).</returns>
+		public Current ReadOverCurrentProtection()
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			return Current.FromAmps(_overCurrentProtection);
+		}
+
+		/// <summary>
+		/// Reads the overvoltage setting from an Eload.
+		/// </summary>
+		/// <returns>Overvoltage setting (simulated).</returns>
+		public Voltage ReadOverVoltageProtection()
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			return Voltage.FromVolts(_overVoltageProtection);
+		}
+
+		/// <summary>
+		/// Reads the resistance of the Eload.
+		/// </summary>
+		/// <returns>The resistance (simulated).</returns>
+		public Resistance ReadResistance()
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			double resistanceToReturn = 0.0;
+
+			if (_isOn)
+			{
+				double maxCurrent = _setpointVal + 1;
+				double minCurrent = _setpointVal - 1;
+
+				Random rnd = new Random();
+
+				double seed = rnd.NextDouble();
+
+				resistanceToReturn = (seed * (maxCurrent - minCurrent)) + minCurrent;
+			}
+
+			return Resistance.FromOhms(resistanceToReturn);
+		}
+
+		/// <summary>
+		/// Reads the setpoint of the Eload.
+		/// </summary>
+		/// <returns>The setpoint (simulated).</returns>
+		public double ReadSetpoint()
+		{
+			return _setpointVal;
+		}
+
+		/// <summary>
+		/// Reads the voltage of the Eload.
+		/// </summary>
+		/// <returns>The voltage (simulated).</returns>
+		public Voltage ReadVoltage()
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			double voltageToReturn = 0.0;
+
+			if (_isOn)
+			{
+				double maxVoltage = _voltage + 1;
+				double minVoltage = _voltage - 1;
+
+				Random rnd = new Random();
+
+				double seed = rnd.NextDouble();
+
+				voltageToReturn = (seed * (maxVoltage - minVoltage)) + minVoltage;
+			}
+
+			return Voltage.FromVolts(voltageToReturn);
+		}
+
+		/// <summary>
+		/// Reads the protection status from an Eload.
+		/// </summary>
+		/// <returns>Protection status (simulated).</returns>
+		public ushort ReadProtectionStatus()
+		{
+			// just to provide a small delay 10ms for the sim
+			Thread.Sleep(10);
+
+			// The sim never triggers the protection status
+			return 0;
+		}
+
+		/// <summary>
+		/// Sets Initial Settings
+		/// </summary>
+		public void SetInitialSetting()
+		{
+			_mode = _originalMode;
+			_setpointVal = _ini_setpointval;
+		}
+
+		/// <summary>
+		/// Change the operation mode of the Eload.
+		/// </summary>
+		/// <param name="mode">The desired Eload mode.</param>
+		public void SetMode(EloadModuleMode mode)
+		{
+			_mode = mode;
+		}
+
+		/// <summary>
+		/// Change the setpoint of the Eload.
+		/// </summary>
+		/// <param name="newSetpoint">The desired setpoint of the Eload.</param>
+		public void SetSetpoint(double newSetpoint, EloadModuleMode mode)
+		{
+			if (mode != _mode)
+			{
+				throw new Exception("the current mode and the specified mode do not match. Current Mode: " + _mode.ToString() + ", specified mode: " + mode.ToString());
+			}
+
+			_setpointVal = newSetpoint;
+		}
+
+		/// <summary>
+		/// Dispose of this object's resources.
+		/// </summary>
+		/// <param name="disposing">True = currently disposing, False = not disposing.</param>
+		protected virtual void Dispose(bool disposing)
+		{
+		}
+
+		public bool ClearErrors()
+		{
+			return true;
+		}
+
+		public void Initialize()
+		{
+			SetInitialSetting();
+		}
+
+		public SelfTestResult PerformSelfTest()
+		{
+			throw new NotImplementedException();
+		}
+
+		public void Reset()
+		{
+			Disable();
+
+			Enable();
+		}
+
+		public void Shutdown()
+		{
+			Dispose();
+		}
+
+		#endregion
+
+	}
+}

Source/TSRealLib/HAL/Implementations/ELoad/ELoadSim/ELoadSim.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+   <Import Project="$(SolutionDir)Solution.props" />
+   <PropertyGroup>
+      <TargetFramework>net472</TargetFramework>
+      <AssemblyName>Raytheon.Instruments.ELoadSim</AssemblyName>
+      <Product>ELoad Sim implementation</Product>
+      <Description>ELoad Sim implementation</Description>
+      <OutputType>Library</OutputType>
+
+      <!-- Static versioning (Suitable for Development) -->
+      <!-- Disable the line below for dynamic versioning -->
+      <Version>1.0.0</Version>
+   </PropertyGroup>
+
+   <ItemGroup>
+      <PackageReference Include="NLog" Version="5.0.0" />
+      <PackageReference Include="Raytheon.Common" Version="1.0.0" />
+      <PackageReference Include="Raytheon.Instruments.ELoad.Contracts" Version="1.1.0" />
+   </ItemGroup>
+
+</Project>

Source/TSRealLib/HAL/Implementations/ELoad/ELoadSim/ELoadSimFactory.cs

@@ -0,0 +1,136 @@
+// **********************************************************************************************************
+//    ELoadSimFactory.cs
+//    2/20/2023
+//    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 NLog;
+using Raytheon.Common;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Reflection;
+
+namespace Raytheon.Instruments
+{
+	[ExportInstrumentFactory(ModelNumber = "ELoadSimFactory")]
+	public class ELoadSimFactory : IInstrumentFactory
+	{
+		/// <summary>
+		/// The supported interfaces
+		/// </summary>
+		private readonly List<Type> _supportedInterfaces = new List<Type>();
+		private ILogger _logger;
+		private readonly IConfigurationManager _configurationManager;
+		private const string DefaultConfigPath = @"C:\ProgramData\Raytheon\InstrumentManagerService";
+		private static string DefaultPath;
+
+		public ELoadSimFactory(string defaultConfigPath = DefaultConfigPath)
+			: this(null, defaultConfigPath)
+		{
+		}
+
+		/// <summary>
+		/// COECommDeviceInstrumentFactory injection constructor
+		/// </summary>
+		/// <param name="configManager"></param>
+		/// <param name="simEngine"></param>
+		/// <param name="logger"></param>
+		[ImportingConstructor]
+		public ELoadSimFactory([Import(AllowDefault = false)] IConfigurationManager configManager,
+								   [Import(AllowDefault = true)] string defaultConfigPath = null)
+		{
+			DefaultPath = defaultConfigPath;
+
+			if (LogManager.Configuration == null)
+			{
+				var assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+				LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration(assemblyFolder + "\\nlog.config");
+			}
+
+			_configurationManager = configManager ?? GetConfigurationManager();
+			_supportedInterfaces.Add(typeof(IEload));
+		}
+		/// <summary>
+		/// Gets the instrument
+		/// </summary>
+		/// <param name="name"></param>
+		/// <returns></returns>
+		public IInstrument GetInstrument(string name)
+		{
+			try
+			{
+				_logger = LogManager.GetLogger(name);
+				return new EloadSim(name, _configurationManager, _logger);
+			}
+			catch (Exception)
+			{
+				throw;
+			}
+		}
+
+      /// <summary>
+      /// Gets the instrument
+      /// </summary>
+      /// <param name="name"></param>
+      /// <returns></returns>
+      public object GetInstrument(string name, bool simulateHw)
+      {
+         try
+         {
+            _logger = LogManager.GetLogger(name);
+
+            return new EloadSim(name, _configurationManager, _logger);
+         }
+         catch (Exception)
+         {
+            throw;
+         }
+      }
+
+      /// <summary>
+      /// Gets supported interfaces
+      /// </summary>
+      /// <returns></returns>
+      public ICollection<Type> GetSupportedInterfaces()
+		{
+			return _supportedInterfaces.ToArray();
+		}
+
+		/// <summary>
+		/// returns configuration based on the predefined path or default path c:/ProgramData/Raytheon/InstrumentManagerService
+		/// </summary>
+		/// <returns></returns>
+		private static IConfigurationManager GetConfigurationManager()
+		{
+			return string.IsNullOrEmpty(DefaultPath) ? new RaytheonConfigurationManager() : new RaytheonConfigurationManager(DefaultPath);
+		}
+	}
+}