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

719
Source/TSRealLib/HAL/Implementations/ELoad/ELoadSim/ELoadSim.cs
View File

@@ -23,366 +23,361 @@ 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
}
/// <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;
private readonly ILogger _logger;
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)
{
const double SETPOINT_VOLTAGE = 28.0;
Name = deviceName;
_logger = LogManager.GetLogger($"{this.GetType().Name} - {deviceName}");
_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
}
}

130
Source/TSRealLib/HAL/Implementations/ELoad/ELoadSim/ELoadSimFactory.cs
View File

@@ -30,71 +30,67 @@
// 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;
using NLog;
using Raytheon.Common;
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;
[ExportInstrumentFactory(ModelNumber = "ELoadSimFactory")]
public class ELoadSimFactory : IInstrumentFactory
{
private readonly List<Type> _supportedInterfaces = new List<Type>();
public ELoadSimFactory(string defaultConfigPath = DefaultConfigPath)
: this(null, defaultConfigPath)
{
}
private readonly IConfigurationManager _configurationManager;
private const string DefaultConfigPath = @"C:\ProgramData\Raytheon\InstrumentManagerService";
private static string DefaultPath;
/// <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;
public ELoadSimFactory(string defaultConfigPath = DefaultConfigPath)
: this(null, defaultConfigPath)
{
}
if (LogManager.Configuration == null)
{
var assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration(assemblyFolder + "\\nlog.config");
}
/// <summary>
/// ELoadSimFactory 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;
_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;
}
}
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
{
return new EloadSim(name, _configurationManager);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Gets the instrument
@@ -105,9 +101,7 @@ namespace Raytheon.Instruments
{
try
{
_logger = LogManager.GetLogger(name);
return new EloadSim(name, _configurationManager, _logger);
return new EloadSim(name, _configurationManager);
}
catch (Exception)
{
@@ -120,17 +114,17 @@ namespace Raytheon.Instruments
/// </summary>
/// <returns></returns>
public ICollection<Type> GetSupportedInterfaces()
{
return _supportedInterfaces.ToArray();
}
{
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);
}
}
/// <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);
}
}
}