// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: BuiltInTestParameters.proto
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Tango.PMR.EmbeddedParameters {

  /// <summary>Holder for reflection information generated from BuiltInTestParameters.proto</summary>
  public static partial class BuiltInTestParametersReflection {

    #region Descriptor
    /// <summary>File descriptor for BuiltInTestParameters.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static BuiltInTestParametersReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "ChtCdWlsdEluVGVzdFBhcmFtZXRlcnMucHJvdG8SHFRhbmdvLlBNUi5FbWJl",
            "ZGRlZFBhcmFtZXRlcnMi+QcKFUJ1aWx0SW5UZXN0UGFyYW1ldGVycxISCgpC",
            "SVRfRW5hYmxlGAEgASgIEhkKEUJsb3dlcnNCaXRfRW5hYmxlGAIgASgIEh4K",
            "FkJsb3dlcnNCaXRBY3Rpdml0eVRpbWUYAyABKA0SGwoTQmxvd2Vyc0JpdEFy",
            "Y0ZhblJwbRgEIAEoDRIiChpCbG93ZXJzQml0V0hTQmxvd2VyVm9sdGFnZRgF",
            "IAEoDRIjChtCbG93ZXJzQml0QXJjSGVhZE1pbmltdW1ScG0YBiABKA0SJAoc",
            "Qmxvd2Vyc0JpdEFyY0hlYWRBY3Rpdml0eVJwbRgHIAEoDRIgChhCbG93ZXJz",
            "Qml0QXJjSGVhZE1pbkZsb3cYCCABKAESJwofQmxvd2Vyc0JpdFdIU0Jsb3dl",
            "ck1pblRvdGFsRmxvdxgJIAEoARIoCiBCbG93ZXJzQml0V0hTQmxvd2VyTWlu",
            "U2luZ2xlRmxvdxgKIAEoARIcChREaXNwZW5zZXJzQml0X0VuYWJsZRgLIAEo",
            "CBIpCiFEaXNwZW5zZXJzQml0TWF4TW90b3JBY3Rpdml0eVRpbWUYDCABKA0S",
            "JwofRGlzcGVuc2Vyc0JpdE1vdG9yQWN0aXZpdHlTcGVlZBgNIAEoDRIlCh1E",
            "aXNwZW5zZXJzQml0UEJVU3RhcnRQcmVzc3VyZRgOIAEoARIjChtEaXNwZW5z",
            "ZXJzQml0UEJVRW5kUHJlc3N1cmUYDyABKAESKAogRGlzcGVuc2Vyc0JpdFBy",
            "ZXNzdXJlTG9zZVRpbWVvdXQYECABKA0SKQohRGlzcGVuc2Vyc0JpdFByZXNz",
            "dXJlTG9zZU1pblZhbHVlGBEgASgBEhkKEUhlYXRlcnNCaXRfRW5hYmxlGBIg",
            "ASgIEiIKGkhlYXRlcnNCaXRDdXJyZW50QnJlYWtUaW1lGBMgASgNEiIKGkhl",
            "YXRlcnNCaXRDdXJyZW50UmFuZ2VUaW1lGBQgASgNEiYKHkhlYXRlcnNCaXRU",
            "ZW1wZXJhdHVyZUNoZWNrVGltZRgVIAEoDRIhChlIZWF0ZXJzQml0RXhwZWN0",
            "ZWRDdXJyZW50GBYgAygBEikKIUhlYXRlcnNCaXRFeHBlY3RlZFRlbXBlcmF0",
            "dXJlRGlmZhgXIAMoARIWCg5GYW5zQml0X0VuYWJsZRgYIAEoCBIYChBNb3Rv",
            "cnNCaXRfRW5hYmxlGBkgASgIEhYKDlJGSURCaXRfRW5hYmxlGBogASgIEhUK",
            "DUkyQ0JpdF9FbmFibGUYGyABKAgSGQoRR2VuZXJhbFBhcmFtZXRlcnMYHCAD",
            "KAESEwoLRmlsZVZlcnNpb24YHSABKA0SEwoLRGVzY3JpcHRpb24YHiABKAlC",
            "KAomY29tLnR3aW5lLnRhbmdvLnBtci5lbWJlZGRlZHBhcmFtZXRlcnNiBnBy",
            "b3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.EmbeddedParameters.BuiltInTestParameters), global::Tango.PMR.EmbeddedParameters.BuiltInTestParameters.Parser, new[]{ "BITEnable", "BlowersBitEnable", "BlowersBitActivityTime", "BlowersBitArcFanRpm", "BlowersBitWHSBlowerVoltage", "BlowersBitArcHeadMinimumRpm", "BlowersBitArcHeadActivityRpm", "BlowersBitArcHeadMinFlow", "BlowersBitWHSBlowerMinTotalFlow", "BlowersBitWHSBlowerMinSingleFlow", "DispensersBitEnable", "DispensersBitMaxMotorActivityTime", "DispensersBitMotorActivitySpeed", "DispensersBitPBUStartPressure", "DispensersBitPBUEndPressure", "DispensersBitPressureLoseTimeout", "DispensersBitPressureLoseMinValue", "HeatersBitEnable", "HeatersBitCurrentBreakTime", "HeatersBitCurrentRangeTime", "HeatersBitTemperatureCheckTime", "HeatersBitExpectedCurrent", "HeatersBitExpectedTemperatureDiff", "FansBitEnable", "MotorsBitEnable", "RFIDBitEnable", "I2CBitEnable", "GeneralParameters", "FileVersion", "Description" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  public sealed partial class BuiltInTestParameters : pb::IMessage<BuiltInTestParameters> {
    private static readonly pb::MessageParser<BuiltInTestParameters> _parser = new pb::MessageParser<BuiltInTestParameters>(() => new BuiltInTestParameters());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<BuiltInTestParameters> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tango.PMR.EmbeddedParameters.BuiltInTestParametersReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BuiltInTestParameters() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BuiltInTestParameters(BuiltInTestParameters other) : this() {
      bITEnable_ = other.bITEnable_;
      blowersBitEnable_ = other.blowersBitEnable_;
      blowersBitActivityTime_ = other.blowersBitActivityTime_;
      blowersBitArcFanRpm_ = other.blowersBitArcFanRpm_;
      blowersBitWHSBlowerVoltage_ = other.blowersBitWHSBlowerVoltage_;
      blowersBitArcHeadMinimumRpm_ = other.blowersBitArcHeadMinimumRpm_;
      blowersBitArcHeadActivityRpm_ = other.blowersBitArcHeadActivityRpm_;
      blowersBitArcHeadMinFlow_ = other.blowersBitArcHeadMinFlow_;
      blowersBitWHSBlowerMinTotalFlow_ = other.blowersBitWHSBlowerMinTotalFlow_;
      blowersBitWHSBlowerMinSingleFlow_ = other.blowersBitWHSBlowerMinSingleFlow_;
      dispensersBitEnable_ = other.dispensersBitEnable_;
      dispensersBitMaxMotorActivityTime_ = other.dispensersBitMaxMotorActivityTime_;
      dispensersBitMotorActivitySpeed_ = other.dispensersBitMotorActivitySpeed_;
      dispensersBitPBUStartPressure_ = other.dispensersBitPBUStartPressure_;
      dispensersBitPBUEndPressure_ = other.dispensersBitPBUEndPressure_;
      dispensersBitPressureLoseTimeout_ = other.dispensersBitPressureLoseTimeout_;
      dispensersBitPressureLoseMinValue_ = other.dispensersBitPressureLoseMinValue_;
      heatersBitEnable_ = other.heatersBitEnable_;
      heatersBitCurrentBreakTime_ = other.heatersBitCurrentBreakTime_;
      heatersBitCurrentRangeTime_ = other.heatersBitCurrentRangeTime_;
      heatersBitTemperatureCheckTime_ = other.heatersBitTemperatureCheckTime_;
      heatersBitExpectedCurrent_ = other.heatersBitExpectedCurrent_.Clone();
      heatersBitExpectedTemperatureDiff_ = other.heatersBitExpectedTemperatureDiff_.Clone();
      fansBitEnable_ = other.fansBitEnable_;
      motorsBitEnable_ = other.motorsBitEnable_;
      rFIDBitEnable_ = other.rFIDBitEnable_;
      i2CBitEnable_ = other.i2CBitEnable_;
      generalParameters_ = other.generalParameters_.Clone();
      fileVersion_ = other.fileVersion_;
      description_ = other.description_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BuiltInTestParameters Clone() {
      return new BuiltInTestParameters(this);
    }

    /// <summary>Field number for the "BIT_Enable" field.</summary>
    public const int BITEnableFieldNumber = 1;
    private bool bITEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool BITEnable {
      get { return bITEnable_; }
      set {
        bITEnable_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBit_Enable" field.</summary>
    public const int BlowersBitEnableFieldNumber = 2;
    private bool blowersBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool BlowersBitEnable {
      get { return blowersBitEnable_; }
      set {
        blowersBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitActivityTime" field.</summary>
    public const int BlowersBitActivityTimeFieldNumber = 3;
    private uint blowersBitActivityTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BlowersBitActivityTime {
      get { return blowersBitActivityTime_; }
      set {
        blowersBitActivityTime_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitArcFanRpm" field.</summary>
    public const int BlowersBitArcFanRpmFieldNumber = 4;
    private uint blowersBitArcFanRpm_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BlowersBitArcFanRpm {
      get { return blowersBitArcFanRpm_; }
      set {
        blowersBitArcFanRpm_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitWHSBlowerVoltage" field.</summary>
    public const int BlowersBitWHSBlowerVoltageFieldNumber = 5;
    private uint blowersBitWHSBlowerVoltage_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BlowersBitWHSBlowerVoltage {
      get { return blowersBitWHSBlowerVoltage_; }
      set {
        blowersBitWHSBlowerVoltage_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitArcHeadMinimumRpm" field.</summary>
    public const int BlowersBitArcHeadMinimumRpmFieldNumber = 6;
    private uint blowersBitArcHeadMinimumRpm_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BlowersBitArcHeadMinimumRpm {
      get { return blowersBitArcHeadMinimumRpm_; }
      set {
        blowersBitArcHeadMinimumRpm_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitArcHeadActivityRpm" field.</summary>
    public const int BlowersBitArcHeadActivityRpmFieldNumber = 7;
    private uint blowersBitArcHeadActivityRpm_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BlowersBitArcHeadActivityRpm {
      get { return blowersBitArcHeadActivityRpm_; }
      set {
        blowersBitArcHeadActivityRpm_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitArcHeadMinFlow" field.</summary>
    public const int BlowersBitArcHeadMinFlowFieldNumber = 8;
    private double blowersBitArcHeadMinFlow_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double BlowersBitArcHeadMinFlow {
      get { return blowersBitArcHeadMinFlow_; }
      set {
        blowersBitArcHeadMinFlow_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitWHSBlowerMinTotalFlow" field.</summary>
    public const int BlowersBitWHSBlowerMinTotalFlowFieldNumber = 9;
    private double blowersBitWHSBlowerMinTotalFlow_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double BlowersBitWHSBlowerMinTotalFlow {
      get { return blowersBitWHSBlowerMinTotalFlow_; }
      set {
        blowersBitWHSBlowerMinTotalFlow_ = value;
      }
    }

    /// <summary>Field number for the "BlowersBitWHSBlowerMinSingleFlow" field.</summary>
    public const int BlowersBitWHSBlowerMinSingleFlowFieldNumber = 10;
    private double blowersBitWHSBlowerMinSingleFlow_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double BlowersBitWHSBlowerMinSingleFlow {
      get { return blowersBitWHSBlowerMinSingleFlow_; }
      set {
        blowersBitWHSBlowerMinSingleFlow_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBit_Enable" field.</summary>
    public const int DispensersBitEnableFieldNumber = 11;
    private bool dispensersBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool DispensersBitEnable {
      get { return dispensersBitEnable_; }
      set {
        dispensersBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitMaxMotorActivityTime" field.</summary>
    public const int DispensersBitMaxMotorActivityTimeFieldNumber = 12;
    private uint dispensersBitMaxMotorActivityTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispensersBitMaxMotorActivityTime {
      get { return dispensersBitMaxMotorActivityTime_; }
      set {
        dispensersBitMaxMotorActivityTime_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitMotorActivitySpeed" field.</summary>
    public const int DispensersBitMotorActivitySpeedFieldNumber = 13;
    private uint dispensersBitMotorActivitySpeed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispensersBitMotorActivitySpeed {
      get { return dispensersBitMotorActivitySpeed_; }
      set {
        dispensersBitMotorActivitySpeed_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitPBUStartPressure" field.</summary>
    public const int DispensersBitPBUStartPressureFieldNumber = 14;
    private double dispensersBitPBUStartPressure_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispensersBitPBUStartPressure {
      get { return dispensersBitPBUStartPressure_; }
      set {
        dispensersBitPBUStartPressure_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitPBUEndPressure" field.</summary>
    public const int DispensersBitPBUEndPressureFieldNumber = 15;
    private double dispensersBitPBUEndPressure_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispensersBitPBUEndPressure {
      get { return dispensersBitPBUEndPressure_; }
      set {
        dispensersBitPBUEndPressure_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitPressureLoseTimeout" field.</summary>
    public const int DispensersBitPressureLoseTimeoutFieldNumber = 16;
    private uint dispensersBitPressureLoseTimeout_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispensersBitPressureLoseTimeout {
      get { return dispensersBitPressureLoseTimeout_; }
      set {
        dispensersBitPressureLoseTimeout_ = value;
      }
    }

    /// <summary>Field number for the "DispensersBitPressureLoseMinValue" field.</summary>
    public const int DispensersBitPressureLoseMinValueFieldNumber = 17;
    private double dispensersBitPressureLoseMinValue_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispensersBitPressureLoseMinValue {
      get { return dispensersBitPressureLoseMinValue_; }
      set {
        dispensersBitPressureLoseMinValue_ = value;
      }
    }

    /// <summary>Field number for the "HeatersBit_Enable" field.</summary>
    public const int HeatersBitEnableFieldNumber = 18;
    private bool heatersBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HeatersBitEnable {
      get { return heatersBitEnable_; }
      set {
        heatersBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "HeatersBitCurrentBreakTime" field.</summary>
    public const int HeatersBitCurrentBreakTimeFieldNumber = 19;
    private uint heatersBitCurrentBreakTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint HeatersBitCurrentBreakTime {
      get { return heatersBitCurrentBreakTime_; }
      set {
        heatersBitCurrentBreakTime_ = value;
      }
    }

    /// <summary>Field number for the "HeatersBitCurrentRangeTime" field.</summary>
    public const int HeatersBitCurrentRangeTimeFieldNumber = 20;
    private uint heatersBitCurrentRangeTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint HeatersBitCurrentRangeTime {
      get { return heatersBitCurrentRangeTime_; }
      set {
        heatersBitCurrentRangeTime_ = value;
      }
    }

    /// <summary>Field number for the "HeatersBitTemperatureCheckTime" field.</summary>
    public const int HeatersBitTemperatureCheckTimeFieldNumber = 21;
    private uint heatersBitTemperatureCheckTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint HeatersBitTemperatureCheckTime {
      get { return heatersBitTemperatureCheckTime_; }
      set {
        heatersBitTemperatureCheckTime_ = value;
      }
    }

    /// <summary>Field number for the "HeatersBitExpectedCurrent" field.</summary>
    public const int HeatersBitExpectedCurrentFieldNumber = 22;
    private static readonly pb::FieldCodec<double> _repeated_heatersBitExpectedCurrent_codec
        = pb::FieldCodec.ForDouble(178);
    private readonly pbc::RepeatedField<double> heatersBitExpectedCurrent_ = new pbc::RepeatedField<double>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<double> HeatersBitExpectedCurrent {
      get { return heatersBitExpectedCurrent_; }
    }

    /// <summary>Field number for the "HeatersBitExpectedTemperatureDiff" field.</summary>
    public const int HeatersBitExpectedTemperatureDiffFieldNumber = 23;
    private static readonly pb::FieldCodec<double> _repeated_heatersBitExpectedTemperatureDiff_codec
        = pb::FieldCodec.ForDouble(186);
    private readonly pbc::RepeatedField<double> heatersBitExpectedTemperatureDiff_ = new pbc::RepeatedField<double>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<double> HeatersBitExpectedTemperatureDiff {
      get { return heatersBitExpectedTemperatureDiff_; }
    }

    /// <summary>Field number for the "FansBit_Enable" field.</summary>
    public const int FansBitEnableFieldNumber = 24;
    private bool fansBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool FansBitEnable {
      get { return fansBitEnable_; }
      set {
        fansBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "MotorsBit_Enable" field.</summary>
    public const int MotorsBitEnableFieldNumber = 25;
    private bool motorsBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool MotorsBitEnable {
      get { return motorsBitEnable_; }
      set {
        motorsBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "RFIDBit_Enable" field.</summary>
    public const int RFIDBitEnableFieldNumber = 26;
    private bool rFIDBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool RFIDBitEnable {
      get { return rFIDBitEnable_; }
      set {
        rFIDBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "I2CBit_Enable" field.</summary>
    public const int I2CBitEnableFieldNumber = 27;
    private bool i2CBitEnable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool I2CBitEnable {
      get { return i2CBitEnable_; }
      set {
        i2CBitEnable_ = value;
      }
    }

    /// <summary>Field number for the "GeneralParameters" field.</summary>
    public const int GeneralParametersFieldNumber = 28;
    private static readonly pb::FieldCodec<double> _repeated_generalParameters_codec
        = pb::FieldCodec.ForDouble(226);
    private readonly pbc::RepeatedField<double> generalParameters_ = new pbc::RepeatedField<double>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<double> GeneralParameters {
      get { return generalParameters_; }
    }

    /// <summary>Field number for the "FileVersion" field.</summary>
    public const int FileVersionFieldNumber = 29;
    private uint fileVersion_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint FileVersion {
      get { return fileVersion_; }
      set {
        fileVersion_ = value;
      }
    }

    /// <summary>Field number for the "Description" field.</summary>
    public const int DescriptionFieldNumber = 30;
    private string description_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Description {
      get { return description_; }
      set {
        description_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as BuiltInTestParameters);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(BuiltInTestParameters other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (BITEnable != other.BITEnable) return false;
      if (BlowersBitEnable != other.BlowersBitEnable) return false;
      if (BlowersBitActivityTime != other.BlowersBitActivityTime) return false;
      if (BlowersBitArcFanRpm != other.BlowersBitArcFanRpm) return false;
      if (BlowersBitWHSBlowerVoltage != other.BlowersBitWHSBlowerVoltage) return false;
      if (BlowersBitArcHeadMinimumRpm != other.BlowersBitArcHeadMinimumRpm) return false;
      if (BlowersBitArcHeadActivityRpm != other.BlowersBitArcHeadActivityRpm) return false;
      if (BlowersBitArcHeadMinFlow != other.BlowersBitArcHeadMinFlow) return false;
      if (BlowersBitWHSBlowerMinTotalFlow != other.BlowersBitWHSBlowerMinTotalFlow) return false;
      if (BlowersBitWHSBlowerMinSingleFlow != other.BlowersBitWHSBlowerMinSingleFlow) return false;
      if (DispensersBitEnable != other.DispensersBitEnable) return false;
      if (DispensersBitMaxMotorActivityTime != other.DispensersBitMaxMotorActivityTime) return false;
      if (DispensersBitMotorActivitySpeed != other.DispensersBitMotorActivitySpeed) return false;
      if (DispensersBitPBUStartPressure != other.DispensersBitPBUStartPressure) return false;
      if (DispensersBitPBUEndPressure != other.DispensersBitPBUEndPressure) return false;
      if (DispensersBitPressureLoseTimeout != other.DispensersBitPressureLoseTimeout) return false;
      if (DispensersBitPressureLoseMinValue != other.DispensersBitPressureLoseMinValue) return false;
      if (HeatersBitEnable != other.HeatersBitEnable) return false;
      if (HeatersBitCurrentBreakTime != other.HeatersBitCurrentBreakTime) return false;
      if (HeatersBitCurrentRangeTime != other.HeatersBitCurrentRangeTime) return false;
      if (HeatersBitTemperatureCheckTime != other.HeatersBitTemperatureCheckTime) return false;
      if(!heatersBitExpectedCurrent_.Equals(other.heatersBitExpectedCurrent_)) return false;
      if(!heatersBitExpectedTemperatureDiff_.Equals(other.heatersBitExpectedTemperatureDiff_)) return false;
      if (FansBitEnable != other.FansBitEnable) return false;
      if (MotorsBitEnable != other.MotorsBitEnable) return false;
      if (RFIDBitEnable != other.RFIDBitEnable) return false;
      if (I2CBitEnable != other.I2CBitEnable) return false;
      if(!generalParameters_.Equals(other.generalParameters_)) return false;
      if (FileVersion != other.FileVersion) return false;
      if (Description != other.Description) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (BITEnable != false) hash ^= BITEnable.GetHashCode();
      if (BlowersBitEnable != false) hash ^= BlowersBitEnable.GetHashCode();
      if (BlowersBitActivityTime != 0) hash ^= BlowersBitActivityTime.GetHashCode();
      if (BlowersBitArcFanRpm != 0) hash ^= BlowersBitArcFanRpm.GetHashCode();
      if (BlowersBitWHSBlowerVoltage != 0) hash ^= BlowersBitWHSBlowerVoltage.GetHashCode();
      if (BlowersBitArcHeadMinimumRpm != 0) hash ^= BlowersBitArcHeadMinimumRpm.GetHashCode();
      if (BlowersBitArcHeadActivityRpm != 0) hash ^= BlowersBitArcHeadActivityRpm.GetHashCode();
      if (BlowersBitArcHeadMinFlow != 0D) hash ^= BlowersBitArcHeadMinFlow.GetHashCode();
      if (BlowersBitWHSBlowerMinTotalFlow != 0D) hash ^= BlowersBitWHSBlowerMinTotalFlow.GetHashCode();
      if (BlowersBitWHSBlowerMinSingleFlow != 0D) hash ^= BlowersBitWHSBlowerMinSingleFlow.GetHashCode();
      if (DispensersBitEnable != false) hash ^= DispensersBitEnable.GetHashCode();
      if (DispensersBitMaxMotorActivityTime != 0) hash ^= DispensersBitMaxMotorActivityTime.GetHashCode();
      if (DispensersBitMotorActivitySpeed != 0) hash ^= DispensersBitMotorActivitySpeed.GetHashCode();
      if (DispensersBitPBUStartPressure != 0D) hash ^= DispensersBitPBUStartPressure.GetHashCode();
      if (DispensersBitPBUEndPressure != 0D) hash ^= DispensersBitPBUEndPressure.GetHashCode();
      if (DispensersBitPressureLoseTimeout != 0) hash ^= DispensersBitPressureLoseTimeout.GetHashCode();
      if (DispensersBitPressureLoseMinValue != 0D) hash ^= DispensersBitPressureLoseMinValue.GetHashCode();
      if (HeatersBitEnable != false) hash ^= HeatersBitEnable.GetHashCode();
      if (HeatersBitCurrentBreakTime != 0) hash ^= HeatersBitCurrentBreakTime.GetHashCode();
      if (HeatersBitCurrentRangeTime != 0) hash ^= HeatersBitCurrentRangeTime.GetHashCode();
      if (HeatersBitTemperatureCheckTime != 0) hash ^= HeatersBitTemperatureCheckTime.GetHashCode();
      hash ^= heatersBitExpectedCurrent_.GetHashCode();
      hash ^= heatersBitExpectedTemperatureDiff_.GetHashCode();
      if (FansBitEnable != false) hash ^= FansBitEnable.GetHashCode();
      if (MotorsBitEnable != false) hash ^= MotorsBitEnable.GetHashCode();
      if (RFIDBitEnable != false) hash ^= RFIDBitEnable.GetHashCode();
      if (I2CBitEnable != false) hash ^= I2CBitEnable.GetHashCode();
      hash ^= generalParameters_.GetHashCode();
      if (FileVersion != 0) hash ^= FileVersion.GetHashCode();
      if (Description.Length != 0) hash ^= Description.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (BITEnable != false) {
        output.WriteRawTag(8);
        output.WriteBool(BITEnable);
      }
      if (BlowersBitEnable != false) {
        output.WriteRawTag(16);
        output.WriteBool(BlowersBitEnable);
      }
      if (BlowersBitActivityTime != 0) {
        output.WriteRawTag(24);
        output.WriteUInt32(BlowersBitActivityTime);
      }
      if (BlowersBitArcFanRpm != 0) {
        output.WriteRawTag(32);
        output.WriteUInt32(BlowersBitArcFanRpm);
      }
      if (BlowersBitWHSBlowerVoltage != 0) {
        output.WriteRawTag(40);
        output.WriteUInt32(BlowersBitWHSBlowerVoltage);
      }
      if (BlowersBitArcHeadMinimumRpm != 0) {
        output.WriteRawTag(48);
        output.WriteUInt32(BlowersBitArcHeadMinimumRpm);
      }
      if (BlowersBitArcHeadActivityRpm != 0) {
        output.WriteRawTag(56);
        output.WriteUInt32(BlowersBitArcHeadActivityRpm);
      }
      if (BlowersBitArcHeadMinFlow != 0D) {
        output.WriteRawTag(65);
        output.WriteDouble(BlowersBitArcHeadMinFlow);
      }
      if (BlowersBitWHSBlowerMinTotalFlow != 0D) {
        output.WriteRawTag(73);
        output.WriteDouble(BlowersBitWHSBlowerMinTotalFlow);
      }
      if (BlowersBitWHSBlowerMinSingleFlow != 0D) {
        output.WriteRawTag(81);
        output.WriteDouble(BlowersBitWHSBlowerMinSingleFlow);
      }
      if (DispensersBitEnable != false) {
        output.WriteRawTag(88);
        output.WriteBool(DispensersBitEnable);
      }
      if (DispensersBitMaxMotorActivityTime != 0) {
        output.WriteRawTag(96);
        output.WriteUInt32(DispensersBitMaxMotorActivityTime);
      }
      if (DispensersBitMotorActivitySpeed != 0) {
        output.WriteRawTag(104);
        output.WriteUInt32(DispensersBitMotorActivitySpeed);
      }
      if (DispensersBitPBUStartPressure != 0D) {
        output.WriteRawTag(113);
        output.WriteDouble(DispensersBitPBUStartPressure);
      }
      if (DispensersBitPBUEndPressure != 0D) {
        output.WriteRawTag(121);
        output.WriteDouble(DispensersBitPBUEndPressure);
      }
      if (DispensersBitPressureLoseTimeout != 0) {
        output.WriteRawTag(128, 1);
        output.WriteUInt32(DispensersBitPressureLoseTimeout);
      }
      if (DispensersBitPressureLoseMinValue != 0D) {
        output.WriteRawTag(137, 1);
        output.WriteDouble(DispensersBitPressureLoseMinValue);
      }
      if (HeatersBitEnable != false) {
        output.WriteRawTag(144, 1);
        output.WriteBool(HeatersBitEnable);
      }
      if (HeatersBitCurrentBreakTime != 0) {
        output.WriteRawTag(152, 1);
        output.WriteUInt32(HeatersBitCurrentBreakTime);
      }
      if (HeatersBitCurrentRangeTime != 0) {
        output.WriteRawTag(160, 1);
        output.WriteUInt32(HeatersBitCurrentRangeTime);
      }
      if (HeatersBitTemperatureCheckTime != 0) {
        output.WriteRawTag(168, 1);
        output.WriteUInt32(HeatersBitTemperatureCheckTime);
      }
      heatersBitExpectedCurrent_.WriteTo(output, _repeated_heatersBitExpectedCurrent_codec);
      heatersBitExpectedTemperatureDiff_.WriteTo(output, _repeated_heatersBitExpectedTemperatureDiff_codec);
      if (FansBitEnable != false) {
        output.WriteRawTag(192, 1);
        output.WriteBool(FansBitEnable);
      }
      if (MotorsBitEnable != false) {
        output.WriteRawTag(200, 1);
        output.WriteBool(MotorsBitEnable);
      }
      if (RFIDBitEnable != false) {
        output.WriteRawTag(208, 1);
        output.WriteBool(RFIDBitEnable);
      }
      if (I2CBitEnable != false) {
        output.WriteRawTag(216, 1);
        output.WriteBool(I2CBitEnable);
      }
      generalParameters_.WriteTo(output, _repeated_generalParameters_codec);
      if (FileVersion != 0) {
        output.WriteRawTag(232, 1);
        output.WriteUInt32(FileVersion);
      }
      if (Description.Length != 0) {
        output.WriteRawTag(242, 1);
        output.WriteString(Description);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (BITEnable != false) {
        size += 1 + 1;
      }
      if (BlowersBitEnable != false) {
        size += 1 + 1;
      }
      if (BlowersBitActivityTime != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BlowersBitActivityTime);
      }
      if (BlowersBitArcFanRpm != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BlowersBitArcFanRpm);
      }
      if (BlowersBitWHSBlowerVoltage != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BlowersBitWHSBlowerVoltage);
      }
      if (BlowersBitArcHeadMinimumRpm != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BlowersBitArcHeadMinimumRpm);
      }
      if (BlowersBitArcHeadActivityRpm != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BlowersBitArcHeadActivityRpm);
      }
      if (BlowersBitArcHeadMinFlow != 0D) {
        size += 1 + 8;
      }
      if (BlowersBitWHSBlowerMinTotalFlow != 0D) {
        size += 1 + 8;
      }
      if (BlowersBitWHSBlowerMinSingleFlow != 0D) {
        size += 1 + 8;
      }
      if (DispensersBitEnable != false) {
        size += 1 + 1;
      }
      if (DispensersBitMaxMotorActivityTime != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispensersBitMaxMotorActivityTime);
      }
      if (DispensersBitMotorActivitySpeed != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispensersBitMotorActivitySpeed);
      }
      if (DispensersBitPBUStartPressure != 0D) {
        size += 1 + 8;
      }
      if (DispensersBitPBUEndPressure != 0D) {
        size += 1 + 8;
      }
      if (DispensersBitPressureLoseTimeout != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(DispensersBitPressureLoseTimeout);
      }
      if (DispensersBitPressureLoseMinValue != 0D) {
        size += 2 + 8;
      }
      if (HeatersBitEnable != false) {
        size += 2 + 1;
      }
      if (HeatersBitCurrentBreakTime != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(HeatersBitCurrentBreakTime);
      }
      if (HeatersBitCurrentRangeTime != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(HeatersBitCurrentRangeTime);
      }
      if (HeatersBitTemperatureCheckTime != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(HeatersBitTemperatureCheckTime);
      }
      size += heatersBitExpectedCurrent_.CalculateSize(_repeated_heatersBitExpectedCurrent_codec);
      size += heatersBitExpectedTemperatureDiff_.CalculateSize(_repeated_heatersBitExpectedTemperatureDiff_codec);
      if (FansBitEnable != false) {
        size += 2 + 1;
      }
      if (MotorsBitEnable != false) {
        size += 2 + 1;
      }
      if (RFIDBitEnable != false) {
        size += 2 + 1;
      }
      if (I2CBitEnable != false) {
        size += 2 + 1;
      }
      size += generalParameters_.CalculateSize(_repeated_generalParameters_codec);
      if (FileVersion != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(FileVersion);
      }
      if (Description.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Description);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(BuiltInTestParameters other) {
      if (other == null) {
        return;
      }
      if (other.BITEnable != false) {
        BITEnable = other.BITEnable;
      }
      if (other.BlowersBitEnable != false) {
        BlowersBitEnable = other.BlowersBitEnable;
      }
      if (other.BlowersBitActivityTime != 0) {
        BlowersBitActivityTime = other.BlowersBitActivityTime;
      }
      if (other.BlowersBitArcFanRpm != 0) {
        BlowersBitArcFanRpm = other.BlowersBitArcFanRpm;
      }
      if (other.BlowersBitWHSBlowerVoltage != 0) {
        BlowersBitWHSBlowerVoltage = other.BlowersBitWHSBlowerVoltage;
      }
      if (other.BlowersBitArcHeadMinimumRpm != 0) {
        BlowersBitArcHeadMinimumRpm = other.BlowersBitArcHeadMinimumRpm;
      }
      if (other.BlowersBitArcHeadActivityRpm != 0) {
        BlowersBitArcHeadActivityRpm = other.BlowersBitArcHeadActivityRpm;
      }
      if (other.BlowersBitArcHeadMinFlow != 0D) {
        BlowersBitArcHeadMinFlow = other.BlowersBitArcHeadMinFlow;
      }
      if (other.BlowersBitWHSBlowerMinTotalFlow != 0D) {
        BlowersBitWHSBlowerMinTotalFlow = other.BlowersBitWHSBlowerMinTotalFlow;
      }
      if (other.BlowersBitWHSBlowerMinSingleFlow != 0D) {
        BlowersBitWHSBlowerMinSingleFlow = other.BlowersBitWHSBlowerMinSingleFlow;
      }
      if (other.DispensersBitEnable != false) {
        DispensersBitEnable = other.DispensersBitEnable;
      }
      if (other.DispensersBitMaxMotorActivityTime != 0) {
        DispensersBitMaxMotorActivityTime = other.DispensersBitMaxMotorActivityTime;
      }
      if (other.DispensersBitMotorActivitySpeed != 0) {
        DispensersBitMotorActivitySpeed = other.DispensersBitMotorActivitySpeed;
      }
      if (other.DispensersBitPBUStartPressure != 0D) {
        DispensersBitPBUStartPressure = other.DispensersBitPBUStartPressure;
      }
      if (other.DispensersBitPBUEndPressure != 0D) {
        DispensersBitPBUEndPressure = other.DispensersBitPBUEndPressure;
      }
      if (other.DispensersBitPressureLoseTimeout != 0) {
        DispensersBitPressureLoseTimeout = other.DispensersBitPressureLoseTimeout;
      }
      if (other.DispensersBitPressureLoseMinValue != 0D) {
        DispensersBitPressureLoseMinValue = other.DispensersBitPressureLoseMinValue;
      }
      if (other.HeatersBitEnable != false) {
        HeatersBitEnable = other.HeatersBitEnable;
      }
      if (other.HeatersBitCurrentBreakTime != 0) {
        HeatersBitCurrentBreakTime = other.HeatersBitCurrentBreakTime;
      }
      if (other.HeatersBitCurrentRangeTime != 0) {
        HeatersBitCurrentRangeTime = other.HeatersBitCurrentRangeTime;
      }
      if (other.HeatersBitTemperatureCheckTime != 0) {
        HeatersBitTemperatureCheckTime = other.HeatersBitTemperatureCheckTime;
      }
      heatersBitExpectedCurrent_.Add(other.heatersBitExpectedCurrent_);
      heatersBitExpectedTemperatureDiff_.Add(other.heatersBitExpectedTemperatureDiff_);
      if (other.FansBitEnable != false) {
        FansBitEnable = other.FansBitEnable;
      }
      if (other.MotorsBitEnable != false) {
        MotorsBitEnable = other.MotorsBitEnable;
      }
      if (other.RFIDBitEnable != false) {
        RFIDBitEnable = other.RFIDBitEnable;
      }
      if (other.I2CBitEnable != false) {
        I2CBitEnable = other.I2CBitEnable;
      }
      generalParameters_.Add(other.generalParameters_);
      if (other.FileVersion != 0) {
        FileVersion = other.FileVersion;
      }
      if (other.Description.Length != 0) {
        Description = other.Description;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            BITEnable = input.ReadBool();
            break;
          }
          case 16: {
            BlowersBitEnable = input.ReadBool();
            break;
          }
          case 24: {
            BlowersBitActivityTime = input.ReadUInt32();
            break;
          }
          case 32: {
            BlowersBitArcFanRpm = input.ReadUInt32();
            break;
          }
          case 40: {
            BlowersBitWHSBlowerVoltage = input.ReadUInt32();
            break;
          }
          case 48: {
            BlowersBitArcHeadMinimumRpm = input.ReadUInt32();
            break;
          }
          case 56: {
            BlowersBitArcHeadActivityRpm = input.ReadUInt32();
            break;
          }
          case 65: {
            BlowersBitArcHeadMinFlow = input.ReadDouble();
            break;
          }
          case 73: {
            BlowersBitWHSBlowerMinTotalFlow = input.ReadDouble();
            break;
          }
          case 81: {
            BlowersBitWHSBlowerMinSingleFlow = input.ReadDouble();
            break;
          }
          case 88: {
            DispensersBitEnable = input.ReadBool();
            break;
          }
          case 96: {
            DispensersBitMaxMotorActivityTime = input.ReadUInt32();
            break;
          }
          case 104: {
            DispensersBitMotorActivitySpeed = input.ReadUInt32();
            break;
          }
          case 113: {
            DispensersBitPBUStartPressure = input.ReadDouble();
            break;
          }
          case 121: {
            DispensersBitPBUEndPressure = input.ReadDouble();
            break;
          }
          case 128: {
            DispensersBitPressureLoseTimeout = input.ReadUInt32();
            break;
          }
          case 137: {
            DispensersBitPressureLoseMinValue = input.ReadDouble();
            break;
          }
          case 144: {
            HeatersBitEnable = input.ReadBool();
            break;
          }
          case 152: {
            HeatersBitCurrentBreakTime = input.ReadUInt32();
            break;
          }
          case 160: {
            HeatersBitCurrentRangeTime = input.ReadUInt32();
            break;
          }
          case 168: {
            HeatersBitTemperatureCheckTime = input.ReadUInt32();
            break;
          }
          case 178:
          case 177: {
            heatersBitExpectedCurrent_.AddEntriesFrom(input, _repeated_heatersBitExpectedCurrent_codec);
            break;
          }
          case 186:
          case 185: {
            heatersBitExpectedTemperatureDiff_.AddEntriesFrom(input, _repeated_heatersBitExpectedTemperatureDiff_codec);
            break;
          }
          case 192: {
            FansBitEnable = input.ReadBool();
            break;
          }
          case 200: {
            MotorsBitEnable = input.ReadBool();
            break;
          }
          case 208: {
            RFIDBitEnable = input.ReadBool();
            break;
          }
          case 216: {
            I2CBitEnable = input.ReadBool();
            break;
          }
          case 226:
          case 225: {
            generalParameters_.AddEntriesFrom(input, _repeated_generalParameters_codec);
            break;
          }
          case 232: {
            FileVersion = input.ReadUInt32();
            break;
          }
          case 242: {
            Description = input.ReadString();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code