Added new PID and heaters to hw, diagnostics and tech.

Implemented proper sorting on hw version and tech board. (DB CHANGE!)

Related Work Items: #1595

5 files changed, 879 insertions, 7 deletions

diff --git a/Software/Visual_Studio/Tango.PMR/Diagnostics/DiagnosticsMonitors.cs b/Software/Visual_Studio/Tango.PMR/Diagnostics/DiagnosticsMonitors.cs
index ea6dfb0cb..dae46d41b 100644
--- a/Software/Visual_Studio/Tango.PMR/Diagnostics/DiagnosticsMonitors.cs
+++ b/Software/Visual_Studio/Tango.PMR/Diagnostics/DiagnosticsMonitors.cs
@@ -23,7 +23,7 @@ namespace Tango.PMR.Diagnostics {
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
             "ChlEaWFnbm9zdGljc01vbml0b3JzLnByb3RvEhVUYW5nby5QTVIuRGlhZ25v",
-            "c3RpY3MaEURvdWJsZUFycmF5LnByb3RvIp8QChNEaWFnbm9zdGljc01vbml0",
+            "c3RpY3MaEURvdWJsZUFycmF5LnByb3RvIvgUChNEaWFnbm9zdGljc01vbml0",
             "b3JzEhQKDERhbmNlcjFBbmdsZRgBIAMoARIUCgxEYW5jZXIyQW5nbGUYAiAD",
             "KAESFAoMRGFuY2VyM0FuZ2xlGAMgAygBEhwKFEZlZWRlck1vdG9yRnJlcXVl",
             "bmN5GAQgAygBEhIKCkRyeWVyTW90b3IYBSADKAESEwoLUG9sbGVyTW90b3IY",
@@ -69,12 +69,26 @@ namespace Tango.PMR.Diagnostics {
             "YXRlckN1cnJlbnQYPyADKAESPgoSRGlzcGVuc2Vyc0lua0xldmVsGEAgAygL",
             "MiIuVGFuZ28uUE1SLkRpYWdub3N0aWNzLkRvdWJsZUFycmF5EjwKEE1pZFRh",
             "bmtzSW5rTGV2ZWwYQSADKAsyIi5UYW5nby5QTVIuRGlhZ25vc3RpY3MuRG91",
-            "YmxlQXJyYXkSGgoST3ZlcmFsbFRlbXBlcmF0dXJlGEIgAygBQiEKH2NvbS50",
-            "d2luZS50YW5nby5wbXIuZGlhZ25vc3RpY3NiBnByb3RvMw=="));
+            "YmxlQXJyYXkSGgoST3ZlcmFsbFRlbXBlcmF0dXJlGEIgAygBEh4KFkhlYWRa",
+            "b25lN0hlYXRlckN1cnJlbnQYQyADKAESHAoUSGVhZFpvbmU3VGVtcGVyYXR1",
+            "cmUYRCADKAESHgoWSGVhZFpvbmU4SGVhdGVyQ3VycmVudBhFIAMoARIcChRI",
+            "ZWFkWm9uZThUZW1wZXJhdHVyZRhGIAMoARIeChZIZWFkWm9uZTlIZWF0ZXJD",
+            "dXJyZW50GEcgAygBEhwKFEhlYWRab25lOVRlbXBlcmF0dXJlGEggAygBEh8K",
+            "F0hlYWRab25lMTBIZWF0ZXJDdXJyZW50GEkgAygBEh0KFUhlYWRab25lMTBU",
+            "ZW1wZXJhdHVyZRhKIAMoARIfChdIZWFkWm9uZTExSGVhdGVyQ3VycmVudBhL",
+            "IAMoARIdChVIZWFkWm9uZTExVGVtcGVyYXR1cmUYTCADKAESHwoXSGVhZFpv",
+            "bmUxMkhlYXRlckN1cnJlbnQYTSADKAESHQoVSGVhZFpvbmUxMlRlbXBlcmF0",
+            "dXJlGE4gAygBEhoKEkhlYWRCbG93ZXJWb2x0YWdlMRhPIAMoARIaChJIZWFk",
+            "Qmxvd2VyVm9sdGFnZTIYUCADKAESHwoXSGVhZENvdmVySGVhdGVyMUN1cnJl",
+            "bnQYUSADKAESIwobSGVhZENvdmVySGVhdGVyMVRlbXBlcmF0dXJlGFIgAygB",
+            "Eh8KF0hlYWRDb3ZlckhlYXRlcjJDdXJyZW50GFMgAygBEiMKG0hlYWRDb3Zl",
+            "ckhlYXRlcjJUZW1wZXJhdHVyZRhUIAMoARIZChFXSFNCbG93ZXIyVm9sdGFn",
+            "ZRhVIAMoAUIhCh9jb20udHdpbmUudGFuZ28ucG1yLmRpYWdub3N0aWNzYgZw",
+            "cm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::Tango.PMR.Diagnostics.DoubleArrayReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
-            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Diagnostics.DiagnosticsMonitors), global::Tango.PMR.Diagnostics.DiagnosticsMonitors.Parser, new[]{ "Dancer1Angle", "Dancer2Angle", "Dancer3Angle", "FeederMotorFrequency", "DryerMotor", "PollerMotor", "WinderMotor", "ScrewMotor", "ThreadSpeed", "MixerTemperature", "HeadZone1Temperature", "HeadZone2Temperature", "HeadZone3Temperature", "HeadAirFlow", "FeederTension", "PullerTension", "DryerZone1Temperature", "DryerZone2Temperature", "DryerZone3Temperature", "DryerAirFlow", "WinderTension", "DispensersMotorsFrequency", "DispensersAngularEncoders", "DispensersLinearPositions", "DispensersPressure", "FilterDeltaPressure", "ChillerTemperature", "Dispenser1MotorFrequency", "Dispenser2MotorFrequency", "Dispenser3MotorFrequency", "Dispenser4MotorFrequency", "Dispenser5MotorFrequency", "Dispenser6MotorFrequency", "Dispenser7MotorFrequency", "Dispenser8MotorFrequency", "HeadZone4Temperature", "HeadZone5Temperature", "HeadZone6Temperature", "BlowerVoltage", "Dispenser1Pressure", "Dispenser2Pressure", "Dispenser3Pressure", "Dispenser4Pressure", "Dispenser5Pressure", "Dispenser6Pressure", "Dispenser7Pressure", "Dispenser8Pressure", "MidTank1Level", "MidTank2Level", "MidTank3Level", "MidTank4Level", "MidTank5Level", "MidTank6Level", "MidTank7Level", "MidTank8Level", "DrierZone1HeaterCurrent", "DrierZone2HeaterCurrent", "HeadZone1HeaterCurrent", "HeadZone2HeaterCurrent", "HeadZone3HeaterCurrent", "HeadZone4HeaterCurrent", "HeadZone56HeaterCurrent", "Mixer1HeaterCurrent", "DispensersInkLevel", "MidTanksInkLevel", "OverallTemperature" }, null, null, null)
+            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Diagnostics.DiagnosticsMonitors), global::Tango.PMR.Diagnostics.DiagnosticsMonitors.Parser, new[]{ "Dancer1Angle", "Dancer2Angle", "Dancer3Angle", "FeederMotorFrequency", "DryerMotor", "PollerMotor", "WinderMotor", "ScrewMotor", "ThreadSpeed", "MixerTemperature", "HeadZone1Temperature", "HeadZone2Temperature", "HeadZone3Temperature", "HeadAirFlow", "FeederTension", "PullerTension", "DryerZone1Temperature", "DryerZone2Temperature", "DryerZone3Temperature", "DryerAirFlow", "WinderTension", "DispensersMotorsFrequency", "DispensersAngularEncoders", "DispensersLinearPositions", "DispensersPressure", "FilterDeltaPressure", "ChillerTemperature", "Dispenser1MotorFrequency", "Dispenser2MotorFrequency", "Dispenser3MotorFrequency", "Dispenser4MotorFrequency", "Dispenser5MotorFrequency", "Dispenser6MotorFrequency", "Dispenser7MotorFrequency", "Dispenser8MotorFrequency", "HeadZone4Temperature", "HeadZone5Temperature", "HeadZone6Temperature", "BlowerVoltage", "Dispenser1Pressure", "Dispenser2Pressure", "Dispenser3Pressure", "Dispenser4Pressure", "Dispenser5Pressure", "Dispenser6Pressure", "Dispenser7Pressure", "Dispenser8Pressure", "MidTank1Level", "MidTank2Level", "MidTank3Level", "MidTank4Level", "MidTank5Level", "MidTank6Level", "MidTank7Level", "MidTank8Level", "DrierZone1HeaterCurrent", "DrierZone2HeaterCurrent", "HeadZone1HeaterCurrent", "HeadZone2HeaterCurrent", "HeadZone3HeaterCurrent", "HeadZone4HeaterCurrent", "HeadZone56HeaterCurrent", "Mixer1HeaterCurrent", "DispensersInkLevel", "MidTanksInkLevel", "OverallTemperature", "HeadZone7HeaterCurrent", "HeadZone7Temperature", "HeadZone8HeaterCurrent", "HeadZone8Temperature", "HeadZone9HeaterCurrent", "HeadZone9Temperature", "HeadZone10HeaterCurrent", "HeadZone10Temperature", "HeadZone11HeaterCurrent", "HeadZone11Temperature", "HeadZone12HeaterCurrent", "HeadZone12Temperature", "HeadBlowerVoltage1", "HeadBlowerVoltage2", "HeadCoverHeater1Current", "HeadCoverHeater1Temperature", "HeadCoverHeater2Current", "HeadCoverHeater2Temperature", "WHSBlower2Voltage" }, null, null, null)
           }));
     }
     #endregion
@@ -171,6 +185,25 @@ namespace Tango.PMR.Diagnostics {
       dispensersInkLevel_ = other.dispensersInkLevel_.Clone();
       midTanksInkLevel_ = other.midTanksInkLevel_.Clone();
       overallTemperature_ = other.overallTemperature_.Clone();
+      headZone7HeaterCurrent_ = other.headZone7HeaterCurrent_.Clone();
+      headZone7Temperature_ = other.headZone7Temperature_.Clone();
+      headZone8HeaterCurrent_ = other.headZone8HeaterCurrent_.Clone();
+      headZone8Temperature_ = other.headZone8Temperature_.Clone();
+      headZone9HeaterCurrent_ = other.headZone9HeaterCurrent_.Clone();
+      headZone9Temperature_ = other.headZone9Temperature_.Clone();
+      headZone10HeaterCurrent_ = other.headZone10HeaterCurrent_.Clone();
+      headZone10Temperature_ = other.headZone10Temperature_.Clone();
+      headZone11HeaterCurrent_ = other.headZone11HeaterCurrent_.Clone();
+      headZone11Temperature_ = other.headZone11Temperature_.Clone();
+      headZone12HeaterCurrent_ = other.headZone12HeaterCurrent_.Clone();
+      headZone12Temperature_ = other.headZone12Temperature_.Clone();
+      headBlowerVoltage1_ = other.headBlowerVoltage1_.Clone();
+      headBlowerVoltage2_ = other.headBlowerVoltage2_.Clone();
+      headCoverHeater1Current_ = other.headCoverHeater1Current_.Clone();
+      headCoverHeater1Temperature_ = other.headCoverHeater1Temperature_.Clone();
+      headCoverHeater2Current_ = other.headCoverHeater2Current_.Clone();
+      headCoverHeater2Temperature_ = other.headCoverHeater2Temperature_.Clone();
+      wHSBlower2Voltage_ = other.wHSBlower2Voltage_.Clone();
     }
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
@@ -1036,6 +1069,253 @@ namespace Tango.PMR.Diagnostics {
       get { return overallTemperature_; }
     }
 
+    /// <summary>Field number for the "HeadZone7HeaterCurrent" field.</summary>
+    public const int HeadZone7HeaterCurrentFieldNumber = 67;
+    private static readonly pb::FieldCodec<double> _repeated_headZone7HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(538);
+    private readonly pbc::RepeatedField<double> headZone7HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 7 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone7HeaterCurrent {
+      get { return headZone7HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone7Temperature" field.</summary>
+    public const int HeadZone7TemperatureFieldNumber = 68;
+    private static readonly pb::FieldCodec<double> _repeated_headZone7Temperature_codec
+        = pb::FieldCodec.ForDouble(546);
+    private readonly pbc::RepeatedField<double> headZone7Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 7 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone7Temperature {
+      get { return headZone7Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadZone8HeaterCurrent" field.</summary>
+    public const int HeadZone8HeaterCurrentFieldNumber = 69;
+    private static readonly pb::FieldCodec<double> _repeated_headZone8HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(554);
+    private readonly pbc::RepeatedField<double> headZone8HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 8 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone8HeaterCurrent {
+      get { return headZone8HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone8Temperature" field.</summary>
+    public const int HeadZone8TemperatureFieldNumber = 70;
+    private static readonly pb::FieldCodec<double> _repeated_headZone8Temperature_codec
+        = pb::FieldCodec.ForDouble(562);
+    private readonly pbc::RepeatedField<double> headZone8Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 8 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone8Temperature {
+      get { return headZone8Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadZone9HeaterCurrent" field.</summary>
+    public const int HeadZone9HeaterCurrentFieldNumber = 71;
+    private static readonly pb::FieldCodec<double> _repeated_headZone9HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(570);
+    private readonly pbc::RepeatedField<double> headZone9HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 9 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone9HeaterCurrent {
+      get { return headZone9HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone9Temperature" field.</summary>
+    public const int HeadZone9TemperatureFieldNumber = 72;
+    private static readonly pb::FieldCodec<double> _repeated_headZone9Temperature_codec
+        = pb::FieldCodec.ForDouble(578);
+    private readonly pbc::RepeatedField<double> headZone9Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 9 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone9Temperature {
+      get { return headZone9Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadZone10HeaterCurrent" field.</summary>
+    public const int HeadZone10HeaterCurrentFieldNumber = 73;
+    private static readonly pb::FieldCodec<double> _repeated_headZone10HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(586);
+    private readonly pbc::RepeatedField<double> headZone10HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 10 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone10HeaterCurrent {
+      get { return headZone10HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone10Temperature" field.</summary>
+    public const int HeadZone10TemperatureFieldNumber = 74;
+    private static readonly pb::FieldCodec<double> _repeated_headZone10Temperature_codec
+        = pb::FieldCodec.ForDouble(594);
+    private readonly pbc::RepeatedField<double> headZone10Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 10 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone10Temperature {
+      get { return headZone10Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadZone11HeaterCurrent" field.</summary>
+    public const int HeadZone11HeaterCurrentFieldNumber = 75;
+    private static readonly pb::FieldCodec<double> _repeated_headZone11HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(602);
+    private readonly pbc::RepeatedField<double> headZone11HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 11 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone11HeaterCurrent {
+      get { return headZone11HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone11Temperature" field.</summary>
+    public const int HeadZone11TemperatureFieldNumber = 76;
+    private static readonly pb::FieldCodec<double> _repeated_headZone11Temperature_codec
+        = pb::FieldCodec.ForDouble(610);
+    private readonly pbc::RepeatedField<double> headZone11Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 11 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone11Temperature {
+      get { return headZone11Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadZone12HeaterCurrent" field.</summary>
+    public const int HeadZone12HeaterCurrentFieldNumber = 77;
+    private static readonly pb::FieldCodec<double> _repeated_headZone12HeaterCurrent_codec
+        = pb::FieldCodec.ForDouble(618);
+    private readonly pbc::RepeatedField<double> headZone12HeaterCurrent_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 12 Heater Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone12HeaterCurrent {
+      get { return headZone12HeaterCurrent_; }
+    }
+
+    /// <summary>Field number for the "HeadZone12Temperature" field.</summary>
+    public const int HeadZone12TemperatureFieldNumber = 78;
+    private static readonly pb::FieldCodec<double> _repeated_headZone12Temperature_codec
+        = pb::FieldCodec.ForDouble(626);
+    private readonly pbc::RepeatedField<double> headZone12Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Zone 12 (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadZone12Temperature {
+      get { return headZone12Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadBlowerVoltage1" field.</summary>
+    public const int HeadBlowerVoltage1FieldNumber = 79;
+    private static readonly pb::FieldCodec<double> _repeated_headBlowerVoltage1_codec
+        = pb::FieldCodec.ForDouble(634);
+    private readonly pbc::RepeatedField<double> headBlowerVoltage1_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Blower Voltage 1 (Min = 0, Max = 100, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadBlowerVoltage1 {
+      get { return headBlowerVoltage1_; }
+    }
+
+    /// <summary>Field number for the "HeadBlowerVoltage2" field.</summary>
+    public const int HeadBlowerVoltage2FieldNumber = 80;
+    private static readonly pb::FieldCodec<double> _repeated_headBlowerVoltage2_codec
+        = pb::FieldCodec.ForDouble(642);
+    private readonly pbc::RepeatedField<double> headBlowerVoltage2_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Blower Voltage 2 (Min = 0, Max = 100, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadBlowerVoltage2 {
+      get { return headBlowerVoltage2_; }
+    }
+
+    /// <summary>Field number for the "HeadCoverHeater1Current" field.</summary>
+    public const int HeadCoverHeater1CurrentFieldNumber = 81;
+    private static readonly pb::FieldCodec<double> _repeated_headCoverHeater1Current_codec
+        = pb::FieldCodec.ForDouble(650);
+    private readonly pbc::RepeatedField<double> headCoverHeater1Current_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Cover Heater 1 Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadCoverHeater1Current {
+      get { return headCoverHeater1Current_; }
+    }
+
+    /// <summary>Field number for the "HeadCoverHeater1Temperature" field.</summary>
+    public const int HeadCoverHeater1TemperatureFieldNumber = 82;
+    private static readonly pb::FieldCodec<double> _repeated_headCoverHeater1Temperature_codec
+        = pb::FieldCodec.ForDouble(658);
+    private readonly pbc::RepeatedField<double> headCoverHeater1Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Cover Heater 1 Temperature (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadCoverHeater1Temperature {
+      get { return headCoverHeater1Temperature_; }
+    }
+
+    /// <summary>Field number for the "HeadCoverHeater2Current" field.</summary>
+    public const int HeadCoverHeater2CurrentFieldNumber = 83;
+    private static readonly pb::FieldCodec<double> _repeated_headCoverHeater2Current_codec
+        = pb::FieldCodec.ForDouble(666);
+    private readonly pbc::RepeatedField<double> headCoverHeater2Current_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Cover Heater 2 Current (Min = 0, Max = 100, PPF = 1)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadCoverHeater2Current {
+      get { return headCoverHeater2Current_; }
+    }
+
+    /// <summary>Field number for the "HeadCoverHeater2Temperature" field.</summary>
+    public const int HeadCoverHeater2TemperatureFieldNumber = 84;
+    private static readonly pb::FieldCodec<double> _repeated_headCoverHeater2Temperature_codec
+        = pb::FieldCodec.ForDouble(674);
+    private readonly pbc::RepeatedField<double> headCoverHeater2Temperature_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///Head Cover Heater 2 Temperature (Min = 0, Max = 300, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> HeadCoverHeater2Temperature {
+      get { return headCoverHeater2Temperature_; }
+    }
+
+    /// <summary>Field number for the "WHSBlower2Voltage" field.</summary>
+    public const int WHSBlower2VoltageFieldNumber = 85;
+    private static readonly pb::FieldCodec<double> _repeated_wHSBlower2Voltage_codec
+        = pb::FieldCodec.ForDouble(682);
+    private readonly pbc::RepeatedField<double> wHSBlower2Voltage_ = new pbc::RepeatedField<double>();
+    /// <summary>
+    ///WHS Blower 2 Voltage (Min = 0, Max = 100, PPF = 10)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<double> WHSBlower2Voltage {
+      get { return wHSBlower2Voltage_; }
+    }
+
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as DiagnosticsMonitors);
@@ -1115,6 +1395,25 @@ namespace Tango.PMR.Diagnostics {
       if(!dispensersInkLevel_.Equals(other.dispensersInkLevel_)) return false;
       if(!midTanksInkLevel_.Equals(other.midTanksInkLevel_)) return false;
       if(!overallTemperature_.Equals(other.overallTemperature_)) return false;
+      if(!headZone7HeaterCurrent_.Equals(other.headZone7HeaterCurrent_)) return false;
+      if(!headZone7Temperature_.Equals(other.headZone7Temperature_)) return false;
+      if(!headZone8HeaterCurrent_.Equals(other.headZone8HeaterCurrent_)) return false;
+      if(!headZone8Temperature_.Equals(other.headZone8Temperature_)) return false;
+      if(!headZone9HeaterCurrent_.Equals(other.headZone9HeaterCurrent_)) return false;
+      if(!headZone9Temperature_.Equals(other.headZone9Temperature_)) return false;
+      if(!headZone10HeaterCurrent_.Equals(other.headZone10HeaterCurrent_)) return false;
+      if(!headZone10Temperature_.Equals(other.headZone10Temperature_)) return false;
+      if(!headZone11HeaterCurrent_.Equals(other.headZone11HeaterCurrent_)) return false;
+      if(!headZone11Temperature_.Equals(other.headZone11Temperature_)) return false;
+      if(!headZone12HeaterCurrent_.Equals(other.headZone12HeaterCurrent_)) return false;
+      if(!headZone12Temperature_.Equals(other.headZone12Temperature_)) return false;
+      if(!headBlowerVoltage1_.Equals(other.headBlowerVoltage1_)) return false;
+      if(!headBlowerVoltage2_.Equals(other.headBlowerVoltage2_)) return false;
+      if(!headCoverHeater1Current_.Equals(other.headCoverHeater1Current_)) return false;
+      if(!headCoverHeater1Temperature_.Equals(other.headCoverHeater1Temperature_)) return false;
+      if(!headCoverHeater2Current_.Equals(other.headCoverHeater2Current_)) return false;
+      if(!headCoverHeater2Temperature_.Equals(other.headCoverHeater2Temperature_)) return false;
+      if(!wHSBlower2Voltage_.Equals(other.wHSBlower2Voltage_)) return false;
       return true;
     }
 
@@ -1187,6 +1486,25 @@ namespace Tango.PMR.Diagnostics {
       hash ^= dispensersInkLevel_.GetHashCode();
       hash ^= midTanksInkLevel_.GetHashCode();
       hash ^= overallTemperature_.GetHashCode();
+      hash ^= headZone7HeaterCurrent_.GetHashCode();
+      hash ^= headZone7Temperature_.GetHashCode();
+      hash ^= headZone8HeaterCurrent_.GetHashCode();
+      hash ^= headZone8Temperature_.GetHashCode();
+      hash ^= headZone9HeaterCurrent_.GetHashCode();
+      hash ^= headZone9Temperature_.GetHashCode();
+      hash ^= headZone10HeaterCurrent_.GetHashCode();
+      hash ^= headZone10Temperature_.GetHashCode();
+      hash ^= headZone11HeaterCurrent_.GetHashCode();
+      hash ^= headZone11Temperature_.GetHashCode();
+      hash ^= headZone12HeaterCurrent_.GetHashCode();
+      hash ^= headZone12Temperature_.GetHashCode();
+      hash ^= headBlowerVoltage1_.GetHashCode();
+      hash ^= headBlowerVoltage2_.GetHashCode();
+      hash ^= headCoverHeater1Current_.GetHashCode();
+      hash ^= headCoverHeater1Temperature_.GetHashCode();
+      hash ^= headCoverHeater2Current_.GetHashCode();
+      hash ^= headCoverHeater2Temperature_.GetHashCode();
+      hash ^= wHSBlower2Voltage_.GetHashCode();
       return hash;
     }
 
@@ -1263,6 +1581,25 @@ namespace Tango.PMR.Diagnostics {
       dispensersInkLevel_.WriteTo(output, _repeated_dispensersInkLevel_codec);
       midTanksInkLevel_.WriteTo(output, _repeated_midTanksInkLevel_codec);
       overallTemperature_.WriteTo(output, _repeated_overallTemperature_codec);
+      headZone7HeaterCurrent_.WriteTo(output, _repeated_headZone7HeaterCurrent_codec);
+      headZone7Temperature_.WriteTo(output, _repeated_headZone7Temperature_codec);
+      headZone8HeaterCurrent_.WriteTo(output, _repeated_headZone8HeaterCurrent_codec);
+      headZone8Temperature_.WriteTo(output, _repeated_headZone8Temperature_codec);
+      headZone9HeaterCurrent_.WriteTo(output, _repeated_headZone9HeaterCurrent_codec);
+      headZone9Temperature_.WriteTo(output, _repeated_headZone9Temperature_codec);
+      headZone10HeaterCurrent_.WriteTo(output, _repeated_headZone10HeaterCurrent_codec);
+      headZone10Temperature_.WriteTo(output, _repeated_headZone10Temperature_codec);
+      headZone11HeaterCurrent_.WriteTo(output, _repeated_headZone11HeaterCurrent_codec);
+      headZone11Temperature_.WriteTo(output, _repeated_headZone11Temperature_codec);
+      headZone12HeaterCurrent_.WriteTo(output, _repeated_headZone12HeaterCurrent_codec);
+      headZone12Temperature_.WriteTo(output, _repeated_headZone12Temperature_codec);
+      headBlowerVoltage1_.WriteTo(output, _repeated_headBlowerVoltage1_codec);
+      headBlowerVoltage2_.WriteTo(output, _repeated_headBlowerVoltage2_codec);
+      headCoverHeater1Current_.WriteTo(output, _repeated_headCoverHeater1Current_codec);
+      headCoverHeater1Temperature_.WriteTo(output, _repeated_headCoverHeater1Temperature_codec);
+      headCoverHeater2Current_.WriteTo(output, _repeated_headCoverHeater2Current_codec);
+      headCoverHeater2Temperature_.WriteTo(output, _repeated_headCoverHeater2Temperature_codec);
+      wHSBlower2Voltage_.WriteTo(output, _repeated_wHSBlower2Voltage_codec);
     }
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
@@ -1334,6 +1671,25 @@ namespace Tango.PMR.Diagnostics {
       size += dispensersInkLevel_.CalculateSize(_repeated_dispensersInkLevel_codec);
       size += midTanksInkLevel_.CalculateSize(_repeated_midTanksInkLevel_codec);
       size += overallTemperature_.CalculateSize(_repeated_overallTemperature_codec);
+      size += headZone7HeaterCurrent_.CalculateSize(_repeated_headZone7HeaterCurrent_codec);
+      size += headZone7Temperature_.CalculateSize(_repeated_headZone7Temperature_codec);
+      size += headZone8HeaterCurrent_.CalculateSize(_repeated_headZone8HeaterCurrent_codec);
+      size += headZone8Temperature_.CalculateSize(_repeated_headZone8Temperature_codec);
+      size += headZone9HeaterCurrent_.CalculateSize(_repeated_headZone9HeaterCurrent_codec);
+      size += headZone9Temperature_.CalculateSize(_repeated_headZone9Temperature_codec);
+      size += headZone10HeaterCurrent_.CalculateSize(_repeated_headZone10HeaterCurrent_codec);
+      size += headZone10Temperature_.CalculateSize(_repeated_headZone10Temperature_codec);
+      size += headZone11HeaterCurrent_.CalculateSize(_repeated_headZone11HeaterCurrent_codec);
+      size += headZone11Temperature_.CalculateSize(_repeated_headZone11Temperature_codec);
+      size += headZone12HeaterCurrent_.CalculateSize(_repeated_headZone12HeaterCurrent_codec);
+      size += headZone12Temperature_.CalculateSize(_repeated_headZone12Temperature_codec);
+      size += headBlowerVoltage1_.CalculateSize(_repeated_headBlowerVoltage1_codec);
+      size += headBlowerVoltage2_.CalculateSize(_repeated_headBlowerVoltage2_codec);
+      size += headCoverHeater1Current_.CalculateSize(_repeated_headCoverHeater1Current_codec);
+      size += headCoverHeater1Temperature_.CalculateSize(_repeated_headCoverHeater1Temperature_codec);
+      size += headCoverHeater2Current_.CalculateSize(_repeated_headCoverHeater2Current_codec);
+      size += headCoverHeater2Temperature_.CalculateSize(_repeated_headCoverHeater2Temperature_codec);
+      size += wHSBlower2Voltage_.CalculateSize(_repeated_wHSBlower2Voltage_codec);
       return size;
     }
 
@@ -1408,6 +1764,25 @@ namespace Tango.PMR.Diagnostics {
       dispensersInkLevel_.Add(other.dispensersInkLevel_);
       midTanksInkLevel_.Add(other.midTanksInkLevel_);
       overallTemperature_.Add(other.overallTemperature_);
+      headZone7HeaterCurrent_.Add(other.headZone7HeaterCurrent_);
+      headZone7Temperature_.Add(other.headZone7Temperature_);
+      headZone8HeaterCurrent_.Add(other.headZone8HeaterCurrent_);
+      headZone8Temperature_.Add(other.headZone8Temperature_);
+      headZone9HeaterCurrent_.Add(other.headZone9HeaterCurrent_);
+      headZone9Temperature_.Add(other.headZone9Temperature_);
+      headZone10HeaterCurrent_.Add(other.headZone10HeaterCurrent_);
+      headZone10Temperature_.Add(other.headZone10Temperature_);
+      headZone11HeaterCurrent_.Add(other.headZone11HeaterCurrent_);
+      headZone11Temperature_.Add(other.headZone11Temperature_);
+      headZone12HeaterCurrent_.Add(other.headZone12HeaterCurrent_);
+      headZone12Temperature_.Add(other.headZone12Temperature_);
+      headBlowerVoltage1_.Add(other.headBlowerVoltage1_);
+      headBlowerVoltage2_.Add(other.headBlowerVoltage2_);
+      headCoverHeater1Current_.Add(other.headCoverHeater1Current_);
+      headCoverHeater1Temperature_.Add(other.headCoverHeater1Temperature_);
+      headCoverHeater2Current_.Add(other.headCoverHeater2Current_);
+      headCoverHeater2Temperature_.Add(other.headCoverHeater2Temperature_);
+      wHSBlower2Voltage_.Add(other.wHSBlower2Voltage_);
     }
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
@@ -1742,6 +2117,101 @@ namespace Tango.PMR.Diagnostics {
             overallTemperature_.AddEntriesFrom(input, _repeated_overallTemperature_codec);
             break;
           }
+          case 538:
+          case 537: {
+            headZone7HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone7HeaterCurrent_codec);
+            break;
+          }
+          case 546:
+          case 545: {
+            headZone7Temperature_.AddEntriesFrom(input, _repeated_headZone7Temperature_codec);
+            break;
+          }
+          case 554:
+          case 553: {
+            headZone8HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone8HeaterCurrent_codec);
+            break;
+          }
+          case 562:
+          case 561: {
+            headZone8Temperature_.AddEntriesFrom(input, _repeated_headZone8Temperature_codec);
+            break;
+          }
+          case 570:
+          case 569: {
+            headZone9HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone9HeaterCurrent_codec);
+            break;
+          }
+          case 578:
+          case 577: {
+            headZone9Temperature_.AddEntriesFrom(input, _repeated_headZone9Temperature_codec);
+            break;
+          }
+          case 586:
+          case 585: {
+            headZone10HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone10HeaterCurrent_codec);
+            break;
+          }
+          case 594:
+          case 593: {
+            headZone10Temperature_.AddEntriesFrom(input, _repeated_headZone10Temperature_codec);
+            break;
+          }
+          case 602:
+          case 601: {
+            headZone11HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone11HeaterCurrent_codec);
+            break;
+          }
+          case 610:
+          case 609: {
+            headZone11Temperature_.AddEntriesFrom(input, _repeated_headZone11Temperature_codec);
+            break;
+          }
+          case 618:
+          case 617: {
+            headZone12HeaterCurrent_.AddEntriesFrom(input, _repeated_headZone12HeaterCurrent_codec);
+            break;
+          }
+          case 626:
+          case 625: {
+            headZone12Temperature_.AddEntriesFrom(input, _repeated_headZone12Temperature_codec);
+            break;
+          }
+          case 634:
+          case 633: {
+            headBlowerVoltage1_.AddEntriesFrom(input, _repeated_headBlowerVoltage1_codec);
+            break;
+          }
+          case 642:
+          case 641: {
+            headBlowerVoltage2_.AddEntriesFrom(input, _repeated_headBlowerVoltage2_codec);
+            break;
+          }
+          case 650:
+          case 649: {
+            headCoverHeater1Current_.AddEntriesFrom(input, _repeated_headCoverHeater1Current_codec);
+            break;
+          }
+          case 658:
+          case 657: {
+            headCoverHeater1Temperature_.AddEntriesFrom(input, _repeated_headCoverHeater1Temperature_codec);
+            break;
+          }
+          case 666:
+          case 665: {
+            headCoverHeater2Current_.AddEntriesFrom(input, _repeated_headCoverHeater2Current_codec);
+            break;
+          }
+          case 674:
+          case 673: {
+            headCoverHeater2Temperature_.AddEntriesFrom(input, _repeated_headCoverHeater2Temperature_codec);
+            break;
+          }
+          case 682:
+          case 681: {
+            wHSBlower2Voltage_.AddEntriesFrom(input, _repeated_wHSBlower2Voltage_codec);
+            break;
+          }
         }
       }
     }
diff --git a/Software/Visual_Studio/Tango.PMR/Diagnostics/HeaterType.cs b/Software/Visual_Studio/Tango.PMR/Diagnostics/HeaterType.cs
index 0f1606597..304e0ebe6 100644
--- a/Software/Visual_Studio/Tango.PMR/Diagnostics/HeaterType.cs
+++ b/Software/Visual_Studio/Tango.PMR/Diagnostics/HeaterType.cs
@@ -22,13 +22,16 @@ namespace Tango.PMR.Diagnostics {
     static HeaterTypeReflection() {
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "ChBIZWF0ZXJUeXBlLnByb3RvEhVUYW5nby5QTVIuRGlhZ25vc3RpY3MqxgEK",
+            "ChBIZWF0ZXJUeXBlLnByb3RvEhVUYW5nby5QTVIuRGlhZ25vc3RpY3Mq2wIK",
             "CkhlYXRlclR5cGUSEgoORHJ5ZXJBaXJIZWF0ZXIQABITCg9Ecnllck1haW5I",
             "ZWF0ZXIQARIYChREcnllclNlY29uZGFyeUhlYXRlchACEg8KC0hlYXRlclpv",
             "bmUxEAMSDwoLSGVhdGVyWm9uZTIQBBIPCgtIZWF0ZXJab25lMxAFEg8KC0hl",
             "YXRlclpvbmU0EAYSDwoLSGVhdGVyWm9uZTUQBxIPCgtIZWF0ZXJab25lNhAI",
-            "Eg8KC01peGVySGVhdGVyEAlCIQofY29tLnR3aW5lLnRhbmdvLnBtci5kaWFn",
-            "bm9zdGljc2IGcHJvdG8z"));
+            "Eg8KC01peGVySGVhdGVyEAkSDwoLSGVhdGVyWm9uZTcQChIPCgtIZWF0ZXJa",
+            "b25lOBALEg8KC0hlYXRlclpvbmU5EAwSEAoMSGVhdGVyWm9uZTEwEA0SEAoM",
+            "SGVhdGVyWm9uZTExEA4SEAoMSGVhdGVyWm9uZTEyEA8SFAoQSGVhZENvdmVy",
+            "SGVhdGVyMRAQEhQKEEhlYWRDb3ZlckhlYXRlcjIQEUIhCh9jb20udHdpbmUu",
+            "dGFuZ28ucG1yLmRpYWdub3N0aWNzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tango.PMR.Diagnostics.HeaterType), }, null));
@@ -48,6 +51,14 @@ namespace Tango.PMR.Diagnostics {
     [pbr::OriginalName("HeaterZone5")] HeaterZone5 = 7,
     [pbr::OriginalName("HeaterZone6")] HeaterZone6 = 8,
     [pbr::OriginalName("MixerHeater")] MixerHeater = 9,
+    [pbr::OriginalName("HeaterZone7")] HeaterZone7 = 10,
+    [pbr::OriginalName("HeaterZone8")] HeaterZone8 = 11,
+    [pbr::OriginalName("HeaterZone9")] HeaterZone9 = 12,
+    [pbr::OriginalName("HeaterZone10")] HeaterZone10 = 13,
+    [pbr::OriginalName("HeaterZone11")] HeaterZone11 = 14,
+    [pbr::OriginalName("HeaterZone12")] HeaterZone12 = 15,
+    [pbr::OriginalName("HeadCoverHeater1")] HeadCoverHeater1 = 16,
+    [pbr::OriginalName("HeadCoverHeater2")] HeadCoverHeater2 = 17,
   }
 
   #endregion
diff --git a/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateRequest.cs b/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateRequest.cs
new file mode 100644
index 000000000..a466722ad
--- /dev/null
+++ b/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateRequest.cs
@@ -0,0 +1,132 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: StartThreadLoadingUpdateRequest.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.Diagnostics {
+
+  /// <summary>Holder for reflection information generated from StartThreadLoadingUpdateRequest.proto</summary>
+  public static partial class StartThreadLoadingUpdateRequestReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for StartThreadLoadingUpdateRequest.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static StartThreadLoadingUpdateRequestReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiVTdGFydFRocmVhZExvYWRpbmdVcGRhdGVSZXF1ZXN0LnByb3RvEhVUYW5n",
+            "by5QTVIuRGlhZ25vc3RpY3MiIQofU3RhcnRUaHJlYWRMb2FkaW5nVXBkYXRl",
+            "UmVxdWVzdEIhCh9jb20udHdpbmUudGFuZ28ucG1yLmRpYWdub3N0aWNzYgZw",
+            "cm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateRequest), global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateRequest.Parser, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class StartThreadLoadingUpdateRequest : pb::IMessage<StartThreadLoadingUpdateRequest> {
+    private static readonly pb::MessageParser<StartThreadLoadingUpdateRequest> _parser = new pb::MessageParser<StartThreadLoadingUpdateRequest>(() => new StartThreadLoadingUpdateRequest());
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<StartThreadLoadingUpdateRequest> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateRequestReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateRequest() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateRequest(StartThreadLoadingUpdateRequest other) : this() {
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateRequest Clone() {
+      return new StartThreadLoadingUpdateRequest(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as StartThreadLoadingUpdateRequest);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(StartThreadLoadingUpdateRequest other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      return true;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      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) {
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(StartThreadLoadingUpdateRequest other) {
+      if (other == null) {
+        return;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            input.SkipLastField();
+            break;
+        }
+      }
+    }
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateResponse.cs b/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateResponse.cs
new file mode 100644
index 000000000..0c62e31c7
--- /dev/null
+++ b/Software/Visual_Studio/Tango.PMR/Diagnostics/StartThreadLoadingUpdateResponse.cs
@@ -0,0 +1,162 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: StartThreadLoadingUpdateResponse.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.Diagnostics {
+
+  /// <summary>Holder for reflection information generated from StartThreadLoadingUpdateResponse.proto</summary>
+  public static partial class StartThreadLoadingUpdateResponseReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for StartThreadLoadingUpdateResponse.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static StartThreadLoadingUpdateResponseReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiZTdGFydFRocmVhZExvYWRpbmdVcGRhdGVSZXNwb25zZS5wcm90bxIVVGFu",
+            "Z28uUE1SLkRpYWdub3N0aWNzGhhUaHJlYWRMb2FkaW5nU3RhdGUucHJvdG8i",
+            "aQogU3RhcnRUaHJlYWRMb2FkaW5nVXBkYXRlUmVzcG9uc2USRQoSVGhyZWFk",
+            "TG9hZGluZ1N0YXRlGAEgASgOMikuVGFuZ28uUE1SLkRpYWdub3N0aWNzLlRo",
+            "cmVhZExvYWRpbmdTdGF0ZUIhCh9jb20udHdpbmUudGFuZ28ucG1yLmRpYWdu",
+            "b3N0aWNzYgZwcm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Tango.PMR.Diagnostics.ThreadLoadingStateReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateResponse), global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateResponse.Parser, new[]{ "ThreadLoadingState" }, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class StartThreadLoadingUpdateResponse : pb::IMessage<StartThreadLoadingUpdateResponse> {
+    private static readonly pb::MessageParser<StartThreadLoadingUpdateResponse> _parser = new pb::MessageParser<StartThreadLoadingUpdateResponse>(() => new StartThreadLoadingUpdateResponse());
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<StartThreadLoadingUpdateResponse> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Tango.PMR.Diagnostics.StartThreadLoadingUpdateResponseReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateResponse() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateResponse(StartThreadLoadingUpdateResponse other) : this() {
+      threadLoadingState_ = other.threadLoadingState_;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StartThreadLoadingUpdateResponse Clone() {
+      return new StartThreadLoadingUpdateResponse(this);
+    }
+
+    /// <summary>Field number for the "ThreadLoadingState" field.</summary>
+    public const int ThreadLoadingStateFieldNumber = 1;
+    private global::Tango.PMR.Diagnostics.ThreadLoadingState threadLoadingState_ = 0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::Tango.PMR.Diagnostics.ThreadLoadingState ThreadLoadingState {
+      get { return threadLoadingState_; }
+      set {
+        threadLoadingState_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as StartThreadLoadingUpdateResponse);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(StartThreadLoadingUpdateResponse other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (ThreadLoadingState != other.ThreadLoadingState) return false;
+      return true;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (ThreadLoadingState != 0) hash ^= ThreadLoadingState.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 (ThreadLoadingState != 0) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) ThreadLoadingState);
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (ThreadLoadingState != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ThreadLoadingState);
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(StartThreadLoadingUpdateResponse other) {
+      if (other == null) {
+        return;
+      }
+      if (other.ThreadLoadingState != 0) {
+        ThreadLoadingState = other.ThreadLoadingState;
+      }
+    }
+
+    [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: {
+            threadLoadingState_ = (global::Tango.PMR.Diagnostics.ThreadLoadingState) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Software/Visual_Studio/Tango.PMR/Diagnostics/ThreadLoadingState.cs b/Software/Visual_Studio/Tango.PMR/Diagnostics/ThreadLoadingState.cs
new file mode 100644
index 000000000..8322cbef4
--- /dev/null
+++ b/Software/Visual_Studio/Tango.PMR/Diagnostics/ThreadLoadingState.cs
@@ -0,0 +1,97 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ThreadLoadingState.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.Diagnostics {
+
+  /// <summary>Holder for reflection information generated from ThreadLoadingState.proto</summary>
+  public static partial class ThreadLoadingStateReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for ThreadLoadingState.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static ThreadLoadingStateReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "ChhUaHJlYWRMb2FkaW5nU3RhdGUucHJvdG8SFVRhbmdvLlBNUi5EaWFnbm9z",
+            "dGljcyq1AwoSVGhyZWFkTG9hZGluZ1N0YXRlEhIKDlRocmVhZExvYWRJbml0",
+            "EAASGAoUVGhyZWFkTG9hZFJlZHVjZUhlYXQQARInCiNUaHJlYWRMb2FkU2V0",
+            "TG9hZEFybVRvU3RhcnRQb3NpdGlvbhACEhgKFFRocmVhZExvYWRPcGVuQ292",
+            "ZXJzEAMSGQoVVGhyZWFkTG9hZExpZnREYW5jZXJzEAQSGQoVVGhyZWFkTG9h",
+            "ZExpZnRSb2NrZXJzEAUSHAoYVGhyZWFkTG9hZEluaXRpYWxUZW5zaW9uEAYS",
+            "GgoWVGhyZWFkTG9hZENsb3NlUm9ja2VycxAHEhoKFlRocmVhZExvYWRDbG9z",
+            "ZURhbmNlcnMQCBIXChNUaHJlYWRMb2FkQ2xvc2VMaWRzEAkSJAogVGhyZWFk",
+            "TG9hZEpvZ0ZlZWRlclRvTWlkZGxlUG9pbnQQChIaChZUaHJlYWRMb2FkRHJ5",
+            "ZXJMb2FkaW5nEAsSGwoXVGhyZWFkTG9hZFJlc3VtZUhlYXRpbmcQDBIXChNU",
+            "aHJlYWRMb2FkSm9nVGhyZWFkEA0SEQoNVGhyZWFkTG9hZEVuZBAOQiEKH2Nv",
+            "bS50d2luZS50YW5nby5wbXIuZGlhZ25vc3RpY3NiBnByb3RvMw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tango.PMR.Diagnostics.ThreadLoadingState), }, null));
+    }
+    #endregion
+
+  }
+  #region Enums
+  public enum ThreadLoadingState {
+    [pbr::OriginalName("ThreadLoadInit")] ThreadLoadInit = 0,
+    /// <summary>
+    ///Heaters Off; Dryer Blower Off; Blower Low;
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadReduceHeat")] ThreadLoadReduceHeat = 1,
+    /// <summary>
+    ///Use Notation How Many Rotations In The Dryer; Or Check Against Stopper. Move Slowly
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadSetLoadArmToStartPosition")] ThreadLoadSetLoadArmToStartPosition = 2,
+    /// <summary>
+    ///Open Dyeing Head Cover And Dryer Lid
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadOpenCovers")] ThreadLoadOpenCovers = 3,
+    [pbr::OriginalName("ThreadLoadLiftDancers")] ThreadLoadLiftDancers = 4,
+    /// <summary>
+    ///Machine Is Ready. Send Message; Start Timer To Close Lids; Wait For Operator Response
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadLiftRockers")] ThreadLoadLiftRockers = 5,
+    /// <summary>
+    ///Check Spool Presencerun Winder Until Break Sensor Is Identifieing Movement For A Second
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadInitialTension")] ThreadLoadInitialTension = 6,
+    [pbr::OriginalName("ThreadLoadCloseRockers")] ThreadLoadCloseRockers = 7,
+    /// <summary>
+    ///Send Dancer Motors To Preset Location; Check That The Dancers Are On The Thread
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadCloseDancers")] ThreadLoadCloseDancers = 8,
+    [pbr::OriginalName("ThreadLoadCloseLids")] ThreadLoadCloseLids = 9,
+    /// <summary>
+    ///Jog The Feeder Motor Until The Feeder Dancer Is At Middle Position
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadJogFeederToMiddlePoint")] ThreadLoadJogFeederToMiddlePoint = 10,
+    /// <summary>
+    ///Start Feeder Pid Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadDryerLoading")] ThreadLoadDryerLoading = 11,
+    /// <summary>
+    ///Keep Notation How Many Rotations In The Dryer
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadResumeHeating")] ThreadLoadResumeHeating = 12,
+    /// <summary>
+    ///Jog Thread Shortly To Make Sure Spool Is Running. Report End Of Loading
+    /// </summary>
+    [pbr::OriginalName("ThreadLoadJogThread")] ThreadLoadJogThread = 13,
+    [pbr::OriginalName("ThreadLoadEnd")] ThreadLoadEnd = 14,
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code