using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Threading;
using System.IO;
using DTS.Common.DASResource;
using DTS.Common.Enums;
using DTS.Common.ICommunication;
using DTS.Common.Utilities.Logging;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.Connection;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Interface.DASFactory.Config;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Interface.StatusAndProgressBar;
using System.IO.Ports;
using DTS.Common.Classes.DSP;
using DTS.Common.SerialConnection;
using DTS.Common;
using DTS.DASLib.Command.TDAS;

namespace DTS.DASLib.Service
{
    public partial class TDAS<T> : Communication<T>,
                           IDASCommunication,
                           IConfigurationActions,
                           IDiagnosticsActions,
                           ITriggerCheckActions,
                           IRealTimeActions,
                           IArmActions,
                           IDownloadActions where T : IConnection, new()
    {
        /// <summary>
        /// indicates date of first use
        /// null indicates the hardware has not been used since calibration
        /// only valid when IsFirstUseDateSupported is true
        /// 15524 DAS "First Use Date"
        /// </summary>
        public DateTime? FirstUseDate { get; set; } = null;
        /// <summary>
        /// returns whether the hardware supports first use or not
        /// for hardware to support first use the hardware must support
        /// storage for user attributes in firmware and also have been
        /// calibrated by software support hardware first use
        /// 15524 DAS "First Use Date"
        /// </summary>
        public bool IsFirstUseDateSupported { get; set; } = false;
        /// <summary>
        /// indicates whether or not streaming is supported
        /// 30429 TSR AIRs can enable/disable streaming via the DISABLE_STREAMING_FEATURE system attribute
        /// </summary>
        public bool IsStreamingSupported { get; set; } = false;
        public int RecordId { get; set; } = Common.Enums.Hardware.HardwareConstants.INVALID_IDASCOMMUNICATION_RECORD_ID;
        public string MACAddress { get; set; }
        public string[] DownstreamMACAddresses { get; set; }
        /// <summary>
        /// right now these are coded in the tdas control .ini file.  we may want to leave these variable, but for now lets
        /// not surface them
        /// this code comes from tdas_setup.c in tdascontrol
        /// </summary>
        public double[] G5GainOptions = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0, 32.0, 36.0, 40.0, 44.0, 48.0, 52.0, 56.0, 60.0, 128.0, 192.0, 256.0, 320.0, 384.0, 448.0, 512.0, 576.0, 640.0, 704.0, 768.0, 832.0, 896.0, 960.0, 1024.0, 2048.0, 4096.0 };
        public double[] ProGainOptions = new double[] { 0.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0, 32.0, 36.0, 40.0, 44.0, 48.0, 52.0, 56.0, 60.0, 64.0, 72.0, 80.0, 88.0, 96.0, 104.0, 112.0, 120.0, 128.0, 144.0, 160.0, 176.0, 192.0, 208.0, 224.0, 240.0, 256.0, 288.0, 320.0, 352.0, 384.0, 426.0, 468.0, 512.0, 598.0, 682.0, 768.0, 854.0, 938.0, 1024.0, 1194.0, 1364.0, 1536.0, 1892.0, 2000.0 };
        private const ushort TDAS_HALFBRIDGE_RESISTANCE = 1000;

        /// <summary>
        /// this is mostly stolen from tdas_setup.c for the purpose of calculating the max gain given
        /// a max input range, a desired range, voltage, and overhead percentage
        /// </summary>
        /// <param name="G5"></param>
        /// <param name="maxInputRange"></param>
        /// <param name="bProportialToExcitation"></param>
        /// <param name="sensitivity"></param>
        /// <param name="desiredRange"></param>
        /// <param name="excitationVoltage"></param>
        /// <returns></returns>
        private double CalculateMaxRangeAndGain(bool G5, double maxInputRange, bool bProportialToExcitation,
            double sensitivity, double desiredRange, double? excitationVoltage, bool bAtCapacity, double capacityOutputIsBasedOn,
            SensorConstants.SensUnits sensitiviyUnits)
        {
            
            double[] array = G5 ? G5GainOptions : ProGainOptions;
            for (int i = array.Length - 1; i >= 0; i--)
            {
                double actualRange;
                if (bProportialToExcitation && sensitiviyUnits != DTS.Common.Enums.Sensors.SensorConstants.SensUnits.mVperEU)
                {
                    if (bAtCapacity)
                    {
                        actualRange = maxInputRange / (array[i] * System.Math.Abs(sensitivity) * (double)excitationVoltage / (double)capacityOutputIsBasedOn);
                    }
                    else
                    {
                        actualRange = maxInputRange / (array[i] * System.Math.Abs(sensitivity) * (double)excitationVoltage);
                    }
                }
                else
                {
                    if (bAtCapacity)
                    {
                        actualRange = maxInputRange / (array[i] * System.Math.Abs(sensitivity) / (double)capacityOutputIsBasedOn);
                    }
                    else
                    {
                        actualRange = maxInputRange / (array[i] * System.Math.Abs(sensitivity));
                    }
                }
                if (actualRange > desiredRange)
                {//passes
                    return array[i];
                }
            }
            return array[0];
        }
        bool IConfiguration.SupportsAutoDetect => false;
        void IConfigurationActions.AutoDetect(bool QueryConfiguration, ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.AutoDetect", AutoDetect, info);
        }

        void IConfigurationActions.SetFirstUseDate(DateTime firstUseDate, ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.Error("Not supported");
        }
        private void AutoDetect(object o)
        {
            if (!(o is TDASServiceAsyncInfo info)) { return; }
            info.Success();
        }
        void IConfigurationActions.CheckAAFilterRate(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);

            // look thru all the config data and make sure it's fit to be used
            // our caller have already checked for null, but...
            if (ConfigData == null)
            {
                // "TDAS.VerifyConfig: ConfigData is null"
                throw new ArgumentException(Strings.Slice_VerifyConfig_Err1);
            }

            if (ConfigData.Modules == null || ConfigData.Modules.Length == 0 || ConfigData.Modules.Length > DASInfo.Modules.Length)
            {
                // "Slice.VerifyConfig: ConfigData.Modules is null, empty or too long"
                throw new ArgumentException(Strings.Slice_VerifyConfig_Err4);
            }

            var AAFilterRateReducedToMax = false;
            for (var moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
            {
                var module = ConfigData.Modules[moduleIdx];
                if (module.IsClock()) continue;
                if (module.ModuleArrayIndex != moduleIdx)
                {
                    // "Slice.VerifyConfig: ConfigData.Module[{0}].ModuleNumber doesn't mach index"
                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err5, moduleIdx));
                }

                if (module.AAFilterRateHz > MaxAAFilterRateHz)
                {
                    module.AAFilterRateHz = MaxAAFilterRateHz;
                    AAFilterRateReducedToMax = true;
                }
            }

            if (AAFilterRateReducedToMax)
            {
                info.Error(SerialNumber);
            }
            else
            {
                info.Success();
            }
        }

        void IConfigurationActions.VerifyConfig(bool DoStrictCheck)
        {
            VerifyConfig(DoStrictCheck, null);
        }
        void IConfigurationActions.ResetHardwareLines(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.ResetHardwareLines", AsyncResetHardwareLines, info);
        }

        private void AsyncResetHardwareLines(object asyncInfo)
        {
            if (!(asyncInfo is TDASServiceAsyncInfo info))
            {
                return;
            }
            if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines))
            {
                info.Success();
                return;
            }

            try
            {
                var armOff = new Command.TDAS.ARMOFF(this);
                armOff.SyncExecute();
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
            }
            info.Success();
        }

        void IConfigurationActions.VerifyConfig(bool DoStrictCheck, ErrorCallback failedChallengeFunc)
        {
            VerifyConfig(DoStrictCheck, failedChallengeFunc);
        }
        void VerifyConfig(bool DoStrictCheck, ErrorCallback failedChallengeFunc)
        {

            // look thru all the config data and make sure it's fit to be used
            // our caller have already checked for null, but...
            if (ConfigData == null)
            {
                // "Slice.VerifyConfig: ConfigData is null"
                throw new ArgumentException(Strings.Slice_VerifyConfig_Err1);
            }

            if (string.IsNullOrEmpty(ConfigData.Description))
            {
                // "Slice.VerifyConfig: ConfigData.Description is null"
                //throw new ArgumentException(Strings.Slice_VerifyConfig_Err2);
                ConfigData.Description = "";
            }

            if (string.IsNullOrEmpty(ConfigData.TestID))
            {
                // "Slice.VerifyConfig: ConfigData.TestID is null"
                //throw new ArgumentException(Strings.Slice_VerifyConfig_Err3);
                APILogger.Log("ConfigData.TestID null, replacing with default");
                ConfigData.TestID = "Default Test ID";
            }

            // we don't care about EID's here

            if (ConfigData.Modules == null || ConfigData.Modules.Length == 0 || ConfigData.Modules.Length > DASInfo.Modules.Length)
            {
                // "Slice.VerifyConfig: ConfigData.Modules is null, empty or too long"
                throw new ArgumentException(Strings.Slice_VerifyConfig_Err4);
            }

            // SLICE have only DAS storage
            if (DASInfo.MaxEventStorageSpaceInBytes != null)
            {
                if (DASInfo.NumberOfBytesPerSampleClock == null)
                {
                    throw new ArgumentException("TDAS.VerifyConfig: DAS is missing NumberOfBytesPerSampleClock");
                }
                // if data is stored on DAS all modules must have same samplerate and pre/post
                if (ConfigData.Modules.Select(module => module.SampleRateHz).Distinct().Count() != 1)
                {
                    for (int i = 1; i < ConfigData.Modules.Length; i++)
                    {
                        ConfigData.Modules[i].SampleRateHz = ConfigData.Modules[0].SampleRateHz;
                    }
                    //throw new ArgumentException("Slice.VerifyConfig: DAS modules have more than one unique samplerate");
                }
                if (ConfigData.Modules.Select(module => module.PreTriggerSeconds).Distinct().Count() != 1)
                {
                    for (int i = 1; i < ConfigData.Modules.Length; i++)
                    {
                        ConfigData.Modules[i].PreTriggerSeconds = ConfigData.Modules[0].PreTriggerSeconds;
                    }
                }
                if (ConfigData.Modules.Select(module => module.PostTriggerSeconds).Distinct().Count() != 1)
                {
                    for (int i = 1; i < ConfigData.Modules.Length; i++)
                    {
                        ConfigData.Modules[i].PostTriggerSeconds = ConfigData.Modules[0].PostTriggerSeconds;
                    }
                }

                var secondsToRecord = ConfigData.Modules[0].PreTriggerSeconds + ConfigData.Modules[0].PostTriggerSeconds;
                var sampleClocksToRecord = (UInt64)(secondsToRecord * ConfigData.Modules[0].SampleRateHz + 1);
                var bytesToRecord = sampleClocksToRecord * (UInt64)DASInfo.NumberOfBytesPerSampleClock;
                if (bytesToRecord > (UInt64)DASInfo.MaxEventStorageSpaceInBytes)
                {
                    throw new ArgumentException(
                        string.Format("TDAS.VerifyConfig: {0} has {1} bytes available and needs {2} to record requested {3} samples",
                        SerialNumber, (UInt64)DASInfo.MaxEventStorageSpaceInBytes, bytesToRecord, sampleClocksToRecord));
                }
            }
            else
            {
                var sufficientMemory = SufficientStorageSpace();
                if (false == sufficientMemory)
                {
                    APILogger.Log($"SufficientStorageSpace() returns {sufficientMemory}");
                    throw new ArgumentException(
                        string.Format("TDAS.VerifyConfig: {0} has insufficient storage space to record.", SerialNumber));
                }
            }
            bool bModuleAAFChallenge = false;
            for (int moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
            {
                var module = ConfigData.Modules[moduleIdx];

                /*
                 * a TDAS rack could have missing modules, so the module index and moduleindex might not match
                 * the modulearrayindex
                 * if (module.ModuleArrayIndex != moduleIdx)
                {
                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err5, moduleIdx));
                }*/


                // we don't care about EID's here

                if (module.AAFilterRateHz > MaxAAFilterRateHz)
                {
                    APILogger.Log("configured AAF is out of range: " + module.SerialNumber() + " [" + module.AAFilterRateHz.ToString() + ">" + MaxAAFilterRateHz.ToString() + "]");
                    module.AAFilterRateHz = MaxAAFilterRateHz;
                    bModuleAAFChallenge = true;
                }

                if (module.RecordingMode != DFConstantsAndEnums.RecordingMode.CircularBuffer &&
                    module.RecordingMode != DFConstantsAndEnums.RecordingMode.RecorderMode &&
                    module.RecordingMode != DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART &&
                    module.RecordingMode != DFConstantsAndEnums.RecordingMode.RecorderModePlusUART &&
                    module.RecordingMode != DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode &&
                    module.RecordingMode != DFConstantsAndEnums.RecordingMode.AutoRecorderMode
                    )
                {
                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err7, moduleIdx));
                }

                if (module.SampleRateHz > MaxSampleRateHz && module.SampleRateHz != uint.MaxValue)
                {
                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err8, moduleIdx, MaxSampleRateHz));
                }

                // module.MaxRecordingSamples is null for SLICE

                if (module.Channels == null || ((module.Channels.Length == 0) && (DASInfo.Modules[moduleIdx].TypeOfModule != DFConstantsAndEnums.ModuleType.EMPTYBANK)) || module.Channels.Length > DASInfo.Modules[moduleIdx].NumberOfChannels)
                {
                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err10, moduleIdx));
                }

                for (int channelIdx = 0; channelIdx < module.Channels.Length; channelIdx++)
                {
                    var channel = (DASChannel)module.Channels[channelIdx];

                    // hack to allow dummy load testing during calibration
                    if (channel.DiagnosticsMode && !string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException("No Diagnostics mode support in TDAS"); }

                    if (channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Disabled)
                        continue;

                    if (channel.OwningModule != module)
                    {
                        throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err11, moduleIdx, channelIdx));
                    }

                    if (channel.ModuleChannelNumber != channelIdx)
                    {
                        // "Slice.VerifyConfig: ConfigData.Module[{0}].Channels[{1}].ChannelNumber doesn't mach index"
                        throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err12, moduleIdx, channelIdx));
                    }

                    if (channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal &&
                       channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.DummyArm &&
                       channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Disabled)
                    {
                        channel.ConfigurationMode = DFConstantsAndEnums.ConfigMode.Disabled;
                        //throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err13, moduleIdx, channelIdx));
                    }

                    var analog = channel as AnalogInputDASChannel;
                    OutputTOMDigitalChannel digital = channel as OutputTOMDigitalChannel;
                    OutputSquibChannel squib = channel as OutputSquibChannel;
                    if (null != analog)
                    {
                        if (analog.TypeOfBridge == SensorConstants.BridgeType.DigitalInput) { }
                        else
                        {
                            if (analog.TypeOfBridge != SensorConstants.BridgeType.FullBridge &&
                               analog.TypeOfBridge != SensorConstants.BridgeType.HalfBridge &&
                                analog.TypeOfBridge != SensorConstants.BridgeType.HalfBridge_SigPlus)
                            {
                                throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err15, moduleIdx, channelIdx));
                            }

                            if (analog.ShuntIsEnabled)
                            {
                                if (analog.BridgeResistanceOhms < SensorConstants.MIN_BRIDGE_RESISTANCE_OHMS) { analog.BridgeResistanceOhms = SensorConstants.MIN_BRIDGE_RESISTANCE_OHMS; }
                                if (analog.BridgeResistanceOhms > SensorConstants.MAX_BRIDGE_RESISTANCE_OHMS) { analog.BridgeResistanceOhms = SensorConstants.MAX_BRIDGE_RESISTANCE_OHMS; }
                            }

                            //if (analog.BypassAAFilter)
                            //{
                            //    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err17, moduleIdx, channelIdx));
                            //}

                            if (analog.DesiredRangeWithHeadroomEU < 0)
                            {
                                throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err18, moduleIdx, channelIdx));
                            }

                            if (DoStrictCheck && string.IsNullOrEmpty(analog.EngineeringUnits))
                            {
                                throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err19, moduleIdx, channelIdx));
                            }

                            //if (analog.Excitation != DTS.Common.DAS.Concepts.Test.Module.Channel.Sensor.ExcitationVoltageOption.Volt5)
                            //{
                            //    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err20, moduleIdx, channelIdx));
                            //}

                            if (analog.ZeroMethod != ZeroMethodType.AverageOverTime &&
                               analog.ZeroMethod != ZeroMethodType.UsePreEventDiagnosticsZero &&
                                analog.ZeroMethod != ZeroMethodType.None)
                            {
                                throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err22, moduleIdx, channelIdx));
                            }

                            if (DoStrictCheck && analog.ZeroMethod == ZeroMethodType.AverageOverTime)
                            {
                                if (analog.ZeroAverageStartSeconds >= analog.ZeroAverageStopSeconds)
                                {
                                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err23, moduleIdx, channelIdx));
                                }

                                if (analog.ZeroAverageStopSeconds > module.PostTriggerSeconds)
                                {
                                    throw new ArgumentException(string.Format(Strings.Slice_VerifyConfig_Err25, moduleIdx, channelIdx));
                                }
                            }
                        }
                    }
                    else if (null != digital)
                    {

                    }
                    else if (null != squib)
                    {
                    }
                }
            }
            if (bModuleAAFChallenge)
            {
                DialogResult dr;
                string err = string.Format("Default hardware filter frequency for {0} is out of range.  Press OK to continue and use the max hardware rate or cancel to cancel.", SerialNumber);
                if (null != failedChallengeFunc)
                {
                    dr = failedChallengeFunc(ConfigurationConstants.VerifyConfig_Errors.DefaultHardwareFilterRateOutOfRange.ToString(), SerialNumber);
                }
                else
                {
                    dr = DialogResult.Cancel;
                }
                APILogger.Log("MessageBox", err, dr);
                if (dr == DialogResult.Cancel) { throw new ArgumentOutOfRangeException(DASModule.AAFilterRateHzTag); }
            }
        }

        bool SufficientStorageSpace()
        {
            bool result = false;

            double rackSecondsAvailableToRecord = ulong.MaxValue;
            var secondsToRecord = ConfigData.Modules[0].PreTriggerSeconds + ConfigData.Modules[0].PostTriggerSeconds;
            APILogger.Log($"SufficientStorageSpace() - Seconds Pre:{ConfigData.Modules[0].PreTriggerSeconds} Seconds Post: {ConfigData.Modules[0].PostTriggerSeconds}");
            foreach (InfoResult.Module module in DASInfo.Modules)
            {
                if (module.SerialNumber != "EMPTY")
                {
                    uint bytesPerClock = 16;
                    var configModule = ConfigData.Modules.Where(x => string.Equals(x.SerialNumber(), module.SerialNumber)).FirstOrDefault();
                    if (configModule.NumberOfConfiguredChannels() == 0) { continue; }
                    switch (module.TypeOfModule)
                    {
                        case DFConstantsAndEnums.ModuleType.ProSIM:
                            // 2 bytes per configured analog channel
                            bytesPerClock = (uint)(configModule.NumberOfConfiguredChannels() * 2);
                            break;
                        case DFConstantsAndEnums.ModuleType.ProTOM:
                            if (configModule.NumberOfConfiguredTOMChannels() == 0) { continue; } //FB16066: we've only configured digital outs, no data will be collected
                            // 2 bytes per each configured channel; each squib configured will give you two channels; 4 bytes total per squib
                            bytesPerClock = (uint)(configModule.NumberOfConfiguredTOMChannels() * 2);
                            break;
                        default:
                            // Assumed to not be allocated dynamically; ie. DIM device
                            bytesPerClock = (uint)module.NumberOfBytesPerSampleClock;
                            break;
                    }
                    double moduleSecondsAvailableToRecord = (double)(module.MaxEventStorageSpaceInBytes / bytesPerClock) / ConfigData.Modules[0].SampleRateHz + 1;
                    APILogger.Log($"SufficientStorageSpace() - {module.SerialNumber} - module.MaxEventStorageSpaceInBytes:{module.MaxEventStorageSpaceInBytes}, bytesPerClock:{bytesPerClock}, ConfigData.Modules[0].SampleRateHz{ConfigData.Modules[0].SampleRateHz}");
                    rackSecondsAvailableToRecord = Math.Min(rackSecondsAvailableToRecord, moduleSecondsAvailableToRecord);
                }
            }
            if (secondsToRecord <= rackSecondsAvailableToRecord)
            {
                result = true;
            }
            APILogger.Log($"SufficientStorageSpace() - seconds to record:{secondsToRecord}, max event seconds available:{rackSecondsAvailableToRecord}");
            return result;
        }

        //note, the file I had originally copied code from (QA_TDAS_CAL.c v1.66??) had 3500 .... but everything seems to indicate it should be 4300 ...
        protected uint MaxAAFilterRateHz = DTS.Common.Constant.DASSpecific.TDAS.MaxAAFilterRateHz;

        const uint MaxSampleRateHz = 304000;
        public const int MaxG5InputRange = 2500;
        public const int MaxPROInputRange = 5000;//6250, but only at gain .8

        private Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte> TDAS_MinimumProtocols = new Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte>();

        public override void InitMinProto()
        {
            // Ribeye Protocol Limitations
            MinimumProtocols = TDAS_MinimumProtocols;
        }

        void IConfigurationActions.UpdateConfigurationFromFile(ServiceCallback callback, object userData,
            string filePath)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.UpdateConfigurationFromFile", new WaitCallback(AsyncUpdateConfigurationFromFile),
                info);
        }

        private void AsyncUpdateConfigurationFromFile(object asyncInfo)
        {
            var info = asyncInfo as TDASServiceAsyncInfo;
            info.Error("Not supported yet");
            return;
        }

        /// <summary>
        /// Retrieve the info to fill in the ConfigData property
        /// </summary>
        /// <param name="callback">The delegate to report to</param>
        /// <param name="userData">User supplied data that we pass along</param>
        void IConfigurationActions.QueryConfiguration(ServiceCallback callback, object userData, uint crc, string strConfig, bool bReadIds, bool bDeviceScaleFactors,
            bool differentModuleCountsAreOK)
        {
            var info = new TDASServiceQueryConfigAsyncInfo(bReadIds, callback, userData);

            LaunchAsyncWorker("TDAS.QueryConfiguration", new WaitCallback(AsyncQueryConfiguration), info);
        }

        //FB 29528 Query the DAS modules
        private IEnumerable<string> QueryDASModules()
        {
            try
            {
                var qm = new Command.TDAS.QueryModules(this);
                qm.SyncExecute();
                return qm.SerialNumbers;
            }
            catch
            {
                return Enumerable.Empty<string>();
            }
        }

        private void AsyncQueryConfiguration(object configAsyncInfo)
        {
            var info = configAsyncInfo as TDASServiceQueryConfigAsyncInfo;

            try
            {
                //calstation would like it if serial connections wouldn't be marked as no channel/empty string
                if (!IsG5() && !(this.Transport is SerialConnection))
                {
                    var updatedModules = QueryDASModules();
                    //FB 29528 Mark the missing modules as EMPTYBANK and set the channels to 0 
                    foreach (var m in DASInfo.Modules.Where(x => !updatedModules.Contains(x.SerialNumber)))
                    {
                        m.SerialNumber = "EMPTY";
                        m.TypeOfModule = DFConstantsAndEnums.ModuleType.EMPTYBANK;
                        m.NumberOfChannels = 0;
                    }
                }

                ConfigData = new ConfigurationData();
                ConfigData.Modules = new DASModule[DASInfo.Modules.Length];
                int validModuleIndex = 0;
                //Assume that validModuleIndex will be changed, possibly more than once, to the index of a valid module, 
                //so that ConfigData.Modules[0] will have the correct RecordingMode, PreTriggerSeconds, and PostTriggerSeconds
                for (int i = 0; i < DASInfo.Modules.Length; i++)
                {
                    TDASModuleConfig tConfig = new TDASModuleConfig(DASInfo.Modules[i].SerialNumber + ".xml");
                    if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
                    {
                        ConfigData.Modules[i] = new DASModule(DASInfo.Modules[i].ModuleArrayIndex, ((InfoResult)DASInfo).OwningDAS);
                        ConfigData.Modules[i].Channels = new DASChannel[DASInfo.Modules[i].NumberOfChannels];
                        for (int z = 0; z < ConfigData.Modules[i].Channels.Length; z++)
                        {
                            AnalogInputDASChannel aic = new AnalogInputDASChannel((DASModule)ConfigData.Modules[i], DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                            if (IsG5())
                            {
                                aic.SupportedBridges = new SensorConstants.BridgeType[]
                                {
                                    SensorConstants.BridgeType.FullBridge,
                                    SensorConstants.BridgeType.HalfBridge,
                                    SensorConstants.BridgeType.HalfBridge_SigPlus,
                                };
                                if (G5Mode == G5Modes.VDS)
                                {
                                    aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt2, ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 };
                                }
                                else { aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 }; }
                            }
                            else
                            {
                                aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5, ExcitationVoltageOptions.ExcitationVoltageOption.Volt10 };
                            }

                            aic.ModuleChannelNumber = z;
                            ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(aic);
                        }
                        if (tConfig.TestId.Length > 0) { ConfigData.TestID = tConfig.TestId; }
                        if (tConfig.TestDescription.Length > 0) { ConfigData.Description = tConfig.TestDescription; }
                    }
                    else
                    {
                        //TDC is not making this call and since we aren't using the results, lets eliminate it, it could save
                        //8 seconds on a 8 module rack ...
                        if (string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))
                        {
                            try
                            {
                                if (!IsG5() && DASInfo.Modules[i].TypeOfModule != DFConstantsAndEnums.ModuleType.ProDIM
                                    && (!IsTom(DASInfo.Modules[i].TypeOfModule)) && (!DASInfo.Modules[i].RackIsUnreadable))
                                {
                                    Command.TDAS.QueryAAFMax f1 = new DTS.DASLib.Command.TDAS.QueryAAFMax(this);
                                    f1.ModuleIndex = DASInfo.Modules[i].ModuleArrayIndex;
                                    f1.SyncExecute();
                                }
                            }
                            catch (Exception ex)
                            {
                                APILogger.Log("Failed to retrieve max filter rate - ", ex);
                            }
                        }
                        ConfigData.Modules[i] = new DASModule(DASInfo.Modules[i].ModuleArrayIndex, ((InfoResult)DASInfo).OwningDAS);
                        ConfigData.Modules[i].Channels = new DASChannel[DASInfo.Modules[i].NumberOfChannels];
                        for (int z = 0; z < ConfigData.Modules[i].Channels.Length; z++)
                        {
                            if (IsTom((DASModule)ConfigData.Modules[i]))
                            {
                                if (z >= 8)
                                {
                                    OutputTOMDigitalChannel c = new OutputTOMDigitalChannel((DASModule)ConfigData.Modules[i], DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                                    c.ModuleChannelNumber = z;
                                    ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(c);
                                }
                                else
                                {
                                    OutputSquibChannel c = new OutputSquibChannel((DASModule)ConfigData.Modules[i], DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                                    if (0 != z % 2) { c.MeasurementType = SquibMeasurementType.CURRENT; }
                                    c.ModuleChannelNumber = z;
                                    ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(c);
                                }
                            }
                            else if (IsG5() && i >= 4)
                            {
                                AnalogInputDASChannel aic = new AnalogInputDASChannel((DASModule)ConfigData.Modules[i], DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                                aic.ModuleChannelNumber = z;
                                ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(aic);
                                aic = ConfigData.Modules[i].Channels[z] as AnalogInputDASChannel;
                                aic.SupportedBridges = new SensorConstants.BridgeType[] { SensorConstants.BridgeType.DigitalInput };
                                aic.TypeOfBridge = SensorConstants.BridgeType.DigitalInput;
                                aic.DigitalInputChannel = true;
                                //g5 only supports CCNO for digital channels
                                aic.SupportedDigitalInputModes = new[] { DigitalInputModes.CCNO };
                            }
                            else if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM)
                            {
                                AnalogInputDASChannel aic = new AnalogInputDASChannel((DASModule)ConfigData.Modules[i],
                                    DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                                aic.ModuleChannelNumber = z;
                                ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(aic);
                                aic = ConfigData.Modules[i].Channels[z] as AnalogInputDASChannel;
                                aic.SupportedBridges = new SensorConstants.BridgeType[]
                                {SensorConstants.BridgeType.DigitalInput};
                                aic.TypeOfBridge = SensorConstants.BridgeType.DigitalInput;
                                aic.DigitalInputChannel = true;
                                aic.SupportedDigitalInputModes = new[]
                                {
                                    DigitalInputModes.CCNO,
                                    DigitalInputModes.CCNC,
                                    DigitalInputModes.THL,
                                    DigitalInputModes.TLH
                                };
                            }
                            else
                            {
                                AnalogInputDASChannel aic = new AnalogInputDASChannel((DASModule)ConfigData.Modules[i],
                                    DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(i, z));
                                //per CPB and rihito, assume G5 is in a rack and supports 2 v
                                //http://fogbugz/fogbugz/default.asp?4150#21991
                                if (IsG5())
                                {
                                    aic.SupportedBridges = new SensorConstants.BridgeType[]
                                    {
                                        SensorConstants.BridgeType.FullBridge,
                                        SensorConstants.BridgeType.HalfBridge,
                                        SensorConstants.BridgeType.HalfBridge_SigPlus,
                                    };
                                    if (G5Mode == G5Modes.VDS)
                                    {
                                        aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption
                                            []
                                        {
                                            ExcitationVoltageOptions.ExcitationVoltageOption.Volt5,
                                            ExcitationVoltageOptions.ExcitationVoltageOption.Volt2
                                        };
                                    }
                                    else
                                    {
                                        aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption
                                            []
                                        {
                                            ExcitationVoltageOptions.ExcitationVoltageOption.Volt5
                                        };
                                    }
                                }
                                else
                                {
                                    aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[]
                                    {
                                        ExcitationVoltageOptions.ExcitationVoltageOption.Volt5,
                                        ExcitationVoltageOptions.ExcitationVoltageOption.Volt10
                                    };
                                }
                                aic.ModuleChannelNumber = z;
                                ConfigData.Modules[i].Channels[z] = tConfig.GetChannel(aic);
                                if (!Matches(aic, (DASChannel)ConfigData.Modules[i].Channels[z]))
                                {
                                    APILogger.Log($"CONFIGURATION MISMATCH ON CHANNEL {i}-{z}, using default");
                                    ConfigData.Modules[i].Channels[z] = aic;
                                }
                            }
                        }
                        ConfigData.Modules[i].RecordingMode = tConfig.RecordingMode;
                        ConfigData.Modules[i].AAFilterRateHz = tConfig.AAFilterRateHz;
                        ConfigData.Modules[i].PreTriggerSeconds = tConfig.PreTriggerSeconds;
                        ConfigData.Modules[i].PostTriggerSeconds = tConfig.PostTriggerSeconds;
                        ConfigData.Modules[i].FirmwareVersion = tConfig.FirmwareVersion;
                        ConfigData.Modules[i].MaxEventStorageSpaceInBytes = tConfig.MaxEventStorageSpaceInBytes;
                        validModuleIndex = i;
                        if (tConfig.TestId.Length > 0) { ConfigData.TestID = tConfig.TestId; }
                        if (tConfig.TestDescription.Length > 0) { ConfigData.Description = tConfig.TestDescription; }
                    }
                }

                // get sensor ID's
                if (ConfigData.Modules != null)
                {
                    foreach (var module in ConfigData.Modules)
                    {
                        if (DASInfo.Modules[module.ModuleArrayIndex].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
                        {
                            module.RecordingMode = ConfigData.Modules[validModuleIndex].RecordingMode;
                            module.PreTriggerSeconds = ConfigData.Modules[validModuleIndex].PreTriggerSeconds;
                            module.PostTriggerSeconds = ConfigData.Modules[validModuleIndex].PostTriggerSeconds;
                            continue;
                        }

                        if (DASInfo.Modules[module.ModuleArrayIndex].TypeOfModule == DFConstantsAndEnums.ModuleType.G5Digital)
                        {
                            // Digitals have not IDS, but still need to do this house keeping.  Probably should be moved elsewhere.
                            for (int i = 0; i < module.Channels.Length; i++)
                            {
                                var channel = (DASChannel)module.Channels[i];
                                channel.OwningModule = (DASModule)module;
                            }
                        }
                        else
                        {
                            for (int i = 0; i < module.Channels.Length; i++)
                            {
                                var channel = (DASChannel)module.Channels[i];
                                channel.OwningModule = (DASModule)module;
                            }

                            if (info.ReadIds && !IsG5()) //g5 will be handled separately at the end all at once
                            {
                                EID[] ids = null;
                                if (!DASInfo.Modules[module.ModuleArrayIndex].RackIsUnreadable)
                                {
                                    ids = EIDReader.RetriveEIDs(this, module.ModuleArrayIndex);
                                    for (int i = 0; i < module.Channels.Length; i++)
                                    {
                                        if (null != ids && i < ids.Length && ids[i].IsValid())
                                        {
                                            if (IsTom(module))
                                            {
                                                module.Channels[i * 2].IDs = new EID[] { ids[i] };
                                            }
                                            else
                                            {
                                                module.Channels[i].IDs = new EID[] { ids[i] };
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (IsG5() && info.ReadIds)
                    {
                        GetEIDSG5();
                    }
                }
                info.Success();
            }
            catch (CanceledException) { info.Cancel(); }
            catch (System.Exception ex) { info.Error(ex.Message, ex); }
        }

        /// <summary>
        /// Checks that the channel from the written xml configuration matches 
        /// what we've queried from the hardware.
        /// </summary>
        /// <param name="queried"></param>
        /// <param name="fromConfig"></param>
        /// <returns></returns>
        private bool Matches(AnalogInputDASChannel queried, DASChannel fromConfig)
        {
            var aicFromConfig = fromConfig as AnalogInputDASChannel;
            if (null == aicFromConfig)
            {
                return false;
            }
            var supportedExcitationFromConfig = 0;
            foreach (var se in aicFromConfig.SupportedExcitation)
            {
                supportedExcitationFromConfig |= (int)se;
            }
            var supportedExcitationQueried = 0;
            foreach (var se in queried.SupportedExcitation)
            {
                supportedExcitationQueried += (int)se;
            }
            if (supportedExcitationQueried != supportedExcitationFromConfig)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// Calculate the EU to mV conversion factor for the specified channel.
        /// </summary>
        /// 
        /// <param name="analog">
        /// The <see cref="DTS.DASLib.Service.AnalogInputDASChannel"/> whose property is being converted from
        /// EU to mV.
        /// </param>
        /// 
        /// <returns>
        /// The mV equivalent of 1 EU on the specified channel.
        /// </returns>
        ///       
        private double GetMvPerEu(AnalogInputDASChannel analog)
        {
            try
            {
                return Math.Abs(analog.SensitivityMilliVoltsPerEU);/*
                                 * (analog.IsProportionalToExcitation
                                     ? DTS.Common.DAS.Concepts.Test.Module.Channel.Sensor.GetExcitationVoltageMagnitudeFromEnum(analog.Excitation)
                                     : 1.0);*/
            }

            catch (System.Exception ex)
            {
                throw new ApplicationException("encountered problem getting EU to MV conversion factor for channel " + (null != analog && null != analog.SerialNumber ? analog.SerialNumber : "<NULL>"), ex);
            }
        }
        private double GetMvPerEuNormalized(AnalogInputDASChannel analog)
        {
            try
            {
                return Math.Abs(analog.SensitivityMilliVoltsPerEU)
                                 * (analog.IsProportionalToExcitation && analog.SensitivityUnits != DTS.Common.Enums.Sensors.SensorConstants.SensUnits.mVperEU
                                     ? DTS.Common.DAS.Concepts.Test.Module.Channel.Sensor.GetExcitationVoltageMagnitudeFromEnum(analog.Excitation)
                                     : 1.0)
                / (double)(analog.AtCapacity ? analog.CapacityOutputIsBasedOn : 1.0);
            }

            catch (System.Exception ex)
            {
                throw new ApplicationException("encountered problem getting EU to MV conversion factor for channel " + (null != analog && null != analog.SerialNumber ? analog.SerialNumber : "<NULL>"), ex);
            }
        }


        #region Set configuration
        /// <summary>
        /// Checks whether the das safety switch is currently in the armed state or not
        /// </summary>
        /// <param name="bArmed"></param>
        /// <param name="callback"></param>
        /// <param name="userData"></param>
        void IConfigurationActions.CheckSafetyState(bool bArmed, ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.functionData = bArmed;
            LaunchAsyncWorker("TDAS.CheckSafetyState", new WaitCallback(AsyncCheckSafetyState), info);
        }
        private class ConfigurePacket : TDASServiceAsyncInfo
        {
            public ConfigurePacket(ServiceCallback callback, object userData) : base(callback, userData) { }

            public bool DummyArm { get; set; }
            public Dictionary<IDASCommunication, ushort> TimeChannelIds { get; set; }
            public Dictionary<IDASCommunication, ushort> DataChannelIds { get; set; }
            public bool ConfigureDigitalOutputs { get; set; }
            public bool DiscardDiagnostics { get; set; }
            /// <summary>
            /// max aaf from config for devices
            /// index 0 is PRO, index 1 is G5
            /// </summary>
            public double[] MaxAAF { get; set; }
        }
        void IConfigurationActions.Configure(ServiceCallback callback, object userData, bool EventConfig, bool DummyArm, double [] maxAAF, bool configureDigitalOutputs, uint crc, bool turnOffAAFRealtime,
            IStreamingFilterProfile dspFilterType, bool discardDiagnostics, Dictionary<IDASCommunication, ushort> timeChannelIds, Dictionary<IDASCommunication, ushort> dataChannelIds,
            Dictionary<IDASCommunication, UDPStreamProfile> streamProfiles, Dictionary<IDASCommunication, int> streamADCPerPacket, Dictionary<IDASCommunication, ushort> irigTDPIntervals,
            Dictionary<IDASCommunication, string> addresses, Dictionary<IDASCommunication, uint[]> tmnsConfigs,
            Dictionary<IDASCommunication, uint> baudRates, Dictionary<IDASCommunication, uint> dataBits, Dictionary<IDASCommunication, StopBits> stopBits,
            Dictionary<IDASCommunication, Parity> parities, Dictionary<IDASCommunication, Handshake> flowControls, Dictionary<IDASCommunication, UartDataFormat> dataFormats,
            Dictionary<IDASCommunication, ushort> tmatsIntervals
            )
        {
            var info = new ConfigurePacket(callback, userData);
            info.ConfigureDigitalOutputs = configureDigitalOutputs || !DummyArm;
            info.DummyArm = false;
            info.DataChannelIds = dataChannelIds;
            info.TimeChannelIds = timeChannelIds;
            info.MaxAAF = maxAAF;
            info.DiscardDiagnostics = discardDiagnostics;
            LaunchAsyncWorker("TDAS.Configure", new WaitCallback(AsyncConfigure), info);
        }

        void IConfigurationActions.ApplyLevelTriggers(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.ApplyLevelTriggers", AsyncApplyLevelTriggers, info);
        }

        private void AsyncApplyLevelTriggers(object asyncInfo)
        {
            var info = (TDASServiceAsyncInfo)asyncInfo;
            info.Success();
        }
        public double[] GetNominalRanges(SensorConstants.BridgeType bridgeType)
        {
            //get the gains and calculate the max input ranges backwards from the max input range and the gain
            int maxInput;
            double[] gains;
            switch (GetHardwareType())
            {
                case Common.Enums.Hardware.HardwareTypes.G5INDUMMY:
                case Common.Enums.Hardware.HardwareTypes.G5VDS:
                    maxInput = MaxG5InputRange;
                    gains = G5GainOptions;
                    break;
                default:
                    maxInput = MaxPROInputRange;
                    gains = ProGainOptions;
                    break;
            }
            var inputRanges = new List<double>();
            foreach (var gain in gains)
            {
                inputRanges.Add(maxInput / gain);
            }
            return inputRanges.ToArray();
        }
        private bool ContainsTOM()
        {
            foreach (var mod in DASInfo.Modules)
            {
                if (IsTom(mod.TypeOfModule)) { return true; }
            }
            return false;
        }
        private void AsyncCheckSafetyState(object configAsyncInfo)
        {
            var info = configAsyncInfo as TDASServiceAsyncInfo;

            if (null == ConfigData || null == ConfigData.Modules)
            {
                ManualResetEvent finished = new ManualResetEvent(false);

                (this as IConfigurationActions).QueryConfiguration(
                    delegate (ServiceCallbackData data)
                    {
                        switch (data.Status)
                        {
                            case ServiceCallbackData.CallbackStatus.Success:
                            case ServiceCallbackData.CallbackStatus.Failure:
                            case ServiceCallbackData.CallbackStatus.Canceled:
                                finished.Set();
                                break;
                            default:
                                break;
                        }

                    }, null, 0, string.Empty, false);

                while (false == finished.WaitOne(50)) { System.Threading.Thread.Sleep(10); }
            }
            bool bArmed = (bool)info.functionData;

            bool bHaveResistances = false;
            bool bNotSafe = false;
            foreach (DASModule module in ConfigData.Modules)
            {
                if (IsTom(module))
                {
                    // Do not put the Arm/Safe switch in the armed position for unused TOMs!
                    if (bArmed && module.NumberOfConfiguredChannels() < 1) { continue; }

                    try
                    {
                        Command.TDAS.GetTOMSwitch gts = new DTS.DASLib.Command.TDAS.GetTOMSwitch(this);
                        gts.ModuleIndex = module.ModuleArrayIndex;
                        gts.SyncExecute();
                        switch (gts.SwitchMode)
                        {
                            case DTS.DASLib.Command.TDAS.GetTOMSwitch.TomSwitchMode.Armed:
                                if (!bArmed)
                                {
                                    bNotSafe = true;
                                    try
                                    {
                                        Command.TDAS.TestSquibArray tsa = new Command.TDAS.TestSquibArray(this);
                                        tsa.ModuleIndex = module.ModuleArrayIndex;
                                        tsa.SyncExecute();
                                        foreach (var d in tsa.ResistanceOhms) { if (d >= 1 && d <= 8) { bHaveResistances = true; break; } }
                                    }
                                    catch (System.Exception ex) { APILogger.Log(ex); }
                                }
                                break;
                            case DTS.DASLib.Command.TDAS.GetTOMSwitch.TomSwitchMode.Fail:
                                info.Error("");
                                return;
                            case DTS.DASLib.Command.TDAS.GetTOMSwitch.TomSwitchMode.Safe:
                                if (bArmed)
                                {
                                    info.Error("");
                                    return;
                                }
                                break;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        APILogger.Log("failed to get checksafetystate, ", ex);
                        info.Error("SAFETYSWITCH_EXCEPTION", ex);
                    }
                }
            }
            if (bHaveResistances) { info.Error("SQUIB_RESISTANCE"); }
            else if (bNotSafe) { info.Error("SAFETYSWITCH_STATE"); }
            else { info.Success(); }
        }
        /// <summary>
        /// if we have only digital channels on a g5, we still want to arm normally and not dummy arm, but to do this
        /// we need setupdasload to operate properly, which means we need atleast one analog dummy channel
        /// this function scans for and fixes this condition if prsent.
        /// </summary>
        private void G5DigitalOnlyCheck()
        {
            bool bAddDummyChannel = true;
            if (IsG5())
            {
                foreach (var m in ConfigData.Modules)
                {
                    foreach (var c in m.Channels)
                    {
                        if (c is AnalogInputDASChannel)
                        {
                            if (c.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal
                                && !(c as AnalogInputDASChannel).DigitalInputChannel)
                            {
                                bAddDummyChannel = false;
                                break;
                            }
                            if (c.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm) { break; }
                        }
                    }
                    if (!bAddDummyChannel) { break; }
                }

                if (bAddDummyChannel)
                {
                    bool bHaveSetDummy = false;
                    foreach (var m in ConfigData.Modules)
                    {
                        foreach (var c in m.Channels)
                        {
                            if (c is AnalogInputDASChannel)
                            {
                                AnalogInputDASChannel aic = c as AnalogInputDASChannel;
                                aic.ConfigurationMode = DFConstantsAndEnums.ConfigMode.DummyArm;
                                aic.Description = "DummyArm";
                                aic.DesiredRangeWithHeadroomEU = 1;
                                aic.EngineeringUnits = "g";
                                aic.Excitation = ExcitationVoltageOptions.ExcitationVoltageOption.Volt5;
                                aic.HardwareChannelName = "DummyArm";
                                aic.IsProportionalToExcitation = false;
                                aic.ScalefactorMilliVoltsPerADC = 1;
                                aic.ScalefactorEngineeringUnitsPerADC = 1;
                                aic.SensitivityMilliVoltsPerEU = 1;
                                aic.SensorCapacityEU = 1;
                                aic.SensorCapacity = 0;
                                aic.SensorPolarity = "";
                                aic.SerialNumber = "";
                                aic.ShuntIsEnabled = false;
                                aic.TypeOfBridge = SensorConstants.BridgeType.FullBridge;
                                aic.UpdateChannelFromDatabase = false;
                                aic.VerifyOffset = false;
                                aic.RemoveOffset = false;
                                aic.ZeroMethod = ZeroMethodType.None;
                                aic.AtCapacity = false;
                                aic.CapacityOutputIsBasedOn = 1.000;
                                aic.SensitivityUnits = SensorConstants.SensUnits.NONE;
                                bHaveSetDummy = true;
                                break;
                            }
                        }
                        if (bHaveSetDummy)
                        {
                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// scan through all modules, make sure all modules have atleast one channel or dummy channel set
        /// </summary>
        private void RackDummyChannelCheck()
        {
            if (IsG5()) { return; }
            foreach (var m in ConfigData.Modules)
            {
                bool bGoodToGo = false;
                foreach (var channel in m.Channels)
                {
                    if (((channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal) && (!(channel is DTS.DASLib.Service.OutputTOMDigitalChannel))) ||
                        (channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm))
                    {
                        bGoodToGo = true; break;
                    }
                }
                if (!bGoodToGo && (m.Channels.Length > 0))
                {
                    AnalogInputDASChannel aic = m.Channels[0] as AnalogInputDASChannel;
                    OutputSquibChannel squib = m.Channels[0] as OutputSquibChannel;
                    if (null != squib)
                    {
                        squib.ConfigurationMode = DFConstantsAndEnums.ConfigMode.DummyArm;
                        squib.SquibToleranceLow = 0;
                        squib.SquibToleranceHigh = 8;
                        squib.FireMode = SquibFireMode.NONE;
                        squib.DurationMS = 0;
                    }
                    else if (null != aic)
                    {
                        aic.ConfigurationMode = DFConstantsAndEnums.ConfigMode.DummyArm;
                        aic.DesiredRangeWithHeadroomEU = 1;
                        aic.SensorCapacityEU = 1;
                        aic.SensorCapacity = 0;
                        aic.SerialNumber = "";
                        aic.ShuntIsEnabled = false;
                        aic.RemoveOffset = false;
                        aic.VoltageInsertionCheckEnabled = false;
                        aic.ChannelName2 = "";
                        aic.ChannelId = "-1";
                        aic.ChannelGroupName = "";
                        aic.VerifyOffset = false;
                        aic.UpdateChannelFromDatabase = false;
                        aic.TypeOfBridge = SensorConstants.BridgeType.FullBridge;
                    }
                }
            }
        }

        private void AsyncConfigure(object configAsyncInfo)
        {
            var info = configAsyncInfo as ConfigurePacket;
            try
            {
                if (IsG5()) { MaxAAFilterRateHz = Convert.ToUInt32(info.MaxAAF[1]); }
                else
                {
                    //for sim, we want to cut off at 650 below the max .., so we just do that here
                    //see notes attached to http://fogbugz/fogbugz/default.asp?5978
                    uint max = Convert.ToUInt32(info.MaxAAF[0]);
                    if (max > 650) { max = max - 650; }
                    MaxAAFilterRateHz = max;
                }
            }
            catch (System.Exception ex) { APILogger.Log(ex); }

            float MaxSquibDurationMS = 40; //Kids need limits, so do unlimited-duration squibs
            try
            {
                //we can dummy arm as long as there's no digital channels, if there's a digital channel, 
                //we have to arm as normal and add a dummy channel so the SDL works
                G5DigitalOnlyCheck();
                RackDummyChannelCheck();

                if (ContainsTOM() && string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))
                {
                    foreach (var m in DASInfo.Modules)
                    {
                        if (m.SerialNumber != "EMPTY" &&
                            IsTom(m.TypeOfModule)) { TurnOffExcitation(m.ModuleArrayIndex); }
                    }

                    foreach (var m in DASInfo.Modules)
                    {
                        if (m.TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }

                        var qsnb = new Command.TDAS.QuerySerialNumberBroadcast(this, m.ModuleArrayIndex);
                        qsnb.SyncExecute();
                        break;
                    }
                }

                // loop thru the modules (slices) and configure the channels
                long numChannels = DASInfo.Modules.Sum(mod => mod.NumberOfChannels);

                int currentChannel = 0;

                info.Progress(50);
                
                var tEntireConfig = new TDASConfig(((InfoResult)DASInfo).OwningDAS + ".xml", true);

                //avoid doing this on Serial TDAS
                if (this is TDAS<EthernetConnection>)
                {
                    try
                    {
                        //added this to clear latched rackfaults ...
                        Command.TDAS.ARMOFF ao = new Command.TDAS.ARMOFF(this);
                        ao.SyncExecute();
                    }

                    catch (System.Exception) 
                    {
                        //no logging requested
                    }
                }

                bool rackCleared = false;
                int firstRackModule = 0;

                for (int i = 0; i < ConfigData.Modules.Length; i++)
                {
                    var tConfig = new TDASModuleConfig(DASInfo.Modules[i].SerialNumber + ".xml");

                    //only wipe out the existing setup if we have to ...
                    if (ConfigData.ClearSetup /*||ContainsTOM()*/)
                    {
                        if (IsG5() && i > 0) 
                        {
                            //only want to clear once with a G5 ...
                        }
                        else if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
                        else
                        {
                            if (IsG5())
                            {
                                Command.TDAS.SetupClear sClear = new DTS.DASLib.Command.TDAS.SetupClear(this);
                                sClear.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;
                                sClear.SyncExecute();
                            }
                            else
                            {
                                if (string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))
                                {
                                    if (this is TDAS<EthernetConnection>)
                                    {
                                        if (!rackCleared)
                                        {
                                            Command.TDAS.SetupClearBroadcast scb = new Command.TDAS.SetupClearBroadcast(this, i, 10 * 1000);
                                            scb.SyncExecute();
                                            Thread.Sleep(1000);
                                            rackCleared = true;
                                            firstRackModule = i;
                                        }
                                    }
                                    else
                                    {
                                        Command.TDAS.SetupClear sClear = new DTS.DASLib.Command.TDAS.SetupClear(this);
                                        sClear.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;
                                        sClear.SyncExecute();
                                    }
                                }
                                else if (!rackCleared)
                                {
                                    var qsn = new Command.TDAS.QuerySerialNumberBroadcast(this, i);
                                    qsn.SyncExecute();

                                    var scb = new Command.TDAS.SetupClearBroadcast(this, i, 10 * 1000);
                                    scb.SyncExecute();
                                    rackCleared = true;
                                }
                            }
                        }
                    }

                    if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
                    else
                    {
                        DASModule module = (DASModule)ConfigData.Modules[i];
                        tConfig.RecordingMode = module.RecordingMode;
                        tConfig.AAFilterRateHz = module.AAFilterRateHz;
                        tConfig.PreTriggerSeconds = module.PreTriggerSeconds;
                        tConfig.PostTriggerSeconds = module.PostTriggerSeconds;
                        tConfig.SerialNumber = module.SerialNumber();
                        tConfig.FirmwareVersion = module.FirmwareVersion;
                        tConfig.MaxEventStorageSpaceInBytes = module.MaxEventStorageSpaceInBytes;
                        tConfig.ModuleArrayIndex = module.ModuleArrayIndex;
                        for (int z = 0; z < ConfigData.Modules[i].Channels.Length; z++)
                        {
                            AnalogInputDASChannel channel = ConfigData.Modules[i].Channels[z] as AnalogInputDASChannel;
                            OutputSquibChannel squib = ConfigData.Modules[i].Channels[z] as OutputSquibChannel;
                            OutputTOMDigitalChannel digital = ConfigData.Modules[i].Channels[z] as OutputTOMDigitalChannel;

                            if (null != channel)
                            {
                                tConfig.SetChannel(channel);
                            }
                            else if (null != squib)
                            {
                                tConfig.SetChannel(squib);
                            }
                            else if (null != digital)
                            {
                                tConfig.SetChannel(digital);
                            }
                        }
                        tEntireConfig.SetModule(tConfig);
                        if (IsTom(module))
                        {
                            try
                            {
                                if (!ConfigData.ClearSetup /*||ContainsTOM()*/)
                                {
                                    Command.TDAS.SetupTOMDASRead sdr = new DTS.DASLib.Command.TDAS.SetupTOMDASRead(this);
                                    sdr.ModuleIndex = module.ModuleArrayIndex;
                                    sdr.SyncExecute();
                                    string[] tokens = sdr.TestConfig.Split(new char[] { SETUPDASREAD_SENTINEL });
                                }
                            }
                            catch (System.Exception) 
                            {
                                //no logging requested
                            }
                        }
                        else
                        {
                            try
                            {
                                if (!ConfigData.ClearSetup /*||ContainsTOM()*/)
                                {
                                    if (DASInfo.Modules[module.ModuleArrayIndex].TypeOfModule ==
                                        DFConstantsAndEnums.ModuleType.ProDIM && !IsG5())
                                    {
                                        Command.TDAS.SetupDASReadDIM sdr = new Command.TDAS.SetupDASReadDIM(this);
                                        sdr.ModuleIndex = module.ModuleArrayIndex;
                                        sdr.SyncExecute();
                                        string[] tokens = sdr.TestConfig.Split(new char[] { SETUPDASREAD_SENTINEL });
                                        if (tokens.Last() == module.GetCRC32().ToString())
                                        {
                                            continue;
                                        }
                                    }
                                    else
                                    {
                                        Command.TDAS.SetupDASRead sdr = new DTS.DASLib.Command.TDAS.SetupDASRead(this);
                                        sdr.ModuleIndex = module.ModuleArrayIndex;
                                        sdr.SyncExecute();
                                        string[] tokens = sdr.TestConfig.Split(new char[] { SETUPDASREAD_SENTINEL });
                                        if (tokens.Last() == module.GetCRC32().ToString())
                                        {
                                            continue;
                                        }
                                    }
                                }
                            }
                            catch (System.Exception) { }

                        }
                    }

                    for (int z = 0; z < ConfigData.Modules[i].Channels.Length; z++)
                    {
                        AnalogInputDASChannel channel = ConfigData.Modules[i].Channels[z] as AnalogInputDASChannel;
                        OutputSquibChannel squib = ConfigData.Modules[i].Channels[z] as OutputSquibChannel;
                        OutputTOMDigitalChannel digital = ConfigData.Modules[i].Channels[z] as OutputTOMDigitalChannel;

                        if (null != channel)
                        {
                            tConfig.SetChannel(channel);
                            if (channel.DigitalInputChannel)
                            {
                                if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM && !IsG5())
                                {
                                    Command.TDAS.SetupDIMChannel dim = new Command.TDAS.SetupDIMChannel(this);
                                    dim.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;
                                    dim.ChannelNumber = z + 1;
                                    switch (channel.DigitalMode)
                                    {
                                        case DigitalInputModes.THL:
                                            dim.InputMode = Command.TDAS.SetupDIMChannel.InputModes.VMHL;
                                            break;
                                        case DigitalInputModes.TLH:
                                            dim.InputMode = Command.TDAS.SetupDIMChannel.InputModes.VMLH;
                                            break;
                                        case DigitalInputModes.CCNC:
                                            dim.InputMode = Command.TDAS.SetupDIMChannel.InputModes.CCNC;
                                            break;
                                        case DigitalInputModes.CCNO:
                                            dim.InputMode = Command.TDAS.SetupDIMChannel.InputModes.CCNO;
                                            break;
                                    }

                                    if (channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Disabled &&
                                        (channel.SerialNumber.Length > 0 ||
                                         channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm))
                                    {
                                        dim.SyncExecute();
                                    }
                                }
                                continue;
                            }
                            var scl = new SetupChannelLoad(this, IsG5()); 
                            if(string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))       // TDAS Bridge Completion (Shunt) test.
                            {
                                scl.ShuntPosition = Convert.ToInt32(channel.BridgeResistanceOhms);
                            }
                            else
                            {
                                switch (channel.TypeOfBridge)
                                {
                                    case SensorConstants.BridgeType.HalfBridge:
                                    case SensorConstants.BridgeType.HalfBridge_SigPlus:
                                        scl.ShuntPosition = Convert.ToInt32(TDAS_HALFBRIDGE_RESISTANCE);
                                        break;
                                    default:
                                        scl.ShuntPosition = Convert.ToInt32(channel.BridgeResistanceOhms);
                                        break;
                                }
                            }
                            if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
                            scl.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;

                            scl.Channel = z + 1;
                            if (SensorConstants.BridgeType.FullBridge == channel.TypeOfBridge)
                            {
                                scl.ChannelType = Command.TDAS.SetupChannelLoad.ChannelTypes.FullBridge;
                            }
                            else if (SensorConstants.BridgeType.HalfBridge == channel.TypeOfBridge
                                || SensorConstants.BridgeType.HalfBridge_SigPlus == channel.TypeOfBridge)
                            {
                                // this property is being re-purposed for TDAS SIM Diagnostics mode for cal station 2.    (CLH) 5/25/2017
                                if (channel.VoltageInsertionCheckEnabled)
                                { scl.ChannelType = Command.TDAS.SetupChannelLoad.ChannelTypes.Diagnostic; }
                                else
                                { scl.ChannelType = Command.TDAS.SetupChannelLoad.ChannelTypes.HalfBridge; }
                            }
                            else
                            {
                                throw new Exception("TDAS only supports full or half bridge sensors.  " + channel.TypeOfBridge.ToString() + " was requested for " + channel.Description);
                            }

                            scl.EUUnit = channel.EngineeringUnits;
                            switch (channel.Excitation)
                            {
                                case ExcitationVoltageOptions.ExcitationVoltageOption.Undefined:
                                    scl.ExcitationSetting = 0D;
                                    break;
                                case ExcitationVoltageOptions.ExcitationVoltageOption.Volt2:
                                    scl.ExcitationSetting = 2D;
                                    break;
                                case ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
                                    scl.ExcitationSetting = 10D;
                                    break;
                                case ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
                                    scl.ExcitationSetting = 5D;
                                    break;
                                default: throw new Exception("TDAS only supports 2,5,10 excitation values");
                            }
                            scl.FilterOption = channel.BypassAAFilter ? DTS.DASLib.Command.TDAS.SetupChannelLoad.FilterOptions.BypassFilter : DASLib.Command.TDAS.SetupChannelLoad.FilterOptions.Filter;

                            var desiredRange = GetRequestedRange(channel, GetMvPerEu(channel));
                            if (IsG5())
                            {
                                scl.Gain = CalculateMaxRangeAndGain(true,
                                    MaxG5InputRange,
                                    channel.IsProportionalToExcitation,
                                    channel.SensitivityMilliVoltsPerEU,
                                    desiredRange,
                                    scl.ExcitationSetting,
                                    channel.AtCapacity,
                                    channel.CapacityOutputIsBasedOn,
                                    channel.SensitivityUnits);
                            }
                            else
                            {
                                scl.Gain = CalculateMaxRangeAndGain(false,
                                    MaxPROInputRange,
                                    channel.IsProportionalToExcitation,
                                    channel.SensitivityMilliVoltsPerEU,
                                    desiredRange,
                                    scl.ExcitationSetting,
                                    channel.AtCapacity,
                                    channel.CapacityOutputIsBasedOn,
                                    channel.SensitivityUnits);
                            }
                            scl.OffsetOption = channel.RemoveOffset ? DTS.DASLib.Command.TDAS.SetupChannelLoad.OffsetOptions.AutoOffset : DASLib.Command.TDAS.SetupChannelLoad.OffsetOptions.DoNotOffset;
                            scl.Sensitivity = channel.SensitivityMilliVoltsPerEU;
                            scl.SensitivityUnit = DTS.DASLib.Command.TDAS.SetupChannelLoad.SensitivityUnits.Volts;
                            if (channel.ShuntIsEnabled) { scl.ShuntMode = DTS.DASLib.Command.TDAS.SetupChannelLoad.ShuntModes.EmulateShunt; }
                            else { scl.ShuntMode = DTS.DASLib.Command.TDAS.SetupChannelLoad.ShuntModes.None; }
                            if (channel.ShuntIsEnabled && string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))
                            {
                                if (scl.ShuntPosition > 0 && scl.ShuntPosition < 9) // internal shunt positions are 1 thru 7, and external shunt is position 8.
                                {
                                    scl.ShuntMode = DTS.DASLib.Command.TDAS.SetupChannelLoad.ShuntModes.ShuntResistance;
                                }
                                else { scl.ShuntMode = DTS.DASLib.Command.TDAS.SetupChannelLoad.ShuntModes.EmulateShunt; }
                            }

                            if (channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Disabled && (channel.SerialNumber.Length > 0 || channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm))
                            {
                                //only send to the unit if there is a sensor on the channel...
                                try
                                {
                                    if (!IsG5() && this is TDAS<EthernetConnection> && string.Equals(ConfigData.Description, "calstation2", StringComparison.OrdinalIgnoreCase))
                                    {
                                        if (firstRackModule == i)    // Send same config to all SIM's in Rack!
                                        {
                                            var sclb = new DTS.DASLib.Command.TDAS.SetupChannelLoadBroadcast(this, i, false);
                                            sclb.Channel = scl.Channel;
                                            sclb.ChannelNumber = scl.ChannelNumber;
                                            sclb.ChannelType = scl.ChannelType;
                                            sclb.EUUnit = scl.EUUnit;
                                            sclb.ExcitationSetting = scl.ExcitationSetting;
                                            sclb.FilterOption = scl.FilterOption;
                                            sclb.Gain = scl.Gain;
                                            sclb.Location = scl.Location;
                                            sclb.OffsetOption = scl.OffsetOption;
                                            sclb.Sensitivity = scl.Sensitivity;
                                            sclb.SensitivityUnit = scl.SensitivityUnit;
                                            sclb.ShuntEUValue = scl.ShuntEUValue;
                                            sclb.ShuntMode = scl.ShuntMode;
                                            sclb.ShuntPosition = scl.ShuntPosition;

                                            sclb.SyncExecute();
                                            channel.ShuntTargetADC = sclb.TargetADC;
                                        }
                                    }
                                    //SCL will cause offsets to be removed or applied, calling SCL after diagnostics has been run has 
                                    //implications
                                    else if (!DiagnosticsHasBeenRun)
                                    {
                                        scl.SyncExecute();
                                        channel.ShuntTargetADC = scl.TargetADC;
                                    }
                                }
                                catch (System.Exception ex)
                                {
                                    throw new System.Exception(string.Format("Could not set channel configuration: {0} - {1} - {2}", SerialNumber, ConfigData.Modules[i].SerialNumber(), ex.Message));
                                }
                            }
                        }
                        else if (null != squib)
                        {
                            tConfig.SetChannel(squib);
                            if (squib.MeasurementType == SquibMeasurementType.CURRENT) { continue; }
                            if (squib.IsConfigured() || squib.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm)
                            {

                                Command.TDAS.SetupSquibLoad ssl = new DTS.DASLib.Command.TDAS.SetupSquibLoad(this);
                                ssl.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;
                                ssl.ChannelNumber = 1 + (z / 2);
                                //20k cutoff based on http://fogbugz/fogbugz/default.asp?6090
                                ssl.BypassCurrentFilter = ConfigData.Modules[i].SampleRateHz > 20000 ? true : false;
                                ssl.DelayMS = squib.DelayMS;
                                if (squib.LimitDuration)
                                {
                                    ssl.DurationMS = squib.DurationMS;
                                }
                                else
                                {
                                    ssl.DurationMS = 0;
                                    ssl.DurationMS = MaxSquibDurationMS;
                                }
                                switch (squib.FireMode)
                                {
                                    case SquibFireMode.CAP:
                                        ssl.FireMode = DTS.DASLib.Command.TDAS.SetupSquibLoad.FireModes.CapacitorDischarge;
                                        break;
                                    case SquibFireMode.CONSTANT:
                                        ssl.FireMode = DTS.DASLib.Command.TDAS.SetupSquibLoad.FireModes.ConstantCurrent;
                                        ssl.OutputCurrent = squib.SquibOutputCurrent;
                                        break;
                                    case SquibFireMode.AC:
                                    default:
                                        ssl.FireMode = DTS.DASLib.Command.TDAS.SetupSquibLoad.FireModes.AlternatingCurrent;
                                        break;

                                }
                                ssl.Location = "";
                                ssl.MeasurementType = squib.MeasurementType == SquibMeasurementType.INIT_SIGNAL ? Command.TDAS.SetupSquibLoad.MeasurementTypes.Insertion : DTS.DASLib.Command.TDAS.SetupSquibLoad.MeasurementTypes.Voltage;
                                ssl.SquibResistanceMax = squib.SquibToleranceHigh;
                                ssl.SquibResistanceMin = squib.SquibToleranceLow;
                                //20k cutoff based on http://fogbugz/fogbugz/default.asp?6090
                                ssl.BypassVoltageFilter = ConfigData.Modules[i].SampleRateHz > 20000 ? true : false;
                                ssl.SyncExecute();
                            }
                        }
                        else if (null != digital)
                        {
                            tConfig.SetChannel(digital);
                            if (digital.IsConfigured() && info.ConfigureDigitalOutputs)
                            {
                                Command.TDAS.SetupDigitalLoad ssl = new DTS.DASLib.Command.TDAS.SetupDigitalLoad(this);
                                ssl.ChannelNumber = z - 7;
                                ssl.ModuleIndex = ConfigData.Modules[i].ModuleArrayIndex;
                                switch (digital.OutputMode)
                                {
                                    case DigitalOutputModes.CCNC:
                                        ssl.OutputMode = DTS.DASLib.Command.TDAS.SetupDigitalLoad.OutputModes.CCNC;
                                        break;
                                    case DigitalOutputModes.CCNO:
                                        ssl.OutputMode = DTS.DASLib.Command.TDAS.SetupDigitalLoad.OutputModes.CCNO;
                                        break;
                                    case DigitalOutputModes.FVHL:
                                        ssl.OutputMode = DTS.DASLib.Command.TDAS.SetupDigitalLoad.OutputModes.VHL;
                                        break;
                                    case DigitalOutputModes.FVLH:
                                    default:
                                        ssl.OutputMode = DTS.DASLib.Command.TDAS.SetupDigitalLoad.OutputModes.VLH;
                                        break;
                                }
                                ssl.DelayMS = digital.DelayMS;
                                ssl.DurationMS = digital.DurationMS;
                                //ssl.Location = "";
                                ssl.SyncExecute();
                            }

                        }
                        info.Progress(Convert.ToInt32(100 * currentChannel++ / (2 * numChannels)));
                    }
                    using (StreamWriter sw = new StreamWriter(tConfig.FileName))
                    {
                        tConfig.WriteXml(System.Xml.XmlWriter.Create(sw));
                        sw.Flush();
                        sw.Close();
                    }

                    tEntireConfig.SetModule(tConfig);
                }
                info.Progress(100);

                using (StreamWriter sw = new StreamWriter(tEntireConfig.FileName))
                {
                    tEntireConfig.WriteXml(System.Xml.XmlWriter.Create(sw));
                    sw.Flush();
                    sw.Close();
                }

                ConfigurationData.SetConfiguration(this, File.ReadAllText(tEntireConfig.FileName), ConfigurationData.DIAGNOSTIC_FILESTORE);

                ConfigureHasBeenRun = true;
                if (info.DiscardDiagnostics) { DiagnosticsHasBeenRun = false; }
                info.Success();
                ConfigData.ClearSetup = false;
            }
            catch (CanceledException)
            {
                info.Cancel();
            }
            catch (System.Exception ex)
            {
                info.Error(ex.Message, ex);
            }
        }
        private double GetRequestedRange(AnalogInputDASChannel analog, double MvPerEu)
        {
            if (null != analog.LinearizationFormula && analog.LinearizationFormula.IsValid())
            {
                switch(analog.LinearizationFormula.NonLinearStyle)
                {
                    case NonLinearStyles.Polynomial:
                        //don't do anything different for polynomial
                        break;
                    default:
                        if (MvPerEu.Equals(1D)) { return GetRequestedRangeFull(); }
                        else { return analog.DesiredRangeWithHeadroomEU* MvPerEu; }
                }
            }
            return analog.DesiredRangeWithHeadroomEU;
        }
        private double GetRequestedRangeFull()
        {
            return IsG5() ? MaxG5InputRange : MaxPROInputRange;
        }
        #endregion

        void IConfigurationActions.Reboot(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.Success();
        }

        #region Update sensor IDs

        /// <summary>
        /// Retrieve the info to fill in the ConfigData property
        /// </summary>
        /// <param name="callback">The delegate to report to</param>
        /// <param name="userData">User supplied data that we pass along</param>
        void IConfigurationActions.UpdateIDs(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.UpdateIDs", new WaitCallback(AsyncUpdateIDs), info);
        }

        private class UpdateIDSInfo : TDASServiceAsyncInfo
        {
            public DASModule Module { get; set; }
            public DASChannel Channel { get; set; }
            public UpdateIDSInfo(ServiceCallback callback, object userData, DASModule module, DASChannel channel)
                : base(callback, userData)
            {
                Module = module;
                Channel = channel;
            }
        }
        void IConfigurationActions.UpdateId(ServiceCallback callback, object userData, DASModule module, DASChannel channel)
        {
            //var info = new UpdateIDSInfo(callback, userData, module, channel);
            //LaunchAsyncWorker("TDAS.UpdateId", new WaitCallback(AsyncUpdateId), info);
            //I don't know if it's possible to retrieve a single channel id yet, so for now just do the UpdateIds
            var info = new TDASServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("TDAS.UpdateIDs", new WaitCallback(AsyncUpdateIDs), info);
        }

        private void AsyncUpdateIDs(object configAsyncInfo)
        {
            var info = configAsyncInfo as TDASServiceAsyncInfo;

            if (ConfigData == null)
            {
                info.Error("DAS doesn't have any ConfigData");
                return;
            }
            try
            {
                // get sensor ID's
                if (ConfigData.Modules != null)
                {
                    if (IsG5())
                    {
                        GetEIDSG5();
                    }
                    else
                    {
                        GetEIDsByModules();
                    }

                }

                info.Success();
            }
            catch (CanceledException)
            {
                info.Cancel();
            }
            catch (System.Exception ex)
            {
                info.Error(ex.Message, ex);
            }
        }

        
        /// <summary>
        /// retrieves all non AUX EIDs on a G5 and populates channels with those EIDs
        /// </summary>
        private void GetEIDSG5()
        {
            if (RunTestVariables.BypassEIDRead)
            {
                RunTestVariables.BlankIds(ConfigData);
                return;
            }
            var EIDs = EIDReader.RetrieveEIDsG5(this);
            var eidIDX = 0;
            for (var moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
            {
                var module = ConfigData.Modules[moduleIdx];
                for (var channelIdx = 0; channelIdx < module.Channels.Length; channelIdx++)
                {
                    var eid = new EID[] { new EID() };
                    if (eidIDX < EIDs.Length)
                    {
                        eid = EIDs[eidIDX++];
                    }
                    module.Channels[channelIdx].IDs = eid;
                }
            }
        }
        /// <summary>
        /// goes module by module and populate channel EIDs  G5 should use G5 version.
        /// </summary>
        private void GetEIDsByModules()
        {
            if (RunTestVariables.BypassEIDRead)
            {
                RunTestVariables.BlankIds(ConfigData);
                return;
            }
            foreach (var module in ConfigData.Modules)
            {
                if (DASInfo.Modules[module.ModuleArrayIndex].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
                EID[] ids = EIDReader.RetriveEIDs(this, module.ModuleArrayIndex);
                if (null != ids && ids.Length > 0)
                {
                    for (int i = 0; i < module.Channels.Length; i++)
                    {
                        if (null != ids && i < ids.Length)
                        {
                            int channelIdx = i;
                            if (IsTom((DASModule)module)) { channelIdx = i * 2; }
                            if (ids[i].IsValid())
                            {
                                module.Channels[channelIdx].IDs = new EID[] { ids[i] };
                            }
                            else
                            {
                                module.Channels[channelIdx].IDs = new EID[] { new EID() };
                            }
                        }
                        else
                        {
                            module.Channels[i].IDs = new EID[] { new EID() };
                        }
                    }
                }
            }
        }

        #endregion
        #region Arm attribute helpers
        /*
        private void SetArmAttribute(AttributeTypes.ArmAndEventAttributes key, object value, bool ShouldOverwrite)
        {
            var set = new SetArmAttribute(this);
            set.SetValue(key, value, ShouldOverwrite);
            set.SyncExecute();
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key,
            Test.Module.RecordingMode value)
        {
            SetArmAttribute(key, (byte)value, true);
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, UInt32 value)
        {
            SetArmAttribute(key, value, true);
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, float value)
        {
            SetArmAttribute(key, value, true);
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, string value)
        {
            SetArmAttribute(key, value, true);
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, UInt64 value)
        {
            SetArmAttribute(key, value, true);
        }
        */
        /*
        private void SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key,
                                    object value)
        {
            var set = new SetArmAttribute(this);
            set.SetValue(key, value, true);
            set.SyncExecute();
        }         
        */
        /*
        private void GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, out Test.Module.RecordingMode value)
        {
            var query = new QueryArmAttribute(this);
            query.Key = key;
            query.SyncExecute();
            if ((AttributeTypes.AttributeDataTypes)query.DataType != AttributeTypes.AttributeDataTypes.UInt8)
                throw new System.Exception("ConfigurationService.GetArmAttribute.RecordingMode: Found type " + (AttributeTypes.AttributeDataTypes)query.DataType);
            value = (Test.Module.RecordingMode)query.Value;
        }
        */
        /*
        private void GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, out UInt32 value)
        {
            var query = new QueryArmAttribute(this);
            query.Key = key;
            query.SyncExecute();
            if ((AttributeTypes.AttributeDataTypes)query.DataType != AttributeTypes.AttributeDataTypes.UInt32)
                throw new System.Exception("ConfigurationService.GetArmAttribute.UInt32: Found type " + (AttributeTypes.AttributeDataTypes)query.DataType);
            value = (UInt32)query.Value;
        }
        */
        /*
        private void GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, out float value)
        {
            var query = new QueryArmAttribute(this);
            query.Key = key;
            query.SyncExecute();
            if ((AttributeTypes.AttributeDataTypes)query.DataType != AttributeTypes.AttributeDataTypes.Float32)
                throw new System.Exception("ConfigurationService.GetArmAttribute.float: Found type " + (AttributeTypes.AttributeDataTypes)query.DataType);
            value = (float)query.Value;
        }
        */
        /*
        private void GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, out string value)
        {
            var query = new QueryArmAttribute(this);
            query.Key = key;
            query.SyncExecute();
            if ((AttributeTypes.AttributeDataTypes)query.DataType != AttributeTypes.AttributeDataTypes.Ascii)
                throw new System.Exception("ConfigurationService.GetArmAttribute.string: Found type " + (AttributeTypes.AttributeDataTypes)query.DataType);
            value = (string)query.Value;
        }
        */
        /*
        private void GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes key, out UInt64 value)
        {
            var query = new QueryArmAttribute(this);
            query.Key = key;
            query.SyncExecute();
            if ((AttributeTypes.AttributeDataTypes)query.DataType != AttributeTypes.AttributeDataTypes.UInt64)
                throw new System.Exception("ConfigurationService.GetArmAttribute.UInt64: Found type " + (AttributeTypes.AttributeDataTypes)query.DataType);
            value = (UInt64)query.Value;
        }
        */
        #endregion

        #region XML attributes

        /*
        private void StoreAttributes(string data, SliceServiceAsyncInfo info, double ProgressSteps)
        {
            // first calc how many we need
            var NumBlocks = data.Length / DTS.Slice.Service.Attribute.MaxSingleAttributeSize;
            if ((data.Length % DTS.Slice.Service.Attribute.MaxSingleAttributeSize) != 0)
                NumBlocks++;

            // write the blocks
            // for progress, assume that we'll have about 40 blocks to write
            var blockWeight = 40.0 / (double)NumBlocks;
            for (int BlockIdx = 0; BlockIdx < NumBlocks; BlockIdx++)
            {
                int blockLength = data.Length - (BlockIdx * DTS.Slice.Service.Attribute.MaxSingleAttributeSize);
                if (blockLength > DTS.Slice.Service.Attribute.MaxSingleAttributeSize)
                    blockLength = DTS.Slice.Service.Attribute.MaxSingleAttributeSize;
                string block = data.Substring(BlockIdx * DTS.Slice.Service.Attribute.MaxSingleAttributeSize, blockLength);
                var AttrSet = new SetArmAttribute(this);
                AttrSet.SetValue((AttributeTypes.ArmAndEventAttributes)(DTS.Slice.Service.Attribute.BulkAttributeStartNumber + BlockIdx),
                    block, AttributeTypes.AttributeDataTypes.Ascii, true);
                AttrSet.SyncExecute();
                info.Progress((int)((12.0 + blockWeight * (double)BlockIdx) / ProgressSteps * 100.0));
            }

            // write our speacial header attribute
            StringBuilder BlockList = new StringBuilder(DTS.Slice.Service.Attribute.BulkAttributeStartNumber.ToString(),
                                                        DTS.Slice.Service.Attribute.MaxSingleAttributeSize);
            for (int BlockIdx = 1; BlockIdx < NumBlocks; BlockIdx++)
                BlockList.Append("," + (DTS.Slice.Service.Attribute.BulkAttributeStartNumber + BlockIdx).ToString());
            var HeaderAttrSet = new SetArmAttribute(this);
            HeaderAttrSet.SetValue(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.StoredConfigIndex,
                BlockList.ToString(), AttributeTypes.AttributeDataTypes.Ascii, true);
            HeaderAttrSet.SyncExecute();
        }
        */
        /*
        private string RetrieveAttributes()
        {
            // first get our special header attribute
            var AttrGet = new QueryArmAttribute(this);
            AttrGet.Key = DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.StoredConfigIndex;
            AttrGet.SyncExecute();

            // make sure we have something
            //if(AttrGet.Value == null || AttrGet.Value.Length == 0)
            //{
            //    // "Slice.RetrieveAttributes: Header attribute is empty"
            //    throw new Exception(Strings.Slice_RetrieveAttributes_Err1);
            //}

            // parse the result
            //System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            var BlockListStr = AttrGet.Value as string;

            // still there?
            if (string.IsNullOrEmpty(BlockListStr))
            {
                // "Slice.RetrieveAttributes: Header attribute as string is empty"
                throw new System.Exception(Strings.Slice_RetrieveAttributes_Err2);
            }

            var BlockListStrArr = BlockListStr.Split(',');
            var BlockList = new List<int>();
            foreach (string NumStr in BlockListStrArr)
            {
                int Number = 0;
                if (!int.TryParse(NumStr, out Number))
                {
                    // "Slice.RetrieveAttributes: Header attribute is invalid"
                    throw new System.Exception(Strings.Slice_RetrieveAttributes_Err3);
                }
                BlockList.Add(Number);
            }
            StringBuilder AllStrings = new StringBuilder(BlockList.Count * DTS.Slice.Service.Attribute.MaxSingleAttributeSize);
            foreach (int AttrNumber in BlockList)
            {
                AttrGet.Key = (AttributeTypes.ArmAndEventAttributes)AttrNumber;
                AttrGet.SyncExecute();
                var str = AttrGet.Value as string;
                AllStrings.Append(str);
            }
            var WholeStr = AllStrings.ToString();
            if (string.IsNullOrEmpty(WholeStr))
            {
                // "Slice.RetrieveAttributes: Attributes are empty"
                throw new System.Exception(Strings.Slice_RetrieveAttributes_Err4);
            }
            return WholeStr;
        }
        */
        #endregion



        #region Attributes
        /*
        private UInt32 SampleRate
        {
            get
            {
                UInt32 Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.SampleRate, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.SampleRate, value);
            }
        }
        */
        /*
        private float AAFilter
        {
            get
            {
                float Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.AAFilterFrequency, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.AAFilterFrequency, value);
            }
        }
        */
        /*
        private string TestID
        {
            get
            {
                string Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.Name, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.Name, value);
            }
        }
        */
        /*
        private string TestDescription
        {
            get
            {
                string Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.Description, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.Description, value);
            }
        }
        */
        /*private uint SliceCount
        {
            get
            {
                var CountAttr = new SliceCountAttribute();
                CountAttr.ReadFromRecorder(this);
                return CountAttr.Value;
            }
            set
            {
                var CountAttr = new SliceCountAttribute();
                if(value == 0)
                {
                    CountAttr.Value = 1;
                }
                else
                {
                    CountAttr.Value = (byte)value;
                }
                CountAttr.SaveToRecorder(this);
            }
        }*/
        /*
        private UInt64 PreTriggerSamples
        {
            get
            {
                UInt64 Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.PreTriggerSamplesRequested, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.PreTriggerSamplesRequested, value);
            }
        }
        */
        /*
        private ulong PostTriggerSamples
        {
            get
            {
                UInt64 Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.PostTriggerSamplesRequested, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.PostTriggerSamplesRequested, value);
            }
        }
        */
        /*
        private Test.Module.RecordingMode TestType
        {
            get
            {
                Test.Module.RecordingMode Value;
                GetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.ArmMode, out Value);
                return Value;
            }
            set
            {
                SetArmAttribute(DTS.DASLib.Command.SLICE.AttributeTypes.ArmAndEventAttributes.ArmMode, value);
            }
        }
        */
        #endregion

        #region EID functions

        #endregion
    }
}