GenericTeProgramLibrary/Source/Program/Program.SetupManager.cs

/*-------------------------------------------------------------------------
//                           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.Collections.Generic;
using System.IO;
using System.Linq;
using MeasurementManagerLib;
using Raytheon.Instruments;

namespace ProgramLib
{
   /// <summary>
	/// Initialization of instruments, measurements, gui, support threads, etc
   /// </summary>
   internal partial class Program
   {
      private ProgramGuiManager _guiManager = null;

      internal ProgramGuiManager GuiManager
      {
         get
         {
            if (_guiManager == null)
               throw new MalMeasurementManagerNullReferenceException(typeof(ProgramGuiManager));

            return _guiManager;
         }

         private set
         {
            _guiManager = value;
         }
      }

      internal bool IsUutPwrOn { get; set; }
      internal PowerSupplySharedData PowerSupplySharedData { get; set; }

      /// <summary>
		/// Initialize power supply measurement manager
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializePowerSupplyMeasurementManager()
      {
         IsUutPwrOn = false;
         PowerSupplySharedData = new PowerSupplySharedData();
         MalMeasurementLibManager.InitializePowerSupplyMeasurementManager();
      }

      /// <summary>
		/// Initialize DIO measurement manager
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializeDioMeasurementManager()
      {
         MalMeasurementLibManager.InitializeDioMeasurementManager();
      }

      /// <summary>
		/// Initialize switch measurement manager
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializeSwitchMeasurementManager()
      {
         string switchMeasurementConfigFilename = ProgramGeneralConfig.ReadValue(ProgramGeneralConfigIni.GENERAL.ToString(), ProgramGeneralConfigIni.SWITCH_MEASUREMENT_MANAGER_CONFIG_FILE_NAME.ToString());
         string configFullPath = Path.Combine(FileAndFolderManager.GetFolder(FileAndFolderManager.Folders.CONFIG_MEASUREMENT), switchMeasurementConfigFilename);
         MalMeasurementLibManager.InitializeSwitchMeasurementManager(configFullPath);
      }

      /// <summary>
		/// Initialize switch measurement manager
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializeCoeMeasurementManager()
      {
         string coeMeasurementConfigFilename = ProgramGeneralConfig.ReadValue(ProgramGeneralConfigIni.GENERAL.ToString(), ProgramGeneralConfigIni.COE_MEASUREMENT_MANAGER_CONFIG_FILE_NAME.ToString());
         string configFullPath = Path.Combine(FileAndFolderManager.GetFolder(FileAndFolderManager.Folders.CONFIG_MEASUREMENT), coeMeasurementConfigFilename);
         MalMeasurementLibManager.InitializeCoeMeasurementManager(configFullPath);
      }

      /// <summary>
		/// Initialize serial devices
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializeSerialDevices()
      {
         ICollection<object> serialDevList = InstrumentManager.GetInstruments(typeof(ICommDevice));
         foreach (ICommDevice dev in serialDevList)
         {
            dev.Initialize();
         }
      }

      /// <summary>
		/// Initialize GUI manager
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
      internal void InitializeGuiManager()
      {
         if (_guiManager == null)
         {
            _guiManager = new ProgramGuiManager();
            _guiManager.Initialize();
            GuiManager[ProgramGuiManager.WINDOWS.DEFAULT].Dispatcher.Invoke((Action)delegate
            {
               GuiManager[ProgramGuiManager.WINDOWS.LIVE_DATA].Show();
            });
         }
      }

      /// <summary>
      /// Start all the monitor/read threads here
      /// Call this only after ProgramGuiManager and PowerSupplyManager has been initialized since these threads could be
      /// accessing those objects
      /// </summary>
      /// <param name=""></param>
      /// <returns></returns>
      internal void InitializeSupportThreads()
      {
         int pollRateMs = 1000;

         if (_threadList.Count() == 0)
         {
            _threadList.Add(new FailureMonitorThread());
            _threadList.Last().Start();

            ICollection<object> powerSystemList = _instrumentManager.GetInstruments(typeof(IPowerSupplySystem));

            if (Int32.TryParse(ProgramSpecificConfig.ReadValue(ProgramSpecificConfigIni.POLL_RATES.ToString(), ProgramSpecificConfigIni.POWER_SUPPLY_READ_RATE.ToString()), out pollRateMs))
               pollRateMs = pollRateMs * 1000;
            foreach (IPowerSupplySystem powerSystem in powerSystemList)
            {
               _threadList.Add(new PowerSupplyReadThread(powerSystem.Name, pollRateMs));
               _threadList.Last().Start();
            }

            pollRateMs = 1000;
            if (Int32.TryParse(ProgramSpecificConfig.ReadValue(ProgramSpecificConfigIni.POLL_RATES.ToString(), ProgramSpecificConfigIni.PASSTHROUGH_DATA_UPDATE_RATE.ToString()), out pollRateMs))
               pollRateMs = pollRateMs * 1000;
            _threadList.Add(new PassthroughDataUpdateThread(pollRateMs));
            _threadList.Last().Start();

            pollRateMs = 1000;
            if (Int32.TryParse(ProgramSpecificConfig.ReadValue(ProgramSpecificConfigIni.POLL_RATES.ToString(), ProgramSpecificConfigIni.POWER_SUPPLY_LOG_RATE.ToString()), out pollRateMs))
               pollRateMs = pollRateMs * 1000;

            string logNamePrefix = ProgramSpecificConfig.ReadValue(ProgramSpecificConfigIni.FILE_NAMES.ToString(), ProgramSpecificConfigIni.POWER_SUPPLY_LOG_PREFIX.ToString());
            string logFileExtension = ProgramSpecificConfig.ReadValue(ProgramSpecificConfigIni.FILE_NAMES.ToString(), ProgramSpecificConfigIni.POWER_SUPPLY_LOG_FILE_EXTENSION.ToString());
            _threadList.Add(new PowerSupplyUpdateThread(pollRateMs, logNamePrefix, logFileExtension));

            _threadList.Last().Start();
         }
      }
   }
}