// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ConfigurationParameters.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 ConfigurationParameters.proto</summary>
  public static partial class ConfigurationParametersReflection {

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

    static ConfigurationParametersReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Ch1Db25maWd1cmF0aW9uUGFyYW1ldGVycy5wcm90bxIcVGFuZ28uUE1SLkVt",
            "YmVkZGVkUGFyYW1ldGVycyKNCgoXQ29uZmlndXJhdGlvblBhcmFtZXRlcnMS",
            "GAoQQnJlYWtTZW5zb3JMaW1pdBgBIAEoDRIhChlEaWFnbm9zdGljQ29sbGVj",
            "dGlvbkxpbWl0GAIgASgNEhoKEk92ZXJIZWF0Q291bnRMaW1pdBgDIAEoDRIb",
            "ChNVbmRlckhlYXRDb3VudExpbWl0GAQgASgNEhkKEUNsb3NlVmFsdmVUaW1l",
            "b3V0GAUgASgNEhgKEE9wZW5WYWx2ZVRpbWVvdXQYBiABKA0SIAoYSW5pdGlh",
            "bERpc3BlbnNlclByZXNzdXJlGAcgASgBEh8KF0luaXRpYWxEaXNwZW5zZXJU",
            "aW1lb3V0GAggASgNEh8KF0luaXRpYWxEaXNwZW5zZXJUaW1lTGFnGAkgASgN",
            "EiMKG0Rpc3BlbnNlckJ1aWxkUHJlc3N1cmVTcGVlZBgKIAEoDRIjChtEaXNw",
            "ZW5zZXJCdWlsZFByZXNzdXJlTGltaXQYCyABKAESJQodRGlzcGVuc2VyQnVp",
            "bGRQcmVzc3VyZVRpbWVvdXQYDCABKA0SIQoZRGlzcGVuc2VyQnVpbGRQcmVz",
            "c3VyZUxhZxgNIAEoDRIkChxBQ0hlYXRlcnNMb3dlck9wZXJhdGlvbkxpbWl0",
            "GA4gASgNEiQKHEFDSGVhdGVyc1VwcGVyT3BlcmF0aW9uTGltaXQYDyABKA0S",
            "JAocRENIZWF0ZXJzTG93ZXJPcGVyYXRpb25MaW1pdBgQIAEoDRIkChxEQ0hl",
            "YXRlcnNVcHBlck9wZXJhdGlvbkxpbWl0GBEgASgNEiEKGU1pZFRhbmtQcmVz",
            "c3VyZUNvcnJlY3Rpb24YEiABKAESHwoXRGlzcGVuc2VyUHJlc2VnbWVudFdG",
            "Q0YYEyABKAESIgoaU3RhcnRIZWF0aW5nT25Jbml0U2VxdWVuY2UYFCABKAgS",
            "GQoRR2VuZXJhbFBhcmFtZXRlcnMYFSADKAESHAoUQ3VycmVudEFsYXJtTG93",
            "TGltaXQYFiABKAESHQoVQ3VycmVudEFsYXJtSGlnaExpbWl0GBcgASgBEiAK",
            "GElEU19TZWdtZW50UmVmaWxsVGltZW91dBgYIAEoARIhChlJRFNfUHJlU2Vn",
            "bWVudEJ1aWxkdXBUaW1lGBkgASgBEhkKEUlEU19DbGVhbmluZ1NwZWVkGBog",
            "ASgBEikKIUlEU19DbGVhbmluZ1N0b3BCZWZvcmVTZWdtZW50VGltZRgbIAEo",
            "ARIsCiRJRFNfQ2xlYW5pbmdTdGFydFNwcmF5UHJlU2VnbWVudFRpbWUYHCAB",
            "KAESIgoaSURTX0xlZnRDbGVhbmluZ01vdG9yU3BlZWQYHSABKAESIwobSURT",
            "X1JpZ2h0Q2xlYW5pbmdNb3RvclNwZWVkGB4gASgBEiEKGVN3aXRjaFRvSWRs",
            "ZVRpbWVpblNlY29uZHMYHyABKA0SHAoUSWRsZURyaWVyVGVtcGVyYXR1cmUY",
            "ICABKA0SGwoTSWRsZUhlYWRUZW1wZXJhdHVyZRghIAEoDRIcChRJZGxlTWl4",
            "ZXJUZW1wZXJhdHVyZRgiIAEoDRIgChhQb3dlck9mZlRlbXBlcmF0dXJlTGlt",
            "aXQYIyABKA0SLQolSURTX1ByZVNlZ21lbnRfV0ZDRl9UaW1lQmVmb3JlU2Vn",
            "bWVudBgkIAEoARITCgtGaWxlVmVyc2lvbhglIAEoDRITCgtEZXNjcmlwdGlv",
            "bhgmIAEoCUIoCiZjb20udHdpbmUudGFuZ28ucG1yLmVtYmVkZGVkcGFyYW1l",
            "dGVyc2IGcHJvdG8z"));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.EmbeddedParameters.ConfigurationParameters), global::Tango.PMR.EmbeddedParameters.ConfigurationParameters.Parser, new[]{ "BreakSensorLimit", "DiagnosticCollectionLimit", "OverHeatCountLimit", "UnderHeatCountLimit", "CloseValveTimeout", "OpenValveTimeout", "InitialDispenserPressure", "InitialDispenserTimeout", "InitialDispenserTimeLag", "DispenserBuildPressureSpeed", "DispenserBuildPressureLimit", "DispenserBuildPressureTimeout", "DispenserBuildPressureLag", "ACHeatersLowerOperationLimit", "ACHeatersUpperOperationLimit", "DCHeatersLowerOperationLimit", "DCHeatersUpperOperationLimit", "MidTankPressureCorrection", "DispenserPresegmentWFCF", "StartHeatingOnInitSequence", "GeneralParameters", "CurrentAlarmLowLimit", "CurrentAlarmHighLimit", "IDSSegmentRefillTimeout", "IDSPreSegmentBuildupTime", "IDSCleaningSpeed", "IDSCleaningStopBeforeSegmentTime", "IDSCleaningStartSprayPreSegmentTime", "IDSLeftCleaningMotorSpeed", "IDSRightCleaningMotorSpeed", "SwitchToIdleTimeinSeconds", "IdleDrierTemperature", "IdleHeadTemperature", "IdleMixerTemperature", "PowerOffTemperatureLimit", "IDSPreSegmentWFCFTimeBeforeSegment", "FileVersion", "Description" }, null, null, null)
          }));
    }
    #endregion

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

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

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

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

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConfigurationParameters(ConfigurationParameters other) : this() {
      breakSensorLimit_ = other.breakSensorLimit_;
      diagnosticCollectionLimit_ = other.diagnosticCollectionLimit_;
      overHeatCountLimit_ = other.overHeatCountLimit_;
      underHeatCountLimit_ = other.underHeatCountLimit_;
      closeValveTimeout_ = other.closeValveTimeout_;
      openValveTimeout_ = other.openValveTimeout_;
      initialDispenserPressure_ = other.initialDispenserPressure_;
      initialDispenserTimeout_ = other.initialDispenserTimeout_;
      initialDispenserTimeLag_ = other.initialDispenserTimeLag_;
      dispenserBuildPressureSpeed_ = other.dispenserBuildPressureSpeed_;
      dispenserBuildPressureLimit_ = other.dispenserBuildPressureLimit_;
      dispenserBuildPressureTimeout_ = other.dispenserBuildPressureTimeout_;
      dispenserBuildPressureLag_ = other.dispenserBuildPressureLag_;
      aCHeatersLowerOperationLimit_ = other.aCHeatersLowerOperationLimit_;
      aCHeatersUpperOperationLimit_ = other.aCHeatersUpperOperationLimit_;
      dCHeatersLowerOperationLimit_ = other.dCHeatersLowerOperationLimit_;
      dCHeatersUpperOperationLimit_ = other.dCHeatersUpperOperationLimit_;
      midTankPressureCorrection_ = other.midTankPressureCorrection_;
      dispenserPresegmentWFCF_ = other.dispenserPresegmentWFCF_;
      startHeatingOnInitSequence_ = other.startHeatingOnInitSequence_;
      generalParameters_ = other.generalParameters_.Clone();
      currentAlarmLowLimit_ = other.currentAlarmLowLimit_;
      currentAlarmHighLimit_ = other.currentAlarmHighLimit_;
      iDSSegmentRefillTimeout_ = other.iDSSegmentRefillTimeout_;
      iDSPreSegmentBuildupTime_ = other.iDSPreSegmentBuildupTime_;
      iDSCleaningSpeed_ = other.iDSCleaningSpeed_;
      iDSCleaningStopBeforeSegmentTime_ = other.iDSCleaningStopBeforeSegmentTime_;
      iDSCleaningStartSprayPreSegmentTime_ = other.iDSCleaningStartSprayPreSegmentTime_;
      iDSLeftCleaningMotorSpeed_ = other.iDSLeftCleaningMotorSpeed_;
      iDSRightCleaningMotorSpeed_ = other.iDSRightCleaningMotorSpeed_;
      switchToIdleTimeinSeconds_ = other.switchToIdleTimeinSeconds_;
      idleDrierTemperature_ = other.idleDrierTemperature_;
      idleHeadTemperature_ = other.idleHeadTemperature_;
      idleMixerTemperature_ = other.idleMixerTemperature_;
      powerOffTemperatureLimit_ = other.powerOffTemperatureLimit_;
      iDSPreSegmentWFCFTimeBeforeSegment_ = other.iDSPreSegmentWFCFTimeBeforeSegment_;
      fileVersion_ = other.fileVersion_;
      description_ = other.description_;
    }

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

    /// <summary>Field number for the "BreakSensorLimit" field.</summary>
    public const int BreakSensorLimitFieldNumber = 1;
    private uint breakSensorLimit_;
    /// <summary>
    /// Break Sensor Limit
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BreakSensorLimit {
      get { return breakSensorLimit_; }
      set {
        breakSensorLimit_ = value;
      }
    }

    /// <summary>Field number for the "DiagnosticCollectionLimit" field.</summary>
    public const int DiagnosticCollectionLimitFieldNumber = 2;
    private uint diagnosticCollectionLimit_;
    /// <summary>
    /// Diagnostics send interval in milliseconds 2
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DiagnosticCollectionLimit {
      get { return diagnosticCollectionLimit_; }
      set {
        diagnosticCollectionLimit_ = value;
      }
    }

    /// <summary>Field number for the "OverHeatCountLimit" field.</summary>
    public const int OverHeatCountLimitFieldNumber = 3;
    private uint overHeatCountLimit_;
    /// <summary>
    /// Overheat Count Limit
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint OverHeatCountLimit {
      get { return overHeatCountLimit_; }
      set {
        overHeatCountLimit_ = value;
      }
    }

    /// <summary>Field number for the "UnderHeatCountLimit" field.</summary>
    public const int UnderHeatCountLimitFieldNumber = 4;
    private uint underHeatCountLimit_;
    /// <summary>
    /// Underheat Count Limit
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint UnderHeatCountLimit {
      get { return underHeatCountLimit_; }
      set {
        underHeatCountLimit_ = value;
      }
    }

    /// <summary>Field number for the "CloseValveTimeout" field.</summary>
    public const int CloseValveTimeoutFieldNumber = 5;
    private uint closeValveTimeout_;
    /// <summary>
    /// Close Valve Timeout
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint CloseValveTimeout {
      get { return closeValveTimeout_; }
      set {
        closeValveTimeout_ = value;
      }
    }

    /// <summary>Field number for the "OpenValveTimeout" field.</summary>
    public const int OpenValveTimeoutFieldNumber = 6;
    private uint openValveTimeout_;
    /// <summary>
    /// Open Valve Timeout = 250;
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint OpenValveTimeout {
      get { return openValveTimeout_; }
      set {
        openValveTimeout_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserPressure" field.</summary>
    public const int InitialDispenserPressureFieldNumber = 7;
    private double initialDispenserPressure_;
    /// <summary>
    /// Initial Dispenser Pressure
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double InitialDispenserPressure {
      get { return initialDispenserPressure_; }
      set {
        initialDispenserPressure_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserTimeout" field.</summary>
    public const int InitialDispenserTimeoutFieldNumber = 8;
    private uint initialDispenserTimeout_;
    /// <summary>
    /// Initial Dispenser Timeout Limit
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint InitialDispenserTimeout {
      get { return initialDispenserTimeout_; }
      set {
        initialDispenserTimeout_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserTimeLag" field.</summary>
    public const int InitialDispenserTimeLagFieldNumber = 9;
    private uint initialDispenserTimeLag_;
    /// <summary>
    /// Initial Dispenser Timeout
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint InitialDispenserTimeLag {
      get { return initialDispenserTimeLag_; }
      set {
        initialDispenserTimeLag_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureSpeed" field.</summary>
    public const int DispenserBuildPressureSpeedFieldNumber = 10;
    private uint dispenserBuildPressureSpeed_;
    /// <summary>
    /// Dispenser prepare pressure building parameters - job prepare
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispenserBuildPressureSpeed {
      get { return dispenserBuildPressureSpeed_; }
      set {
        dispenserBuildPressureSpeed_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureLimit" field.</summary>
    public const int DispenserBuildPressureLimitFieldNumber = 11;
    private double dispenserBuildPressureLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispenserBuildPressureLimit {
      get { return dispenserBuildPressureLimit_; }
      set {
        dispenserBuildPressureLimit_ = value;
      }
    }

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

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

    /// <summary>Field number for the "ACHeatersLowerOperationLimit" field.</summary>
    public const int ACHeatersLowerOperationLimitFieldNumber = 14;
    private uint aCHeatersLowerOperationLimit_;
    /// <summary>
    ///sets the temperature frame for approving job start - in promil above and beyond target temperatures
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ACHeatersLowerOperationLimit {
      get { return aCHeatersLowerOperationLimit_; }
      set {
        aCHeatersLowerOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "ACHeatersUpperOperationLimit" field.</summary>
    public const int ACHeatersUpperOperationLimitFieldNumber = 15;
    private uint aCHeatersUpperOperationLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ACHeatersUpperOperationLimit {
      get { return aCHeatersUpperOperationLimit_; }
      set {
        aCHeatersUpperOperationLimit_ = value;
      }
    }

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

    /// <summary>Field number for the "DCHeatersUpperOperationLimit" field.</summary>
    public const int DCHeatersUpperOperationLimitFieldNumber = 17;
    private uint dCHeatersUpperOperationLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DCHeatersUpperOperationLimit {
      get { return dCHeatersUpperOperationLimit_; }
      set {
        dCHeatersUpperOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "MidTankPressureCorrection" field.</summary>
    public const int MidTankPressureCorrectionFieldNumber = 18;
    private double midTankPressureCorrection_;
    /// <summary>
    ///obsolete
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double MidTankPressureCorrection {
      get { return midTankPressureCorrection_; }
      set {
        midTankPressureCorrection_ = value;
      }
    }

    /// <summary>Field number for the "DispenserPresegmentWFCF" field.</summary>
    public const int DispenserPresegmentWFCFFieldNumber = 19;
    private double dispenserPresegmentWFCF_;
    /// <summary>
    ///Waste Flow Correction Factor
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispenserPresegmentWFCF {
      get { return dispenserPresegmentWFCF_; }
      set {
        dispenserPresegmentWFCF_ = value;
      }
    }

    /// <summary>Field number for the "StartHeatingOnInitSequence" field.</summary>
    public const int StartHeatingOnInitSequenceFieldNumber = 20;
    private bool startHeatingOnInitSequence_;
    /// <summary>
    ///disable heating start on init
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool StartHeatingOnInitSequence {
      get { return startHeatingOnInitSequence_; }
      set {
        startHeatingOnInitSequence_ = value;
      }
    }

    /// <summary>Field number for the "GeneralParameters" field.</summary>
    public const int GeneralParametersFieldNumber = 21;
    private static readonly pb::FieldCodec<double> _repeated_generalParameters_codec
        = pb::FieldCodec.ForDouble(170);
    private readonly pbc::RepeatedField<double> generalParameters_ = new pbc::RepeatedField<double>();
    /// <summary>
    /// general storage for parameters that do not have a specific name updated
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<double> GeneralParameters {
      get { return generalParameters_; }
    }

    /// <summary>Field number for the "CurrentAlarmLowLimit" field.</summary>
    public const int CurrentAlarmLowLimitFieldNumber = 22;
    private double currentAlarmLowLimit_;
    /// <summary>
    /// a limit percentage for current deviation below predefined level
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double CurrentAlarmLowLimit {
      get { return currentAlarmLowLimit_; }
      set {
        currentAlarmLowLimit_ = value;
      }
    }

    /// <summary>Field number for the "CurrentAlarmHighLimit" field.</summary>
    public const int CurrentAlarmHighLimitFieldNumber = 23;
    private double currentAlarmHighLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double CurrentAlarmHighLimit {
      get { return currentAlarmHighLimit_; }
      set {
        currentAlarmHighLimit_ = value;
      }
    }

    /// <summary>Field number for the "IDS_SegmentRefillTimeout" field.</summary>
    public const int IDSSegmentRefillTimeoutFieldNumber = 24;
    private double iDSSegmentRefillTimeout_;
    /// <summary>
    ///how much time before next segment the automatic refill should stop
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSSegmentRefillTimeout {
      get { return iDSSegmentRefillTimeout_; }
      set {
        iDSSegmentRefillTimeout_ = value;
      }
    }

    /// <summary>Field number for the "IDS_PreSegmentBuildupTime" field.</summary>
    public const int IDSPreSegmentBuildupTimeFieldNumber = 25;
    private double iDSPreSegmentBuildupTime_;
    /// <summary>
    /// how much running to waste time during presegment
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSPreSegmentBuildupTime {
      get { return iDSPreSegmentBuildupTime_; }
      set {
        iDSPreSegmentBuildupTime_ = value;
      }
    }

    /// <summary>Field number for the "IDS_CleaningSpeed" field.</summary>
    public const int IDSCleaningSpeedFieldNumber = 26;
    private double iDSCleaningSpeed_;
    /// <summary>
    ///cleaning dispenser motor speed and timing - going to move to RML
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSCleaningSpeed {
      get { return iDSCleaningSpeed_; }
      set {
        iDSCleaningSpeed_ = value;
      }
    }

    /// <summary>Field number for the "IDS_CleaningStopBeforeSegmentTime" field.</summary>
    public const int IDSCleaningStopBeforeSegmentTimeFieldNumber = 27;
    private double iDSCleaningStopBeforeSegmentTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSCleaningStopBeforeSegmentTime {
      get { return iDSCleaningStopBeforeSegmentTime_; }
      set {
        iDSCleaningStopBeforeSegmentTime_ = value;
      }
    }

    /// <summary>Field number for the "IDS_CleaningStartSprayPreSegmentTime" field.</summary>
    public const int IDSCleaningStartSprayPreSegmentTimeFieldNumber = 28;
    private double iDSCleaningStartSprayPreSegmentTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSCleaningStartSprayPreSegmentTime {
      get { return iDSCleaningStartSprayPreSegmentTime_; }
      set {
        iDSCleaningStartSprayPreSegmentTime_ = value;
      }
    }

    /// <summary>Field number for the "IDS_LeftCleaningMotorSpeed" field.</summary>
    public const int IDSLeftCleaningMotorSpeedFieldNumber = 29;
    private double iDSLeftCleaningMotorSpeed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSLeftCleaningMotorSpeed {
      get { return iDSLeftCleaningMotorSpeed_; }
      set {
        iDSLeftCleaningMotorSpeed_ = value;
      }
    }

    /// <summary>Field number for the "IDS_RightCleaningMotorSpeed" field.</summary>
    public const int IDSRightCleaningMotorSpeedFieldNumber = 30;
    private double iDSRightCleaningMotorSpeed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSRightCleaningMotorSpeed {
      get { return iDSRightCleaningMotorSpeed_; }
      set {
        iDSRightCleaningMotorSpeed_ = value;
      }
    }

    /// <summary>Field number for the "SwitchToIdleTimeinSeconds" field.</summary>
    public const int SwitchToIdleTimeinSecondsFieldNumber = 31;
    private uint switchToIdleTimeinSeconds_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint SwitchToIdleTimeinSeconds {
      get { return switchToIdleTimeinSeconds_; }
      set {
        switchToIdleTimeinSeconds_ = value;
      }
    }

    /// <summary>Field number for the "IdleDrierTemperature" field.</summary>
    public const int IdleDrierTemperatureFieldNumber = 32;
    private uint idleDrierTemperature_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint IdleDrierTemperature {
      get { return idleDrierTemperature_; }
      set {
        idleDrierTemperature_ = value;
      }
    }

    /// <summary>Field number for the "IdleHeadTemperature" field.</summary>
    public const int IdleHeadTemperatureFieldNumber = 33;
    private uint idleHeadTemperature_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint IdleHeadTemperature {
      get { return idleHeadTemperature_; }
      set {
        idleHeadTemperature_ = value;
      }
    }

    /// <summary>Field number for the "IdleMixerTemperature" field.</summary>
    public const int IdleMixerTemperatureFieldNumber = 34;
    private uint idleMixerTemperature_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint IdleMixerTemperature {
      get { return idleMixerTemperature_; }
      set {
        idleMixerTemperature_ = value;
      }
    }

    /// <summary>Field number for the "PowerOffTemperatureLimit" field.</summary>
    public const int PowerOffTemperatureLimitFieldNumber = 35;
    private uint powerOffTemperatureLimit_;
    /// <summary>
    ///temperature to allow machine power off
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint PowerOffTemperatureLimit {
      get { return powerOffTemperatureLimit_; }
      set {
        powerOffTemperatureLimit_ = value;
      }
    }

    /// <summary>Field number for the "IDS_PreSegment_WFCF_TimeBeforeSegment" field.</summary>
    public const int IDSPreSegmentWFCFTimeBeforeSegmentFieldNumber = 36;
    private double iDSPreSegmentWFCFTimeBeforeSegment_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSPreSegmentWFCFTimeBeforeSegment {
      get { return iDSPreSegmentWFCFTimeBeforeSegment_; }
      set {
        iDSPreSegmentWFCFTimeBeforeSegment_ = value;
      }
    }

    /// <summary>Field number for the "FileVersion" field.</summary>
    public const int FileVersionFieldNumber = 37;
    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 = 38;
    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 ConfigurationParameters);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ConfigurationParameters other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (BreakSensorLimit != other.BreakSensorLimit) return false;
      if (DiagnosticCollectionLimit != other.DiagnosticCollectionLimit) return false;
      if (OverHeatCountLimit != other.OverHeatCountLimit) return false;
      if (UnderHeatCountLimit != other.UnderHeatCountLimit) return false;
      if (CloseValveTimeout != other.CloseValveTimeout) return false;
      if (OpenValveTimeout != other.OpenValveTimeout) return false;
      if (InitialDispenserPressure != other.InitialDispenserPressure) return false;
      if (InitialDispenserTimeout != other.InitialDispenserTimeout) return false;
      if (InitialDispenserTimeLag != other.InitialDispenserTimeLag) return false;
      if (DispenserBuildPressureSpeed != other.DispenserBuildPressureSpeed) return false;
      if (DispenserBuildPressureLimit != other.DispenserBuildPressureLimit) return false;
      if (DispenserBuildPressureTimeout != other.DispenserBuildPressureTimeout) return false;
      if (DispenserBuildPressureLag != other.DispenserBuildPressureLag) return false;
      if (ACHeatersLowerOperationLimit != other.ACHeatersLowerOperationLimit) return false;
      if (ACHeatersUpperOperationLimit != other.ACHeatersUpperOperationLimit) return false;
      if (DCHeatersLowerOperationLimit != other.DCHeatersLowerOperationLimit) return false;
      if (DCHeatersUpperOperationLimit != other.DCHeatersUpperOperationLimit) return false;
      if (MidTankPressureCorrection != other.MidTankPressureCorrection) return false;
      if (DispenserPresegmentWFCF != other.DispenserPresegmentWFCF) return false;
      if (StartHeatingOnInitSequence != other.StartHeatingOnInitSequence) return false;
      if(!generalParameters_.Equals(other.generalParameters_)) return false;
      if (CurrentAlarmLowLimit != other.CurrentAlarmLowLimit) return false;
      if (CurrentAlarmHighLimit != other.CurrentAlarmHighLimit) return false;
      if (IDSSegmentRefillTimeout != other.IDSSegmentRefillTimeout) return false;
      if (IDSPreSegmentBuildupTime != other.IDSPreSegmentBuildupTime) return false;
      if (IDSCleaningSpeed != other.IDSCleaningSpeed) return false;
      if (IDSCleaningStopBeforeSegmentTime != other.IDSCleaningStopBeforeSegmentTime) return false;
      if (IDSCleaningStartSprayPreSegmentTime != other.IDSCleaningStartSprayPreSegmentTime) return false;
      if (IDSLeftCleaningMotorSpeed != other.IDSLeftCleaningMotorSpeed) return false;
      if (IDSRightCleaningMotorSpeed != other.IDSRightCleaningMotorSpeed) return false;
      if (SwitchToIdleTimeinSeconds != other.SwitchToIdleTimeinSeconds) return false;
      if (IdleDrierTemperature != other.IdleDrierTemperature) return false;
      if (IdleHeadTemperature != other.IdleHeadTemperature) return false;
      if (IdleMixerTemperature != other.IdleMixerTemperature) return false;
      if (PowerOffTemperatureLimit != other.PowerOffTemperatureLimit) return false;
      if (IDSPreSegmentWFCFTimeBeforeSegment != other.IDSPreSegmentWFCFTimeBeforeSegment) 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 (BreakSensorLimit != 0) hash ^= BreakSensorLimit.GetHashCode();
      if (DiagnosticCollectionLimit != 0) hash ^= DiagnosticCollectionLimit.GetHashCode();
      if (OverHeatCountLimit != 0) hash ^= OverHeatCountLimit.GetHashCode();
      if (UnderHeatCountLimit != 0) hash ^= UnderHeatCountLimit.GetHashCode();
      if (CloseValveTimeout != 0) hash ^= CloseValveTimeout.GetHashCode();
      if (OpenValveTimeout != 0) hash ^= OpenValveTimeout.GetHashCode();
      if (InitialDispenserPressure != 0D) hash ^= InitialDispenserPressure.GetHashCode();
      if (InitialDispenserTimeout != 0) hash ^= InitialDispenserTimeout.GetHashCode();
      if (InitialDispenserTimeLag != 0) hash ^= InitialDispenserTimeLag.GetHashCode();
      if (DispenserBuildPressureSpeed != 0) hash ^= DispenserBuildPressureSpeed.GetHashCode();
      if (DispenserBuildPressureLimit != 0D) hash ^= DispenserBuildPressureLimit.GetHashCode();
      if (DispenserBuildPressureTimeout != 0) hash ^= DispenserBuildPressureTimeout.GetHashCode();
      if (DispenserBuildPressureLag != 0) hash ^= DispenserBuildPressureLag.GetHashCode();
      if (ACHeatersLowerOperationLimit != 0) hash ^= ACHeatersLowerOperationLimit.GetHashCode();
      if (ACHeatersUpperOperationLimit != 0) hash ^= ACHeatersUpperOperationLimit.GetHashCode();
      if (DCHeatersLowerOperationLimit != 0) hash ^= DCHeatersLowerOperationLimit.GetHashCode();
      if (DCHeatersUpperOperationLimit != 0) hash ^= DCHeatersUpperOperationLimit.GetHashCode();
      if (MidTankPressureCorrection != 0D) hash ^= MidTankPressureCorrection.GetHashCode();
      if (DispenserPresegmentWFCF != 0D) hash ^= DispenserPresegmentWFCF.GetHashCode();
      if (StartHeatingOnInitSequence != false) hash ^= StartHeatingOnInitSequence.GetHashCode();
      hash ^= generalParameters_.GetHashCode();
      if (CurrentAlarmLowLimit != 0D) hash ^= CurrentAlarmLowLimit.GetHashCode();
      if (CurrentAlarmHighLimit != 0D) hash ^= CurrentAlarmHighLimit.GetHashCode();
      if (IDSSegmentRefillTimeout != 0D) hash ^= IDSSegmentRefillTimeout.GetHashCode();
      if (IDSPreSegmentBuildupTime != 0D) hash ^= IDSPreSegmentBuildupTime.GetHashCode();
      if (IDSCleaningSpeed != 0D) hash ^= IDSCleaningSpeed.GetHashCode();
      if (IDSCleaningStopBeforeSegmentTime != 0D) hash ^= IDSCleaningStopBeforeSegmentTime.GetHashCode();
      if (IDSCleaningStartSprayPreSegmentTime != 0D) hash ^= IDSCleaningStartSprayPreSegmentTime.GetHashCode();
      if (IDSLeftCleaningMotorSpeed != 0D) hash ^= IDSLeftCleaningMotorSpeed.GetHashCode();
      if (IDSRightCleaningMotorSpeed != 0D) hash ^= IDSRightCleaningMotorSpeed.GetHashCode();
      if (SwitchToIdleTimeinSeconds != 0) hash ^= SwitchToIdleTimeinSeconds.GetHashCode();
      if (IdleDrierTemperature != 0) hash ^= IdleDrierTemperature.GetHashCode();
      if (IdleHeadTemperature != 0) hash ^= IdleHeadTemperature.GetHashCode();
      if (IdleMixerTemperature != 0) hash ^= IdleMixerTemperature.GetHashCode();
      if (PowerOffTemperatureLimit != 0) hash ^= PowerOffTemperatureLimit.GetHashCode();
      if (IDSPreSegmentWFCFTimeBeforeSegment != 0D) hash ^= IDSPreSegmentWFCFTimeBeforeSegment.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 (BreakSensorLimit != 0) {
        output.WriteRawTag(8);
        output.WriteUInt32(BreakSensorLimit);
      }
      if (DiagnosticCollectionLimit != 0) {
        output.WriteRawTag(16);
        output.WriteUInt32(DiagnosticCollectionLimit);
      }
      if (OverHeatCountLimit != 0) {
        output.WriteRawTag(24);
        output.WriteUInt32(OverHeatCountLimit);
      }
      if (UnderHeatCountLimit != 0) {
        output.WriteRawTag(32);
        output.WriteUInt32(UnderHeatCountLimit);
      }
      if (CloseValveTimeout != 0) {
        output.WriteRawTag(40);
        output.WriteUInt32(CloseValveTimeout);
      }
      if (OpenValveTimeout != 0) {
        output.WriteRawTag(48);
        output.WriteUInt32(OpenValveTimeout);
      }
      if (InitialDispenserPressure != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(InitialDispenserPressure);
      }
      if (InitialDispenserTimeout != 0) {
        output.WriteRawTag(64);
        output.WriteUInt32(InitialDispenserTimeout);
      }
      if (InitialDispenserTimeLag != 0) {
        output.WriteRawTag(72);
        output.WriteUInt32(InitialDispenserTimeLag);
      }
      if (DispenserBuildPressureSpeed != 0) {
        output.WriteRawTag(80);
        output.WriteUInt32(DispenserBuildPressureSpeed);
      }
      if (DispenserBuildPressureLimit != 0D) {
        output.WriteRawTag(89);
        output.WriteDouble(DispenserBuildPressureLimit);
      }
      if (DispenserBuildPressureTimeout != 0) {
        output.WriteRawTag(96);
        output.WriteUInt32(DispenserBuildPressureTimeout);
      }
      if (DispenserBuildPressureLag != 0) {
        output.WriteRawTag(104);
        output.WriteUInt32(DispenserBuildPressureLag);
      }
      if (ACHeatersLowerOperationLimit != 0) {
        output.WriteRawTag(112);
        output.WriteUInt32(ACHeatersLowerOperationLimit);
      }
      if (ACHeatersUpperOperationLimit != 0) {
        output.WriteRawTag(120);
        output.WriteUInt32(ACHeatersUpperOperationLimit);
      }
      if (DCHeatersLowerOperationLimit != 0) {
        output.WriteRawTag(128, 1);
        output.WriteUInt32(DCHeatersLowerOperationLimit);
      }
      if (DCHeatersUpperOperationLimit != 0) {
        output.WriteRawTag(136, 1);
        output.WriteUInt32(DCHeatersUpperOperationLimit);
      }
      if (MidTankPressureCorrection != 0D) {
        output.WriteRawTag(145, 1);
        output.WriteDouble(MidTankPressureCorrection);
      }
      if (DispenserPresegmentWFCF != 0D) {
        output.WriteRawTag(153, 1);
        output.WriteDouble(DispenserPresegmentWFCF);
      }
      if (StartHeatingOnInitSequence != false) {
        output.WriteRawTag(160, 1);
        output.WriteBool(StartHeatingOnInitSequence);
      }
      generalParameters_.WriteTo(output, _repeated_generalParameters_codec);
      if (CurrentAlarmLowLimit != 0D) {
        output.WriteRawTag(177, 1);
        output.WriteDouble(CurrentAlarmLowLimit);
      }
      if (CurrentAlarmHighLimit != 0D) {
        output.WriteRawTag(185, 1);
        output.WriteDouble(CurrentAlarmHighLimit);
      }
      if (IDSSegmentRefillTimeout != 0D) {
        output.WriteRawTag(193, 1);
        output.WriteDouble(IDSSegmentRefillTimeout);
      }
      if (IDSPreSegmentBuildupTime != 0D) {
        output.WriteRawTag(201, 1);
        output.WriteDouble(IDSPreSegmentBuildupTime);
      }
      if (IDSCleaningSpeed != 0D) {
        output.WriteRawTag(209, 1);
        output.WriteDouble(IDSCleaningSpeed);
      }
      if (IDSCleaningStopBeforeSegmentTime != 0D) {
        output.WriteRawTag(217, 1);
        output.WriteDouble(IDSCleaningStopBeforeSegmentTime);
      }
      if (IDSCleaningStartSprayPreSegmentTime != 0D) {
        output.WriteRawTag(225, 1);
        output.WriteDouble(IDSCleaningStartSprayPreSegmentTime);
      }
      if (IDSLeftCleaningMotorSpeed != 0D) {
        output.WriteRawTag(233, 1);
        output.WriteDouble(IDSLeftCleaningMotorSpeed);
      }
      if (IDSRightCleaningMotorSpeed != 0D) {
        output.WriteRawTag(241, 1);
        output.WriteDouble(IDSRightCleaningMotorSpeed);
      }
      if (SwitchToIdleTimeinSeconds != 0) {
        output.WriteRawTag(248, 1);
        output.WriteUInt32(SwitchToIdleTimeinSeconds);
      }
      if (IdleDrierTemperature != 0) {
        output.WriteRawTag(128, 2);
        output.WriteUInt32(IdleDrierTemperature);
      }
      if (IdleHeadTemperature != 0) {
        output.WriteRawTag(136, 2);
        output.WriteUInt32(IdleHeadTemperature);
      }
      if (IdleMixerTemperature != 0) {
        output.WriteRawTag(144, 2);
        output.WriteUInt32(IdleMixerTemperature);
      }
      if (PowerOffTemperatureLimit != 0) {
        output.WriteRawTag(152, 2);
        output.WriteUInt32(PowerOffTemperatureLimit);
      }
      if (IDSPreSegmentWFCFTimeBeforeSegment != 0D) {
        output.WriteRawTag(161, 2);
        output.WriteDouble(IDSPreSegmentWFCFTimeBeforeSegment);
      }
      if (FileVersion != 0) {
        output.WriteRawTag(168, 2);
        output.WriteUInt32(FileVersion);
      }
      if (Description.Length != 0) {
        output.WriteRawTag(178, 2);
        output.WriteString(Description);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (BreakSensorLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BreakSensorLimit);
      }
      if (DiagnosticCollectionLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DiagnosticCollectionLimit);
      }
      if (OverHeatCountLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(OverHeatCountLimit);
      }
      if (UnderHeatCountLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(UnderHeatCountLimit);
      }
      if (CloseValveTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CloseValveTimeout);
      }
      if (OpenValveTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(OpenValveTimeout);
      }
      if (InitialDispenserPressure != 0D) {
        size += 1 + 8;
      }
      if (InitialDispenserTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialDispenserTimeout);
      }
      if (InitialDispenserTimeLag != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialDispenserTimeLag);
      }
      if (DispenserBuildPressureSpeed != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureSpeed);
      }
      if (DispenserBuildPressureLimit != 0D) {
        size += 1 + 8;
      }
      if (DispenserBuildPressureTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureTimeout);
      }
      if (DispenserBuildPressureLag != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureLag);
      }
      if (ACHeatersLowerOperationLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ACHeatersLowerOperationLimit);
      }
      if (ACHeatersUpperOperationLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ACHeatersUpperOperationLimit);
      }
      if (DCHeatersLowerOperationLimit != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(DCHeatersLowerOperationLimit);
      }
      if (DCHeatersUpperOperationLimit != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(DCHeatersUpperOperationLimit);
      }
      if (MidTankPressureCorrection != 0D) {
        size += 2 + 8;
      }
      if (DispenserPresegmentWFCF != 0D) {
        size += 2 + 8;
      }
      if (StartHeatingOnInitSequence != false) {
        size += 2 + 1;
      }
      size += generalParameters_.CalculateSize(_repeated_generalParameters_codec);
      if (CurrentAlarmLowLimit != 0D) {
        size += 2 + 8;
      }
      if (CurrentAlarmHighLimit != 0D) {
        size += 2 + 8;
      }
      if (IDSSegmentRefillTimeout != 0D) {
        size += 2 + 8;
      }
      if (IDSPreSegmentBuildupTime != 0D) {
        size += 2 + 8;
      }
      if (IDSCleaningSpeed != 0D) {
        size += 2 + 8;
      }
      if (IDSCleaningStopBeforeSegmentTime != 0D) {
        size += 2 + 8;
      }
      if (IDSCleaningStartSprayPreSegmentTime != 0D) {
        size += 2 + 8;
      }
      if (IDSLeftCleaningMotorSpeed != 0D) {
        size += 2 + 8;
      }
      if (IDSRightCleaningMotorSpeed != 0D) {
        size += 2 + 8;
      }
      if (SwitchToIdleTimeinSeconds != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(SwitchToIdleTimeinSeconds);
      }
      if (IdleDrierTemperature != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(IdleDrierTemperature);
      }
      if (IdleHeadTemperature != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(IdleHeadTemperature);
      }
      if (IdleMixerTemperature != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(IdleMixerTemperature);
      }
      if (PowerOffTemperatureLimit != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(PowerOffTemperatureLimit);
      }
      if (IDSPreSegmentWFCFTimeBeforeSegment != 0D) {
        size += 2 + 8;
      }
      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(ConfigurationParameters other) {
      if (other == null) {
        return;
      }
      if (other.BreakSensorLimit != 0) {
        BreakSensorLimit = other.BreakSensorLimit;
      }
      if (other.DiagnosticCollectionLimit != 0) {
        DiagnosticCollectionLimit = other.DiagnosticCollectionLimit;
      }
      if (other.OverHeatCountLimit != 0) {
        OverHeatCountLimit = other.OverHeatCountLimit;
      }
      if (other.UnderHeatCountLimit != 0) {
        UnderHeatCountLimit = other.UnderHeatCountLimit;
      }
      if (other.CloseValveTimeout != 0) {
        CloseValveTimeout = other.CloseValveTimeout;
      }
      if (other.OpenValveTimeout != 0) {
        OpenValveTimeout = other.OpenValveTimeout;
      }
      if (other.InitialDispenserPressure != 0D) {
        InitialDispenserPressure = other.InitialDispenserPressure;
      }
      if (other.InitialDispenserTimeout != 0) {
        InitialDispenserTimeout = other.InitialDispenserTimeout;
      }
      if (other.InitialDispenserTimeLag != 0) {
        InitialDispenserTimeLag = other.InitialDispenserTimeLag;
      }
      if (other.DispenserBuildPressureSpeed != 0) {
        DispenserBuildPressureSpeed = other.DispenserBuildPressureSpeed;
      }
      if (other.DispenserBuildPressureLimit != 0D) {
        DispenserBuildPressureLimit = other.DispenserBuildPressureLimit;
      }
      if (other.DispenserBuildPressureTimeout != 0) {
        DispenserBuildPressureTimeout = other.DispenserBuildPressureTimeout;
      }
      if (other.DispenserBuildPressureLag != 0) {
        DispenserBuildPressureLag = other.DispenserBuildPressureLag;
      }
      if (other.ACHeatersLowerOperationLimit != 0) {
        ACHeatersLowerOperationLimit = other.ACHeatersLowerOperationLimit;
      }
      if (other.ACHeatersUpperOperationLimit != 0) {
        ACHeatersUpperOperationLimit = other.ACHeatersUpperOperationLimit;
      }
      if (other.DCHeatersLowerOperationLimit != 0) {
        DCHeatersLowerOperationLimit = other.DCHeatersLowerOperationLimit;
      }
      if (other.DCHeatersUpperOperationLimit != 0) {
        DCHeatersUpperOperationLimit = other.DCHeatersUpperOperationLimit;
      }
      if (other.MidTankPressureCorrection != 0D) {
        MidTankPressureCorrection = other.MidTankPressureCorrection;
      }
      if (other.DispenserPresegmentWFCF != 0D) {
        DispenserPresegmentWFCF = other.DispenserPresegmentWFCF;
      }
      if (other.StartHeatingOnInitSequence != false) {
        StartHeatingOnInitSequence = other.StartHeatingOnInitSequence;
      }
      generalParameters_.Add(other.generalParameters_);
      if (other.CurrentAlarmLowLimit != 0D) {
        CurrentAlarmLowLimit = other.CurrentAlarmLowLimit;
      }
      if (other.CurrentAlarmHighLimit != 0D) {
        CurrentAlarmHighLimit = other.CurrentAlarmHighLimit;
      }
      if (other.IDSSegmentRefillTimeout != 0D) {
        IDSSegmentRefillTimeout = other.IDSSegmentRefillTimeout;
      }
      if (other.IDSPreSegmentBuildupTime != 0D) {
        IDSPreSegmentBuildupTime = other.IDSPreSegmentBuildupTime;
      }
      if (other.IDSCleaningSpeed != 0D) {
        IDSCleaningSpeed = other.IDSCleaningSpeed;
      }
      if (other.IDSCleaningStopBeforeSegmentTime != 0D) {
        IDSCleaningStopBeforeSegmentTime = other.IDSCleaningStopBeforeSegmentTime;
      }
      if (other.IDSCleaningStartSprayPreSegmentTime != 0D) {
        IDSCleaningStartSprayPreSegmentTime = other.IDSCleaningStartSprayPreSegmentTime;
      }
      if (other.IDSLeftCleaningMotorSpeed != 0D) {
        IDSLeftCleaningMotorSpeed = other.IDSLeftCleaningMotorSpeed;
      }
      if (other.IDSRightCleaningMotorSpeed != 0D) {
        IDSRightCleaningMotorSpeed = other.IDSRightCleaningMotorSpeed;
      }
      if (other.SwitchToIdleTimeinSeconds != 0) {
        SwitchToIdleTimeinSeconds = other.SwitchToIdleTimeinSeconds;
      }
      if (other.IdleDrierTemperature != 0) {
        IdleDrierTemperature = other.IdleDrierTemperature;
      }
      if (other.IdleHeadTemperature != 0) {
        IdleHeadTemperature = other.IdleHeadTemperature;
      }
      if (other.IdleMixerTemperature != 0) {
        IdleMixerTemperature = other.IdleMixerTemperature;
      }
      if (other.PowerOffTemperatureLimit != 0) {
        PowerOffTemperatureLimit = other.PowerOffTemperatureLimit;
      }
      if (other.IDSPreSegmentWFCFTimeBeforeSegment != 0D) {
        IDSPreSegmentWFCFTimeBeforeSegment = other.IDSPreSegmentWFCFTimeBeforeSegment;
      }
      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: {
            BreakSensorLimit = input.ReadUInt32();
            break;
          }
          case 16: {
            DiagnosticCollectionLimit = input.ReadUInt32();
            break;
          }
          case 24: {
            OverHeatCountLimit = input.ReadUInt32();
            break;
          }
          case 32: {
            UnderHeatCountLimit = input.ReadUInt32();
            break;
          }
          case 40: {
            CloseValveTimeout = input.ReadUInt32();
            break;
          }
          case 48: {
            OpenValveTimeout = input.ReadUInt32();
            break;
          }
          case 57: {
            InitialDispenserPressure = input.ReadDouble();
            break;
          }
          case 64: {
            InitialDispenserTimeout = input.ReadUInt32();
            break;
          }
          case 72: {
            InitialDispenserTimeLag = input.ReadUInt32();
            break;
          }
          case 80: {
            DispenserBuildPressureSpeed = input.ReadUInt32();
            break;
          }
          case 89: {
            DispenserBuildPressureLimit = input.ReadDouble();
            break;
          }
          case 96: {
            DispenserBuildPressureTimeout = input.ReadUInt32();
            break;
          }
          case 104: {
            DispenserBuildPressureLag = input.ReadUInt32();
            break;
          }
          case 112: {
            ACHeatersLowerOperationLimit = input.ReadUInt32();
            break;
          }
          case 120: {
            ACHeatersUpperOperationLimit = input.ReadUInt32();
            break;
          }
          case 128: {
            DCHeatersLowerOperationLimit = input.ReadUInt32();
            break;
          }
          case 136: {
            DCHeatersUpperOperationLimit = input.ReadUInt32();
            break;
          }
          case 145: {
            MidTankPressureCorrection = input.ReadDouble();
            break;
          }
          case 153: {
            DispenserPresegmentWFCF = input.ReadDouble();
            break;
          }
          case 160: {
            StartHeatingOnInitSequence = input.ReadBool();
            break;
          }
          case 170:
          case 169: {
            generalParameters_.AddEntriesFrom(input, _repeated_generalParameters_codec);
            break;
          }
          case 177: {
            CurrentAlarmLowLimit = input.ReadDouble();
            break;
          }
          case 185: {
            CurrentAlarmHighLimit = input.ReadDouble();
            break;
          }
          case 193: {
            IDSSegmentRefillTimeout = input.ReadDouble();
            break;
          }
          case 201: {
            IDSPreSegmentBuildupTime = input.ReadDouble();
            break;
          }
          case 209: {
            IDSCleaningSpeed = input.ReadDouble();
            break;
          }
          case 217: {
            IDSCleaningStopBeforeSegmentTime = input.ReadDouble();
            break;
          }
          case 225: {
            IDSCleaningStartSprayPreSegmentTime = input.ReadDouble();
            break;
          }
          case 233: {
            IDSLeftCleaningMotorSpeed = input.ReadDouble();
            break;
          }
          case 241: {
            IDSRightCleaningMotorSpeed = input.ReadDouble();
            break;
          }
          case 248: {
            SwitchToIdleTimeinSeconds = input.ReadUInt32();
            break;
          }
          case 256: {
            IdleDrierTemperature = input.ReadUInt32();
            break;
          }
          case 264: {
            IdleHeadTemperature = input.ReadUInt32();
            break;
          }
          case 272: {
            IdleMixerTemperature = input.ReadUInt32();
            break;
          }
          case 280: {
            PowerOffTemperatureLimit = input.ReadUInt32();
            break;
          }
          case 289: {
            IDSPreSegmentWFCFTimeBeforeSegment = input.ReadDouble();
            break;
          }
          case 296: {
            FileVersion = input.ReadUInt32();
            break;
          }
          case 306: {
            Description = input.ReadString();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code