From e0c98ae05879016c49ef24b3cbae11b41c716b58 Mon Sep 17 00:00:00 2001 From: Roy Date: Sat, 8 Apr 2023 23:56:44 +0300 Subject: Eureka Process Parameters. --- .../Tango.PMR/Printing/ProcessParameters.cs | 836 ++++++++++++++++++++- 1 file changed, 832 insertions(+), 4 deletions(-) (limited to 'Software/Visual_Studio/Tango.PMR') diff --git a/Software/Visual_Studio/Tango.PMR/Printing/ProcessParameters.cs b/Software/Visual_Studio/Tango.PMR/Printing/ProcessParameters.cs index 0d45ef6bf..29b8c2d9f 100644 --- a/Software/Visual_Studio/Tango.PMR/Printing/ProcessParameters.cs +++ b/Software/Visual_Studio/Tango.PMR/Printing/ProcessParameters.cs @@ -23,7 +23,7 @@ namespace Tango.PMR.Printing { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "ChdQcm9jZXNzUGFyYW1ldGVycy5wcm90bxISVGFuZ28uUE1SLlByaW50aW5n", - "IqMGChFQcm9jZXNzUGFyYW1ldGVycxITCgtEeWVpbmdTcGVlZBgBIAEoARIU", + "IvALChFQcm9jZXNzUGFyYW1ldGVycxITCgtEeWVpbmdTcGVlZBgBIAEoARIU", "CgxNaW5JbmtVcHRha2UYAiABKAESFAoMTWF4SW5rVXB0YWtlGAMgASgBEhUK", "DUZlZWRlclRlbnNpb24YBCABKAESFQoNUHVsbGVyVGVuc2lvbhgFIAEoARIV", "Cg1XaW5kZXJUZW5zaW9uGAYgASgBEhEKCU1peGVyVGVtcBgHIAEoARIVCg1I", @@ -40,12 +40,28 @@ namespace Tango.PMR.Printing { "dxgbIAEoARITCgtSQmxvd2VyVGVtcBgcIAEoARITCgtMQmxvd2VyRmxvdxgd", "IAEoARITCgtMQmxvd2VyVGVtcBgeIAEoARIXCg9QcmVzc3VyZUJ1aWxkVXAY", "HyABKAESGgoSQnRzckZlZWRpbmdUZW5zaW9uGCAgASgBEhMKC0V4aXRUZW5z", - "aW9uGCEgASgBEh4KFkJ0c3JUaHJlYWRMZW5ndGhPZmZzZXQYIiABKAFCHgoc", - "Y29tLnR3aW5lLnRhbmdvLnBtci5wcmludGluZ2IGcHJvdG8z")); + "aW9uGCEgASgBEh4KFkJ0c3JUaHJlYWRMZW5ndGhPZmZzZXQYIiABKAESFwoP", + "RVdpbmRlcjFUZW5zaW9uGCMgASgBEhcKD0VXaW5kZXIyVGVuc2lvbhgkIAEo", + "ARIXCg9FV2luZGVyM1RlbnNpb24YJSABKAESFwoPRVdpbmRlcjRUZW5zaW9u", + "GCYgASgBEhwKFEVCdHNyMUZlZWRpbmdUZW5zaW9uGCcgASgBEhwKFEVCdHNy", + "MkZlZWRpbmdUZW5zaW9uGCggASgBEhwKFEVCdHNyM0ZlZWRpbmdUZW5zaW9u", + "GCkgASgBEhwKFEVCdHNyNEZlZWRpbmdUZW5zaW9uGCogASgBEhIKCkVNaXhl", + "clRlbXAYKyABKAESFgoORUhlYWRab25lMVRlbXAYLCABKAESFgoORUhlYWRa", + "b25lMlRlbXAYLSABKAESFgoORUhlYWRab25lM1RlbXAYLiABKAESFwoPRURy", + "eWVyWm9uZTFUZW1wGC8gASgBEhcKD0VEcnllclpvbmUyVGVtcBgwIAEoARIX", + "Cg9FRHJ5ZXJab25lM1RlbXAYMSABKAESFgoORUx1YnJpY2FudFRlbXAYMiAB", + "KAESHQoVRURyeWVySW5jb21pbmdBaXJGbG93GDMgASgBEh0KFUVEcnllck91", + "dGdvaW5nQWlyRmxvdxg0IAEoARIeChZFVHVubmVsSW5jb21pbmdBaXJGbG93", + "GDUgASgBEh4KFkVUdW5uZWxPdXRnb2luZ0FpckZsb3cYNiABKAESFQoNRVdh", + "c3RlQWlyRmxvdxg3IAEoARIZChFFV2FzdGVQcmVwYXJlVGltZRg4IAEoARIR", + "CglFUHVtcFRlbXAYOSABKAESGAoQRVByZXNzdXJlQnVpbGRVcBg6IAEoARIP", + "CgdFU3BhcmUxGDsgASgBEg8KB0VTcGFyZTIYPCABKAESDwoHRVNwYXJlMxg9", + "IAEoARIPCgdFU3BhcmU0GD4gASgBEg8KB0VTcGFyZTUYPyABKAFCHgocY29t", + "LnR3aW5lLnRhbmdvLnBtci5wcmludGluZ2IGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Printing.ProcessParameters), global::Tango.PMR.Printing.ProcessParameters.Parser, new[]{ "DyeingSpeed", "MinInkUptake", "MaxInkUptake", "FeederTension", "PullerTension", "WinderTension", "MixerTemp", "HeadZone1Temp", "HeadZone2Temp", "HeadZone3Temp", "HeadZone4Temp", "HeadZone5Temp", "HeadZone6Temp", "DryerAirFlow", "DryerZone1Temp", "DryerZone2Temp", "DryerZone3Temp", "DryerBufferLength", "HeadAirFlow", "TableIndex", "HeadZone7Temp", "HeadZone8Temp", "HeadZone9Temp", "HeadZone10Temp", "HeadZone11Temp", "HeadZone12Temp", "RBlowerFlow", "RBlowerTemp", "LBlowerFlow", "LBlowerTemp", "PressureBuildUp", "BtsrFeedingTension", "ExitTension", "BtsrThreadLengthOffset" }, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Printing.ProcessParameters), global::Tango.PMR.Printing.ProcessParameters.Parser, new[]{ "DyeingSpeed", "MinInkUptake", "MaxInkUptake", "FeederTension", "PullerTension", "WinderTension", "MixerTemp", "HeadZone1Temp", "HeadZone2Temp", "HeadZone3Temp", "HeadZone4Temp", "HeadZone5Temp", "HeadZone6Temp", "DryerAirFlow", "DryerZone1Temp", "DryerZone2Temp", "DryerZone3Temp", "DryerBufferLength", "HeadAirFlow", "TableIndex", "HeadZone7Temp", "HeadZone8Temp", "HeadZone9Temp", "HeadZone10Temp", "HeadZone11Temp", "HeadZone12Temp", "RBlowerFlow", "RBlowerTemp", "LBlowerFlow", "LBlowerTemp", "PressureBuildUp", "BtsrFeedingTension", "ExitTension", "BtsrThreadLengthOffset", "EWinder1Tension", "EWinder2Tension", "EWinder3Tension", "EWinder4Tension", "EBtsr1FeedingTension", "EBtsr2FeedingTension", "EBtsr3FeedingTension", "EBtsr4FeedingTension", "EMixerTemp", "EHeadZone1Temp", "EHeadZone2Temp", "EHeadZone3Temp", "EDryerZone1Temp", "EDryerZone2Temp", "EDryerZone3Temp", "ELubricantTemp", "EDryerIncomingAirFlow", "EDryerOutgoingAirFlow", "ETunnelIncomingAirFlow", "ETunnelOutgoingAirFlow", "EWasteAirFlow", "EWastePrepareTime", "EPumpTemp", "EPressureBuildUp", "ESpare1", "ESpare2", "ESpare3", "ESpare4", "ESpare5" }, null, null, null) })); } #endregion @@ -110,6 +126,35 @@ namespace Tango.PMR.Printing { btsrFeedingTension_ = other.btsrFeedingTension_; exitTension_ = other.exitTension_; btsrThreadLengthOffset_ = other.btsrThreadLengthOffset_; + eWinder1Tension_ = other.eWinder1Tension_; + eWinder2Tension_ = other.eWinder2Tension_; + eWinder3Tension_ = other.eWinder3Tension_; + eWinder4Tension_ = other.eWinder4Tension_; + eBtsr1FeedingTension_ = other.eBtsr1FeedingTension_; + eBtsr2FeedingTension_ = other.eBtsr2FeedingTension_; + eBtsr3FeedingTension_ = other.eBtsr3FeedingTension_; + eBtsr4FeedingTension_ = other.eBtsr4FeedingTension_; + eMixerTemp_ = other.eMixerTemp_; + eHeadZone1Temp_ = other.eHeadZone1Temp_; + eHeadZone2Temp_ = other.eHeadZone2Temp_; + eHeadZone3Temp_ = other.eHeadZone3Temp_; + eDryerZone1Temp_ = other.eDryerZone1Temp_; + eDryerZone2Temp_ = other.eDryerZone2Temp_; + eDryerZone3Temp_ = other.eDryerZone3Temp_; + eLubricantTemp_ = other.eLubricantTemp_; + eDryerIncomingAirFlow_ = other.eDryerIncomingAirFlow_; + eDryerOutgoingAirFlow_ = other.eDryerOutgoingAirFlow_; + eTunnelIncomingAirFlow_ = other.eTunnelIncomingAirFlow_; + eTunnelOutgoingAirFlow_ = other.eTunnelOutgoingAirFlow_; + eWasteAirFlow_ = other.eWasteAirFlow_; + eWastePrepareTime_ = other.eWastePrepareTime_; + ePumpTemp_ = other.ePumpTemp_; + ePressureBuildUp_ = other.ePressureBuildUp_; + eSpare1_ = other.eSpare1_; + eSpare2_ = other.eSpare2_; + eSpare3_ = other.eSpare3_; + eSpare4_ = other.eSpare4_; + eSpare5_ = other.eSpare5_; } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -491,6 +536,325 @@ namespace Tango.PMR.Printing { } } + /// Field number for the "EWinder1Tension" field. + public const int EWinder1TensionFieldNumber = 35; + private double eWinder1Tension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWinder1Tension { + get { return eWinder1Tension_; } + set { + eWinder1Tension_ = value; + } + } + + /// Field number for the "EWinder2Tension" field. + public const int EWinder2TensionFieldNumber = 36; + private double eWinder2Tension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWinder2Tension { + get { return eWinder2Tension_; } + set { + eWinder2Tension_ = value; + } + } + + /// Field number for the "EWinder3Tension" field. + public const int EWinder3TensionFieldNumber = 37; + private double eWinder3Tension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWinder3Tension { + get { return eWinder3Tension_; } + set { + eWinder3Tension_ = value; + } + } + + /// Field number for the "EWinder4Tension" field. + public const int EWinder4TensionFieldNumber = 38; + private double eWinder4Tension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWinder4Tension { + get { return eWinder4Tension_; } + set { + eWinder4Tension_ = value; + } + } + + /// Field number for the "EBtsr1FeedingTension" field. + public const int EBtsr1FeedingTensionFieldNumber = 39; + private double eBtsr1FeedingTension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EBtsr1FeedingTension { + get { return eBtsr1FeedingTension_; } + set { + eBtsr1FeedingTension_ = value; + } + } + + /// Field number for the "EBtsr2FeedingTension" field. + public const int EBtsr2FeedingTensionFieldNumber = 40; + private double eBtsr2FeedingTension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EBtsr2FeedingTension { + get { return eBtsr2FeedingTension_; } + set { + eBtsr2FeedingTension_ = value; + } + } + + /// Field number for the "EBtsr3FeedingTension" field. + public const int EBtsr3FeedingTensionFieldNumber = 41; + private double eBtsr3FeedingTension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EBtsr3FeedingTension { + get { return eBtsr3FeedingTension_; } + set { + eBtsr3FeedingTension_ = value; + } + } + + /// Field number for the "EBtsr4FeedingTension" field. + public const int EBtsr4FeedingTensionFieldNumber = 42; + private double eBtsr4FeedingTension_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EBtsr4FeedingTension { + get { return eBtsr4FeedingTension_; } + set { + eBtsr4FeedingTension_ = value; + } + } + + /// Field number for the "EMixerTemp" field. + public const int EMixerTempFieldNumber = 43; + private double eMixerTemp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EMixerTemp { + get { return eMixerTemp_; } + set { + eMixerTemp_ = value; + } + } + + /// Field number for the "EHeadZone1Temp" field. + public const int EHeadZone1TempFieldNumber = 44; + private double eHeadZone1Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EHeadZone1Temp { + get { return eHeadZone1Temp_; } + set { + eHeadZone1Temp_ = value; + } + } + + /// Field number for the "EHeadZone2Temp" field. + public const int EHeadZone2TempFieldNumber = 45; + private double eHeadZone2Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EHeadZone2Temp { + get { return eHeadZone2Temp_; } + set { + eHeadZone2Temp_ = value; + } + } + + /// Field number for the "EHeadZone3Temp" field. + public const int EHeadZone3TempFieldNumber = 46; + private double eHeadZone3Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EHeadZone3Temp { + get { return eHeadZone3Temp_; } + set { + eHeadZone3Temp_ = value; + } + } + + /// Field number for the "EDryerZone1Temp" field. + public const int EDryerZone1TempFieldNumber = 47; + private double eDryerZone1Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EDryerZone1Temp { + get { return eDryerZone1Temp_; } + set { + eDryerZone1Temp_ = value; + } + } + + /// Field number for the "EDryerZone2Temp" field. + public const int EDryerZone2TempFieldNumber = 48; + private double eDryerZone2Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EDryerZone2Temp { + get { return eDryerZone2Temp_; } + set { + eDryerZone2Temp_ = value; + } + } + + /// Field number for the "EDryerZone3Temp" field. + public const int EDryerZone3TempFieldNumber = 49; + private double eDryerZone3Temp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EDryerZone3Temp { + get { return eDryerZone3Temp_; } + set { + eDryerZone3Temp_ = value; + } + } + + /// Field number for the "ELubricantTemp" field. + public const int ELubricantTempFieldNumber = 50; + private double eLubricantTemp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ELubricantTemp { + get { return eLubricantTemp_; } + set { + eLubricantTemp_ = value; + } + } + + /// Field number for the "EDryerIncomingAirFlow" field. + public const int EDryerIncomingAirFlowFieldNumber = 51; + private double eDryerIncomingAirFlow_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EDryerIncomingAirFlow { + get { return eDryerIncomingAirFlow_; } + set { + eDryerIncomingAirFlow_ = value; + } + } + + /// Field number for the "EDryerOutgoingAirFlow" field. + public const int EDryerOutgoingAirFlowFieldNumber = 52; + private double eDryerOutgoingAirFlow_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EDryerOutgoingAirFlow { + get { return eDryerOutgoingAirFlow_; } + set { + eDryerOutgoingAirFlow_ = value; + } + } + + /// Field number for the "ETunnelIncomingAirFlow" field. + public const int ETunnelIncomingAirFlowFieldNumber = 53; + private double eTunnelIncomingAirFlow_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ETunnelIncomingAirFlow { + get { return eTunnelIncomingAirFlow_; } + set { + eTunnelIncomingAirFlow_ = value; + } + } + + /// Field number for the "ETunnelOutgoingAirFlow" field. + public const int ETunnelOutgoingAirFlowFieldNumber = 54; + private double eTunnelOutgoingAirFlow_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ETunnelOutgoingAirFlow { + get { return eTunnelOutgoingAirFlow_; } + set { + eTunnelOutgoingAirFlow_ = value; + } + } + + /// Field number for the "EWasteAirFlow" field. + public const int EWasteAirFlowFieldNumber = 55; + private double eWasteAirFlow_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWasteAirFlow { + get { return eWasteAirFlow_; } + set { + eWasteAirFlow_ = value; + } + } + + /// Field number for the "EWastePrepareTime" field. + public const int EWastePrepareTimeFieldNumber = 56; + private double eWastePrepareTime_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EWastePrepareTime { + get { return eWastePrepareTime_; } + set { + eWastePrepareTime_ = value; + } + } + + /// Field number for the "EPumpTemp" field. + public const int EPumpTempFieldNumber = 57; + private double ePumpTemp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EPumpTemp { + get { return ePumpTemp_; } + set { + ePumpTemp_ = value; + } + } + + /// Field number for the "EPressureBuildUp" field. + public const int EPressureBuildUpFieldNumber = 58; + private double ePressureBuildUp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double EPressureBuildUp { + get { return ePressureBuildUp_; } + set { + ePressureBuildUp_ = value; + } + } + + /// Field number for the "ESpare1" field. + public const int ESpare1FieldNumber = 59; + private double eSpare1_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ESpare1 { + get { return eSpare1_; } + set { + eSpare1_ = value; + } + } + + /// Field number for the "ESpare2" field. + public const int ESpare2FieldNumber = 60; + private double eSpare2_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ESpare2 { + get { return eSpare2_; } + set { + eSpare2_ = value; + } + } + + /// Field number for the "ESpare3" field. + public const int ESpare3FieldNumber = 61; + private double eSpare3_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ESpare3 { + get { return eSpare3_; } + set { + eSpare3_ = value; + } + } + + /// Field number for the "ESpare4" field. + public const int ESpare4FieldNumber = 62; + private double eSpare4_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ESpare4 { + get { return eSpare4_; } + set { + eSpare4_ = value; + } + } + + /// Field number for the "ESpare5" field. + public const int ESpare5FieldNumber = 63; + private double eSpare5_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ESpare5 { + get { return eSpare5_; } + set { + eSpare5_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { return Equals(other as ProcessParameters); @@ -538,6 +902,35 @@ namespace Tango.PMR.Printing { if (BtsrFeedingTension != other.BtsrFeedingTension) return false; if (ExitTension != other.ExitTension) return false; if (BtsrThreadLengthOffset != other.BtsrThreadLengthOffset) return false; + if (EWinder1Tension != other.EWinder1Tension) return false; + if (EWinder2Tension != other.EWinder2Tension) return false; + if (EWinder3Tension != other.EWinder3Tension) return false; + if (EWinder4Tension != other.EWinder4Tension) return false; + if (EBtsr1FeedingTension != other.EBtsr1FeedingTension) return false; + if (EBtsr2FeedingTension != other.EBtsr2FeedingTension) return false; + if (EBtsr3FeedingTension != other.EBtsr3FeedingTension) return false; + if (EBtsr4FeedingTension != other.EBtsr4FeedingTension) return false; + if (EMixerTemp != other.EMixerTemp) return false; + if (EHeadZone1Temp != other.EHeadZone1Temp) return false; + if (EHeadZone2Temp != other.EHeadZone2Temp) return false; + if (EHeadZone3Temp != other.EHeadZone3Temp) return false; + if (EDryerZone1Temp != other.EDryerZone1Temp) return false; + if (EDryerZone2Temp != other.EDryerZone2Temp) return false; + if (EDryerZone3Temp != other.EDryerZone3Temp) return false; + if (ELubricantTemp != other.ELubricantTemp) return false; + if (EDryerIncomingAirFlow != other.EDryerIncomingAirFlow) return false; + if (EDryerOutgoingAirFlow != other.EDryerOutgoingAirFlow) return false; + if (ETunnelIncomingAirFlow != other.ETunnelIncomingAirFlow) return false; + if (ETunnelOutgoingAirFlow != other.ETunnelOutgoingAirFlow) return false; + if (EWasteAirFlow != other.EWasteAirFlow) return false; + if (EWastePrepareTime != other.EWastePrepareTime) return false; + if (EPumpTemp != other.EPumpTemp) return false; + if (EPressureBuildUp != other.EPressureBuildUp) return false; + if (ESpare1 != other.ESpare1) return false; + if (ESpare2 != other.ESpare2) return false; + if (ESpare3 != other.ESpare3) return false; + if (ESpare4 != other.ESpare4) return false; + if (ESpare5 != other.ESpare5) return false; return true; } @@ -578,6 +971,35 @@ namespace Tango.PMR.Printing { if (BtsrFeedingTension != 0D) hash ^= BtsrFeedingTension.GetHashCode(); if (ExitTension != 0D) hash ^= ExitTension.GetHashCode(); if (BtsrThreadLengthOffset != 0D) hash ^= BtsrThreadLengthOffset.GetHashCode(); + if (EWinder1Tension != 0D) hash ^= EWinder1Tension.GetHashCode(); + if (EWinder2Tension != 0D) hash ^= EWinder2Tension.GetHashCode(); + if (EWinder3Tension != 0D) hash ^= EWinder3Tension.GetHashCode(); + if (EWinder4Tension != 0D) hash ^= EWinder4Tension.GetHashCode(); + if (EBtsr1FeedingTension != 0D) hash ^= EBtsr1FeedingTension.GetHashCode(); + if (EBtsr2FeedingTension != 0D) hash ^= EBtsr2FeedingTension.GetHashCode(); + if (EBtsr3FeedingTension != 0D) hash ^= EBtsr3FeedingTension.GetHashCode(); + if (EBtsr4FeedingTension != 0D) hash ^= EBtsr4FeedingTension.GetHashCode(); + if (EMixerTemp != 0D) hash ^= EMixerTemp.GetHashCode(); + if (EHeadZone1Temp != 0D) hash ^= EHeadZone1Temp.GetHashCode(); + if (EHeadZone2Temp != 0D) hash ^= EHeadZone2Temp.GetHashCode(); + if (EHeadZone3Temp != 0D) hash ^= EHeadZone3Temp.GetHashCode(); + if (EDryerZone1Temp != 0D) hash ^= EDryerZone1Temp.GetHashCode(); + if (EDryerZone2Temp != 0D) hash ^= EDryerZone2Temp.GetHashCode(); + if (EDryerZone3Temp != 0D) hash ^= EDryerZone3Temp.GetHashCode(); + if (ELubricantTemp != 0D) hash ^= ELubricantTemp.GetHashCode(); + if (EDryerIncomingAirFlow != 0D) hash ^= EDryerIncomingAirFlow.GetHashCode(); + if (EDryerOutgoingAirFlow != 0D) hash ^= EDryerOutgoingAirFlow.GetHashCode(); + if (ETunnelIncomingAirFlow != 0D) hash ^= ETunnelIncomingAirFlow.GetHashCode(); + if (ETunnelOutgoingAirFlow != 0D) hash ^= ETunnelOutgoingAirFlow.GetHashCode(); + if (EWasteAirFlow != 0D) hash ^= EWasteAirFlow.GetHashCode(); + if (EWastePrepareTime != 0D) hash ^= EWastePrepareTime.GetHashCode(); + if (EPumpTemp != 0D) hash ^= EPumpTemp.GetHashCode(); + if (EPressureBuildUp != 0D) hash ^= EPressureBuildUp.GetHashCode(); + if (ESpare1 != 0D) hash ^= ESpare1.GetHashCode(); + if (ESpare2 != 0D) hash ^= ESpare2.GetHashCode(); + if (ESpare3 != 0D) hash ^= ESpare3.GetHashCode(); + if (ESpare4 != 0D) hash ^= ESpare4.GetHashCode(); + if (ESpare5 != 0D) hash ^= ESpare5.GetHashCode(); return hash; } @@ -724,6 +1146,122 @@ namespace Tango.PMR.Printing { output.WriteRawTag(145, 2); output.WriteDouble(BtsrThreadLengthOffset); } + if (EWinder1Tension != 0D) { + output.WriteRawTag(153, 2); + output.WriteDouble(EWinder1Tension); + } + if (EWinder2Tension != 0D) { + output.WriteRawTag(161, 2); + output.WriteDouble(EWinder2Tension); + } + if (EWinder3Tension != 0D) { + output.WriteRawTag(169, 2); + output.WriteDouble(EWinder3Tension); + } + if (EWinder4Tension != 0D) { + output.WriteRawTag(177, 2); + output.WriteDouble(EWinder4Tension); + } + if (EBtsr1FeedingTension != 0D) { + output.WriteRawTag(185, 2); + output.WriteDouble(EBtsr1FeedingTension); + } + if (EBtsr2FeedingTension != 0D) { + output.WriteRawTag(193, 2); + output.WriteDouble(EBtsr2FeedingTension); + } + if (EBtsr3FeedingTension != 0D) { + output.WriteRawTag(201, 2); + output.WriteDouble(EBtsr3FeedingTension); + } + if (EBtsr4FeedingTension != 0D) { + output.WriteRawTag(209, 2); + output.WriteDouble(EBtsr4FeedingTension); + } + if (EMixerTemp != 0D) { + output.WriteRawTag(217, 2); + output.WriteDouble(EMixerTemp); + } + if (EHeadZone1Temp != 0D) { + output.WriteRawTag(225, 2); + output.WriteDouble(EHeadZone1Temp); + } + if (EHeadZone2Temp != 0D) { + output.WriteRawTag(233, 2); + output.WriteDouble(EHeadZone2Temp); + } + if (EHeadZone3Temp != 0D) { + output.WriteRawTag(241, 2); + output.WriteDouble(EHeadZone3Temp); + } + if (EDryerZone1Temp != 0D) { + output.WriteRawTag(249, 2); + output.WriteDouble(EDryerZone1Temp); + } + if (EDryerZone2Temp != 0D) { + output.WriteRawTag(129, 3); + output.WriteDouble(EDryerZone2Temp); + } + if (EDryerZone3Temp != 0D) { + output.WriteRawTag(137, 3); + output.WriteDouble(EDryerZone3Temp); + } + if (ELubricantTemp != 0D) { + output.WriteRawTag(145, 3); + output.WriteDouble(ELubricantTemp); + } + if (EDryerIncomingAirFlow != 0D) { + output.WriteRawTag(153, 3); + output.WriteDouble(EDryerIncomingAirFlow); + } + if (EDryerOutgoingAirFlow != 0D) { + output.WriteRawTag(161, 3); + output.WriteDouble(EDryerOutgoingAirFlow); + } + if (ETunnelIncomingAirFlow != 0D) { + output.WriteRawTag(169, 3); + output.WriteDouble(ETunnelIncomingAirFlow); + } + if (ETunnelOutgoingAirFlow != 0D) { + output.WriteRawTag(177, 3); + output.WriteDouble(ETunnelOutgoingAirFlow); + } + if (EWasteAirFlow != 0D) { + output.WriteRawTag(185, 3); + output.WriteDouble(EWasteAirFlow); + } + if (EWastePrepareTime != 0D) { + output.WriteRawTag(193, 3); + output.WriteDouble(EWastePrepareTime); + } + if (EPumpTemp != 0D) { + output.WriteRawTag(201, 3); + output.WriteDouble(EPumpTemp); + } + if (EPressureBuildUp != 0D) { + output.WriteRawTag(209, 3); + output.WriteDouble(EPressureBuildUp); + } + if (ESpare1 != 0D) { + output.WriteRawTag(217, 3); + output.WriteDouble(ESpare1); + } + if (ESpare2 != 0D) { + output.WriteRawTag(225, 3); + output.WriteDouble(ESpare2); + } + if (ESpare3 != 0D) { + output.WriteRawTag(233, 3); + output.WriteDouble(ESpare3); + } + if (ESpare4 != 0D) { + output.WriteRawTag(241, 3); + output.WriteDouble(ESpare4); + } + if (ESpare5 != 0D) { + output.WriteRawTag(249, 3); + output.WriteDouble(ESpare5); + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -831,6 +1369,93 @@ namespace Tango.PMR.Printing { if (BtsrThreadLengthOffset != 0D) { size += 2 + 8; } + if (EWinder1Tension != 0D) { + size += 2 + 8; + } + if (EWinder2Tension != 0D) { + size += 2 + 8; + } + if (EWinder3Tension != 0D) { + size += 2 + 8; + } + if (EWinder4Tension != 0D) { + size += 2 + 8; + } + if (EBtsr1FeedingTension != 0D) { + size += 2 + 8; + } + if (EBtsr2FeedingTension != 0D) { + size += 2 + 8; + } + if (EBtsr3FeedingTension != 0D) { + size += 2 + 8; + } + if (EBtsr4FeedingTension != 0D) { + size += 2 + 8; + } + if (EMixerTemp != 0D) { + size += 2 + 8; + } + if (EHeadZone1Temp != 0D) { + size += 2 + 8; + } + if (EHeadZone2Temp != 0D) { + size += 2 + 8; + } + if (EHeadZone3Temp != 0D) { + size += 2 + 8; + } + if (EDryerZone1Temp != 0D) { + size += 2 + 8; + } + if (EDryerZone2Temp != 0D) { + size += 2 + 8; + } + if (EDryerZone3Temp != 0D) { + size += 2 + 8; + } + if (ELubricantTemp != 0D) { + size += 2 + 8; + } + if (EDryerIncomingAirFlow != 0D) { + size += 2 + 8; + } + if (EDryerOutgoingAirFlow != 0D) { + size += 2 + 8; + } + if (ETunnelIncomingAirFlow != 0D) { + size += 2 + 8; + } + if (ETunnelOutgoingAirFlow != 0D) { + size += 2 + 8; + } + if (EWasteAirFlow != 0D) { + size += 2 + 8; + } + if (EWastePrepareTime != 0D) { + size += 2 + 8; + } + if (EPumpTemp != 0D) { + size += 2 + 8; + } + if (EPressureBuildUp != 0D) { + size += 2 + 8; + } + if (ESpare1 != 0D) { + size += 2 + 8; + } + if (ESpare2 != 0D) { + size += 2 + 8; + } + if (ESpare3 != 0D) { + size += 2 + 8; + } + if (ESpare4 != 0D) { + size += 2 + 8; + } + if (ESpare5 != 0D) { + size += 2 + 8; + } return size; } @@ -941,6 +1566,93 @@ namespace Tango.PMR.Printing { if (other.BtsrThreadLengthOffset != 0D) { BtsrThreadLengthOffset = other.BtsrThreadLengthOffset; } + if (other.EWinder1Tension != 0D) { + EWinder1Tension = other.EWinder1Tension; + } + if (other.EWinder2Tension != 0D) { + EWinder2Tension = other.EWinder2Tension; + } + if (other.EWinder3Tension != 0D) { + EWinder3Tension = other.EWinder3Tension; + } + if (other.EWinder4Tension != 0D) { + EWinder4Tension = other.EWinder4Tension; + } + if (other.EBtsr1FeedingTension != 0D) { + EBtsr1FeedingTension = other.EBtsr1FeedingTension; + } + if (other.EBtsr2FeedingTension != 0D) { + EBtsr2FeedingTension = other.EBtsr2FeedingTension; + } + if (other.EBtsr3FeedingTension != 0D) { + EBtsr3FeedingTension = other.EBtsr3FeedingTension; + } + if (other.EBtsr4FeedingTension != 0D) { + EBtsr4FeedingTension = other.EBtsr4FeedingTension; + } + if (other.EMixerTemp != 0D) { + EMixerTemp = other.EMixerTemp; + } + if (other.EHeadZone1Temp != 0D) { + EHeadZone1Temp = other.EHeadZone1Temp; + } + if (other.EHeadZone2Temp != 0D) { + EHeadZone2Temp = other.EHeadZone2Temp; + } + if (other.EHeadZone3Temp != 0D) { + EHeadZone3Temp = other.EHeadZone3Temp; + } + if (other.EDryerZone1Temp != 0D) { + EDryerZone1Temp = other.EDryerZone1Temp; + } + if (other.EDryerZone2Temp != 0D) { + EDryerZone2Temp = other.EDryerZone2Temp; + } + if (other.EDryerZone3Temp != 0D) { + EDryerZone3Temp = other.EDryerZone3Temp; + } + if (other.ELubricantTemp != 0D) { + ELubricantTemp = other.ELubricantTemp; + } + if (other.EDryerIncomingAirFlow != 0D) { + EDryerIncomingAirFlow = other.EDryerIncomingAirFlow; + } + if (other.EDryerOutgoingAirFlow != 0D) { + EDryerOutgoingAirFlow = other.EDryerOutgoingAirFlow; + } + if (other.ETunnelIncomingAirFlow != 0D) { + ETunnelIncomingAirFlow = other.ETunnelIncomingAirFlow; + } + if (other.ETunnelOutgoingAirFlow != 0D) { + ETunnelOutgoingAirFlow = other.ETunnelOutgoingAirFlow; + } + if (other.EWasteAirFlow != 0D) { + EWasteAirFlow = other.EWasteAirFlow; + } + if (other.EWastePrepareTime != 0D) { + EWastePrepareTime = other.EWastePrepareTime; + } + if (other.EPumpTemp != 0D) { + EPumpTemp = other.EPumpTemp; + } + if (other.EPressureBuildUp != 0D) { + EPressureBuildUp = other.EPressureBuildUp; + } + if (other.ESpare1 != 0D) { + ESpare1 = other.ESpare1; + } + if (other.ESpare2 != 0D) { + ESpare2 = other.ESpare2; + } + if (other.ESpare3 != 0D) { + ESpare3 = other.ESpare3; + } + if (other.ESpare4 != 0D) { + ESpare4 = other.ESpare4; + } + if (other.ESpare5 != 0D) { + ESpare5 = other.ESpare5; + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -1087,6 +1799,122 @@ namespace Tango.PMR.Printing { BtsrThreadLengthOffset = input.ReadDouble(); break; } + case 281: { + EWinder1Tension = input.ReadDouble(); + break; + } + case 289: { + EWinder2Tension = input.ReadDouble(); + break; + } + case 297: { + EWinder3Tension = input.ReadDouble(); + break; + } + case 305: { + EWinder4Tension = input.ReadDouble(); + break; + } + case 313: { + EBtsr1FeedingTension = input.ReadDouble(); + break; + } + case 321: { + EBtsr2FeedingTension = input.ReadDouble(); + break; + } + case 329: { + EBtsr3FeedingTension = input.ReadDouble(); + break; + } + case 337: { + EBtsr4FeedingTension = input.ReadDouble(); + break; + } + case 345: { + EMixerTemp = input.ReadDouble(); + break; + } + case 353: { + EHeadZone1Temp = input.ReadDouble(); + break; + } + case 361: { + EHeadZone2Temp = input.ReadDouble(); + break; + } + case 369: { + EHeadZone3Temp = input.ReadDouble(); + break; + } + case 377: { + EDryerZone1Temp = input.ReadDouble(); + break; + } + case 385: { + EDryerZone2Temp = input.ReadDouble(); + break; + } + case 393: { + EDryerZone3Temp = input.ReadDouble(); + break; + } + case 401: { + ELubricantTemp = input.ReadDouble(); + break; + } + case 409: { + EDryerIncomingAirFlow = input.ReadDouble(); + break; + } + case 417: { + EDryerOutgoingAirFlow = input.ReadDouble(); + break; + } + case 425: { + ETunnelIncomingAirFlow = input.ReadDouble(); + break; + } + case 433: { + ETunnelOutgoingAirFlow = input.ReadDouble(); + break; + } + case 441: { + EWasteAirFlow = input.ReadDouble(); + break; + } + case 449: { + EWastePrepareTime = input.ReadDouble(); + break; + } + case 457: { + EPumpTemp = input.ReadDouble(); + break; + } + case 465: { + EPressureBuildUp = input.ReadDouble(); + break; + } + case 473: { + ESpare1 = input.ReadDouble(); + break; + } + case 481: { + ESpare2 = input.ReadDouble(); + break; + } + case 489: { + ESpare3 = input.ReadDouble(); + break; + } + case 497: { + ESpare4 = input.ReadDouble(); + break; + } + case 505: { + ESpare5 = input.ReadDouble(); + break; + } } } } -- cgit v1.3.1