Major upgrade

Source/TSRealLib/MAL/ManagerMaster/Raytheon.MAL/MalMeasurementLibManager.cs

@@ -32,9 +32,6 @@ INFORMATION SECURITY PROGRAM: CONTROLLED UNCLASSIFIED INFORMATION
 
 using System;
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Threading;
-
 using Raytheon.Instruments;
 using static MeasurementManagerLib.BitMeasurementManager;
 
@@ -45,23 +42,249 @@ namespace MeasurementManagerLib
    /// </summary>
    public class MalMeasurementLibManager : IDisposable
    {
-      public FpgaMeasurementManager FpgaMeasurementManager { get; set; }
-      public PowerSupplyMeasurementManager PowerSupplyMeasurementManager { get; set; }
-      public SwitchMeasurementManager SwitchMeasurementManager { get; set; }
-      public BitMeasurementManager BitMeasurementManager { get; set; }
-      public BitGenSoftMeasurementManager BitGenSoftMeasurementManager { get; set; }
-      public ChillerCartMeasurementManager ChillerMeasurementManager { get; set; }
-      public DioMeasurementManager DioMeasurementManager { get; set; }
-      public JtagMeasurementManager JtagMeasurementManager { get; set; }
-      public VideoRecorderMeasurementManager VideoRecorderMeasurementManager { get; set; }
-      public RelayMeasurementManager RelayMeasurementManager { get; set; }
-      public RfMeasurementManager RfMeasurementManager { get; set; }
-      public SpaceChamberLSPSMeasurementManager SpaceChamberLSPSMeasurementManager { get; set; }
-      public TelemetryMeasurementManager TelemetryMeasurementManager { get; set; }
-      public CryoMeasurementManager CryoMeasurementManager { get; set; }
-      public OpticalBenchMeasurementManager OpticalBenchMeasurementManager { get; set; }
+      private FpgaMeasurementManager _fpgaMeasurementManager;
+      private PowerSupplyMeasurementManager _powerSupplyMeasurementManager;
+      private SwitchMeasurementManager _switchMeasurementManager;
+      private BitMeasurementManager _bitMeasurementManager;
+      private CoeMeasurementManager _coeMeasurementManager;
+      private ChillerCartMeasurementManager _chillerMeasurementManager;
+      private DioMeasurementManager _dioMeasurementManager;
+      private JtagMeasurementManager _jtagMeasurementManager;
+      private VideoRecorderMeasurementManager _videoRecorderMeasurementManager;
+      private RelayMeasurementManager _relayMeasurementManager;
+      private RfMeasurementManager _rfMeasurementManager;
+      private SpaceChamberLspsMeasurementManager _spaceChamberLspsMeasurementManager;
+      private TelemetryMeasurementManager _telemetryMeasurementManager;
+      private CryoMeasurementManager _cryoMeasurementManager;
+      private OpticalBenchMeasurementManager _opticalBenchMeasurementManager;
 
-      public IInstrumentManager InstrumentManager { get; set; }
+      public FpgaMeasurementManager FpgaMeasurementManager
+      {
+         get
+         {
+            if (_fpgaMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(FpgaMeasurementManager));
+
+            return _fpgaMeasurementManager;
+         }
+
+         private set
+         {
+            _fpgaMeasurementManager = value;
+         }
+      }
+      public PowerSupplyMeasurementManager PowerSupplyMeasurementManager
+      {
+         get
+         {
+            if (_powerSupplyMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(PowerSupplyMeasurementManager));
+
+            return _powerSupplyMeasurementManager;
+         }
+
+         private set
+         {
+            _powerSupplyMeasurementManager = value;
+         }
+      }
+      public SwitchMeasurementManager SwitchMeasurementManager
+      {
+         get
+         {
+            if (_switchMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(SwitchMeasurementManager));
+
+            return _switchMeasurementManager;
+         }
+
+         private set
+         {
+            _switchMeasurementManager = value;
+         }
+      }
+      public BitMeasurementManager BitMeasurementManager
+      {
+         get
+         {
+            if (_bitMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(BitMeasurementManager));
+
+            return _bitMeasurementManager;
+         }
+
+         private set
+         {
+            _bitMeasurementManager = value;
+         }
+      }
+      public CoeMeasurementManager CoeMeasurementManager
+      {
+         get
+         {
+            if (_coeMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(CoeMeasurementManager));
+
+            return _coeMeasurementManager;
+         }
+
+         private set
+         {
+            _coeMeasurementManager = value;
+         }
+      }
+      public ChillerCartMeasurementManager ChillerMeasurementManager
+      {
+         get
+         {
+            if (_chillerMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(ChillerCartMeasurementManager));
+
+            return _chillerMeasurementManager;
+         }
+
+         private set
+         {
+            _chillerMeasurementManager = value;
+         }
+      }
+      public DioMeasurementManager DioMeasurementManager
+      {
+         get
+         {
+            if (_dioMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(DioMeasurementManager));
+
+            return _dioMeasurementManager;
+         }
+
+         private set
+         {
+            _dioMeasurementManager = value;
+         }
+      }
+      public JtagMeasurementManager JtagMeasurementManager
+      {
+         get
+         {
+            if (_jtagMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(JtagMeasurementManager));
+
+            return _jtagMeasurementManager;
+         }
+
+         private set
+         {
+            _jtagMeasurementManager = value;
+         }
+      }
+      public VideoRecorderMeasurementManager VideoRecorderMeasurementManager
+      {
+         get
+         {
+            if (_videoRecorderMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(VideoRecorderMeasurementManager));
+
+            return _videoRecorderMeasurementManager;
+         }
+
+         private set
+         {
+            _videoRecorderMeasurementManager = value;
+         }
+      }
+      public RelayMeasurementManager RelayMeasurementManager
+      {
+         get
+         {
+            if (_relayMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(RelayMeasurementManager));
+
+            return _relayMeasurementManager;
+         }
+
+         private set
+         {
+            _relayMeasurementManager = value;
+         }
+      }
+      public RfMeasurementManager RfMeasurementManager
+      {
+         get
+         {
+            if (_rfMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(RfMeasurementManager));
+
+            return _rfMeasurementManager;
+         }
+
+         private set
+         {
+            _rfMeasurementManager = value;
+         }
+      }
+      public SpaceChamberLspsMeasurementManager SpaceChamberLspsMeasurementManager
+      {
+         get
+         {
+            if (_spaceChamberLspsMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(SpaceChamberLspsMeasurementManager));
+
+            return _spaceChamberLspsMeasurementManager;
+         }
+
+         private set
+         {
+            _spaceChamberLspsMeasurementManager = value;
+         }
+      }
+      public TelemetryMeasurementManager TelemetryMeasurementManager
+      {
+         get
+         {
+            if (_telemetryMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(TelemetryMeasurementManager));
+
+            return _telemetryMeasurementManager;
+         }
+
+         private set
+         {
+            _telemetryMeasurementManager = value;
+         }
+      }
+      public CryoMeasurementManager CryoMeasurementManager
+      {
+         get
+         {
+            if (_cryoMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(CryoMeasurementManager));
+
+            return _cryoMeasurementManager;
+         }
+
+         private set
+         {
+            _cryoMeasurementManager = value;
+         }
+      }
+      public OpticalBenchMeasurementManager OpticalBenchMeasurementManager
+      {
+         get
+         {
+            if (_opticalBenchMeasurementManager == null)
+               throw new MalMeasurementManagerNullReferenceException(typeof(OpticalBenchMeasurementManager));
+
+            return _opticalBenchMeasurementManager;
+         }
+
+         private set
+         {
+            _opticalBenchMeasurementManager = value;
+         }
+      }
+
+      public IInstrumentManager InstrumentManager { get; private set; }
 
       ~MalMeasurementLibManager()
       {
@@ -98,34 +321,36 @@ namespace MeasurementManagerLib
       /// Initialize the BIT interface manager
       /// </summary>
       /// <param name="measurementDefFile"></param>
-      /// <param name="instrumentDefFile"></param>
+      /// <param name="comDeviceName"></param>
+      /// <param name="comNodeName"></param>
+      /// <param name="binDataLogFilename"></param>
+      /// <param name="asciiDataLogFileName"></param>
+      /// <param name="callback"></param>
       public void InitializeBitMeasurementManager(string measurementDefFile, string comDeviceName, string comNodeName, string binDataLogFilename, string asciiDataLogFileName, MessageReceivedDelegate callback)
       {
          // create the object once no matter how many times the host calls this
-         if (BitMeasurementManager == null)
+         if (_bitMeasurementManager == null)
          {
-            BitMeasurementManager = new BitMeasurementManager(InstrumentManager, measurementDefFile, comDeviceName, comNodeName, binDataLogFilename, asciiDataLogFileName, callback);
+            _bitMeasurementManager = new BitMeasurementManager(InstrumentManager, measurementDefFile, comDeviceName, comNodeName, binDataLogFilename, asciiDataLogFileName, callback);
          }
       }
 
       /// <summary>
       /// Initialize the BIT interface manager
       /// </summary>
-      /// <param name="instrumentDefFilePath"></param>
-      /// <param name="instrumentName"></param>
-      /// <param name="testType"></param>
-      public void InitializeBitGenSoftMeasurementManager(List<string> instrumentNames)
+      /// <param name="instrumentNames"></param>
+      public void InitializeCoeMeasurementManager(string coeMeasurementManagerConfigFullPath)
       {
-         if (BitGenSoftMeasurementManager == null)
+         if (_coeMeasurementManager == null)
          {
-            BitGenSoftMeasurementManager = new BitGenSoftMeasurementManager(InstrumentManager, instrumentNames);
+            _coeMeasurementManager = new CoeMeasurementManager(InstrumentManager, coeMeasurementManagerConfigFullPath);
+            _coeMeasurementManager.InitNodes();
          }
       }
 
       /// <summary>
       /// Initialize the Chiller interface manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="chillerName"></param>
       /// <param name="flowMeeterName"></param>
       /// <param name="tempSensorName"></param>
@@ -133,90 +358,81 @@ namespace MeasurementManagerLib
       public void InitializeChillerCartMeasurementManager(string chillerName, string flowMeeterName, string tempSensorName, string errorLog)
       {
          // create the object once no matter how many times the host calls this
-         if (ChillerMeasurementManager == null)
+         if (_chillerMeasurementManager == null)
          {
-            ChillerMeasurementManager = new ChillerCartMeasurementManager(InstrumentManager, chillerName, flowMeeterName, tempSensorName, errorLog);
+            _chillerMeasurementManager = new ChillerCartMeasurementManager(InstrumentManager, chillerName, flowMeeterName, tempSensorName, errorLog);
          }
       }
 
       /// <summary>
       /// Initialize the Dio interface manager
       /// </summary>
-      /// <param name="measurementDefFile"></param>
-      /// <param name="instrumentDefFile"></param>
       public void InitializeDioMeasurementManager()
       {
          // create the object once no matter how many times the host calls this
-         if (DioMeasurementManager == null)
+         if (_dioMeasurementManager == null)
          {
-            DioMeasurementManager = new DioMeasurementManager(InstrumentManager);
+            _dioMeasurementManager = new DioMeasurementManager(InstrumentManager);
          }
       }
 
       /// <summary>
       /// Initialize the Jtag interface manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="instrumentName"></param>
       /// <param name="measurementDefFile"></param>
-      /// <param name="errorLogFileName"></param>
       public void InitializeJtagMeasurementManager(string instrumentName, string measurementDefFile)
       {
          // create the object once no matter how many times the host calls this
-         if (JtagMeasurementManager == null)
+         if (_jtagMeasurementManager == null)
          {
-            JtagMeasurementManager = new JtagMeasurementManager(InstrumentManager, instrumentName, measurementDefFile);
+            _jtagMeasurementManager = new JtagMeasurementManager(InstrumentManager, instrumentName, measurementDefFile);
          }
       }
 
       /// <summary>
       /// Initialize the fpga communication manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="instrumentNames"></param>
       /// <param name="instrumentDefFile"></param>
       public void InitializeFpgaMeasurementManager(List<string> instrumentNames, string instrumentDefFile)
       {
          // create the object once no matter how many times the host calls this
-         if (FpgaMeasurementManager == null)
+         if (_fpgaMeasurementManager == null)
          {
-            FpgaMeasurementManager = new FpgaMeasurementManager(InstrumentManager, instrumentNames, instrumentDefFile);
+            _fpgaMeasurementManager = new FpgaMeasurementManager(InstrumentManager, instrumentNames, instrumentDefFile);
          }
       }
 
       /// <summary>
       /// Initialize the power system and connect to the power supplies
       /// </summary>
-      /// <param name="measurementDefFile"></param>
-      /// <param name="instrumentDefFile"></param>
       public void InitializePowerSupplyMeasurementManager()
       {
          // create the object once no matter how many times the host calls this
-         if (PowerSupplyMeasurementManager == null)
+         if (_powerSupplyMeasurementManager == null)
          {
-            PowerSupplyMeasurementManager = new PowerSupplyMeasurementManager(InstrumentManager);
+            _powerSupplyMeasurementManager = new PowerSupplyMeasurementManager(InstrumentManager);
          }
       }
 
       /// <summary>
       /// Initialize the relay manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="instrumentNames"></param>
       /// <param name="configFileName"></param>
       public void InitializeRelayMeasurementManager(List<string> instrumentNames, string configFileName)
       {
          // create the object once no matter how many times the host calls this
-         if (RelayMeasurementManager == null)
+         if (_relayMeasurementManager == null)
          {
-            RelayMeasurementManager = new RelayMeasurementManager(InstrumentManager, instrumentNames, configFileName);
+            _relayMeasurementManager = new RelayMeasurementManager(InstrumentManager, instrumentNames, configFileName);
          }
       }
 
       /// <summary>
       /// Initializes Rf Measurement Manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="switchInstrumentNames"></param>
       /// <param name="powerMeeterName"></param>
       /// <param name="signalGeneratorName"></param>
@@ -225,62 +441,55 @@ namespace MeasurementManagerLib
       public void InitializeRfMeasurementManager(List<string> switchInstrumentNames, string powerMeeterName, string signalGeneratorName, string specAnalyzerName, string configFileName)
       {
          // create the object once no matter how many times the host calls this
-         if (RfMeasurementManager == null)
+         if (_rfMeasurementManager == null)
          {
-            RfMeasurementManager = new RfMeasurementManager(InstrumentManager, switchInstrumentNames, powerMeeterName, signalGeneratorName, specAnalyzerName, configFileName);
+            _rfMeasurementManager = new RfMeasurementManager(InstrumentManager, switchInstrumentNames, powerMeeterName, signalGeneratorName, specAnalyzerName, configFileName);
          }
       }
 
       /// <summary>
       /// Initializes Space Chamber LSPS Measurement Manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="lspsChamber"></param>
       /// <param name="netCdfData"></param>
       public void InitializeSpaceChamberLSPSMeasurementManager(string lspsChamber, string netCdfData)
       {
          // create the object once no matter how many times the host calls this
-         if (SpaceChamberLSPSMeasurementManager == null)
+         if (_spaceChamberLspsMeasurementManager == null)
          {
-            SpaceChamberLSPSMeasurementManager = new SpaceChamberLSPSMeasurementManager(InstrumentManager, lspsChamber, netCdfData);
+            _spaceChamberLspsMeasurementManager = new SpaceChamberLspsMeasurementManager(InstrumentManager, lspsChamber, netCdfData);
          }
       }
 
       /// <summary>
       /// Initializes Switch Measurement Manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
-      /// <param name="switchCardNames"></param>
-      /// <param name="dmmName"></param>
-      /// <param name="scopeName"></param>
-      /// <param name="configFileName"></param>
-      public void InitializeSwitchMeasurementManager()
+      /// <param name="switchMeasurementManagerConfigFullPath"></param>
+      public void InitializeSwitchMeasurementManager(string switchMeasurementManagerConfigFullPath, bool skipDmmInitialization = false)
       {
          // create the object once no matter how many times the host calls this
-         if (SwitchMeasurementManager == null)
+         if (_switchMeasurementManager == null)
          {
-            SwitchMeasurementManager = new SwitchMeasurementManager(InstrumentManager);
+            _switchMeasurementManager = new SwitchMeasurementManager(InstrumentManager, switchMeasurementManagerConfigFullPath, skipDmmInitialization);
          }
       }
 
       /// <summary>
       /// Initialize the video recorder manager
       /// </summary>
-      /// <param name="measurementDefFile"></param>
-      /// <param name="instrumentDefFile"></param>
+      /// <param name="deviceName"></param>
       public void InitializeVideoRecorderMeasurementManager(string deviceName)
       {
          // create the object once no matter how many times the host calls this
-         if (VideoRecorderMeasurementManager == null)
+         if (_videoRecorderMeasurementManager == null)
          {
-            VideoRecorderMeasurementManager = new VideoRecorderMeasurementManager(InstrumentManager, deviceName);
+            _videoRecorderMeasurementManager = new VideoRecorderMeasurementManager(InstrumentManager, deviceName);
          }
       }
 
       /// <summary>
       /// Initializes Cryo Measurement Manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="commDeviceName"></param>
       /// <param name="serialDeviceName"></param>
       /// <param name="isThereHardware"></param>
@@ -288,40 +497,39 @@ namespace MeasurementManagerLib
       public void InitializeCryoMeasurementManager(string commDeviceName, string serialDeviceName, bool isThereHardware, string errorLogFileName)
       {
          // create the object once no matter how many times the host calls this
-         if (CryoMeasurementManager == null)
+         if (_cryoMeasurementManager == null)
          {
-            CryoMeasurementManager = new CryoMeasurementManager(InstrumentManager, commDeviceName, serialDeviceName, isThereHardware, errorLogFileName);
+            _cryoMeasurementManager = new CryoMeasurementManager(InstrumentManager, commDeviceName, serialDeviceName, isThereHardware, errorLogFileName);
          }
       }
 
       /// <summary>
       /// Initializes Optical Bench Measurement Manager
       /// </summary>
-      /// <param name="InstrumentManager"></param>
       /// <param name="instrumentName"></param>
       /// <param name="measurementDefFile"></param>
       /// <param name="instrumentDefFile"></param>
       public void InitializeOpticalBenchMeasurementManager(string instrumentName, string measurementDefFile, string instrumentDefFile)
       {
          // create the object once no matter how many times the host calls this
-         if (OpticalBenchMeasurementManager == null)
+         if (_opticalBenchMeasurementManager == null)
          {
-            OpticalBenchMeasurementManager = new OpticalBenchMeasurementManager(InstrumentManager, instrumentName, measurementDefFile, instrumentDefFile);
+            _opticalBenchMeasurementManager = new OpticalBenchMeasurementManager(InstrumentManager, instrumentName, measurementDefFile, instrumentDefFile);
          }
       }
 
       /// <summary>
       /// initializes Telemetry Measurement Manager for multiple instruments
       /// </summary>
-      /// <param name="measurementDefFile"></param>
-      /// <param name="instrumentDefFile"></param>
+      /// <param name="instrumentNames"></param>
+      /// <param name="telemetryMalFile"></param>
       public void InitializeTelemetryMeasurementManager(List<string> instrumentNames, string telemetryMalFile)
       {
 
          // create the object once no matter how many times the host calls this
-         if (TelemetryMeasurementManager == null)
+         if (_telemetryMeasurementManager == null)
          {
-            TelemetryMeasurementManager = new TelemetryMeasurementManager(InstrumentManager, instrumentNames, telemetryMalFile);
+            _telemetryMeasurementManager = new TelemetryMeasurementManager(InstrumentManager, instrumentNames, telemetryMalFile);
          }
       }