using System;
using System.Collections.Generic;
using System.Linq;
using DTS.Common.Enums.DASFactory;
using DTS.Common.ICommunication;
using DTS.Common.Utilities;

namespace DTS.DASLib.Command.SLICE
{
    public abstract class DiagnosticsCommands : CommandBase
    {
        protected enum Commands
        {
            Reserved = 0x00,
            QueryDiagnosticMeasurementChannel = 0x01,
            QueryChannelShuntResults = 0x02,
            QueryChannelOffset = 0x03,
            QueryBridgeResistance = 0x04,
            QueryChannelNoiseStatistic = 0x05,
            // Doesn't exist -- what should it do?
            QueryRecorderHealth = 0x06,
            SetChannelOffset = 0x07,
            DiagnosShuntDACs = 0x08,
            QueryChannelCalSignalResults = 0x09,
            //Commands_CalibrateCalSignalDAC = 0x0A // Not implemented
            CalibrateCALSignalDAC = 0x0A,
            QueryVoltageInsertaionResult_SLICE2 = 0x0B,
            SetChannelDiagnosticVoltageInsertion_SLICE2 = 0x0C,
            QueryStackChannelDiagnosticVoltageInsert_SLICE2 = 0x0D,

            SetStackChannelExcitationLevel_SLICE2 = 0x0E,
            QueryStackChannelExcitationLevel_SLICE2 = 0x0F,

            // being default to 0 when prepareForDiagnostic is called.
            SetAutoArmStackChannelDiagnosticLevel_SLICE2 = 0x10, // protocol 137.
            QueryAutoArmStackChannelDiagnosticLevel_SLICE2 = 0x11, // protocol 137.
            SetRearmStackChannelDiagnosticLevel_SLICE2 = 0x12, // protocol 137.
            QueryRearmStackChannelDiagnosticLevel_SLICE2 = 0x13, // protocol 137.
            SetSliceDefaultMIF_SLICE2 = 0x14, // protocol 140
            RunAutoArmDiagnostics = 0x15, // protocol ??
            RunAutoReArmDiagnostics = 0x16,
            SetPostEventChannelDiagnosticLevel = 0x17, // protocol 143.
            QueryPostEventChannelDiagnosticLevel = 0x18, // protocol 143.
            QuerySquibChannelConfiguration = 0x19, // for TOM CMDCAL_QUERY_SQUIB_CHANNEL_CONFIGURATION 
            SetSquibChannelConfiguraion = 0x1A, // for TOM CMDCAL_SET_SQUIB_CHANNEL_CONFIGURATION 
            QueryDigitalChannelConfiguration = 0x1B, // for TOM digital output. CMDCAL_QUERY_DIGITAL_CHANNEL_CONFIGURATION
            SetDigitalChannelConfiguration = 0x1C, // for TOM digital output. CMDCAL_SET_DIGITAL_CHANNEL_CONFIGURATION
            QuerySquibResistance = 0x1D, // protocol ?? CMDCAL_QUERY_SQUIB_RESISTANCE
            QueryInternalChannelOffset = 0x1E,  // protocol 148 CMDCAL_QUERY_INTERNAL_CHANNEL_OFFSET
            QueryAllDiagnosticMeasurementChannel = 0x1F, //for Power Pro query all diagnostic measurement
        };

        protected abstract Commands _Command { get; }

        protected DiagnosticsCommands(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Type = CommandPacket.CommandType.Diagnostics;
            command.SetCommand((byte)_Command, _Command.ToString());
        }

        protected DiagnosticsCommands(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Type = CommandPacket.CommandType.Diagnostics;
            command.SetCommand((byte)_Command, _Command.ToString());
        }
    }

    public class MeasureS6DBDiagnosticChannel : MeasureDiagnosticChannel
    {


        public MeasureS6DBDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureS6DBDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
        /// <summary>
        /// The measurement channel within the BASE
        /// </summary>
        public S6DBDiagnosticChannelList Channel
        {
            get => (S6DBDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"Channel: {Channel}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {Channel}, Measurement: {Measurement}"
            });
        }
    }
    public class MeasureSPDBDiagnosticChannel : MeasureDiagnosticChannel
    {
        public enum BaseDiagnosticChannelList
        {
            InputVoltage = 0x00,
            BackupVoltage = 0x01,
            TemperatureC = 0x02,

            //These are the rest of the DB diag channels
            DIAGNOSTICS_CHANNEL__BATTERY1_C = 100,                    // 0
            DIAGNOSTICS_CHANNEL__BATTERY1_V = 101,                    // 1
            DIAGNOSTICS_CHANNEL__BATTERY2_C = 102,                    // 2
            DIAGNOSTICS_CHANNEL__BATTERY2_V = 103,                    // 3
            DIAGNOSTICS_CHANNEL__OUTPUT1_C = 104,                     // 4
            DIAGNOSTICS_CHANNEL__OUTPUT1_V = 105,                     // 5
            DIAGNOSTICS_CHANNEL__OUTPUT2_C = 106,                     // 6
            DIAGNOSTICS_CHANNEL__OUTPUT2_V = 107,                     // 7
            DIAGNOSTICS_CHANNEL__OUTPUT3_C = 108,                     // 8
            DIAGNOSTICS_CHANNEL__OUTPUT3_V = 109,                     // 9
            DIAGNOSTICS_CHANNEL__OUTPUT4_C = 110,                     // 10
            DIAGNOSTICS_CHANNEL__OUTPUT4_V = 111,                     // 11
            DIAGNOSTICS_CHANNEL__OUTPUT5_C = 112,                     // 12
            DIAGNOSTICS_CHANNEL__OUTPUT5_V = 113,                     // 13
            DIAGNOSTICS_CHANNEL__OUTPUT6_C = 114,                     // 14
            DIAGNOSTICS_CHANNEL__OUTPUT6_V = 115,                     // 15
            DIAGNOSTICS_CHANNEL__OUTPUT7_C = 116,                     // 16
            DIAGNOSTICS_CHANNEL__OUTPUT7_V = 117,                     // 17
            DIAGNOSTICS_CHANNEL__OUTPUT8_C = 118,                     // 18
            DIAGNOSTICS_CHANNEL__OUTPUT8_V = 119,                     // 19
            DIAGNOSTICS_CHANNEL__OUTPUT_B1_C = 120,                   // 20
            DIAGNOSTICS_CHANNEL__OUTPUT_B1_V = 121,                   // 21
            DIAGNOSTICS_CHANNEL__OUTPUT_B2_C = 122,                   // 22
            DIAGNOSTICS_CHANNEL__OUTPUT_B2_V = 123,                   // 23
            DIAGNOSTICS_CHANNEL__INPUT_C = 124,                       // 24
            DIAGNOSTICS_CHANNEL__INPUT_V = 125,                       // 25
            DIAGNOSTICS_CHANNEL__FAN_V = 126,                         // 26
            DIAGNOSTICS_CHANNEL__SBUS_V = 127,                        // 27
            DIAGNOSTICS_CHANNEL__SCAP_V = 128,                        // 28
            DIAGNOSTICS_CHANNEL__TEMPERATURE1 = 129,
            DIAGNOSTICS_CHANNEL__TEMPERATURE2 = 130,
            DIAGNOSTICS_CHANNEL__TEMPERATURE3 = 131,

        };

        public MeasureSPDBDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureSPDBDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
        /// <summary>
        /// The measurement channel within the BASE
        /// </summary>
        public BaseDiagnosticChannelList Channel
        {
            get => (BaseDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"Channel: {Channel}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {Channel}, Measurement: {Measurement}"
            });
        }
    }
    public class MeasureBaseDiagnosticChannel : MeasureDiagnosticChannel
    {
        public enum BaseDiagnosticChannelList
        {
            InputVoltage = 0x00,
            BackupVoltage = 0x01,
            TemperatureC = 0x02,
        };

        public MeasureBaseDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureBaseDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
        /// <summary>
        /// The measurement channel within the BASE
        /// </summary>
        public BaseDiagnosticChannelList Channel
        {
            get => (BaseDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"Channel: {Channel.ToString()}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {Channel}, Measurement: {Measurement}"
            });
        }
    }

    public class MeasurePowerProDiagnosticChannel : MeasureDiagnosticChannel
    {
        public enum PowerProDiagnosticChannelList
        {
            InputVoltage_A = 0x00,
            InputCurrent_A = 0x01,
            InputVoltage_L = 0x02,
            InputCurrent_L = 0x03,
            InputVoltage_C = 0x04,
            InputCurrent_C = 0x05,
            InputCurrent_TOTAL = 0x06,
            OutputVoltage_A = 0x07,
            OutputCurrent_A = 0x08,
            OutputVoltage_L = 0x09,
            OutputCurrent_L = 0x0A,
            OutputVoltage_W = 0x0B,
            OutputCurrent_W = 0x0C,
            OutputVoltage_B = 0x0D,
            OutputCurrent_B = 0x0E,
            BatterySOC = 0x0F,
            BatteryVoltage = 0x10,
            BatteryCurrent = 0x11,
            TemperatureC = 0x12,
        };

        public MeasurePowerProDiagnosticChannel(Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasurePowerProDiagnosticChannel(Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
        /// <summary>
        /// The measurement channel within the BASE
        /// </summary>
        public PowerProDiagnosticChannelList Channel
        {
            get => (PowerProDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { string.Format("Channel: {0}", Channel.ToString()) });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                string.Format("Channel: {0}, Measurement: {1}", Channel, Measurement)
            });
        }
    }

    public class MeasureTomBaseDiagnosticChannel : MeasureDiagnosticChannel
    {

        public enum TomBaseDiagnosticChannelList
        {
            RawInputVoltage = 0x00, // legacy value in SLICE PRO
            BackupVoltage = 0x01, // legacy value in SLICE PRO
            TomTemperatureC = 0x02, // legacy value in SLICE PRO
            BackupCapacity = 0x03,
            Power17V = 0x04,
            Power5V = 0x05,
            Power3p3V = 0x06,
            PowerMinus5V = 0x07
        };

        public MeasureTomBaseDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureTomBaseDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
        /// <summary>
        /// The measurement channel within the BASE
        /// </summary>
        public TomBaseDiagnosticChannelList Channel
        {
            get => (TomBaseDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"Channel: {Channel.ToString()}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {Channel}, Measurement: {Measurement}"
            });
        }
    }

    public class MeasureBridgeDiagnosticChannel : MeasureDiagnosticChannel
    {
        public enum BridgeDiagnosticChannelList
        {
            ExcitationA = 0x0B,
            ThreeVoltFilter = 0x0A,
            FiveVoltAnalog = 0x09,
            SupplyMon = 0x08,
            TwoPointFiveVoltReference = 0x07,
            // Channel 0x06 is actually hooked up to a digital and isn't a valid measurement
            ExcitationB = 0x05,
            ExcitationC = 0x04,
            VeREFPlus = 0x03,
            VeREFMinus = 0x02,
            Temperature = 0x01,
            VccMinusVssOverTwo = 0x00
        };

        public MeasureBridgeDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureBridgeDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        /// <summary>
        /// The measurement channel within the given BRIDGE (specified by the DeviceID property)
        /// </summary>
        public BridgeDiagnosticChannelList Channel
        {
            get => (BridgeDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            lines.Add(new List<string>() { $"Address: {DeviceID}, Channel: {Channel}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {Channel}, Measurement: {Measurement}"
            });
        }
    }
    public class MeasureIEPEDiagnosticChannel : MeasureDiagnosticChannel
    {
        public enum IEPEDiagnosticChannelList
        {
            // Digital Channels are not valid measurements
            // IM_ExcitationA = 0x0B,     // A0 -- DIGITAL
            // IM_ThreeVoltFilter = 0x0A,    // A1 -- DIGITAL
            // IM_FiveVoltAnalog = 0x09,    // A2 -- DIGITAL
            IM_SupplyMon = 0x08,     // A3
            IM_TwoPointFiveVoltReference = 0x07,  // A4 
            // DIGITAL 0x06       // A5 -- DIGITAL
            IM_24VPowerSupply = 0x05,    // A6
            // IM_ExcitationC = 0x04,     // A7 -- DIGITAL
            IM_VeREFPlus = 0x03,
            IM_VeREFMinus = 0x02,
            IM_Temperature = 0x01,
            IM_VccMinusVssOverTwo = 0x00
        }

        public MeasureIEPEDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureIEPEDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        /// <summary>
        /// The measurement channel within the given BRIDGE (specified by the DeviceID property)
        /// </summary>
        public IEPEDiagnosticChannelList DiagnosticField
        {
            get => (IEPEDiagnosticChannelList)_channel;
            set { _channel = (byte)value; command.SetParameter(0, _channel); }
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            lines.Add(new List<string>() { $"Address: {DeviceID}, DiagnosticField: {DiagnosticField}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"DiagnosticField: {DiagnosticField}, Measurement: {Measurement}"
            });
        }
    }
    public abstract class MeasureDiagnosticChannel : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryDiagnosticMeasurementChannel;
        protected byte _channel;

        protected float _value;
        public float Measurement => _value;

        protected MeasureDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Parameter = new byte[1];
        }

        protected MeasureDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Parameter = new byte[1];
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                if (response.Parameter.Length > 1)
                {
                    response.GetParameter(1, out _value);
                }
                else
                {
                    _value = float.NaN;
                }
            }

            return CommandReceiveAction.StopReceiving;
        }
    }

    //
    // output digital channel format
    //
    public class SetDigitalChannelConfiguration : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetDigitalChannelConfiguration;

        public SetDigitalChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Parameter = new byte[10];
        }
        public SetDigitalChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Parameter = new byte[10];
        }

        /// <summary>
        /// channel ID
        /// </summary>
        public byte GetDigitalChannel { get; private set; }
        public void SetDigitalChannelID(byte value)
        {
            GetDigitalChannel = value;
            command.SetParameter(0, GetDigitalChannel);
        }

        /// <summary>
        /// return output mode
        /// </summary>
        public byte GetDigitalOutputMode { get; private set; }
        public void SetDigitalOutputMode(byte value)
        {
            GetDigitalOutputMode = value;
            command.SetParameter(1, GetDigitalOutputMode);
        }


        /// <summary>
        /// Delay in msec.
        /// </summary>
        public float GetDigitalDelayMs { get; private set; }
        public void SetDigitalDelayMs(float value)
        {
            GetDigitalDelayMs = value;
            command.SetParameter(2, GetDigitalDelayMs);
        }

        /// <summary>
        /// output duraiton in msec.
        /// </summary>
        public float GetDigitalDurationMs { get; private set; }
        public void SetDigitalDurationMs(float value)
        {
            GetDigitalDurationMs = value;
            command.SetParameter(6, GetDigitalDurationMs);
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status != DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                throw new Exception(MakeLogString("Can't set digital channel configuration"));
            }
            return CommandReceiveAction.StopReceiving;
        }
    }
    public class QueryDigitalChannelConfiguration : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryDigitalChannelConfiguration;

        public QueryDigitalChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Parameter = new byte[] { 0x01 };
        }

        public QueryDigitalChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Parameter = new byte[] { 0x01 };
        }

        private byte _outputMode;
        private float _outputDelayMs;
        private float _outputDurationMs;

        /// <summary>
        /// channel ID
        /// </summary>
        public byte DigitalChannelGet { get; private set; }
        public void SetDigitalChannelID(byte value)
        {
            DigitalChannelGet = value;
            command.SetParameter(0, DigitalChannelGet);
        }

        /// <summary>
        /// return output mode
        /// </summary>
        public byte DigitalOutputMode { get { return _outputMode; } }

        /// <summary>
        /// Delay in msec.
        /// </summary>
        public float DigitalDelayMs { get { return _outputDelayMs; } }

        /// <summary>
        /// output duraiton in msec.
        /// </summary>
        public float DigitalDurationMs { get { return _outputDurationMs; } }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                response.GetParameter(1, out _outputMode);
                response.GetParameter(2, out _outputDelayMs);
                response.GetParameter(6, out _outputDurationMs);
            }
            return CommandReceiveAction.StopReceiving;
        }
    }

    // 0	     Squib Channel ID	uint8_t	1	Channel ID from 0-3.
    // 1	     Output Mode	     uint8_t	1	Fire Mode
    //                                           0 = Disable.
    //                                           1 = Cap Discharge.
    //                                           2 = Constant Current.
    //                                           3 = Cap Discharge to dummy load.
    //                                           4 = Constant Current to dummy load.
    // 2	     Measurement Type	uint8_t	1	Signal type for recording.
    //                                           1 = Squib Voltage.
    //                                           2 = Initiation Signal
    // 3-6	Output Delay        float32_t	4	Output delay in msec. Ranges 0.0-msec to 167,700.0-msec with 0.1msec resolution.
    // 7-10	Output Duration     float32_t	4	Output active duration ranges from 0.0-msec to 2,600.00msec with 0.1msec resolution.
    //                                           Value 0 will keep the output active as long as trigger active (for entire post-event duration).
    // 11-14	Resistance Low      float32_t	4	SQUIB resistance LOW threshold 0.0 to 10.0 Ohm.
    // 15-18	Resistance High     float32_t	4	SQUIB resistance HIGH threshold 0.0 to 10.0 Ohm.
    // 19-22	Output Current	     float32_t	4	SQUIB output current 0.0 to 4.0 Amp
    public class SetSquibChannelConfiguraion : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetSquibChannelConfiguraion;

        public SetSquibChannelConfiguraion(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Parameter = new byte[23];
        }
        public SetSquibChannelConfiguraion(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Parameter = new byte[23];
        }
        private const int CHANNELID_PARM_OFFSET = 0;
        private const int FIREMODE_PARM_OFFSET = 1;
        private const int MEASURETYPE_PARM_OFFSET = 2;
        private const int OUTPUT_DELAY_PARM_OFFSET = 3;
        private const int OUTPUT_DUR_PARAM_OFFSET = 7;
        private const int RES_LOW_PARM_OFFSET = 11;
        private const int RES_HI_PARM_OFFSET = 15;
        private const int OUTPUT_I_PARM_OFFSET = 19;

        /// <summary>
        /// channel ID
        /// </summary>
        public byte GetSquibChannel { get; private set; }
        public void SetSquibChannelID(byte value)
        {
            GetSquibChannel = value;
            command.SetParameter(CHANNELID_PARM_OFFSET, GetSquibChannel);
        }

        /// <summary>
        /// return output mode
        /// </summary>
        public byte GetSquibOutputMode { get; private set; }
        public void SetSquibOutputMode(byte value)
        {
            GetSquibOutputMode = value;
            command.SetParameter(FIREMODE_PARM_OFFSET, GetSquibOutputMode);
        }

        /// <summary>
        /// return record mode.
        /// </summary>
        public byte GetSquibRecordMode { get; private set; }
        public void SetSquibRecordMode(byte value)
        {
            GetSquibRecordMode = value;
            command.SetParameter(MEASURETYPE_PARM_OFFSET, GetSquibRecordMode);
        }

        /// <summary>
        /// Delay in msec.
        /// </summary>
        public float GetSquibDelayMs { get; private set; }
        public void SetSquibDelayMs(float value)
        {
            GetSquibDelayMs = value;
            command.SetParameter(OUTPUT_DELAY_PARM_OFFSET, GetSquibDelayMs);
        }

        /// <summary>
        /// output duraiton in msec.
        /// </summary>
        public float GetSquibDurationMs { get; private set; }
        public void SetSquibDurationMs(float value)
        {
            GetSquibDurationMs = value;
            command.SetParameter(OUTPUT_DUR_PARAM_OFFSET, GetSquibDurationMs);
        }

        /// <summary>
        /// resistance low limit.
        /// </summary>
        public float GetSquibResMin { get; private set; }
        public void SetSquibResMin(float value)
        {
            GetSquibResMin = value;
            command.SetParameter(RES_LOW_PARM_OFFSET, GetSquibResMin);
        }

        /// <summary>
        /// resistance high limit.
        /// </summary>
        public float GetSquibResMax { get; private set; }
        public void SetSquibResMax(float value)
        {
            GetSquibResMax = value;
            command.SetParameter(RES_HI_PARM_OFFSET, GetSquibResMax);
        }

        /// <summary>
        /// output current value
        /// </summary>
        public float GetSquibOutputCurrentAmp { get; private set; }
        public void SetSquibOutputCurrentAmp(float value)
        {
            GetSquibOutputCurrentAmp = value;
            command.SetParameter(OUTPUT_I_PARM_OFFSET, GetSquibOutputCurrentAmp);
        }


        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
            }
            else
            {
                throw new Exception(MakeLogString($"Can't set squib: {response.Status}"));
            }
            return CommandReceiveAction.StopReceiving;
        }

        /*
         * private const int CHANNELID_PARM_OFFSET     = 0;
        private const int FIREMODE_PARM_OFFSET      = 1;
        private const int MEASURETYPE_PARM_OFFSET   = 2;
        private const int OUTPUT_DELAY_PARM_OFFSET  = 3;
        private const int OUTPUT_DUR_PARAM_OFFSET   = 7;
        private const int RES_LOW_PARM_OFFSET       = 11;
        private const int RES_HI_PARM_OFFSET        = 15;
        private const int OUTPUT_I_PARM_OFFSET      = 19;
         */

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {GetSquibChannel}, Firemode: {GetSquibOutputMode}, MeasurementType: {GetSquibRecordMode}, Delay: {GetSquibDelayMs}, Duration: {GetSquibDurationMs}, OutputCurrent: {GetSquibOutputCurrentAmp}, ResistanceLow: {GetSquibResMin}, ResistanceHigh: {GetSquibResMax}"
            });
        }
    }


    public class QuerySquibChannelConfiguration : DiagnosticsCommands
    {
        public QuerySquibChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            command.Parameter = new byte[] { 0x01 };
        }

        public QuerySquibChannelConfiguration(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            command.Parameter = new byte[] { 0x01 };
        }
        protected override Commands _Command => Commands.QuerySquibChannelConfiguration;

        private byte _outputMode;
        private byte _recordType;
        private float _outputDelayMs;
        private float _outputDurationMs;
        private float _squibResLowLimit;
        private float _squibResHiLimit;
        private float _squibOutputCurrent;

        /// <summary>
        /// channel ID
        /// </summary>
        public byte SquibChannelGet { get; private set; }
        public void SetSquibChannelID(byte value)
        {
            SquibChannelGet = value;
            command.SetParameter(0, SquibChannelGet);
        }

        /// <summary>
        /// return output mode
        /// </summary>
        public byte SquibOutputMode => _outputMode;

        /// <summary>
        /// return record mode.
        /// </summary>
        public byte SquibRecordMode => _recordType;

        /// <summary>
        /// Delay in msec.
        /// </summary>
        public float SquibDelayMs => _outputDelayMs;

        /// <summary>
        /// output duraiton in msec.
        /// </summary>
        public float SquibDurationMs => _outputDurationMs;

        /// <summary>
        /// resistance low limit.
        /// </summary>
        public float SquibResMin => _squibResLowLimit;

        /// <summary>
        /// resistance high limit.
        /// </summary>
        public float SquibResMax => _squibResHiLimit;

        /// <summary>
        /// output current value
        /// </summary>
        public float SquibOutputCurrentAmp => _squibOutputCurrent;


        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                response.GetParameter(1, out _outputMode);
                response.GetParameter(2, out _recordType);
                response.GetParameter(3, out _outputDelayMs);
                response.GetParameter(7, out _outputDurationMs);
                response.GetParameter(11, out _squibResLowLimit);
                response.GetParameter(15, out _squibResHiLimit);
                response.GetParameter(19, out _squibOutputCurrent);
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {SquibChannelGet}"
            });
        }
        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Channel: {SquibChannelGet}, Firemode: {SquibOutputMode}, MeasurementType: {SquibRecordMode}, Delay: {SquibDelayMs}, Duration: {SquibDurationMs}, OutputCurrent {SquibOutputCurrentAmp}"
            });
        }
    }
    public class QueryChannelShuntResults : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryChannelShuntResults;

        private byte[] _channelList;

        /// <summary>
        /// Wipes out the ChannelList, TargetDeflectionMV and ActualDeflectionMV 
        /// arrays and sets the number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
            ActualDeflectionMV = new float[NumberOfStackChannels];
            TargetDeflectionMV = new float[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        /// <summary>
        /// The millivolt value that the channel targeted.
        /// </summary>
        public float[] TargetDeflectionMV { get; private set; }

        /// <summary>
        /// The millivolt value that the channel deflected to with the target deflection applied.
        /// </summary>
        public float[] ActualDeflectionMV { get; private set; }

        public QueryChannelShuntResults(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public QueryChannelShuntResults(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                TargetDeflectionMV = new float[NumberOfStackChannels];
                ActualDeflectionMV = new float[NumberOfStackChannels];

                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    response.GetParameter(8 * i, out TargetDeflectionMV[i]);
                    response.GetParameter(8 * i + 4, out ActualDeflectionMV[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}"
            });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Target Deflection (mv): {ArrayToString.ArrayObjectToString(TargetDeflectionMV)}, Actual Deflection (mv): {ArrayToString.ArrayObjectToString(ActualDeflectionMV)}"
            });
        }
    }
    public class QueryChannelCalSignalResults : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryChannelCalSignalResults;

        private byte[] _channelList;

        /// <summary>
        /// Wipes out the ChannelList, TargetDeflectionMV and ActualDeflectionMV 
        /// arrays and sets the number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
            ActualMV = new float[NumberOfStackChannels];
            TargetMV = new float[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        /// <summary>
        /// The millivolt value that the channel targeted.
        /// </summary>
        public float[] TargetMV { get; private set; }

        /// <summary>
        /// The millivolt value that the channel deflected to with the target deflection applied.
        /// </summary>
        public float[] ActualMV { get; private set; }

        public QueryChannelCalSignalResults(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public QueryChannelCalSignalResults(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                TargetMV = new float[NumberOfStackChannels];
                ActualMV = new float[NumberOfStackChannels];

                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    response.GetParameter(8 * i, out TargetMV[i]);
                    response.GetParameter(8 * i + 4, out ActualMV[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}"
            });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Target (mv): {ArrayToString.ArrayObjectToString(TargetMV)}, Actual (mv): {ArrayToString.ArrayObjectToString(ActualMV)}"
            });
        }
    }
    public class OffsetChannel : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetChannelOffset;

        private byte[] _channelList;
        private short[] _zeroTarget;
        private ushort[] _targetTolerance;

        /// <summary>
        /// Wipes out the ChannelList, ZeroTarget and TargetTolerance arrays and sets the
        /// number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[5 * NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
            _zeroTarget = new short[NumberOfStackChannels];
            _targetTolerance = new ushort[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        /// <summary>
        /// The list of zero targets (as signed 16-bit a/d counts) for the stack channels being offset.  Each channel will try to adjust
        /// its output to match the corresponding value in this array.
        /// </summary>
        public short[] ZeroTarget
        {
            get => _zeroTarget;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via ZeroTarget");
                }

                _zeroTarget = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(NumberOfStackChannels + 2 * i, _zeroTarget[i]);
                }
            }
        }

        /// <summary>
        /// The list of tolerances (as unsigned 16-bit a/d counts) for each stack channel.  The channels will
        /// stop trying to zero themselves when they get within +/- this value of the corresponding ZeroTarget.
        /// </summary>
        public ushort[] TargetTolerance
        {
            get => _targetTolerance;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    NumberOfStackChannels = value.Length;
                    //throw new ApplicationException("NumberOfChannels must be set before ChannelList, ZeroTarget, or TargetTolerance");
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via TargetTolerance");
                }

                _targetTolerance = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(3 * NumberOfStackChannels + 2 * i, _targetTolerance[i]);
                }
            }
        }

        /// <summary>
        /// The value (in signed 16-bit a/d counts) that the channel zeroed to.
        /// </summary>
        public short[] FinalZero { get; private set; }

        /// <summary>
        /// The difference (in signed 16-bit a/d counts) between the FinalZero and the ZeroTarget.  A positive
        /// value indicates that the channel settled above the ZeroTarget, a negative value indicates that it
        /// settled below.
        /// </summary>
        public short[] FinalZeroError { get; private set; }

        public OffsetChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public OffsetChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                FinalZero = new short[NumberOfStackChannels];
                FinalZeroError = new short[NumberOfStackChannels];

                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    response.GetParameter(2 * i, out FinalZero[i]);
                    FinalZeroError[i] = (short)(FinalZero[i] - _zeroTarget[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>(){string.Format("StackChannels: {0}, ZeroTargets: {1}, TargetTolerances: {2}",
                ArrayToString.ArrayObjectToString(StackChannelList),
                ArrayToString.ArrayObjectToString(ZeroTarget),
                ArrayToString.ArrayObjectToString(TargetTolerance))});
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>() { $"FinalZero: {ArrayToString.ArrayObjectToString(FinalZero)}, ZeroError: {ArrayToString.ArrayObjectToString(FinalZeroError)}" });
        }
    }

    public class MeasureStackChannelOffset : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryChannelOffset;

        private byte _numChannels;
        private byte[] _channelList;

        public byte NumberOfChannels
        {
            get => _numChannels;
            set
            {
                _numChannels = value;
                // Wipe out the existing parameters ...
                command.Parameter = new byte[_numChannels];
                _channelList = new byte[_numChannels];
            }
        }

        public byte[] ChannelList
        {
            get => _channelList;
            set
            {
                _channelList = value;
                if (_numChannels != _channelList.Length)
                {
                    _numChannels = (byte)_channelList.Length;
                    command.Parameter = new byte[_numChannels];
                }

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        public float[] MeasuredOffset { get; private set; }

        public MeasureStackChannelOffset(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureStackChannelOffset(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                MeasuredOffset = new float[_numChannels];

                for (int i = 0; i < _numChannels; i++)
                {
                    response.GetParameter(_numChannels + 4 * i, out MeasuredOffset[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"StackChannels: {ArrayToString.ArrayObjectToString(ChannelList)}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Measured Offset (mv): {ArrayToString.ArrayObjectToString (MeasuredOffset)}"
            });
        }
    }

    public class MeasureStackInternalChannelOffset : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryInternalChannelOffset;

        private byte _numChannels;
        private byte[] _channelList;

        public byte NumberOfChannels
        {
            get => _numChannels;
            set
            {
                _numChannels = value;
                // Wipe out the existing parameters ...
                command.Parameter = new byte[_numChannels];
                _channelList = new byte[_numChannels];
            }
        }

        public byte[] ChannelList
        {
            get => _channelList;
            set
            {
                _channelList = value;
                if (_numChannels != _channelList.Length)
                {
                    _numChannels = (byte)_channelList.Length;
                    command.Parameter = new byte[_numChannels];
                }

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        public float[] MeasuredInternalOffset { get; private set; }

        public MeasureStackInternalChannelOffset(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureStackInternalChannelOffset(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                MeasuredInternalOffset = new float[_numChannels];

                for (int i = 0; i < _numChannels; i++)
                {
                    response.GetParameter(_numChannels + 4 * i, out MeasuredInternalOffset[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"StackChannels: {ArrayToString.ArrayObjectToString(ChannelList)}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Measured Internal Offset (mv): {ArrayToString.ArrayObjectToString (MeasuredInternalOffset)}"
            });
        }
    }

    public class MeasureSquibChannelResistances : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QuerySquibResistance;
        public MeasureSquibChannelResistances(DTS.Common.Interface.DASFactory.ICommunication sock) : base(sock)
        {
            command.Parameter = new byte[4] { 0, 1, 2, 3 };
            for (int i = 0; i < 4; i++) { MeasuredResistanceOhms[i] = float.NaN; }
        }
        public MeasureSquibChannelResistances(DTS.Common.Interface.DASFactory.ICommunication sock, int timeoutMS) : base(sock, timeoutMS)
        {
            command.Parameter = new byte[4] { 0, 1, 2, 3 };
            for (int i = 0; i < 4; i++) { MeasuredResistanceOhms[i] = float.NaN; }
        }

        public float[] MeasuredResistanceOhms { get; } = new float[4];
        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                for (int i = 0; i < 4; i++)
                {
                    response.GetParameter(i * 4, out float f);
                    MeasuredResistanceOhms[i] = f;
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Measured Resistance (ohms): {ArrayToString.ArrayObjectToString (MeasuredResistanceOhms)}"
            });
        }

    }

    public class MeasureStackChannelBridgeResistance : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryBridgeResistance;

        private byte _numChannels;
        private byte[] _channelList;

        public byte NumberOfChannels
        {
            get => _numChannels;
            set
            {
                _numChannels = value;
                // Wipe out the existing parameters ...
                command.Parameter = new byte[_numChannels];
                _channelList = new byte[_numChannels];
            }
        }

        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                _channelList = value;
                if (_numChannels != _channelList.Length)
                {
                    _numChannels = (byte)_channelList.Length;
                    command.Parameter = new byte[_numChannels];
                }

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        public float[] MeasuredBridgeResistanceOhms { get; private set; }

        public MeasureStackChannelBridgeResistance(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureStackChannelBridgeResistance(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                MeasuredBridgeResistanceOhms = new float[_numChannels];

                for (int i = 0; i < _numChannels; i++)
                {
                    // Firmware returns bridge resistance as u16s, we want it as floats
                    response.GetParameter(2 * i, out ushort ohms);
                    MeasuredBridgeResistanceOhms[i] = ohms;
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Measured Resistance (ohms): {ArrayToString.ArrayObjectToString (MeasuredBridgeResistanceOhms)}"
            });
        }
    }

    // QuerySquibResistance
    public class QuerySquibResistance : DiagnosticsCommands
    {
        protected override DiagnosticsCommands.Commands _Command
        {
            get { return Commands.QuerySquibResistance; }
        }

        private byte _numChannels;
        private byte[] _channelList;
        private float[] _measuredSquibResistanceOhms;

        public byte NumberOfChannels
        {
            get => _numChannels;
            set
            {
                _numChannels = value;
                // Wipe out the existing parameters ...
                command.Parameter = new byte[_numChannels];
                _channelList = new byte[_numChannels];
            }
        }

        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                _channelList = value;
                if (_numChannels != _channelList.Length)
                {
                    _numChannels = (byte)_channelList.Length;
                    command.Parameter = new byte[_numChannels];
                }

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        public float[] MeasuredSquibResistanceOhms { get { return _measuredSquibResistanceOhms; } }

        public QuerySquibResistance(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public QuerySquibResistance(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                _measuredSquibResistanceOhms = new float[_numChannels];

                for (int i = 0; i < _numChannels; i++)
                {
                    // Firmware returns bridge resistance as u16s, we want it as floats
                    float ohms;
                    response.GetParameter(4 * i, out ohms);
                    _measuredSquibResistanceOhms[i] = ohms;
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>(){string.Format("StackChannels: {0}",
                ArrayToString.ArrayObjectToString (StackChannelList))});
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                string.Format("Measured Resistance (ohms): {0}",
                    ArrayToString.ArrayObjectToString (MeasuredSquibResistanceOhms))
            });
        }
    }

    public class MeasureChannelNoiseStatistic : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryChannelNoiseStatistic;
        private byte _numChannels;
        private byte[] _channelList;
        private bool[] _usegainofone;

        public byte[] ChannelList
        {
            get => _channelList;
            set
            {
                if (value.Length != _numChannels)
                {
                    _channelList = new byte[value.Length];
                    _usegainofone = new bool[value.Length];
                    _numChannels = (byte)value.Length;
                    command.Parameter = new byte[2 * _numChannels];
                }

                _channelList = value;

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(i, value[i]);
                }
            }
        }
        public bool[] UseGainOfOne
        {
            get => _usegainofone;
            set
            {
                if (value.Length != _numChannels)
                {
                    _channelList = new byte[value.Length];
                    _usegainofone = new bool[value.Length];
                    _numChannels = (byte)value.Length;
                    command.Parameter = new byte[2 * _numChannels];
                }

                _usegainofone = value;

                for (int i = 0; i < _numChannels; i++)
                {
                    command.SetParameter(_numChannels + i, value[i]);
                }
            }
        }

        public float[] StandardDeviation { get; private set; }

        public MeasureChannelNoiseStatistic(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public MeasureChannelNoiseStatistic(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }

        protected override CommandReceiveAction WholePackage()
        {
            StandardDeviation = new float[_numChannels];
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                if (response.ParameterLength != sizeof(ushort) * _numChannels + _numChannels)
                {
                    throw new ApplicationException("MeasureChannelNoiseStatistic: Error getting standard deviation values for all channels requested: length is " + response.ParameterLength.ToString());
                }

                var _ustddev = new ushort[_numChannels];
                for (int i = 0; i < _numChannels; i++)
                {
                    response.GetParameter(_numChannels + i * sizeof(ushort), out _ustddev[i]);
                    StandardDeviation[i] = _ustddev[i];
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"Stack channels: {ArrayToString.ArrayObjectToString(ChannelList)}, Use G=1: {ArrayToString.ArrayObjectToString(UseGainOfOne)}" });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                string.Format("Stack channels: {0}, Use G=1: {1}, Standard deviation: {2}",
                    ArrayToString.ArrayObjectToString(ChannelList),
                    ArrayToString.ArrayObjectToString(UseGainOfOne),
                    ArrayToString.ArrayObjectToString(StandardDeviation))
            });
        }
    }

    public class DiagnosShuntDACs : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.DiagnosShuntDACs;

        private byte[] _channelList;

        /// <summary>
        /// Wipes out the ChannelList, TargetDeflectionMV and ActualDeflectionMV 
        /// arrays and sets the number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        public DiagnosShuntDACs(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.DiangosShuntDAC);
        }

        public DiagnosShuntDACs(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.DiangosShuntDAC);
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>() { $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}" });
        }
    }

    public class QueryVoltageInsertaionResult_SLICE2 : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.QueryVoltageInsertaionResult_SLICE2;

        private byte[] _channelList;

        /// <summary>
        /// Wipes out the ChannelList, TargetDeflectionMV and ActualDeflectionMV 
        /// arrays and sets the number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
            ActualGain = new float[NumberOfStackChannels];
            ExpectedGain = new float[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        /// <summary>
        /// The millivolt value that the channel targeted.
        /// </summary>
        public float[] ExpectedGain { get; private set; }

        /// <summary>
        /// The millivolt value that the channel deflected to with the target deflection applied.
        /// </summary>
        public float[] ActualGain { get; private set; }

        public QueryVoltageInsertaionResult_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.VoltageInsertion);
        }

        public QueryVoltageInsertaionResult_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.VoltageInsertion);
        }

        protected override CommandReceiveAction WholePackage()
        {
            if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
            {
                ExpectedGain = new float[NumberOfStackChannels];
                ActualGain = new float[NumberOfStackChannels];

                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    response.GetParameter(8 * i, out ExpectedGain[i]);
                    response.GetParameter(8 * i + 4, out ActualGain[i]);
                }
            }
            return CommandReceiveAction.StopReceiving;
        }

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}"
            });
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);
            lines.Add(new List<string>()
            {
                $"Expected Gain: {ArrayToString.ArrayObjectToString(ExpectedGain)}, Actual Gain: {ArrayToString.ArrayObjectToString(ActualGain)}"
            });
        }
    }

    public class SetChannelDiagnosticVoltageInsertion_SLICE2 : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetChannelDiagnosticVoltageInsertion_SLICE2;

        private byte[] _channelList;

        /// <summary>
        /// Wipes out the ChannelList, TargetDeflectionMV and ActualDeflectionMV 
        /// arrays and sets the number of stack channels to value.
        /// </summary>
        /// <param name="value"></param>
        private void SetNumberOfStackChannels(int value)
        {
            NumberOfStackChannels = value;
            // Wipe out the existing parameters ...
            command.Parameter = new byte[NumberOfStackChannels];
            _channelList = new byte[NumberOfStackChannels];
            ActualGain = new float[NumberOfStackChannels];
            ExpectedGain = new float[NumberOfStackChannels];
        }

        /// <summary>
        /// Read-only property to retrieve the number of stack channels being offset.
        /// </summary>
        public int NumberOfStackChannels { get; private set; } = 0;

        /// <summary>
        /// The list of stack channels to offset.
        /// </summary>
        public byte[] StackChannelList
        {
            get => _channelList;
            set
            {
                if (0 == NumberOfStackChannels)
                {
                    SetNumberOfStackChannels(value.Length);
                }
                else if (value.Length != NumberOfStackChannels)
                {
                    throw new ApplicationException("Inconsistent channel count set via StackChannelList");
                }

                _channelList = value;
                for (int i = 0; i < NumberOfStackChannels; i++)
                {
                    command.SetParameter(i, _channelList[i]);
                }
            }
        }

        /// <summary>
        /// The millivolt value that the channel targeted.
        /// </summary>
        public float[] ExpectedGain { get; private set; }

        /// <summary>
        /// The millivolt value that the channel deflected to with the target deflection applied.
        /// </summary>
        public float[] ActualGain { get; private set; }

        public SetChannelDiagnosticVoltageInsertion_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            //per CPB, tie this to diagnostics mode, not voltage insertion for this call
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticsMode);
        }

        public SetChannelDiagnosticVoltageInsertion_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            //per CPB tie this  to diagnostics mode, not voltage insertion for this call
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticsMode);
        }

        protected override CommandReceiveAction WholePackage() => CommandReceiveAction.StopReceiving;

        public override void CommandToString(ref List<List<string>> lines)
        {
            base.CommandToString(ref lines);
            lines.Add(new List<string>()
            {
                $"StackChannels: {ArrayToString.ArrayObjectToString(StackChannelList)}"
            });
        }

        public override void ResponseToString(ref List<List<string>> lines) => base.ResponseToString(ref lines);
    }
    public class SetSliceDefaultMIF_SLICE2 : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetSliceDefaultMIF_SLICE2;


        public SetSliceDefaultMIF_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            MinimumProtocolVersion = 129; //  sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF);
        }

        public SetSliceDefaultMIF_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF);
        }
    }

    public class SetSliceDefaultMIF_SLICE6 : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.SetSliceDefaultMIF_SLICE2;


        public SetSliceDefaultMIF_SLICE6(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            MinimumProtocolVersion = 0; //  sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF);
        }

        public SetSliceDefaultMIF_SLICE6(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF);
        }
    }

    public class RunAutoArmDiagnostics : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.RunAutoArmDiagnostics;

        public RunAutoArmDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public RunAutoArmDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
    }

    public class RunAutoReArmDiagnostics : DiagnosticsCommands
    {
        protected override Commands _Command => Commands.RunAutoReArmDiagnostics;

        public RunAutoReArmDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
        }

        public RunAutoReArmDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
        }
    }

    public class MeasurePowerProAllDiagnosticChannel : DiagnosticsCommands
    {
        private byte _numberOfchannel;
        public float[] Value { get; } = new float[32];
        public System.Collections.BitArray ChannelFlags
        {
            get
            {
                return new System.Collections.BitArray(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus]));
            }
        }

        public class ChannelStatus
        {
            public ChannelStatus(byte statusByte)
            {
                var flags = new System.Collections.BitArray(statusByte);
                Fault = flags[(int)StatusList.FaultStatus];
                Protection = flags[(int)StatusList.ProtectionStatus];
                CurrentOutOfRange = flags[(int)StatusList.CurrentOutOfRange];
                VoltageOutOfRange = flags[(int)StatusList.VoltageOutOfRange];
            }
            public bool Fault { get; set; }
            public bool Protection { get; set; }
            public bool CurrentOutOfRange { get; set; }
            public bool VoltageOutOfRange { get; set; }
        }

        public ChannelStatus InputAmphenolChannelStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.InputAmphenol]);
            }
        }

        public ChannelStatus InputLemoChannelStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.InputLemo]);
            }
        }

        public ChannelStatus InputLemoWETCHARGERStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.InputWETCHARGER]);
            }
        }

        public ChannelStatus OutputAmphenolStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.OutputAmphenol]);
            }
        }

        public ChannelStatus OutputLemoStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.OutputLemo]);
            }
        }

        public ChannelStatus OutputWETStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.OutputWET]);
            }
        }

        public ChannelStatus OutputBatteryStatus
        {
            get
            {
                return new ChannelStatus(BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus])[(int)ChannelsList.OutputBattery]);
            }
        }

        public bool TemperatureOutOfOperationRangeStaus
        {
            get
            {
                return ChannelFlags[(int)ChannelStatusList.TemperatureOutOfOperationRange];
            }
        }

        public bool DtsStatusInput
        {
            get
            {
                return ChannelFlags[(int)ChannelStatusList.DtsStatus];
            }
        }
        public bool DtsStartInput
        {
            get
            {
                return ChannelFlags[(int)ChannelStatusList.DtsStart];
            }
        }
        public bool DtsEventInput
        {
            get
            {
                return ChannelFlags[(int)ChannelStatusList.DtsEvent];
            }
        }

        public enum ChannelsList
        {
            InputAmphenol,
            InputLemo,
            InputWETCHARGER,
            OutputAmphenol,
            OutputLemo,
            OutputWET,
            OutputBattery,
        }

        public enum StatusList
        {
            FaultStatus,
            ProtectionStatus,
            CurrentOutOfRange,
            VoltageOutOfRange,
        }

        public enum ChannelStatusList
        {
            InputAmphenolfault,
            InputAmphenolprotection,
            InputAmphenolcurrentoutofrange,
            InputAmphenolvoltageoutofrange,

            InputLemofault,
            InputLemoprotection,
            InputLemoCurrentOutOfRange,
            InputLemoVoltageOutOfRange,

            InputWETCHARGERfault,
            InputWETCHARGERProtection,
            InputWETCHARGERcurrentOutOfRange,
            InputWETCHARGERVoltageOutOfRange,

            OutputAmphenolFault,
            OutputAmphenolProtection,
            OutputAmphenolCurrentOutOfRange,
            OutputAmphenolVoltageOutOfRange,

            OutputLemoFault,
            OutputLemoProtection,
            OutputLemoCurrentOutOfRange,
            OutputLemoVoltageOutOfRange,

            OutputWETFault,
            OutputWETProtection,
            OutputWETCurrentOutOfRange,
            OutputWETVoltageOutOfRange,

            OutputBatteryFault,
            OutputBatteryProtection,
            OutputBatteryCurrentOutOfRange,
            OutputBatteryVoltageOutOfRange,

            TemperatureOutOfOperationRange,
            DtsStatus,
            DtsStart,
            DtsEvent,
        }

        public float InputAmphenolVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputVoltage_A];
            }
        }

        public float InputAmphenolCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputCurrent_A];
            }
        }

        public float InputLemoVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputVoltage_L];
            }
        }

        public float InputLemoCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputCurrent_L];
            }
        }

        public float InputChargerVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputVoltage_C];
            }
        }

        public float InputChargerCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputCurrent_C];
            }
        }

        public float InputCurrentTotal
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.InputCurrent_TOTAL];
            }
        }

        public float OutputAmphenolVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputVoltage_A];
            }
        }

        public float OutputAmphenolCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputCurrent_A];
            }
        }

        public float OutputLemoVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputVoltage_L];
            }
        }

        public float OutputLemoCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputCurrent_L];
            }
        }

        public float OutputWETVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputVoltage_W];
            }
        }

        public float OutputWETCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputCurrent_W];
            }
        }

        public float OutputBatteryVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputVoltage_B];
            }
        }

        public float OutputBatteryCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.OutputCurrent_B];
            }
        }

        public float BatterySOC
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatterySOC];
            }
        }

        public float BatteryVoltage
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatteryVoltage];
            }
        }

        public float BatteryCurrent
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatteryCurrent];
            }
        }

        public float TemperatureC
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.TemperatureC];
            }
        }

        public float BatteryChipTemperatureC
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatteryChipTemperatureC];
            }
        }
        public float BatteryThermistor1TemperatureC
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatteryThermistor1TemperatureC];
            }
        }
        public float BatteryThermistor2TemperatureC
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.BatteryThermistor2TemperatureC];
            }
        }
        public float ChargerPowerW
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.ChargerPowerW];
            }
        }
        public float ChargerInputCurrentA
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.ChargerInputCurrentA];
            }
        }
        public float DischargeCurrentA
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.DischargeCurrentA];
            }
        }
        public float CalculateTotalOUT_CURRENT_A
        {
            get
            {
                return Value[(int)PowerProDiagnosticChannelList.CalculateTotalOUT_CURRENT_A];
            }
        }
        public enum PowerProDiagnosticChannelList
        {
            InputVoltage_A = 0x00,
            InputCurrent_A = 0x01,
            InputVoltage_L = 0x02,
            InputCurrent_L = 0x03,
            InputVoltage_C = 0x04,
            InputCurrent_C = 0x05,
            InputCurrent_TOTAL = 0x06,
            OutputVoltage_A = 0x07,
            OutputCurrent_A = 0x08,
            OutputVoltage_L = 0x09,
            OutputCurrent_L = 0x0A,
            OutputVoltage_W = 0x0B,
            OutputCurrent_W = 0x0C,
            OutputVoltage_B = 0x0D,
            OutputCurrent_B = 0x0E,
            BatterySOC = 0x0F,
            BatteryVoltage = 0x10,
            BatteryCurrent = 0x11,
            TemperatureC = 0x12,
            BatteryChipTemperatureC = 0x13,   // 19
            BatteryThermistor1TemperatureC = 0x14,   // 20
            BatteryThermistor2TemperatureC = 0x15,   // 21
            ChargerPowerW = 0x16,   // 22
            ChargerInputCurrentA = 0x17,   // 23
            DischargeCurrentA = 0x18,   // 24
            CalculateTotalOUT_CURRENT_A = 0x19,   // 25
            ChannelStatus = 0x1A,   // 26
        };

        protected override DiagnosticsCommands.Commands _Command
        {
            get { return Commands.QueryAllDiagnosticMeasurementChannel; }
        }

        public MeasurePowerProAllDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock)
            : base(sock)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel);
        }

        public MeasurePowerProAllDiagnosticChannel(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
            : base(sock, TimeoutMillisec)
        {
            MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel);
        }
        protected override CommandReceiveAction WholePackage()
        {
            int offset = 1;
            // we have a whole package
            if (response.Status != DFConstantsAndEnums.CommandStatus.StatusNoError) return CommandReceiveAction.StopReceiving;

            response.GetParameter(0, out _numberOfchannel);
            for (int i = 0; i < _numberOfchannel; i++)
            {
                response.GetParameter(offset, out Value[i]);
                offset += 4;
            }

            return CommandReceiveAction.StopReceiving;
        }

        public override void ResponseToString(ref List<List<string>> lines)
        {
            base.ResponseToString(ref lines);

            var sb = new System.Text.StringBuilder();
            BitConverter.GetBytes(Value[(int)PowerProDiagnosticChannelList.ChannelStatus]).ToList().ForEach(x => sb.Append($"{x.ToString("X")} "));
            lines.Add(new List<string>()
            {
                $"StatusBytes: {sb.ToString()}, InputCurrentTotal: {InputCurrentTotal}, ",

                $"InputAmphenolVoltage: {InputAmphenolVoltage}, InputAmphenolCurrent: {InputLemoCurrent}, ",
                $"InputLemoVoltage: {InputLemoVoltage}, InputLemoCurrent: {InputLemoCurrent}, ",
                $"InputChargerVoltage: {InputChargerVoltage}, InputChargerCurrent: {InputChargerCurrent}, ",

                $"OutputAmphenolVoltage: {OutputAmphenolVoltage}, OutputAmphenolCurrent: {OutputLemoCurrent}, ",
                $"OutputLemoVoltage: {OutputLemoVoltage}, OutputLemoCurrent: {OutputLemoCurrent}, ",
                $"OutputWETVoltage: {OutputWETVoltage}, OutputWETCurrent: {OutputWETCurrent}, ",
                $"OutputBatteryVoltage: {OutputBatteryVoltage}, OutputBatteryCurrent: {OutputBatteryCurrent}, ",

                $"BatterySOC: {BatterySOC}, BatteryVoltage: {BatteryVoltage}, BatteryCurrent: {BatteryCurrent}, ",

                $"TemperatureC: {TemperatureC}, BatteryChipTemperatureC: {BatteryChipTemperatureC}, ",
                $"BatteryThermistor1TemperatureC: {BatteryThermistor1TemperatureC}, BatteryThermistor2TemperatureC: {BatteryThermistor2TemperatureC}, ",

                $"ChargerPowerW: {ChargerPowerW}, ChargerInputCurrentA: {ChargerInputCurrentA}, ",

                $"DischargeCurrentA: {DischargeCurrentA}, CalculateTotalOUT_CURRENT_A : {CalculateTotalOUT_CURRENT_A}",
            });
        }
    }
}