diff options
Diffstat (limited to 'Software/Visual_Studio')
15 files changed, 3513 insertions, 17 deletions
diff --git a/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/DefaultInsightsService.cs b/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/DefaultInsightsService.cs new file mode 100644 index 000000000..e5148cfe5 --- /dev/null +++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/DefaultInsightsService.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Tango.Core; +using Tango.Core.DI; +using Tango.Insights; +using Tango.PPC.Common.Application; +using Tango.PPC.Common.Connection; + +namespace Tango.PPC.Common.Insights +{ + [TangoCreateWhenRegistered] + public class DefaultInsightsService : ExtendedObject, IInsightsService + { + private InsightsListener _listener; + public bool Enabled { get; set; } + + private IMachineProvider MachineProvider { get; set; } + + public DefaultInsightsService(IMachineProvider machineProvider, IPPCApplicationManager applicationManager) + { + MachineProvider = machineProvider; + + applicationManager.ApplicationStarted += ApplicationManager_ApplicationStarted; + } + + private void ApplicationManager_ApplicationStarted(object sender, EventArgs e) + { + Task.Factory.StartNew(() => + { + try + { + _listener = new InsightsListener(MachineProvider.MachineOperator); + _listener.Start(); + } + catch (Exception ex) + { + LogManager.Log(ex, "Error initializing insights listener."); + } + }); + } + } +} diff --git a/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/IInsightsService.cs b/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/IInsightsService.cs new file mode 100644 index 000000000..d7c5497d6 --- /dev/null +++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/Insights/IInsightsService.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Tango.PPC.Common.Insights +{ + public interface IInsightsService: IPPCService + { + + } +} diff --git a/Software/Visual_Studio/PPC/Tango.PPC.Common/Tango.PPC.Common.csproj b/Software/Visual_Studio/PPC/Tango.PPC.Common/Tango.PPC.Common.csproj index b15ca60bd..08e49621c 100644 --- a/Software/Visual_Studio/PPC/Tango.PPC.Common/Tango.PPC.Common.csproj +++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/Tango.PPC.Common.csproj @@ -163,6 +163,8 @@ <Compile Include="Helpers\LogsHelper.cs" /> <Compile Include="HotSpot\DefaultHotSpotProvider.cs" /> <Compile Include="HotSpot\IHotSpotProvider.cs" /> + <Compile Include="Insights\DefaultInsightsService.cs" /> + <Compile Include="Insights\IInsightsService.cs" /> <Compile Include="IPPCView.cs" /> <Compile Include="IPPCService.cs" /> <Compile Include="MachineSetup\IMachineSetupManager.cs" /> @@ -389,6 +391,10 @@ <Project>{c6ebbbbe-2123-44dc-aef7-a0d47d736ac0}</Project> <Name>Tango.FileSystem</Name> </ProjectReference> + <ProjectReference Include="..\..\Tango.Insights\Tango.Insights.csproj"> + <Project>{4a55c185-3f8d-41b0-8815-c15f6213a14a}</Project> + <Name>Tango.Insights</Name> + </ProjectReference> <ProjectReference Include="..\..\Tango.Integration\Tango.Integration.csproj"> <Project>{4206ac58-3b57-4699-8835-90bf6db01a61}</Project> <Name>Tango.Integration</Name> @@ -477,7 +483,7 @@ </Target> <ProjectExtensions> <VisualStudio> - <UserProperties BuildVersion_StartDate="2000/1/1" BuildVersion_UseGlobalSettings="False" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" /> + <UserProperties BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_UseGlobalSettings="False" BuildVersion_StartDate="2000/1/1" /> </VisualStudio> </ProjectExtensions> </Project>
\ No newline at end of file diff --git a/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModelLocator.cs b/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModelLocator.cs index 05d844782..b5da9f066 100644 --- a/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModelLocator.cs +++ b/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModelLocator.cs @@ -15,6 +15,7 @@ using Tango.PPC.Common.EventLogging; using Tango.PPC.Common.ExternalBridge; using Tango.PPC.Common.FileSystem; using Tango.PPC.Common.HotSpot; +using Tango.PPC.Common.Insights; using Tango.PPC.Common.MachineSetup; using Tango.PPC.Common.MachineUpdate; using Tango.PPC.Common.Modules; @@ -92,6 +93,7 @@ namespace Tango.PPC.UI TangoIOC.Default.Unregister<IFileSystemService>(); TangoIOC.Default.Unregister<IRemoteJobService>(); TangoIOC.Default.Unregister<IRemoteSqlService>(); + TangoIOC.Default.Unregister<IInsightsService>(); if (App.StartupArgs != null && App.StartupArgs.Contains("-webDebug")) { @@ -132,6 +134,7 @@ namespace Tango.PPC.UI TangoIOC.Default.Register<IRemoteDesktopService, DefaultRemoteDesktopService>(); TangoIOC.Default.Register<IRemoteJobService, DefaultRemoteJobService>(); TangoIOC.Default.Register<IRemoteSqlService, DefaultRemoteSqlService>(); + TangoIOC.Default.Register<IInsightsService, DefaultInsightsService>(); TangoIOC.Default.Register<LoadingViewVM>(); TangoIOC.Default.Register<MainViewVM>(); diff --git a/Software/Visual_Studio/Tango.Insights/InsightsFrame.cs b/Software/Visual_Studio/Tango.Insights/InsightsFrame.cs new file mode 100644 index 000000000..4ea2a1c13 --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/InsightsFrame.cs @@ -0,0 +1,64 @@ +using LiteDB; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Tango.PMR.Diagnostics; +using Tango.PMR.Insights; +using Tango.Transport.Compression; + +namespace Tango.Insights +{ + public class InsightsFrame + { + [BsonId(true)] + public int Id { get; set; } + public DateTime Time { get; set; } + public bool IsEmpty { get; set; } + public byte[] MonitorsData { get; set; } + + public static InsightsFrame CreateEmpty(DateTime timeUtc) + { + InsightsFrame frame = new InsightsFrame(); + frame.Time = timeUtc; + frame.IsEmpty = true; + frame.MonitorsData = null; + return frame; + } + + public static InsightsFrame FromDiagnosticsMonitors(DiagnosticsMonitors diagnosticsMonitors, DateTime timeUtc) + { + InsightsMonitors insightsMonitors = InsightsHelper.MapMonitors(diagnosticsMonitors); + return FromInsightsMonitors(insightsMonitors, timeUtc); + } + + public static InsightsFrame FromInsightsMonitors(InsightsMonitors insightsMonitors, DateTime timeUtc) + { + InsightsFrame frame = new InsightsFrame(); + frame.Time = timeUtc; + + byte[] data = insightsMonitors.ToBytes(); + byte[] compressedData = SevenZipHelper.Compress(data); + + frame.MonitorsData = compressedData; + + return frame; + } + + public InsightsMonitors ToInsightsMonitors() + { + if (IsEmpty) + { + return InsightsHelper.CreateEmptyGap(); + } + else + { + var uncompressed = SevenZipHelper.Decompress(MonitorsData); + var insightsMonitors = InsightsMonitors.Parser.ParseFrom(uncompressed); + return insightsMonitors; + } + } + } +} diff --git a/Software/Visual_Studio/Tango.Insights/InsightsHelper.cs b/Software/Visual_Studio/Tango.Insights/InsightsHelper.cs new file mode 100644 index 000000000..202e2574d --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/InsightsHelper.cs @@ -0,0 +1,85 @@ +using Google.Protobuf.Collections; +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; +using Tango.PMR.Diagnostics; +using Tango.PMR.Insights; + +namespace Tango.Insights +{ + public static class InsightsHelper + { + private static List<PropertyInfo> _diagnosticsProperties; + private static List<PropertyInfo> _insightsProperties; + + static InsightsHelper() + { + _diagnosticsProperties = new List<PropertyInfo>(); + _insightsProperties = new List<PropertyInfo>(); + + foreach (var prop in typeof(DiagnosticsMonitors).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) + { + _diagnosticsProperties.Add(prop); + } + + foreach (var prop in typeof(InsightsMonitors).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) + { + _insightsProperties.Add(prop); + } + } + + public static InsightsMonitors MapMonitors(DiagnosticsMonitors diagnosticsMonitors) + { + InsightsMonitors insightsMonitors = new InsightsMonitors(); + + for (int i = 0; i < _diagnosticsProperties.Count; i++) + { + if (_diagnosticsProperties[i].PropertyType == typeof(RepeatedField<double>)) + { + var arr = _diagnosticsProperties[i].GetValue(diagnosticsMonitors) as RepeatedField<double>; + + if (arr.Count > 0) + { + _insightsProperties[i].SetValue(insightsMonitors, arr.Average()); + } + } + } + + return insightsMonitors; + } + + public static InsightsMonitors AverageMonitors(List<InsightsMonitors> insightsMonitorsCollection) + { + InsightsMonitors monitors = new InsightsMonitors(); + + foreach (var prop in _insightsProperties.Where(x => !typeof(IEnumerable).IsAssignableFrom(x.PropertyType)).ToList()) + { + prop.SetValue(monitors, insightsMonitorsCollection.Average(x => (double)prop.GetValue(x))); + } + + return monitors; + } + + public static InsightsMonitors AverageMonitors(List<DiagnosticsMonitors> diagnosticsMonitorsCollection) + { + List<InsightsMonitors> insightsMonitorsCollection = diagnosticsMonitorsCollection.ToList().Select(x => InsightsHelper.MapMonitors(x)).ToList(); + return AverageMonitors(insightsMonitorsCollection); + } + + public static InsightsMonitors CreateEmptyGap() + { + InsightsMonitors monitors = new InsightsMonitors(); + + foreach (var prop in _insightsProperties.Where(x => !typeof(IEnumerable).IsAssignableFrom(x.PropertyType)).ToList()) + { + prop.SetValue(monitors, double.NaN); + } + + return monitors; + } + } +} diff --git a/Software/Visual_Studio/Tango.Insights/InsightsListener.cs b/Software/Visual_Studio/Tango.Insights/InsightsListener.cs new file mode 100644 index 000000000..0df5b63a1 --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/InsightsListener.cs @@ -0,0 +1,121 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Timers; +using Tango.Integration.Operation; +using Tango.PMR.Diagnostics; +using Tango.PMR.Insights; + +namespace Tango.Insights +{ + public class InsightsListener + { + private InsightsManager _manager; + private IMachineOperator _operator; + private Timer _timer; + private List<DiagnosticsMonitors> _diagnosticsQueue; + private int _timerCount; + private int _deleteTicks; + private bool _writing; + + public bool IsStarted { get; private set; } + public TimeSpan WriteInterval { get; set; } + public TimeSpan DeleteInterval { get; set; } + public TimeSpan MaxFramesStorage { get; set; } + + public InsightsListener(InsightsManager manager, IMachineOperator machineOperator) + { + _diagnosticsQueue = new List<DiagnosticsMonitors>(); + + WriteInterval = TimeSpan.FromMinutes(0.1); + DeleteInterval = TimeSpan.FromMinutes(60); + MaxFramesStorage = TimeSpan.FromDays(30); + + _manager = manager; + _operator = machineOperator; + + _operator.DiagnosticsDataAvailable += _operator_DiagnosticsDataAvailable; + } + + public InsightsListener(IMachineOperator machineOperator) : this(InsightsManager.Default, machineOperator) + { + + } + + public void Start() + { + if (!IsStarted) + { + if (_timer == null) + { + _timer = new Timer(); + _timer.Interval = WriteInterval.TotalMilliseconds; + } + + _writing = false; + _timerCount = 0; + _deleteTicks = (int)(DeleteInterval.TotalMilliseconds / WriteInterval.TotalMilliseconds); + + _diagnosticsQueue.Clear(); + IsStarted = true; + _timer.Elapsed += _timer_Elapsed; + _timer.Start(); + } + } + + public void Stop() + { + if (IsStarted) + { + _timer.Stop(); + _diagnosticsQueue.Clear(); + } + } + + private void _operator_DiagnosticsDataAvailable(object sender, PMR.Diagnostics.StartDiagnosticsResponse e) + { + if (IsStarted && e.Monitors != null) + { + _diagnosticsQueue.Add(e.Monitors); + } + } + + private void _timer_Elapsed(object sender, ElapsedEventArgs e) + { + if (!IsStarted || _writing) return; + + _writing = true; + + InsightsFrame frame = null; + + if (_diagnosticsQueue.Count > 0) + { + var queue = _diagnosticsQueue.ToList(); + _diagnosticsQueue.Clear(); + + InsightsMonitors monitorsAvg = InsightsHelper.AverageMonitors(queue); + queue.Clear(); + + frame = InsightsFrame.FromInsightsMonitors(monitorsAvg, DateTime.UtcNow.Subtract(WriteInterval)); + } + else + { + frame = InsightsFrame.CreateEmpty(DateTime.UtcNow.Subtract(WriteInterval)); + } + + _manager.InsertFrame(frame); + + _timerCount++; + + if (_timerCount >= _deleteTicks) + { + _timerCount = 0; + _manager.DeleteFrames(DateTime.UtcNow.Subtract(MaxFramesStorage)); + } + + _writing = false; + } + } +} diff --git a/Software/Visual_Studio/Tango.Insights/InsightsManager.cs b/Software/Visual_Studio/Tango.Insights/InsightsManager.cs new file mode 100644 index 000000000..7597aabf4 --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/InsightsManager.cs @@ -0,0 +1,81 @@ +using LiteDB; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Tango.Insights +{ + public class InsightsManager : IDisposable + { + private const string INSIGHTS_COLLECTION = "Insights"; + + private static InsightsManager _instance; + public static InsightsManager Default + { + get + { + if (_instance == null) + { + _instance = new InsightsManager(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Twine", "Tango", "Insights", Path.GetFileNameWithoutExtension(AppDomain.CurrentDomain.FriendlyName) + ".insights")); + } + + return _instance; + } + } + + private LiteDatabase _database; + + public String DatabasePath { get; private set; } + + private InsightsManager(String databasePath) + { + DatabasePath = databasePath; + Directory.CreateDirectory(Path.GetDirectoryName(DatabasePath)); + _database = new LiteDatabase($"Filename={DatabasePath}"); + } + + public virtual void Dispose() + { + if (_database != null) + { + try + { + _database.Dispose(); + _database = null; + } + catch { } + } + } + + ~InsightsManager() + { + Dispose(); + } + + private ILiteCollection<InsightsFrame> GetCollection() + { + return _database.GetCollection<InsightsFrame>(INSIGHTS_COLLECTION); + } + + public virtual void InsertFrame(InsightsFrame frame) + { + var collection = GetCollection(); + collection.Insert(frame); + } + + public virtual List<InsightsFrame> GetFrames(DateTime startUTC, DateTime endUTC) + { + var collection = GetCollection(); + return collection.Find(x => x.Time >= startUTC && x.Time <= endUTC).ToList(); + } + + public virtual int DeleteFrames(DateTime maxDateUTC) + { + var collection = GetCollection(); + return collection.DeleteMany(x => x.Time < maxDateUTC); + } + } +} diff --git a/Software/Visual_Studio/Tango.Insights/Properties/AssemblyInfo.cs b/Software/Visual_Studio/Tango.Insights/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..2c2308493 --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/Properties/AssemblyInfo.cs @@ -0,0 +1,7 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("Tango - Insights Library")] +[assembly: AssemblyVersion("2.0.12.1737")] +[assembly: ComVisible(false)]
\ No newline at end of file diff --git a/Software/Visual_Studio/Tango.Insights/Tango.Insights.csproj b/Software/Visual_Studio/Tango.Insights/Tango.Insights.csproj new file mode 100644 index 000000000..0b9ecc641 --- /dev/null +++ b/Software/Visual_Studio/Tango.Insights/Tango.Insights.csproj @@ -0,0 +1,80 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProjectGuid>{4A55C185-3F8D-41B0-8815-C15F6213A14A}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Tango.Insights</RootNamespace> + <AssemblyName>Tango.Insights</AssemblyName> + <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <Deterministic>true</Deterministic> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.Core" /> + <Reference Include="System.Xml.Linq" /> + <Reference Include="System.Data.DataSetExtensions" /> + <Reference Include="Microsoft.CSharp" /> + <Reference Include="System.Data" /> + <Reference Include="System.Net.Http" /> + <Reference Include="System.Xml" /> + </ItemGroup> + <ItemGroup> + <Compile Include="..\Versioning\GlobalVersionInfo.cs"> + <Link>GlobalVersionInfo.cs</Link> + </Compile> + <Compile Include="InsightsHelper.cs" /> + <Compile Include="InsightsFrame.cs" /> + <Compile Include="InsightsListener.cs" /> + <Compile Include="InsightsManager.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\Tango.Core\Tango.Core.csproj"> + <Project>{a34ee0f0-649d-41c8-8489-b6f1cc6924ee}</Project> + <Name>Tango.Core</Name> + </ProjectReference> + <ProjectReference Include="..\Tango.Integration\Tango.Integration.csproj"> + <Project>{4206ac58-3b57-4699-8835-90bf6db01a61}</Project> + <Name>Tango.Integration</Name> + </ProjectReference> + <ProjectReference Include="..\Tango.PMR\Tango.PMR.csproj"> + <Project>{e4927038-348d-4295-aaf4-861c58cb3943}</Project> + <Name>Tango.PMR</Name> + </ProjectReference> + <ProjectReference Include="..\Tango.Transport\Tango.Transport.csproj"> + <Project>{74e700b0-1156-4126-be40-ee450d3c3026}</Project> + <Name>Tango.Transport</Name> + </ProjectReference> + </ItemGroup> + <ItemGroup> + <PackageReference Include="Google.Protobuf"> + <Version>3.4.1</Version> + </PackageReference> + <PackageReference Include="LiteDB"> + <Version>5.0.4</Version> + </PackageReference> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> +</Project>
\ No newline at end of file diff --git a/Software/Visual_Studio/Tango.PMR/Common/ErrorCode.cs b/Software/Visual_Studio/Tango.PMR/Common/ErrorCode.cs index eeac2edba..057820787 100644 --- a/Software/Visual_Studio/Tango.PMR/Common/ErrorCode.cs +++ b/Software/Visual_Studio/Tango.PMR/Common/ErrorCode.cs @@ -22,7 +22,7 @@ namespace Tango.PMR.Common { static ErrorCodeReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( - "Cg9FcnJvckNvZGUucHJvdG8SEFRhbmdvLlBNUi5Db21tb24q+gsKCUVycm9y", + "Cg9FcnJvckNvZGUucHJvdG8SEFRhbmdvLlBNUi5Db21tb24qsgwKCUVycm9y", "Q29kZRIICgROT05FEAASEQoNR0VORVJBTF9FUlJPUhABEgsKB0JBRF9DUkMQ", "AhIeChpJTlZBTElEX0RJR0lUQUxfUElOX05VTUJFUhADEhsKF1VOQVVUSE9S", "SVpFRF9DT05ORUNUSU9OEAQSHwobQ09OVElOVU9VU19SRVNQT05TRV9BQk9S", @@ -51,13 +51,14 @@ namespace Tango.PMR.Common { "UkVTU1VSRV9BTEFSTRDaDxIWChFKT0JfQ1VSUkVOVF9BTEFSTRDbDxIUCg9K", "T0JfTU9UT1JfQUxBUk0Q3A8SEgoNSk9CX0xJRFNfT1BFThDdDxIYChNKT0Jf", "QUJPUlRFRF9CWV9VU0VSEN4PEhUKEEpPQl9TQUZFVFlfQUxBUk0Q3w8SFgoR", - "Sk9CX05PX0FMQVJNX0ZJTEUQ4A8SGQoUUE9XRVJfVVBfTk9fQ0ZHX0ZJTEUQ", - "uBcSHgoZUE9XRVJfVVBfSFdfQ09ORklHX0ZBSUxFRBC5FxIdChhQT1dFUl9V", - "UF9CVUlMVF9JTl9GQUlMRUQQuhcSIwoeUE9XRVJfVVBfSU5JVElBTF9CTE9X", - "RVJfRkFJTEVEELsXEi8KKlBPV0VSX1VQX0RJU1BFTlNFUl9QUkVTU1VSRV9C", - "VUlMRFVQX0ZBSUxFRBC8FxIgChtQT1dFUl9VUF9OT19USFJFQURfREVURUNU", - "RUQQvRcSHwoaUE9XRVJfVVBfTk9fUFJPQ0VTU19QQVJBTVMQvhdCHAoaY29t", - "LnR3aW5lLnRhbmdvLnBtci5jb21tb25iBnByb3RvMw==")); + "Sk9CX05PX0FMQVJNX0ZJTEUQ4A8SFQoQSk9CX0ZJTEVfUFJPQkxFTRDhDxIf", + "ChpKT0JfV0FTVEVfSEFORExJTkdfUFJPQkxFTRDiDxIZChRQT1dFUl9VUF9O", + "T19DRkdfRklMRRC4FxIeChlQT1dFUl9VUF9IV19DT05GSUdfRkFJTEVEELkX", + "Eh0KGFBPV0VSX1VQX0JVSUxUX0lOX0ZBSUxFRBC6FxIjCh5QT1dFUl9VUF9J", + "TklUSUFMX0JMT1dFUl9GQUlMRUQQuxcSLwoqUE9XRVJfVVBfRElTUEVOU0VS", + "X1BSRVNTVVJFX0JVSUxEVVBfRkFJTEVEELwXEiAKG1BPV0VSX1VQX05PX1RI", + "UkVBRF9ERVRFQ1RFRBC9FxIfChpQT1dFUl9VUF9OT19QUk9DRVNTX1BBUkFN", + "UxC+F0IcChpjb20udHdpbmUudGFuZ28ucG1yLmNvbW1vbmIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tango.PMR.Common.ErrorCode), }, null)); @@ -145,6 +146,8 @@ namespace Tango.PMR.Common { [pbr::OriginalName("JOB_ABORTED_BY_USER")] JobAbortedByUser = 2014, [pbr::OriginalName("JOB_SAFETY_ALARM")] JobSafetyAlarm = 2015, [pbr::OriginalName("JOB_NO_ALARM_FILE")] JobNoAlarmFile = 2016, + [pbr::OriginalName("JOB_FILE_PROBLEM")] JobFileProblem = 2017, + [pbr::OriginalName("JOB_WASTE_HANDLING_PROBLEM")] JobWasteHandlingProblem = 2018, /// <summary> ///power up /// </summary> diff --git a/Software/Visual_Studio/Tango.PMR/Insights/InsightsMonitors.cs b/Software/Visual_Studio/Tango.PMR/Insights/InsightsMonitors.cs new file mode 100644 index 000000000..e5faefcc4 --- /dev/null +++ b/Software/Visual_Studio/Tango.PMR/Insights/InsightsMonitors.cs @@ -0,0 +1,2936 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: InsightsMonitors.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.Insights { + + /// <summary>Holder for reflection information generated from InsightsMonitors.proto</summary> + public static partial class InsightsMonitorsReflection { + + #region Descriptor + /// <summary>File descriptor for InsightsMonitors.proto</summary> + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static InsightsMonitorsReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChZJbnNpZ2h0c01vbml0b3JzLnByb3RvEhJUYW5nby5QTVIuSW5zaWdodHMi", + "lRQKEEluc2lnaHRzTW9uaXRvcnMSFAoMRGFuY2VyMUFuZ2xlGAEgASgBEhQK", + "DERhbmNlcjJBbmdsZRgCIAEoARIUCgxEYW5jZXIzQW5nbGUYAyABKAESHAoU", + "RmVlZGVyTW90b3JGcmVxdWVuY3kYBCABKAESEgoKRHJ5ZXJNb3RvchgFIAEo", + "ARITCgtQb2xsZXJNb3RvchgGIAEoARITCgtXaW5kZXJNb3RvchgHIAEoARIS", + "CgpTY3Jld01vdG9yGAggASgBEhMKC1RocmVhZFNwZWVkGAkgASgBEhgKEE1p", + "eGVyVGVtcGVyYXR1cmUYCiABKAESHAoUSGVhZFpvbmUxVGVtcGVyYXR1cmUY", + "CyABKAESHAoUSGVhZFpvbmUyVGVtcGVyYXR1cmUYDCABKAESHAoUSGVhZFpv", + "bmUzVGVtcGVyYXR1cmUYDSABKAESEwoLSGVhZEFpckZsb3cYDiABKAESFQoN", + "RmVlZGVyVGVuc2lvbhgPIAEoARIVCg1QdWxsZXJUZW5zaW9uGBAgASgBEh0K", + "FURyeWVyWm9uZTFUZW1wZXJhdHVyZRgRIAEoARIdChVEcnllclpvbmUyVGVt", + "cGVyYXR1cmUYEiABKAESHQoVRHJ5ZXJab25lM1RlbXBlcmF0dXJlGBMgASgB", + "EhQKDERyeWVyQWlyRmxvdxgUIAEoARIVCg1XaW5kZXJUZW5zaW9uGBUgASgB", + "EiEKGURpc3BlbnNlcnNNb3RvcnNGcmVxdWVuY3kYFiADKAESIQoZRGlzcGVu", + "c2Vyc0FuZ3VsYXJFbmNvZGVycxgXIAMoARIhChlEaXNwZW5zZXJzTGluZWFy", + "UG9zaXRpb25zGBggAygBEhoKEkRpc3BlbnNlcnNQcmVzc3VyZRgZIAMoARIb", + "ChNGaWx0ZXJEZWx0YVByZXNzdXJlGBogASgBEhoKEkNoaWxsZXJUZW1wZXJh", + "dHVyZRgbIAEoARIgChhEaXNwZW5zZXIxTW90b3JGcmVxdWVuY3kYHCABKAES", + "IAoYRGlzcGVuc2VyMk1vdG9yRnJlcXVlbmN5GB0gASgBEiAKGERpc3BlbnNl", + "cjNNb3RvckZyZXF1ZW5jeRgeIAEoARIgChhEaXNwZW5zZXI0TW90b3JGcmVx", + "dWVuY3kYHyABKAESIAoYRGlzcGVuc2VyNU1vdG9yRnJlcXVlbmN5GCAgASgB", + "EiAKGERpc3BlbnNlcjZNb3RvckZyZXF1ZW5jeRghIAEoARIgChhEaXNwZW5z", + "ZXI3TW90b3JGcmVxdWVuY3kYIiABKAESIAoYRGlzcGVuc2VyOE1vdG9yRnJl", + "cXVlbmN5GCMgASgBEhwKFEhlYWRab25lNFRlbXBlcmF0dXJlGCQgASgBEhwK", + "FEhlYWRab25lNVRlbXBlcmF0dXJlGCUgASgBEhwKFEhlYWRab25lNlRlbXBl", + "cmF0dXJlGCYgASgBEhUKDUJsb3dlclZvbHRhZ2UYJyABKAESGgoSRGlzcGVu", + "c2VyMVByZXNzdXJlGCggASgBEhoKEkRpc3BlbnNlcjJQcmVzc3VyZRgpIAEo", + "ARIaChJEaXNwZW5zZXIzUHJlc3N1cmUYKiABKAESGgoSRGlzcGVuc2VyNFBy", + "ZXNzdXJlGCsgASgBEhoKEkRpc3BlbnNlcjVQcmVzc3VyZRgsIAEoARIaChJE", + "aXNwZW5zZXI2UHJlc3N1cmUYLSABKAESGgoSRGlzcGVuc2VyN1ByZXNzdXJl", + "GC4gASgBEhoKEkRpc3BlbnNlcjhQcmVzc3VyZRgvIAEoARIVCg1NaWRUYW5r", + "MUxldmVsGDAgASgBEhUKDU1pZFRhbmsyTGV2ZWwYMSABKAESFQoNTWlkVGFu", + "azNMZXZlbBgyIAEoARIVCg1NaWRUYW5rNExldmVsGDMgASgBEhUKDU1pZFRh", + "bms1TGV2ZWwYNCABKAESFQoNTWlkVGFuazZMZXZlbBg1IAEoARIVCg1NaWRU", + "YW5rN0xldmVsGDYgASgBEhUKDU1pZFRhbms4TGV2ZWwYNyABKAESHwoXRHJp", + "ZXJab25lMUhlYXRlckN1cnJlbnQYOCABKAESHwoXRHJpZXJab25lMkhlYXRl", + "ckN1cnJlbnQYOSABKAESHgoWSGVhZFpvbmUxSGVhdGVyQ3VycmVudBg6IAEo", + "ARIeChZIZWFkWm9uZTJIZWF0ZXJDdXJyZW50GDsgASgBEh4KFkhlYWRab25l", + "M0hlYXRlckN1cnJlbnQYPCABKAESHgoWSGVhZFpvbmU0SGVhdGVyQ3VycmVu", + "dBg9IAEoARIgChhIZWFkWm9uZTVfNkhlYXRlckN1cnJlbnQYPiABKAESGwoT", + "TWl4ZXIxSGVhdGVyQ3VycmVudBg/IAEoARIaChJEaXNwZW5zZXJzSW5rTGV2", + "ZWwYQCADKAESGAoQTWlkVGFua3NJbmtMZXZlbBhBIAMoARIaChJPdmVyYWxs", + "VGVtcGVyYXR1cmUYQiABKAESHgoWSGVhZFpvbmU3SGVhdGVyQ3VycmVudBhD", + "IAEoARIcChRIZWFkWm9uZTdUZW1wZXJhdHVyZRhEIAEoARIeChZIZWFkWm9u", + "ZThIZWF0ZXJDdXJyZW50GEUgASgBEhwKFEhlYWRab25lOFRlbXBlcmF0dXJl", + "GEYgASgBEh4KFkhlYWRab25lOUhlYXRlckN1cnJlbnQYRyABKAESHAoUSGVh", + "ZFpvbmU5VGVtcGVyYXR1cmUYSCABKAESHwoXSGVhZFpvbmUxMEhlYXRlckN1", + "cnJlbnQYSSABKAESHQoVSGVhZFpvbmUxMFRlbXBlcmF0dXJlGEogASgBEh8K", + "F0hlYWRab25lMTFIZWF0ZXJDdXJyZW50GEsgASgBEh0KFUhlYWRab25lMTFU", + "ZW1wZXJhdHVyZRhMIAEoARIfChdIZWFkWm9uZTEySGVhdGVyQ3VycmVudBhN", + "IAEoARIdChVIZWFkWm9uZTEyVGVtcGVyYXR1cmUYTiABKAESGgoSSGVhZEJs", + "b3dlclZvbHRhZ2UxGE8gASgBEhoKEkhlYWRCbG93ZXJWb2x0YWdlMhhQIAEo", + "ARIfChdIZWFkQ292ZXJIZWF0ZXIxQ3VycmVudBhRIAEoARIjChtIZWFkQ292", + "ZXJIZWF0ZXIxVGVtcGVyYXR1cmUYUiABKAESHwoXSGVhZENvdmVySGVhdGVy", + "MkN1cnJlbnQYUyABKAESIwobSGVhZENvdmVySGVhdGVyMlRlbXBlcmF0dXJl", + "GFQgASgBEhkKEVdIU0Jsb3dlcjJWb2x0YWdlGFUgASgBEhEKCUdhc1NlbnNv", + "chhWIAEoARIXCg9JbmNvbWluZ1ZvbHRhZ2UYVyABKAESEgoKV2FzdGVMZXZl", + "bBhYIAEoARIaChJIZWFkQmxvd2VyMUFpckZsb3cYWSABKAESGgoSSGVhZEJs", + "b3dlcjJBaXJGbG93GFogASgBQh4KHGNvbS50d2luZS50YW5nby5wbXIuaW5z", + "aWdodHNiBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { }, + new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.Insights.InsightsMonitors), global::Tango.PMR.Insights.InsightsMonitors.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", "GasSensor", "IncomingVoltage", "WasteLevel", "HeadBlower1AirFlow", "HeadBlower2AirFlow" }, null, null, null) + })); + } + #endregion + + } + #region Messages + public sealed partial class InsightsMonitors : pb::IMessage<InsightsMonitors> { + private static readonly pb::MessageParser<InsightsMonitors> _parser = new pb::MessageParser<InsightsMonitors>(() => new InsightsMonitors()); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser<InsightsMonitors> Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Tango.PMR.Insights.InsightsMonitorsReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public InsightsMonitors() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public InsightsMonitors(InsightsMonitors other) : this() { + dancer1Angle_ = other.dancer1Angle_; + dancer2Angle_ = other.dancer2Angle_; + dancer3Angle_ = other.dancer3Angle_; + feederMotorFrequency_ = other.feederMotorFrequency_; + dryerMotor_ = other.dryerMotor_; + pollerMotor_ = other.pollerMotor_; + winderMotor_ = other.winderMotor_; + screwMotor_ = other.screwMotor_; + threadSpeed_ = other.threadSpeed_; + mixerTemperature_ = other.mixerTemperature_; + headZone1Temperature_ = other.headZone1Temperature_; + headZone2Temperature_ = other.headZone2Temperature_; + headZone3Temperature_ = other.headZone3Temperature_; + headAirFlow_ = other.headAirFlow_; + feederTension_ = other.feederTension_; + pullerTension_ = other.pullerTension_; + dryerZone1Temperature_ = other.dryerZone1Temperature_; + dryerZone2Temperature_ = other.dryerZone2Temperature_; + dryerZone3Temperature_ = other.dryerZone3Temperature_; + dryerAirFlow_ = other.dryerAirFlow_; + winderTension_ = other.winderTension_; + dispensersMotorsFrequency_ = other.dispensersMotorsFrequency_.Clone(); + dispensersAngularEncoders_ = other.dispensersAngularEncoders_.Clone(); + dispensersLinearPositions_ = other.dispensersLinearPositions_.Clone(); + dispensersPressure_ = other.dispensersPressure_.Clone(); + filterDeltaPressure_ = other.filterDeltaPressure_; + chillerTemperature_ = other.chillerTemperature_; + dispenser1MotorFrequency_ = other.dispenser1MotorFrequency_; + dispenser2MotorFrequency_ = other.dispenser2MotorFrequency_; + dispenser3MotorFrequency_ = other.dispenser3MotorFrequency_; + dispenser4MotorFrequency_ = other.dispenser4MotorFrequency_; + dispenser5MotorFrequency_ = other.dispenser5MotorFrequency_; + dispenser6MotorFrequency_ = other.dispenser6MotorFrequency_; + dispenser7MotorFrequency_ = other.dispenser7MotorFrequency_; + dispenser8MotorFrequency_ = other.dispenser8MotorFrequency_; + headZone4Temperature_ = other.headZone4Temperature_; + headZone5Temperature_ = other.headZone5Temperature_; + headZone6Temperature_ = other.headZone6Temperature_; + blowerVoltage_ = other.blowerVoltage_; + dispenser1Pressure_ = other.dispenser1Pressure_; + dispenser2Pressure_ = other.dispenser2Pressure_; + dispenser3Pressure_ = other.dispenser3Pressure_; + dispenser4Pressure_ = other.dispenser4Pressure_; + dispenser5Pressure_ = other.dispenser5Pressure_; + dispenser6Pressure_ = other.dispenser6Pressure_; + dispenser7Pressure_ = other.dispenser7Pressure_; + dispenser8Pressure_ = other.dispenser8Pressure_; + midTank1Level_ = other.midTank1Level_; + midTank2Level_ = other.midTank2Level_; + midTank3Level_ = other.midTank3Level_; + midTank4Level_ = other.midTank4Level_; + midTank5Level_ = other.midTank5Level_; + midTank6Level_ = other.midTank6Level_; + midTank7Level_ = other.midTank7Level_; + midTank8Level_ = other.midTank8Level_; + drierZone1HeaterCurrent_ = other.drierZone1HeaterCurrent_; + drierZone2HeaterCurrent_ = other.drierZone2HeaterCurrent_; + headZone1HeaterCurrent_ = other.headZone1HeaterCurrent_; + headZone2HeaterCurrent_ = other.headZone2HeaterCurrent_; + headZone3HeaterCurrent_ = other.headZone3HeaterCurrent_; + headZone4HeaterCurrent_ = other.headZone4HeaterCurrent_; + headZone56HeaterCurrent_ = other.headZone56HeaterCurrent_; + mixer1HeaterCurrent_ = other.mixer1HeaterCurrent_; + dispensersInkLevel_ = other.dispensersInkLevel_.Clone(); + midTanksInkLevel_ = other.midTanksInkLevel_.Clone(); + overallTemperature_ = other.overallTemperature_; + headZone7HeaterCurrent_ = other.headZone7HeaterCurrent_; + headZone7Temperature_ = other.headZone7Temperature_; + headZone8HeaterCurrent_ = other.headZone8HeaterCurrent_; + headZone8Temperature_ = other.headZone8Temperature_; + headZone9HeaterCurrent_ = other.headZone9HeaterCurrent_; + headZone9Temperature_ = other.headZone9Temperature_; + headZone10HeaterCurrent_ = other.headZone10HeaterCurrent_; + headZone10Temperature_ = other.headZone10Temperature_; + headZone11HeaterCurrent_ = other.headZone11HeaterCurrent_; + headZone11Temperature_ = other.headZone11Temperature_; + headZone12HeaterCurrent_ = other.headZone12HeaterCurrent_; + headZone12Temperature_ = other.headZone12Temperature_; + headBlowerVoltage1_ = other.headBlowerVoltage1_; + headBlowerVoltage2_ = other.headBlowerVoltage2_; + headCoverHeater1Current_ = other.headCoverHeater1Current_; + headCoverHeater1Temperature_ = other.headCoverHeater1Temperature_; + headCoverHeater2Current_ = other.headCoverHeater2Current_; + headCoverHeater2Temperature_ = other.headCoverHeater2Temperature_; + wHSBlower2Voltage_ = other.wHSBlower2Voltage_; + gasSensor_ = other.gasSensor_; + incomingVoltage_ = other.incomingVoltage_; + wasteLevel_ = other.wasteLevel_; + headBlower1AirFlow_ = other.headBlower1AirFlow_; + headBlower2AirFlow_ = other.headBlower2AirFlow_; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public InsightsMonitors Clone() { + return new InsightsMonitors(this); + } + + /// <summary>Field number for the "Dancer1Angle" field.</summary> + public const int Dancer1AngleFieldNumber = 1; + private double dancer1Angle_; + /// <summary> + ///Left Dancer + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dancer1Angle { + get { return dancer1Angle_; } + set { + dancer1Angle_ = value; + } + } + + /// <summary>Field number for the "Dancer2Angle" field.</summary> + public const int Dancer2AngleFieldNumber = 2; + private double dancer2Angle_; + /// <summary> + ///Middle Dancer + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dancer2Angle { + get { return dancer2Angle_; } + set { + dancer2Angle_ = value; + } + } + + /// <summary>Field number for the "Dancer3Angle" field.</summary> + public const int Dancer3AngleFieldNumber = 3; + private double dancer3Angle_; + /// <summary> + ///Right Dancer + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dancer3Angle { + get { return dancer3Angle_; } + set { + dancer3Angle_ = value; + } + } + + /// <summary>Field number for the "FeederMotorFrequency" field.</summary> + public const int FeederMotorFrequencyFieldNumber = 4; + private double feederMotorFrequency_; + /// <summary> + ///Feeder Motor + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double FeederMotorFrequency { + get { return feederMotorFrequency_; } + set { + feederMotorFrequency_ = value; + } + } + + /// <summary>Field number for the "DryerMotor" field.</summary> + public const int DryerMotorFieldNumber = 5; + private double dryerMotor_; + /// <summary> + ///Dryer Motor + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DryerMotor { + get { return dryerMotor_; } + set { + dryerMotor_ = value; + } + } + + /// <summary>Field number for the "PollerMotor" field.</summary> + public const int PollerMotorFieldNumber = 6; + private double pollerMotor_; + /// <summary> + ///Poller Motor + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double PollerMotor { + get { return pollerMotor_; } + set { + pollerMotor_ = value; + } + } + + /// <summary>Field number for the "WinderMotor" field.</summary> + public const int WinderMotorFieldNumber = 7; + private double winderMotor_; + /// <summary> + ///Winder Motor + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double WinderMotor { + get { return winderMotor_; } + set { + winderMotor_ = value; + } + } + + /// <summary>Field number for the "ScrewMotor" field.</summary> + public const int ScrewMotorFieldNumber = 8; + private double screwMotor_; + /// <summary> + ///Screw Motor + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ScrewMotor { + get { return screwMotor_; } + set { + screwMotor_ = value; + } + } + + /// <summary>Field number for the "ThreadSpeed" field.</summary> + public const int ThreadSpeedFieldNumber = 9; + private double threadSpeed_; + /// <summary> + ///Thread Speed + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ThreadSpeed { + get { return threadSpeed_; } + set { + threadSpeed_ = value; + } + } + + /// <summary>Field number for the "MixerTemperature" field.</summary> + public const int MixerTemperatureFieldNumber = 10; + private double mixerTemperature_; + /// <summary> + ///Mixer + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MixerTemperature { + get { return mixerTemperature_; } + set { + mixerTemperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone1Temperature" field.</summary> + public const int HeadZone1TemperatureFieldNumber = 11; + private double headZone1Temperature_; + /// <summary> + ///Head Zone 1 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone1Temperature { + get { return headZone1Temperature_; } + set { + headZone1Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone2Temperature" field.</summary> + public const int HeadZone2TemperatureFieldNumber = 12; + private double headZone2Temperature_; + /// <summary> + ///Head Zone 2 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone2Temperature { + get { return headZone2Temperature_; } + set { + headZone2Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone3Temperature" field.</summary> + public const int HeadZone3TemperatureFieldNumber = 13; + private double headZone3Temperature_; + /// <summary> + ///Head Zone 3 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone3Temperature { + get { return headZone3Temperature_; } + set { + headZone3Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadAirFlow" field.</summary> + public const int HeadAirFlowFieldNumber = 14; + private double headAirFlow_; + /// <summary> + ///Head Air Flow + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadAirFlow { + get { return headAirFlow_; } + set { + headAirFlow_ = value; + } + } + + /// <summary>Field number for the "FeederTension" field.</summary> + public const int FeederTensionFieldNumber = 15; + private double feederTension_; + /// <summary> + ///Feeder Tension + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double FeederTension { + get { return feederTension_; } + set { + feederTension_ = value; + } + } + + /// <summary>Field number for the "PullerTension" field.</summary> + public const int PullerTensionFieldNumber = 16; + private double pullerTension_; + /// <summary> + ///Puller Tension + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double PullerTension { + get { return pullerTension_; } + set { + pullerTension_ = value; + } + } + + /// <summary>Field number for the "DryerZone1Temperature" field.</summary> + public const int DryerZone1TemperatureFieldNumber = 17; + private double dryerZone1Temperature_; + /// <summary> + ///Dryer Zone 1 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DryerZone1Temperature { + get { return dryerZone1Temperature_; } + set { + dryerZone1Temperature_ = value; + } + } + + /// <summary>Field number for the "DryerZone2Temperature" field.</summary> + public const int DryerZone2TemperatureFieldNumber = 18; + private double dryerZone2Temperature_; + /// <summary> + ///Dryer Zone 2 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DryerZone2Temperature { + get { return dryerZone2Temperature_; } + set { + dryerZone2Temperature_ = value; + } + } + + /// <summary>Field number for the "DryerZone3Temperature" field.</summary> + public const int DryerZone3TemperatureFieldNumber = 19; + private double dryerZone3Temperature_; + /// <summary> + ///Dryer Zone 3 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DryerZone3Temperature { + get { return dryerZone3Temperature_; } + set { + dryerZone3Temperature_ = value; + } + } + + /// <summary>Field number for the "DryerAirFlow" field.</summary> + public const int DryerAirFlowFieldNumber = 20; + private double dryerAirFlow_; + /// <summary> + ///Dryer Air Flow + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DryerAirFlow { + get { return dryerAirFlow_; } + set { + dryerAirFlow_ = value; + } + } + + /// <summary>Field number for the "WinderTension" field.</summary> + public const int WinderTensionFieldNumber = 21; + private double winderTension_; + /// <summary> + ///Winder Tension + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double WinderTension { + get { return winderTension_; } + set { + winderTension_ = value; + } + } + + /// <summary>Field number for the "DispensersMotorsFrequency" field.</summary> + public const int DispensersMotorsFrequencyFieldNumber = 22; + private static readonly pb::FieldCodec<double> _repeated_dispensersMotorsFrequency_codec + = pb::FieldCodec.ForDouble(178); + private readonly pbc::RepeatedField<double> dispensersMotorsFrequency_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Dispensers Motors + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> DispensersMotorsFrequency { + get { return dispensersMotorsFrequency_; } + } + + /// <summary>Field number for the "DispensersAngularEncoders" field.</summary> + public const int DispensersAngularEncodersFieldNumber = 23; + private static readonly pb::FieldCodec<double> _repeated_dispensersAngularEncoders_codec + = pb::FieldCodec.ForDouble(186); + private readonly pbc::RepeatedField<double> dispensersAngularEncoders_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Dispensers Angular Encoders + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> DispensersAngularEncoders { + get { return dispensersAngularEncoders_; } + } + + /// <summary>Field number for the "DispensersLinearPositions" field.</summary> + public const int DispensersLinearPositionsFieldNumber = 24; + private static readonly pb::FieldCodec<double> _repeated_dispensersLinearPositions_codec + = pb::FieldCodec.ForDouble(194); + private readonly pbc::RepeatedField<double> dispensersLinearPositions_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Dispensers Linear Positions + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> DispensersLinearPositions { + get { return dispensersLinearPositions_; } + } + + /// <summary>Field number for the "DispensersPressure" field.</summary> + public const int DispensersPressureFieldNumber = 25; + private static readonly pb::FieldCodec<double> _repeated_dispensersPressure_codec + = pb::FieldCodec.ForDouble(202); + private readonly pbc::RepeatedField<double> dispensersPressure_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Dispensers Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> DispensersPressure { + get { return dispensersPressure_; } + } + + /// <summary>Field number for the "FilterDeltaPressure" field.</summary> + public const int FilterDeltaPressureFieldNumber = 26; + private double filterDeltaPressure_; + /// <summary> + ///Filter Delta Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double FilterDeltaPressure { + get { return filterDeltaPressure_; } + set { + filterDeltaPressure_ = value; + } + } + + /// <summary>Field number for the "ChillerTemperature" field.</summary> + public const int ChillerTemperatureFieldNumber = 27; + private double chillerTemperature_; + /// <summary> + ///Chiller Temperature + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double ChillerTemperature { + get { return chillerTemperature_; } + set { + chillerTemperature_ = value; + } + } + + /// <summary>Field number for the "Dispenser1MotorFrequency" field.</summary> + public const int Dispenser1MotorFrequencyFieldNumber = 28; + private double dispenser1MotorFrequency_; + /// <summary> + ///Dispenser 1 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser1MotorFrequency { + get { return dispenser1MotorFrequency_; } + set { + dispenser1MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser2MotorFrequency" field.</summary> + public const int Dispenser2MotorFrequencyFieldNumber = 29; + private double dispenser2MotorFrequency_; + /// <summary> + ///Dispenser 2 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser2MotorFrequency { + get { return dispenser2MotorFrequency_; } + set { + dispenser2MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser3MotorFrequency" field.</summary> + public const int Dispenser3MotorFrequencyFieldNumber = 30; + private double dispenser3MotorFrequency_; + /// <summary> + ///Dispenser 3 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser3MotorFrequency { + get { return dispenser3MotorFrequency_; } + set { + dispenser3MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser4MotorFrequency" field.</summary> + public const int Dispenser4MotorFrequencyFieldNumber = 31; + private double dispenser4MotorFrequency_; + /// <summary> + ///Dispenser 4 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser4MotorFrequency { + get { return dispenser4MotorFrequency_; } + set { + dispenser4MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser5MotorFrequency" field.</summary> + public const int Dispenser5MotorFrequencyFieldNumber = 32; + private double dispenser5MotorFrequency_; + /// <summary> + ///Dispenser 5 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser5MotorFrequency { + get { return dispenser5MotorFrequency_; } + set { + dispenser5MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser6MotorFrequency" field.</summary> + public const int Dispenser6MotorFrequencyFieldNumber = 33; + private double dispenser6MotorFrequency_; + /// <summary> + ///Dispenser 6 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser6MotorFrequency { + get { return dispenser6MotorFrequency_; } + set { + dispenser6MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser7MotorFrequency" field.</summary> + public const int Dispenser7MotorFrequencyFieldNumber = 34; + private double dispenser7MotorFrequency_; + /// <summary> + ///Dispenser 7 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser7MotorFrequency { + get { return dispenser7MotorFrequency_; } + set { + dispenser7MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "Dispenser8MotorFrequency" field.</summary> + public const int Dispenser8MotorFrequencyFieldNumber = 35; + private double dispenser8MotorFrequency_; + /// <summary> + ///Dispenser 8 Motor Frequency + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser8MotorFrequency { + get { return dispenser8MotorFrequency_; } + set { + dispenser8MotorFrequency_ = value; + } + } + + /// <summary>Field number for the "HeadZone4Temperature" field.</summary> + public const int HeadZone4TemperatureFieldNumber = 36; + private double headZone4Temperature_; + /// <summary> + ///Head Zone 4 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone4Temperature { + get { return headZone4Temperature_; } + set { + headZone4Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone5Temperature" field.</summary> + public const int HeadZone5TemperatureFieldNumber = 37; + private double headZone5Temperature_; + /// <summary> + ///Head Zone 5 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone5Temperature { + get { return headZone5Temperature_; } + set { + headZone5Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone6Temperature" field.</summary> + public const int HeadZone6TemperatureFieldNumber = 38; + private double headZone6Temperature_; + /// <summary> + ///Head Zone 6 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone6Temperature { + get { return headZone6Temperature_; } + set { + headZone6Temperature_ = value; + } + } + + /// <summary>Field number for the "BlowerVoltage" field.</summary> + public const int BlowerVoltageFieldNumber = 39; + private double blowerVoltage_; + /// <summary> + ///Blower Voltage + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double BlowerVoltage { + get { return blowerVoltage_; } + set { + blowerVoltage_ = value; + } + } + + /// <summary>Field number for the "Dispenser1Pressure" field.</summary> + public const int Dispenser1PressureFieldNumber = 40; + private double dispenser1Pressure_; + /// <summary> + ///Dispenser 1 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser1Pressure { + get { return dispenser1Pressure_; } + set { + dispenser1Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser2Pressure" field.</summary> + public const int Dispenser2PressureFieldNumber = 41; + private double dispenser2Pressure_; + /// <summary> + ///Dispenser 2 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser2Pressure { + get { return dispenser2Pressure_; } + set { + dispenser2Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser3Pressure" field.</summary> + public const int Dispenser3PressureFieldNumber = 42; + private double dispenser3Pressure_; + /// <summary> + ///Dispenser 3 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser3Pressure { + get { return dispenser3Pressure_; } + set { + dispenser3Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser4Pressure" field.</summary> + public const int Dispenser4PressureFieldNumber = 43; + private double dispenser4Pressure_; + /// <summary> + ///Dispenser 4 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser4Pressure { + get { return dispenser4Pressure_; } + set { + dispenser4Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser5Pressure" field.</summary> + public const int Dispenser5PressureFieldNumber = 44; + private double dispenser5Pressure_; + /// <summary> + ///Dispenser 5 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser5Pressure { + get { return dispenser5Pressure_; } + set { + dispenser5Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser6Pressure" field.</summary> + public const int Dispenser6PressureFieldNumber = 45; + private double dispenser6Pressure_; + /// <summary> + ///Dispenser 6 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser6Pressure { + get { return dispenser6Pressure_; } + set { + dispenser6Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser7Pressure" field.</summary> + public const int Dispenser7PressureFieldNumber = 46; + private double dispenser7Pressure_; + /// <summary> + ///Dispenser 7 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser7Pressure { + get { return dispenser7Pressure_; } + set { + dispenser7Pressure_ = value; + } + } + + /// <summary>Field number for the "Dispenser8Pressure" field.</summary> + public const int Dispenser8PressureFieldNumber = 47; + private double dispenser8Pressure_; + /// <summary> + ///Dispenser 8 Pressure + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Dispenser8Pressure { + get { return dispenser8Pressure_; } + set { + dispenser8Pressure_ = value; + } + } + + /// <summary>Field number for the "MidTank1Level" field.</summary> + public const int MidTank1LevelFieldNumber = 48; + private double midTank1Level_; + /// <summary> + ///Mid Tank 1 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank1Level { + get { return midTank1Level_; } + set { + midTank1Level_ = value; + } + } + + /// <summary>Field number for the "MidTank2Level" field.</summary> + public const int MidTank2LevelFieldNumber = 49; + private double midTank2Level_; + /// <summary> + ///Mid Tank 2 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank2Level { + get { return midTank2Level_; } + set { + midTank2Level_ = value; + } + } + + /// <summary>Field number for the "MidTank3Level" field.</summary> + public const int MidTank3LevelFieldNumber = 50; + private double midTank3Level_; + /// <summary> + ///Mid Tank 3 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank3Level { + get { return midTank3Level_; } + set { + midTank3Level_ = value; + } + } + + /// <summary>Field number for the "MidTank4Level" field.</summary> + public const int MidTank4LevelFieldNumber = 51; + private double midTank4Level_; + /// <summary> + ///Mid Tank 4 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank4Level { + get { return midTank4Level_; } + set { + midTank4Level_ = value; + } + } + + /// <summary>Field number for the "MidTank5Level" field.</summary> + public const int MidTank5LevelFieldNumber = 52; + private double midTank5Level_; + /// <summary> + ///Mid Tank 5 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank5Level { + get { return midTank5Level_; } + set { + midTank5Level_ = value; + } + } + + /// <summary>Field number for the "MidTank6Level" field.</summary> + public const int MidTank6LevelFieldNumber = 53; + private double midTank6Level_; + /// <summary> + ///Mid Tank 6 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank6Level { + get { return midTank6Level_; } + set { + midTank6Level_ = value; + } + } + + /// <summary>Field number for the "MidTank7Level" field.</summary> + public const int MidTank7LevelFieldNumber = 54; + private double midTank7Level_; + /// <summary> + ///Mid Tank 7 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank7Level { + get { return midTank7Level_; } + set { + midTank7Level_ = value; + } + } + + /// <summary>Field number for the "MidTank8Level" field.</summary> + public const int MidTank8LevelFieldNumber = 55; + private double midTank8Level_; + /// <summary> + ///Mid Tank 8 Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MidTank8Level { + get { return midTank8Level_; } + set { + midTank8Level_ = value; + } + } + + /// <summary>Field number for the "DrierZone1HeaterCurrent" field.</summary> + public const int DrierZone1HeaterCurrentFieldNumber = 56; + private double drierZone1HeaterCurrent_; + /// <summary> + ///Drier Zone1 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DrierZone1HeaterCurrent { + get { return drierZone1HeaterCurrent_; } + set { + drierZone1HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "DrierZone2HeaterCurrent" field.</summary> + public const int DrierZone2HeaterCurrentFieldNumber = 57; + private double drierZone2HeaterCurrent_; + /// <summary> + ///Drier Zone 2 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DrierZone2HeaterCurrent { + get { return drierZone2HeaterCurrent_; } + set { + drierZone2HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone1HeaterCurrent" field.</summary> + public const int HeadZone1HeaterCurrentFieldNumber = 58; + private double headZone1HeaterCurrent_; + /// <summary> + ///Head Zone 1 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone1HeaterCurrent { + get { return headZone1HeaterCurrent_; } + set { + headZone1HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone2HeaterCurrent" field.</summary> + public const int HeadZone2HeaterCurrentFieldNumber = 59; + private double headZone2HeaterCurrent_; + /// <summary> + ///Head Zone 2 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone2HeaterCurrent { + get { return headZone2HeaterCurrent_; } + set { + headZone2HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone3HeaterCurrent" field.</summary> + public const int HeadZone3HeaterCurrentFieldNumber = 60; + private double headZone3HeaterCurrent_; + /// <summary> + ///Head Zone 3 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone3HeaterCurrent { + get { return headZone3HeaterCurrent_; } + set { + headZone3HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone4HeaterCurrent" field.</summary> + public const int HeadZone4HeaterCurrentFieldNumber = 61; + private double headZone4HeaterCurrent_; + /// <summary> + ///Head Zone 4 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone4HeaterCurrent { + get { return headZone4HeaterCurrent_; } + set { + headZone4HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone5_6HeaterCurrent" field.</summary> + public const int HeadZone56HeaterCurrentFieldNumber = 62; + private double headZone56HeaterCurrent_; + /// <summary> + ///Head Zone 5-6 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone56HeaterCurrent { + get { return headZone56HeaterCurrent_; } + set { + headZone56HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "Mixer1HeaterCurrent" field.</summary> + public const int Mixer1HeaterCurrentFieldNumber = 63; + private double mixer1HeaterCurrent_; + /// <summary> + ///Mixer 1 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Mixer1HeaterCurrent { + get { return mixer1HeaterCurrent_; } + set { + mixer1HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "DispensersInkLevel" field.</summary> + public const int DispensersInkLevelFieldNumber = 64; + private static readonly pb::FieldCodec<double> _repeated_dispensersInkLevel_codec + = pb::FieldCodec.ForDouble(514); + private readonly pbc::RepeatedField<double> dispensersInkLevel_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Dispensers Ink Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> DispensersInkLevel { + get { return dispensersInkLevel_; } + } + + /// <summary>Field number for the "MidTanksInkLevel" field.</summary> + public const int MidTanksInkLevelFieldNumber = 65; + private static readonly pb::FieldCodec<double> _repeated_midTanksInkLevel_codec + = pb::FieldCodec.ForDouble(522); + private readonly pbc::RepeatedField<double> midTanksInkLevel_ = new pbc::RepeatedField<double>(); + /// <summary> + ///Mid Tanks Ink Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField<double> MidTanksInkLevel { + get { return midTanksInkLevel_; } + } + + /// <summary>Field number for the "OverallTemperature" field.</summary> + public const int OverallTemperatureFieldNumber = 66; + private double overallTemperature_; + /// <summary> + ///Overall Temperature + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double OverallTemperature { + get { return overallTemperature_; } + set { + overallTemperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone7HeaterCurrent" field.</summary> + public const int HeadZone7HeaterCurrentFieldNumber = 67; + private double headZone7HeaterCurrent_; + /// <summary> + ///Head Zone 7 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone7HeaterCurrent { + get { return headZone7HeaterCurrent_; } + set { + headZone7HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone7Temperature" field.</summary> + public const int HeadZone7TemperatureFieldNumber = 68; + private double headZone7Temperature_; + /// <summary> + ///Head Zone 7 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone7Temperature { + get { return headZone7Temperature_; } + set { + headZone7Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone8HeaterCurrent" field.</summary> + public const int HeadZone8HeaterCurrentFieldNumber = 69; + private double headZone8HeaterCurrent_; + /// <summary> + ///Head Zone 8 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone8HeaterCurrent { + get { return headZone8HeaterCurrent_; } + set { + headZone8HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone8Temperature" field.</summary> + public const int HeadZone8TemperatureFieldNumber = 70; + private double headZone8Temperature_; + /// <summary> + ///Head Zone 8 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone8Temperature { + get { return headZone8Temperature_; } + set { + headZone8Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone9HeaterCurrent" field.</summary> + public const int HeadZone9HeaterCurrentFieldNumber = 71; + private double headZone9HeaterCurrent_; + /// <summary> + ///Head Zone 9 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone9HeaterCurrent { + get { return headZone9HeaterCurrent_; } + set { + headZone9HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone9Temperature" field.</summary> + public const int HeadZone9TemperatureFieldNumber = 72; + private double headZone9Temperature_; + /// <summary> + ///Head Zone 9 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone9Temperature { + get { return headZone9Temperature_; } + set { + headZone9Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone10HeaterCurrent" field.</summary> + public const int HeadZone10HeaterCurrentFieldNumber = 73; + private double headZone10HeaterCurrent_; + /// <summary> + ///Head Zone 10 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone10HeaterCurrent { + get { return headZone10HeaterCurrent_; } + set { + headZone10HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone10Temperature" field.</summary> + public const int HeadZone10TemperatureFieldNumber = 74; + private double headZone10Temperature_; + /// <summary> + ///Head Zone 10 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone10Temperature { + get { return headZone10Temperature_; } + set { + headZone10Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone11HeaterCurrent" field.</summary> + public const int HeadZone11HeaterCurrentFieldNumber = 75; + private double headZone11HeaterCurrent_; + /// <summary> + ///Head Zone 11 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone11HeaterCurrent { + get { return headZone11HeaterCurrent_; } + set { + headZone11HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone11Temperature" field.</summary> + public const int HeadZone11TemperatureFieldNumber = 76; + private double headZone11Temperature_; + /// <summary> + ///Head Zone 11 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone11Temperature { + get { return headZone11Temperature_; } + set { + headZone11Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadZone12HeaterCurrent" field.</summary> + public const int HeadZone12HeaterCurrentFieldNumber = 77; + private double headZone12HeaterCurrent_; + /// <summary> + ///Head Zone 12 Heater Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone12HeaterCurrent { + get { return headZone12HeaterCurrent_; } + set { + headZone12HeaterCurrent_ = value; + } + } + + /// <summary>Field number for the "HeadZone12Temperature" field.</summary> + public const int HeadZone12TemperatureFieldNumber = 78; + private double headZone12Temperature_; + /// <summary> + ///Head Zone 12 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadZone12Temperature { + get { return headZone12Temperature_; } + set { + headZone12Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadBlowerVoltage1" field.</summary> + public const int HeadBlowerVoltage1FieldNumber = 79; + private double headBlowerVoltage1_; + /// <summary> + ///Head Blower Voltage 1 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadBlowerVoltage1 { + get { return headBlowerVoltage1_; } + set { + headBlowerVoltage1_ = value; + } + } + + /// <summary>Field number for the "HeadBlowerVoltage2" field.</summary> + public const int HeadBlowerVoltage2FieldNumber = 80; + private double headBlowerVoltage2_; + /// <summary> + ///Head Blower Voltage 2 + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadBlowerVoltage2 { + get { return headBlowerVoltage2_; } + set { + headBlowerVoltage2_ = value; + } + } + + /// <summary>Field number for the "HeadCoverHeater1Current" field.</summary> + public const int HeadCoverHeater1CurrentFieldNumber = 81; + private double headCoverHeater1Current_; + /// <summary> + ///Head Cover Heater 1 Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadCoverHeater1Current { + get { return headCoverHeater1Current_; } + set { + headCoverHeater1Current_ = value; + } + } + + /// <summary>Field number for the "HeadCoverHeater1Temperature" field.</summary> + public const int HeadCoverHeater1TemperatureFieldNumber = 82; + private double headCoverHeater1Temperature_; + /// <summary> + ///Head Cover Heater 1 Temperature + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadCoverHeater1Temperature { + get { return headCoverHeater1Temperature_; } + set { + headCoverHeater1Temperature_ = value; + } + } + + /// <summary>Field number for the "HeadCoverHeater2Current" field.</summary> + public const int HeadCoverHeater2CurrentFieldNumber = 83; + private double headCoverHeater2Current_; + /// <summary> + ///Head Cover Heater 2 Current + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadCoverHeater2Current { + get { return headCoverHeater2Current_; } + set { + headCoverHeater2Current_ = value; + } + } + + /// <summary>Field number for the "HeadCoverHeater2Temperature" field.</summary> + public const int HeadCoverHeater2TemperatureFieldNumber = 84; + private double headCoverHeater2Temperature_; + /// <summary> + ///Head Cover Heater 2 Temperature + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadCoverHeater2Temperature { + get { return headCoverHeater2Temperature_; } + set { + headCoverHeater2Temperature_ = value; + } + } + + /// <summary>Field number for the "WHSBlower2Voltage" field.</summary> + public const int WHSBlower2VoltageFieldNumber = 85; + private double wHSBlower2Voltage_; + /// <summary> + ///WHS Blower 2 Voltage + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double WHSBlower2Voltage { + get { return wHSBlower2Voltage_; } + set { + wHSBlower2Voltage_ = value; + } + } + + /// <summary>Field number for the "GasSensor" field.</summary> + public const int GasSensorFieldNumber = 86; + private double gasSensor_; + /// <summary> + ///Gas Sensor (VOC Sensor) + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double GasSensor { + get { return gasSensor_; } + set { + gasSensor_ = value; + } + } + + /// <summary>Field number for the "IncomingVoltage" field.</summary> + public const int IncomingVoltageFieldNumber = 87; + private double incomingVoltage_; + /// <summary> + ///Incoming Voltage (VAC Sensor) + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double IncomingVoltage { + get { return incomingVoltage_; } + set { + incomingVoltage_ = value; + } + } + + /// <summary>Field number for the "WasteLevel" field.</summary> + public const int WasteLevelFieldNumber = 88; + private double wasteLevel_; + /// <summary> + ///Waste Level + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double WasteLevel { + get { return wasteLevel_; } + set { + wasteLevel_ = value; + } + } + + /// <summary>Field number for the "HeadBlower1AirFlow" field.</summary> + public const int HeadBlower1AirFlowFieldNumber = 89; + private double headBlower1AirFlow_; + /// <summary> + ///Head Blower 1 Air Flow + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadBlower1AirFlow { + get { return headBlower1AirFlow_; } + set { + headBlower1AirFlow_ = value; + } + } + + /// <summary>Field number for the "HeadBlower2AirFlow" field.</summary> + public const int HeadBlower2AirFlowFieldNumber = 90; + private double headBlower2AirFlow_; + /// <summary> + ///Head Blower 2 Air Flow + /// </summary> + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double HeadBlower2AirFlow { + get { return headBlower2AirFlow_; } + set { + headBlower2AirFlow_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as InsightsMonitors); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(InsightsMonitors other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Dancer1Angle != other.Dancer1Angle) return false; + if (Dancer2Angle != other.Dancer2Angle) return false; + if (Dancer3Angle != other.Dancer3Angle) return false; + if (FeederMotorFrequency != other.FeederMotorFrequency) return false; + if (DryerMotor != other.DryerMotor) return false; + if (PollerMotor != other.PollerMotor) return false; + if (WinderMotor != other.WinderMotor) return false; + if (ScrewMotor != other.ScrewMotor) return false; + if (ThreadSpeed != other.ThreadSpeed) return false; + if (MixerTemperature != other.MixerTemperature) return false; + if (HeadZone1Temperature != other.HeadZone1Temperature) return false; + if (HeadZone2Temperature != other.HeadZone2Temperature) return false; + if (HeadZone3Temperature != other.HeadZone3Temperature) return false; + if (HeadAirFlow != other.HeadAirFlow) return false; + if (FeederTension != other.FeederTension) return false; + if (PullerTension != other.PullerTension) return false; + if (DryerZone1Temperature != other.DryerZone1Temperature) return false; + if (DryerZone2Temperature != other.DryerZone2Temperature) return false; + if (DryerZone3Temperature != other.DryerZone3Temperature) return false; + if (DryerAirFlow != other.DryerAirFlow) return false; + if (WinderTension != other.WinderTension) return false; + if(!dispensersMotorsFrequency_.Equals(other.dispensersMotorsFrequency_)) return false; + if(!dispensersAngularEncoders_.Equals(other.dispensersAngularEncoders_)) return false; + if(!dispensersLinearPositions_.Equals(other.dispensersLinearPositions_)) return false; + if(!dispensersPressure_.Equals(other.dispensersPressure_)) return false; + if (FilterDeltaPressure != other.FilterDeltaPressure) return false; + if (ChillerTemperature != other.ChillerTemperature) return false; + if (Dispenser1MotorFrequency != other.Dispenser1MotorFrequency) return false; + if (Dispenser2MotorFrequency != other.Dispenser2MotorFrequency) return false; + if (Dispenser3MotorFrequency != other.Dispenser3MotorFrequency) return false; + if (Dispenser4MotorFrequency != other.Dispenser4MotorFrequency) return false; + if (Dispenser5MotorFrequency != other.Dispenser5MotorFrequency) return false; + if (Dispenser6MotorFrequency != other.Dispenser6MotorFrequency) return false; + if (Dispenser7MotorFrequency != other.Dispenser7MotorFrequency) return false; + if (Dispenser8MotorFrequency != other.Dispenser8MotorFrequency) return false; + if (HeadZone4Temperature != other.HeadZone4Temperature) return false; + if (HeadZone5Temperature != other.HeadZone5Temperature) return false; + if (HeadZone6Temperature != other.HeadZone6Temperature) return false; + if (BlowerVoltage != other.BlowerVoltage) return false; + if (Dispenser1Pressure != other.Dispenser1Pressure) return false; + if (Dispenser2Pressure != other.Dispenser2Pressure) return false; + if (Dispenser3Pressure != other.Dispenser3Pressure) return false; + if (Dispenser4Pressure != other.Dispenser4Pressure) return false; + if (Dispenser5Pressure != other.Dispenser5Pressure) return false; + if (Dispenser6Pressure != other.Dispenser6Pressure) return false; + if (Dispenser7Pressure != other.Dispenser7Pressure) return false; + if (Dispenser8Pressure != other.Dispenser8Pressure) return false; + if (MidTank1Level != other.MidTank1Level) return false; + if (MidTank2Level != other.MidTank2Level) return false; + if (MidTank3Level != other.MidTank3Level) return false; + if (MidTank4Level != other.MidTank4Level) return false; + if (MidTank5Level != other.MidTank5Level) return false; + if (MidTank6Level != other.MidTank6Level) return false; + if (MidTank7Level != other.MidTank7Level) return false; + if (MidTank8Level != other.MidTank8Level) return false; + if (DrierZone1HeaterCurrent != other.DrierZone1HeaterCurrent) return false; + if (DrierZone2HeaterCurrent != other.DrierZone2HeaterCurrent) return false; + if (HeadZone1HeaterCurrent != other.HeadZone1HeaterCurrent) return false; + if (HeadZone2HeaterCurrent != other.HeadZone2HeaterCurrent) return false; + if (HeadZone3HeaterCurrent != other.HeadZone3HeaterCurrent) return false; + if (HeadZone4HeaterCurrent != other.HeadZone4HeaterCurrent) return false; + if (HeadZone56HeaterCurrent != other.HeadZone56HeaterCurrent) return false; + if (Mixer1HeaterCurrent != other.Mixer1HeaterCurrent) return false; + if(!dispensersInkLevel_.Equals(other.dispensersInkLevel_)) return false; + if(!midTanksInkLevel_.Equals(other.midTanksInkLevel_)) return false; + if (OverallTemperature != other.OverallTemperature) return false; + if (HeadZone7HeaterCurrent != other.HeadZone7HeaterCurrent) return false; + if (HeadZone7Temperature != other.HeadZone7Temperature) return false; + if (HeadZone8HeaterCurrent != other.HeadZone8HeaterCurrent) return false; + if (HeadZone8Temperature != other.HeadZone8Temperature) return false; + if (HeadZone9HeaterCurrent != other.HeadZone9HeaterCurrent) return false; + if (HeadZone9Temperature != other.HeadZone9Temperature) return false; + if (HeadZone10HeaterCurrent != other.HeadZone10HeaterCurrent) return false; + if (HeadZone10Temperature != other.HeadZone10Temperature) return false; + if (HeadZone11HeaterCurrent != other.HeadZone11HeaterCurrent) return false; + if (HeadZone11Temperature != other.HeadZone11Temperature) return false; + if (HeadZone12HeaterCurrent != other.HeadZone12HeaterCurrent) return false; + if (HeadZone12Temperature != other.HeadZone12Temperature) return false; + if (HeadBlowerVoltage1 != other.HeadBlowerVoltage1) return false; + if (HeadBlowerVoltage2 != other.HeadBlowerVoltage2) return false; + if (HeadCoverHeater1Current != other.HeadCoverHeater1Current) return false; + if (HeadCoverHeater1Temperature != other.HeadCoverHeater1Temperature) return false; + if (HeadCoverHeater2Current != other.HeadCoverHeater2Current) return false; + if (HeadCoverHeater2Temperature != other.HeadCoverHeater2Temperature) return false; + if (WHSBlower2Voltage != other.WHSBlower2Voltage) return false; + if (GasSensor != other.GasSensor) return false; + if (IncomingVoltage != other.IncomingVoltage) return false; + if (WasteLevel != other.WasteLevel) return false; + if (HeadBlower1AirFlow != other.HeadBlower1AirFlow) return false; + if (HeadBlower2AirFlow != other.HeadBlower2AirFlow) return false; + return true; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Dancer1Angle != 0D) hash ^= Dancer1Angle.GetHashCode(); + if (Dancer2Angle != 0D) hash ^= Dancer2Angle.GetHashCode(); + if (Dancer3Angle != 0D) hash ^= Dancer3Angle.GetHashCode(); + if (FeederMotorFrequency != 0D) hash ^= FeederMotorFrequency.GetHashCode(); + if (DryerMotor != 0D) hash ^= DryerMotor.GetHashCode(); + if (PollerMotor != 0D) hash ^= PollerMotor.GetHashCode(); + if (WinderMotor != 0D) hash ^= WinderMotor.GetHashCode(); + if (ScrewMotor != 0D) hash ^= ScrewMotor.GetHashCode(); + if (ThreadSpeed != 0D) hash ^= ThreadSpeed.GetHashCode(); + if (MixerTemperature != 0D) hash ^= MixerTemperature.GetHashCode(); + if (HeadZone1Temperature != 0D) hash ^= HeadZone1Temperature.GetHashCode(); + if (HeadZone2Temperature != 0D) hash ^= HeadZone2Temperature.GetHashCode(); + if (HeadZone3Temperature != 0D) hash ^= HeadZone3Temperature.GetHashCode(); + if (HeadAirFlow != 0D) hash ^= HeadAirFlow.GetHashCode(); + if (FeederTension != 0D) hash ^= FeederTension.GetHashCode(); + if (PullerTension != 0D) hash ^= PullerTension.GetHashCode(); + if (DryerZone1Temperature != 0D) hash ^= DryerZone1Temperature.GetHashCode(); + if (DryerZone2Temperature != 0D) hash ^= DryerZone2Temperature.GetHashCode(); + if (DryerZone3Temperature != 0D) hash ^= DryerZone3Temperature.GetHashCode(); + if (DryerAirFlow != 0D) hash ^= DryerAirFlow.GetHashCode(); + if (WinderTension != 0D) hash ^= WinderTension.GetHashCode(); + hash ^= dispensersMotorsFrequency_.GetHashCode(); + hash ^= dispensersAngularEncoders_.GetHashCode(); + hash ^= dispensersLinearPositions_.GetHashCode(); + hash ^= dispensersPressure_.GetHashCode(); + if (FilterDeltaPressure != 0D) hash ^= FilterDeltaPressure.GetHashCode(); + if (ChillerTemperature != 0D) hash ^= ChillerTemperature.GetHashCode(); + if (Dispenser1MotorFrequency != 0D) hash ^= Dispenser1MotorFrequency.GetHashCode(); + if (Dispenser2MotorFrequency != 0D) hash ^= Dispenser2MotorFrequency.GetHashCode(); + if (Dispenser3MotorFrequency != 0D) hash ^= Dispenser3MotorFrequency.GetHashCode(); + if (Dispenser4MotorFrequency != 0D) hash ^= Dispenser4MotorFrequency.GetHashCode(); + if (Dispenser5MotorFrequency != 0D) hash ^= Dispenser5MotorFrequency.GetHashCode(); + if (Dispenser6MotorFrequency != 0D) hash ^= Dispenser6MotorFrequency.GetHashCode(); + if (Dispenser7MotorFrequency != 0D) hash ^= Dispenser7MotorFrequency.GetHashCode(); + if (Dispenser8MotorFrequency != 0D) hash ^= Dispenser8MotorFrequency.GetHashCode(); + if (HeadZone4Temperature != 0D) hash ^= HeadZone4Temperature.GetHashCode(); + if (HeadZone5Temperature != 0D) hash ^= HeadZone5Temperature.GetHashCode(); + if (HeadZone6Temperature != 0D) hash ^= HeadZone6Temperature.GetHashCode(); + if (BlowerVoltage != 0D) hash ^= BlowerVoltage.GetHashCode(); + if (Dispenser1Pressure != 0D) hash ^= Dispenser1Pressure.GetHashCode(); + if (Dispenser2Pressure != 0D) hash ^= Dispenser2Pressure.GetHashCode(); + if (Dispenser3Pressure != 0D) hash ^= Dispenser3Pressure.GetHashCode(); + if (Dispenser4Pressure != 0D) hash ^= Dispenser4Pressure.GetHashCode(); + if (Dispenser5Pressure != 0D) hash ^= Dispenser5Pressure.GetHashCode(); + if (Dispenser6Pressure != 0D) hash ^= Dispenser6Pressure.GetHashCode(); + if (Dispenser7Pressure != 0D) hash ^= Dispenser7Pressure.GetHashCode(); + if (Dispenser8Pressure != 0D) hash ^= Dispenser8Pressure.GetHashCode(); + if (MidTank1Level != 0D) hash ^= MidTank1Level.GetHashCode(); + if (MidTank2Level != 0D) hash ^= MidTank2Level.GetHashCode(); + if (MidTank3Level != 0D) hash ^= MidTank3Level.GetHashCode(); + if (MidTank4Level != 0D) hash ^= MidTank4Level.GetHashCode(); + if (MidTank5Level != 0D) hash ^= MidTank5Level.GetHashCode(); + if (MidTank6Level != 0D) hash ^= MidTank6Level.GetHashCode(); + if (MidTank7Level != 0D) hash ^= MidTank7Level.GetHashCode(); + if (MidTank8Level != 0D) hash ^= MidTank8Level.GetHashCode(); + if (DrierZone1HeaterCurrent != 0D) hash ^= DrierZone1HeaterCurrent.GetHashCode(); + if (DrierZone2HeaterCurrent != 0D) hash ^= DrierZone2HeaterCurrent.GetHashCode(); + if (HeadZone1HeaterCurrent != 0D) hash ^= HeadZone1HeaterCurrent.GetHashCode(); + if (HeadZone2HeaterCurrent != 0D) hash ^= HeadZone2HeaterCurrent.GetHashCode(); + if (HeadZone3HeaterCurrent != 0D) hash ^= HeadZone3HeaterCurrent.GetHashCode(); + if (HeadZone4HeaterCurrent != 0D) hash ^= HeadZone4HeaterCurrent.GetHashCode(); + if (HeadZone56HeaterCurrent != 0D) hash ^= HeadZone56HeaterCurrent.GetHashCode(); + if (Mixer1HeaterCurrent != 0D) hash ^= Mixer1HeaterCurrent.GetHashCode(); + hash ^= dispensersInkLevel_.GetHashCode(); + hash ^= midTanksInkLevel_.GetHashCode(); + if (OverallTemperature != 0D) hash ^= OverallTemperature.GetHashCode(); + if (HeadZone7HeaterCurrent != 0D) hash ^= HeadZone7HeaterCurrent.GetHashCode(); + if (HeadZone7Temperature != 0D) hash ^= HeadZone7Temperature.GetHashCode(); + if (HeadZone8HeaterCurrent != 0D) hash ^= HeadZone8HeaterCurrent.GetHashCode(); + if (HeadZone8Temperature != 0D) hash ^= HeadZone8Temperature.GetHashCode(); + if (HeadZone9HeaterCurrent != 0D) hash ^= HeadZone9HeaterCurrent.GetHashCode(); + if (HeadZone9Temperature != 0D) hash ^= HeadZone9Temperature.GetHashCode(); + if (HeadZone10HeaterCurrent != 0D) hash ^= HeadZone10HeaterCurrent.GetHashCode(); + if (HeadZone10Temperature != 0D) hash ^= HeadZone10Temperature.GetHashCode(); + if (HeadZone11HeaterCurrent != 0D) hash ^= HeadZone11HeaterCurrent.GetHashCode(); + if (HeadZone11Temperature != 0D) hash ^= HeadZone11Temperature.GetHashCode(); + if (HeadZone12HeaterCurrent != 0D) hash ^= HeadZone12HeaterCurrent.GetHashCode(); + if (HeadZone12Temperature != 0D) hash ^= HeadZone12Temperature.GetHashCode(); + if (HeadBlowerVoltage1 != 0D) hash ^= HeadBlowerVoltage1.GetHashCode(); + if (HeadBlowerVoltage2 != 0D) hash ^= HeadBlowerVoltage2.GetHashCode(); + if (HeadCoverHeater1Current != 0D) hash ^= HeadCoverHeater1Current.GetHashCode(); + if (HeadCoverHeater1Temperature != 0D) hash ^= HeadCoverHeater1Temperature.GetHashCode(); + if (HeadCoverHeater2Current != 0D) hash ^= HeadCoverHeater2Current.GetHashCode(); + if (HeadCoverHeater2Temperature != 0D) hash ^= HeadCoverHeater2Temperature.GetHashCode(); + if (WHSBlower2Voltage != 0D) hash ^= WHSBlower2Voltage.GetHashCode(); + if (GasSensor != 0D) hash ^= GasSensor.GetHashCode(); + if (IncomingVoltage != 0D) hash ^= IncomingVoltage.GetHashCode(); + if (WasteLevel != 0D) hash ^= WasteLevel.GetHashCode(); + if (HeadBlower1AirFlow != 0D) hash ^= HeadBlower1AirFlow.GetHashCode(); + if (HeadBlower2AirFlow != 0D) hash ^= HeadBlower2AirFlow.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 (Dancer1Angle != 0D) { + output.WriteRawTag(9); + output.WriteDouble(Dancer1Angle); + } + if (Dancer2Angle != 0D) { + output.WriteRawTag(17); + output.WriteDouble(Dancer2Angle); + } + if (Dancer3Angle != 0D) { + output.WriteRawTag(25); + output.WriteDouble(Dancer3Angle); + } + if (FeederMotorFrequency != 0D) { + output.WriteRawTag(33); + output.WriteDouble(FeederMotorFrequency); + } + if (DryerMotor != 0D) { + output.WriteRawTag(41); + output.WriteDouble(DryerMotor); + } + if (PollerMotor != 0D) { + output.WriteRawTag(49); + output.WriteDouble(PollerMotor); + } + if (WinderMotor != 0D) { + output.WriteRawTag(57); + output.WriteDouble(WinderMotor); + } + if (ScrewMotor != 0D) { + output.WriteRawTag(65); + output.WriteDouble(ScrewMotor); + } + if (ThreadSpeed != 0D) { + output.WriteRawTag(73); + output.WriteDouble(ThreadSpeed); + } + if (MixerTemperature != 0D) { + output.WriteRawTag(81); + output.WriteDouble(MixerTemperature); + } + if (HeadZone1Temperature != 0D) { + output.WriteRawTag(89); + output.WriteDouble(HeadZone1Temperature); + } + if (HeadZone2Temperature != 0D) { + output.WriteRawTag(97); + output.WriteDouble(HeadZone2Temperature); + } + if (HeadZone3Temperature != 0D) { + output.WriteRawTag(105); + output.WriteDouble(HeadZone3Temperature); + } + if (HeadAirFlow != 0D) { + output.WriteRawTag(113); + output.WriteDouble(HeadAirFlow); + } + if (FeederTension != 0D) { + output.WriteRawTag(121); + output.WriteDouble(FeederTension); + } + if (PullerTension != 0D) { + output.WriteRawTag(129, 1); + output.WriteDouble(PullerTension); + } + if (DryerZone1Temperature != 0D) { + output.WriteRawTag(137, 1); + output.WriteDouble(DryerZone1Temperature); + } + if (DryerZone2Temperature != 0D) { + output.WriteRawTag(145, 1); + output.WriteDouble(DryerZone2Temperature); + } + if (DryerZone3Temperature != 0D) { + output.WriteRawTag(153, 1); + output.WriteDouble(DryerZone3Temperature); + } + if (DryerAirFlow != 0D) { + output.WriteRawTag(161, 1); + output.WriteDouble(DryerAirFlow); + } + if (WinderTension != 0D) { + output.WriteRawTag(169, 1); + output.WriteDouble(WinderTension); + } + dispensersMotorsFrequency_.WriteTo(output, _repeated_dispensersMotorsFrequency_codec); + dispensersAngularEncoders_.WriteTo(output, _repeated_dispensersAngularEncoders_codec); + dispensersLinearPositions_.WriteTo(output, _repeated_dispensersLinearPositions_codec); + dispensersPressure_.WriteTo(output, _repeated_dispensersPressure_codec); + if (FilterDeltaPressure != 0D) { + output.WriteRawTag(209, 1); + output.WriteDouble(FilterDeltaPressure); + } + if (ChillerTemperature != 0D) { + output.WriteRawTag(217, 1); + output.WriteDouble(ChillerTemperature); + } + if (Dispenser1MotorFrequency != 0D) { + output.WriteRawTag(225, 1); + output.WriteDouble(Dispenser1MotorFrequency); + } + if (Dispenser2MotorFrequency != 0D) { + output.WriteRawTag(233, 1); + output.WriteDouble(Dispenser2MotorFrequency); + } + if (Dispenser3MotorFrequency != 0D) { + output.WriteRawTag(241, 1); + output.WriteDouble(Dispenser3MotorFrequency); + } + if (Dispenser4MotorFrequency != 0D) { + output.WriteRawTag(249, 1); + output.WriteDouble(Dispenser4MotorFrequency); + } + if (Dispenser5MotorFrequency != 0D) { + output.WriteRawTag(129, 2); + output.WriteDouble(Dispenser5MotorFrequency); + } + if (Dispenser6MotorFrequency != 0D) { + output.WriteRawTag(137, 2); + output.WriteDouble(Dispenser6MotorFrequency); + } + if (Dispenser7MotorFrequency != 0D) { + output.WriteRawTag(145, 2); + output.WriteDouble(Dispenser7MotorFrequency); + } + if (Dispenser8MotorFrequency != 0D) { + output.WriteRawTag(153, 2); + output.WriteDouble(Dispenser8MotorFrequency); + } + if (HeadZone4Temperature != 0D) { + output.WriteRawTag(161, 2); + output.WriteDouble(HeadZone4Temperature); + } + if (HeadZone5Temperature != 0D) { + output.WriteRawTag(169, 2); + output.WriteDouble(HeadZone5Temperature); + } + if (HeadZone6Temperature != 0D) { + output.WriteRawTag(177, 2); + output.WriteDouble(HeadZone6Temperature); + } + if (BlowerVoltage != 0D) { + output.WriteRawTag(185, 2); + output.WriteDouble(BlowerVoltage); + } + if (Dispenser1Pressure != 0D) { + output.WriteRawTag(193, 2); + output.WriteDouble(Dispenser1Pressure); + } + if (Dispenser2Pressure != 0D) { + output.WriteRawTag(201, 2); + output.WriteDouble(Dispenser2Pressure); + } + if (Dispenser3Pressure != 0D) { + output.WriteRawTag(209, 2); + output.WriteDouble(Dispenser3Pressure); + } + if (Dispenser4Pressure != 0D) { + output.WriteRawTag(217, 2); + output.WriteDouble(Dispenser4Pressure); + } + if (Dispenser5Pressure != 0D) { + output.WriteRawTag(225, 2); + output.WriteDouble(Dispenser5Pressure); + } + if (Dispenser6Pressure != 0D) { + output.WriteRawTag(233, 2); + output.WriteDouble(Dispenser6Pressure); + } + if (Dispenser7Pressure != 0D) { + output.WriteRawTag(241, 2); + output.WriteDouble(Dispenser7Pressure); + } + if (Dispenser8Pressure != 0D) { + output.WriteRawTag(249, 2); + output.WriteDouble(Dispenser8Pressure); + } + if (MidTank1Level != 0D) { + output.WriteRawTag(129, 3); + output.WriteDouble(MidTank1Level); + } + if (MidTank2Level != 0D) { + output.WriteRawTag(137, 3); + output.WriteDouble(MidTank2Level); + } + if (MidTank3Level != 0D) { + output.WriteRawTag(145, 3); + output.WriteDouble(MidTank3Level); + } + if (MidTank4Level != 0D) { + output.WriteRawTag(153, 3); + output.WriteDouble(MidTank4Level); + } + if (MidTank5Level != 0D) { + output.WriteRawTag(161, 3); + output.WriteDouble(MidTank5Level); + } + if (MidTank6Level != 0D) { + output.WriteRawTag(169, 3); + output.WriteDouble(MidTank6Level); + } + if (MidTank7Level != 0D) { + output.WriteRawTag(177, 3); + output.WriteDouble(MidTank7Level); + } + if (MidTank8Level != 0D) { + output.WriteRawTag(185, 3); + output.WriteDouble(MidTank8Level); + } + if (DrierZone1HeaterCurrent != 0D) { + output.WriteRawTag(193, 3); + output.WriteDouble(DrierZone1HeaterCurrent); + } + if (DrierZone2HeaterCurrent != 0D) { + output.WriteRawTag(201, 3); + output.WriteDouble(DrierZone2HeaterCurrent); + } + if (HeadZone1HeaterCurrent != 0D) { + output.WriteRawTag(209, 3); + output.WriteDouble(HeadZone1HeaterCurrent); + } + if (HeadZone2HeaterCurrent != 0D) { + output.WriteRawTag(217, 3); + output.WriteDouble(HeadZone2HeaterCurrent); + } + if (HeadZone3HeaterCurrent != 0D) { + output.WriteRawTag(225, 3); + output.WriteDouble(HeadZone3HeaterCurrent); + } + if (HeadZone4HeaterCurrent != 0D) { + output.WriteRawTag(233, 3); + output.WriteDouble(HeadZone4HeaterCurrent); + } + if (HeadZone56HeaterCurrent != 0D) { + output.WriteRawTag(241, 3); + output.WriteDouble(HeadZone56HeaterCurrent); + } + if (Mixer1HeaterCurrent != 0D) { + output.WriteRawTag(249, 3); + output.WriteDouble(Mixer1HeaterCurrent); + } + dispensersInkLevel_.WriteTo(output, _repeated_dispensersInkLevel_codec); + midTanksInkLevel_.WriteTo(output, _repeated_midTanksInkLevel_codec); + if (OverallTemperature != 0D) { + output.WriteRawTag(145, 4); + output.WriteDouble(OverallTemperature); + } + if (HeadZone7HeaterCurrent != 0D) { + output.WriteRawTag(153, 4); + output.WriteDouble(HeadZone7HeaterCurrent); + } + if (HeadZone7Temperature != 0D) { + output.WriteRawTag(161, 4); + output.WriteDouble(HeadZone7Temperature); + } + if (HeadZone8HeaterCurrent != 0D) { + output.WriteRawTag(169, 4); + output.WriteDouble(HeadZone8HeaterCurrent); + } + if (HeadZone8Temperature != 0D) { + output.WriteRawTag(177, 4); + output.WriteDouble(HeadZone8Temperature); + } + if (HeadZone9HeaterCurrent != 0D) { + output.WriteRawTag(185, 4); + output.WriteDouble(HeadZone9HeaterCurrent); + } + if (HeadZone9Temperature != 0D) { + output.WriteRawTag(193, 4); + output.WriteDouble(HeadZone9Temperature); + } + if (HeadZone10HeaterCurrent != 0D) { + output.WriteRawTag(201, 4); + output.WriteDouble(HeadZone10HeaterCurrent); + } + if (HeadZone10Temperature != 0D) { + output.WriteRawTag(209, 4); + output.WriteDouble(HeadZone10Temperature); + } + if (HeadZone11HeaterCurrent != 0D) { + output.WriteRawTag(217, 4); + output.WriteDouble(HeadZone11HeaterCurrent); + } + if (HeadZone11Temperature != 0D) { + output.WriteRawTag(225, 4); + output.WriteDouble(HeadZone11Temperature); + } + if (HeadZone12HeaterCurrent != 0D) { + output.WriteRawTag(233, 4); + output.WriteDouble(HeadZone12HeaterCurrent); + } + if (HeadZone12Temperature != 0D) { + output.WriteRawTag(241, 4); + output.WriteDouble(HeadZone12Temperature); + } + if (HeadBlowerVoltage1 != 0D) { + output.WriteRawTag(249, 4); + output.WriteDouble(HeadBlowerVoltage1); + } + if (HeadBlowerVoltage2 != 0D) { + output.WriteRawTag(129, 5); + output.WriteDouble(HeadBlowerVoltage2); + } + if (HeadCoverHeater1Current != 0D) { + output.WriteRawTag(137, 5); + output.WriteDouble(HeadCoverHeater1Current); + } + if (HeadCoverHeater1Temperature != 0D) { + output.WriteRawTag(145, 5); + output.WriteDouble(HeadCoverHeater1Temperature); + } + if (HeadCoverHeater2Current != 0D) { + output.WriteRawTag(153, 5); + output.WriteDouble(HeadCoverHeater2Current); + } + if (HeadCoverHeater2Temperature != 0D) { + output.WriteRawTag(161, 5); + output.WriteDouble(HeadCoverHeater2Temperature); + } + if (WHSBlower2Voltage != 0D) { + output.WriteRawTag(169, 5); + output.WriteDouble(WHSBlower2Voltage); + } + if (GasSensor != 0D) { + output.WriteRawTag(177, 5); + output.WriteDouble(GasSensor); + } + if (IncomingVoltage != 0D) { + output.WriteRawTag(185, 5); + output.WriteDouble(IncomingVoltage); + } + if (WasteLevel != 0D) { + output.WriteRawTag(193, 5); + output.WriteDouble(WasteLevel); + } + if (HeadBlower1AirFlow != 0D) { + output.WriteRawTag(201, 5); + output.WriteDouble(HeadBlower1AirFlow); + } + if (HeadBlower2AirFlow != 0D) { + output.WriteRawTag(209, 5); + output.WriteDouble(HeadBlower2AirFlow); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Dancer1Angle != 0D) { + size += 1 + 8; + } + if (Dancer2Angle != 0D) { + size += 1 + 8; + } + if (Dancer3Angle != 0D) { + size += 1 + 8; + } + if (FeederMotorFrequency != 0D) { + size += 1 + 8; + } + if (DryerMotor != 0D) { + size += 1 + 8; + } + if (PollerMotor != 0D) { + size += 1 + 8; + } + if (WinderMotor != 0D) { + size += 1 + 8; + } + if (ScrewMotor != 0D) { + size += 1 + 8; + } + if (ThreadSpeed != 0D) { + size += 1 + 8; + } + if (MixerTemperature != 0D) { + size += 1 + 8; + } + if (HeadZone1Temperature != 0D) { + size += 1 + 8; + } + if (HeadZone2Temperature != 0D) { + size += 1 + 8; + } + if (HeadZone3Temperature != 0D) { + size += 1 + 8; + } + if (HeadAirFlow != 0D) { + size += 1 + 8; + } + if (FeederTension != 0D) { + size += 1 + 8; + } + if (PullerTension != 0D) { + size += 2 + 8; + } + if (DryerZone1Temperature != 0D) { + size += 2 + 8; + } + if (DryerZone2Temperature != 0D) { + size += 2 + 8; + } + if (DryerZone3Temperature != 0D) { + size += 2 + 8; + } + if (DryerAirFlow != 0D) { + size += 2 + 8; + } + if (WinderTension != 0D) { + size += 2 + 8; + } + size += dispensersMotorsFrequency_.CalculateSize(_repeated_dispensersMotorsFrequency_codec); + size += dispensersAngularEncoders_.CalculateSize(_repeated_dispensersAngularEncoders_codec); + size += dispensersLinearPositions_.CalculateSize(_repeated_dispensersLinearPositions_codec); + size += dispensersPressure_.CalculateSize(_repeated_dispensersPressure_codec); + if (FilterDeltaPressure != 0D) { + size += 2 + 8; + } + if (ChillerTemperature != 0D) { + size += 2 + 8; + } + if (Dispenser1MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser2MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser3MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser4MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser5MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser6MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser7MotorFrequency != 0D) { + size += 2 + 8; + } + if (Dispenser8MotorFrequency != 0D) { + size += 2 + 8; + } + if (HeadZone4Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone5Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone6Temperature != 0D) { + size += 2 + 8; + } + if (BlowerVoltage != 0D) { + size += 2 + 8; + } + if (Dispenser1Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser2Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser3Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser4Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser5Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser6Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser7Pressure != 0D) { + size += 2 + 8; + } + if (Dispenser8Pressure != 0D) { + size += 2 + 8; + } + if (MidTank1Level != 0D) { + size += 2 + 8; + } + if (MidTank2Level != 0D) { + size += 2 + 8; + } + if (MidTank3Level != 0D) { + size += 2 + 8; + } + if (MidTank4Level != 0D) { + size += 2 + 8; + } + if (MidTank5Level != 0D) { + size += 2 + 8; + } + if (MidTank6Level != 0D) { + size += 2 + 8; + } + if (MidTank7Level != 0D) { + size += 2 + 8; + } + if (MidTank8Level != 0D) { + size += 2 + 8; + } + if (DrierZone1HeaterCurrent != 0D) { + size += 2 + 8; + } + if (DrierZone2HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone1HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone2HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone3HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone4HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone56HeaterCurrent != 0D) { + size += 2 + 8; + } + if (Mixer1HeaterCurrent != 0D) { + size += 2 + 8; + } + size += dispensersInkLevel_.CalculateSize(_repeated_dispensersInkLevel_codec); + size += midTanksInkLevel_.CalculateSize(_repeated_midTanksInkLevel_codec); + if (OverallTemperature != 0D) { + size += 2 + 8; + } + if (HeadZone7HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone7Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone8HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone8Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone9HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone9Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone10HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone10Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone11HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone11Temperature != 0D) { + size += 2 + 8; + } + if (HeadZone12HeaterCurrent != 0D) { + size += 2 + 8; + } + if (HeadZone12Temperature != 0D) { + size += 2 + 8; + } + if (HeadBlowerVoltage1 != 0D) { + size += 2 + 8; + } + if (HeadBlowerVoltage2 != 0D) { + size += 2 + 8; + } + if (HeadCoverHeater1Current != 0D) { + size += 2 + 8; + } + if (HeadCoverHeater1Temperature != 0D) { + size += 2 + 8; + } + if (HeadCoverHeater2Current != 0D) { + size += 2 + 8; + } + if (HeadCoverHeater2Temperature != 0D) { + size += 2 + 8; + } + if (WHSBlower2Voltage != 0D) { + size += 2 + 8; + } + if (GasSensor != 0D) { + size += 2 + 8; + } + if (IncomingVoltage != 0D) { + size += 2 + 8; + } + if (WasteLevel != 0D) { + size += 2 + 8; + } + if (HeadBlower1AirFlow != 0D) { + size += 2 + 8; + } + if (HeadBlower2AirFlow != 0D) { + size += 2 + 8; + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(InsightsMonitors other) { + if (other == null) { + return; + } + if (other.Dancer1Angle != 0D) { + Dancer1Angle = other.Dancer1Angle; + } + if (other.Dancer2Angle != 0D) { + Dancer2Angle = other.Dancer2Angle; + } + if (other.Dancer3Angle != 0D) { + Dancer3Angle = other.Dancer3Angle; + } + if (other.FeederMotorFrequency != 0D) { + FeederMotorFrequency = other.FeederMotorFrequency; + } + if (other.DryerMotor != 0D) { + DryerMotor = other.DryerMotor; + } + if (other.PollerMotor != 0D) { + PollerMotor = other.PollerMotor; + } + if (other.WinderMotor != 0D) { + WinderMotor = other.WinderMotor; + } + if (other.ScrewMotor != 0D) { + ScrewMotor = other.ScrewMotor; + } + if (other.ThreadSpeed != 0D) { + ThreadSpeed = other.ThreadSpeed; + } + if (other.MixerTemperature != 0D) { + MixerTemperature = other.MixerTemperature; + } + if (other.HeadZone1Temperature != 0D) { + HeadZone1Temperature = other.HeadZone1Temperature; + } + if (other.HeadZone2Temperature != 0D) { + HeadZone2Temperature = other.HeadZone2Temperature; + } + if (other.HeadZone3Temperature != 0D) { + HeadZone3Temperature = other.HeadZone3Temperature; + } + if (other.HeadAirFlow != 0D) { + HeadAirFlow = other.HeadAirFlow; + } + if (other.FeederTension != 0D) { + FeederTension = other.FeederTension; + } + if (other.PullerTension != 0D) { + PullerTension = other.PullerTension; + } + if (other.DryerZone1Temperature != 0D) { + DryerZone1Temperature = other.DryerZone1Temperature; + } + if (other.DryerZone2Temperature != 0D) { + DryerZone2Temperature = other.DryerZone2Temperature; + } + if (other.DryerZone3Temperature != 0D) { + DryerZone3Temperature = other.DryerZone3Temperature; + } + if (other.DryerAirFlow != 0D) { + DryerAirFlow = other.DryerAirFlow; + } + if (other.WinderTension != 0D) { + WinderTension = other.WinderTension; + } + dispensersMotorsFrequency_.Add(other.dispensersMotorsFrequency_); + dispensersAngularEncoders_.Add(other.dispensersAngularEncoders_); + dispensersLinearPositions_.Add(other.dispensersLinearPositions_); + dispensersPressure_.Add(other.dispensersPressure_); + if (other.FilterDeltaPressure != 0D) { + FilterDeltaPressure = other.FilterDeltaPressure; + } + if (other.ChillerTemperature != 0D) { + ChillerTemperature = other.ChillerTemperature; + } + if (other.Dispenser1MotorFrequency != 0D) { + Dispenser1MotorFrequency = other.Dispenser1MotorFrequency; + } + if (other.Dispenser2MotorFrequency != 0D) { + Dispenser2MotorFrequency = other.Dispenser2MotorFrequency; + } + if (other.Dispenser3MotorFrequency != 0D) { + Dispenser3MotorFrequency = other.Dispenser3MotorFrequency; + } + if (other.Dispenser4MotorFrequency != 0D) { + Dispenser4MotorFrequency = other.Dispenser4MotorFrequency; + } + if (other.Dispenser5MotorFrequency != 0D) { + Dispenser5MotorFrequency = other.Dispenser5MotorFrequency; + } + if (other.Dispenser6MotorFrequency != 0D) { + Dispenser6MotorFrequency = other.Dispenser6MotorFrequency; + } + if (other.Dispenser7MotorFrequency != 0D) { + Dispenser7MotorFrequency = other.Dispenser7MotorFrequency; + } + if (other.Dispenser8MotorFrequency != 0D) { + Dispenser8MotorFrequency = other.Dispenser8MotorFrequency; + } + if (other.HeadZone4Temperature != 0D) { + HeadZone4Temperature = other.HeadZone4Temperature; + } + if (other.HeadZone5Temperature != 0D) { + HeadZone5Temperature = other.HeadZone5Temperature; + } + if (other.HeadZone6Temperature != 0D) { + HeadZone6Temperature = other.HeadZone6Temperature; + } + if (other.BlowerVoltage != 0D) { + BlowerVoltage = other.BlowerVoltage; + } + if (other.Dispenser1Pressure != 0D) { + Dispenser1Pressure = other.Dispenser1Pressure; + } + if (other.Dispenser2Pressure != 0D) { + Dispenser2Pressure = other.Dispenser2Pressure; + } + if (other.Dispenser3Pressure != 0D) { + Dispenser3Pressure = other.Dispenser3Pressure; + } + if (other.Dispenser4Pressure != 0D) { + Dispenser4Pressure = other.Dispenser4Pressure; + } + if (other.Dispenser5Pressure != 0D) { + Dispenser5Pressure = other.Dispenser5Pressure; + } + if (other.Dispenser6Pressure != 0D) { + Dispenser6Pressure = other.Dispenser6Pressure; + } + if (other.Dispenser7Pressure != 0D) { + Dispenser7Pressure = other.Dispenser7Pressure; + } + if (other.Dispenser8Pressure != 0D) { + Dispenser8Pressure = other.Dispenser8Pressure; + } + if (other.MidTank1Level != 0D) { + MidTank1Level = other.MidTank1Level; + } + if (other.MidTank2Level != 0D) { + MidTank2Level = other.MidTank2Level; + } + if (other.MidTank3Level != 0D) { + MidTank3Level = other.MidTank3Level; + } + if (other.MidTank4Level != 0D) { + MidTank4Level = other.MidTank4Level; + } + if (other.MidTank5Level != 0D) { + MidTank5Level = other.MidTank5Level; + } + if (other.MidTank6Level != 0D) { + MidTank6Level = other.MidTank6Level; + } + if (other.MidTank7Level != 0D) { + MidTank7Level = other.MidTank7Level; + } + if (other.MidTank8Level != 0D) { + MidTank8Level = other.MidTank8Level; + } + if (other.DrierZone1HeaterCurrent != 0D) { + DrierZone1HeaterCurrent = other.DrierZone1HeaterCurrent; + } + if (other.DrierZone2HeaterCurrent != 0D) { + DrierZone2HeaterCurrent = other.DrierZone2HeaterCurrent; + } + if (other.HeadZone1HeaterCurrent != 0D) { + HeadZone1HeaterCurrent = other.HeadZone1HeaterCurrent; + } + if (other.HeadZone2HeaterCurrent != 0D) { + HeadZone2HeaterCurrent = other.HeadZone2HeaterCurrent; + } + if (other.HeadZone3HeaterCurrent != 0D) { + HeadZone3HeaterCurrent = other.HeadZone3HeaterCurrent; + } + if (other.HeadZone4HeaterCurrent != 0D) { + HeadZone4HeaterCurrent = other.HeadZone4HeaterCurrent; + } + if (other.HeadZone56HeaterCurrent != 0D) { + HeadZone56HeaterCurrent = other.HeadZone56HeaterCurrent; + } + if (other.Mixer1HeaterCurrent != 0D) { + Mixer1HeaterCurrent = other.Mixer1HeaterCurrent; + } + dispensersInkLevel_.Add(other.dispensersInkLevel_); + midTanksInkLevel_.Add(other.midTanksInkLevel_); + if (other.OverallTemperature != 0D) { + OverallTemperature = other.OverallTemperature; + } + if (other.HeadZone7HeaterCurrent != 0D) { + HeadZone7HeaterCurrent = other.HeadZone7HeaterCurrent; + } + if (other.HeadZone7Temperature != 0D) { + HeadZone7Temperature = other.HeadZone7Temperature; + } + if (other.HeadZone8HeaterCurrent != 0D) { + HeadZone8HeaterCurrent = other.HeadZone8HeaterCurrent; + } + if (other.HeadZone8Temperature != 0D) { + HeadZone8Temperature = other.HeadZone8Temperature; + } + if (other.HeadZone9HeaterCurrent != 0D) { + HeadZone9HeaterCurrent = other.HeadZone9HeaterCurrent; + } + if (other.HeadZone9Temperature != 0D) { + HeadZone9Temperature = other.HeadZone9Temperature; + } + if (other.HeadZone10HeaterCurrent != 0D) { + HeadZone10HeaterCurrent = other.HeadZone10HeaterCurrent; + } + if (other.HeadZone10Temperature != 0D) { + HeadZone10Temperature = other.HeadZone10Temperature; + } + if (other.HeadZone11HeaterCurrent != 0D) { + HeadZone11HeaterCurrent = other.HeadZone11HeaterCurrent; + } + if (other.HeadZone11Temperature != 0D) { + HeadZone11Temperature = other.HeadZone11Temperature; + } + if (other.HeadZone12HeaterCurrent != 0D) { + HeadZone12HeaterCurrent = other.HeadZone12HeaterCurrent; + } + if (other.HeadZone12Temperature != 0D) { + HeadZone12Temperature = other.HeadZone12Temperature; + } + if (other.HeadBlowerVoltage1 != 0D) { + HeadBlowerVoltage1 = other.HeadBlowerVoltage1; + } + if (other.HeadBlowerVoltage2 != 0D) { + HeadBlowerVoltage2 = other.HeadBlowerVoltage2; + } + if (other.HeadCoverHeater1Current != 0D) { + HeadCoverHeater1Current = other.HeadCoverHeater1Current; + } + if (other.HeadCoverHeater1Temperature != 0D) { + HeadCoverHeater1Temperature = other.HeadCoverHeater1Temperature; + } + if (other.HeadCoverHeater2Current != 0D) { + HeadCoverHeater2Current = other.HeadCoverHeater2Current; + } + if (other.HeadCoverHeater2Temperature != 0D) { + HeadCoverHeater2Temperature = other.HeadCoverHeater2Temperature; + } + if (other.WHSBlower2Voltage != 0D) { + WHSBlower2Voltage = other.WHSBlower2Voltage; + } + if (other.GasSensor != 0D) { + GasSensor = other.GasSensor; + } + if (other.IncomingVoltage != 0D) { + IncomingVoltage = other.IncomingVoltage; + } + if (other.WasteLevel != 0D) { + WasteLevel = other.WasteLevel; + } + if (other.HeadBlower1AirFlow != 0D) { + HeadBlower1AirFlow = other.HeadBlower1AirFlow; + } + if (other.HeadBlower2AirFlow != 0D) { + HeadBlower2AirFlow = other.HeadBlower2AirFlow; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + input.SkipLastField(); + break; + case 9: { + Dancer1Angle = input.ReadDouble(); + break; + } + case 17: { + Dancer2Angle = input.ReadDouble(); + break; + } + case 25: { + Dancer3Angle = input.ReadDouble(); + break; + } + case 33: { + FeederMotorFrequency = input.ReadDouble(); + break; + } + case 41: { + DryerMotor = input.ReadDouble(); + break; + } + case 49: { + PollerMotor = input.ReadDouble(); + break; + } + case 57: { + WinderMotor = input.ReadDouble(); + break; + } + case 65: { + ScrewMotor = input.ReadDouble(); + break; + } + case 73: { + ThreadSpeed = input.ReadDouble(); + break; + } + case 81: { + MixerTemperature = input.ReadDouble(); + break; + } + case 89: { + HeadZone1Temperature = input.ReadDouble(); + break; + } + case 97: { + HeadZone2Temperature = input.ReadDouble(); + break; + } + case 105: { + HeadZone3Temperature = input.ReadDouble(); + break; + } + case 113: { + HeadAirFlow = input.ReadDouble(); + break; + } + case 121: { + FeederTension = input.ReadDouble(); + break; + } + case 129: { + PullerTension = input.ReadDouble(); + break; + } + case 137: { + DryerZone1Temperature = input.ReadDouble(); + break; + } + case 145: { + DryerZone2Temperature = input.ReadDouble(); + break; + } + case 153: { + DryerZone3Temperature = input.ReadDouble(); + break; + } + case 161: { + DryerAirFlow = input.ReadDouble(); + break; + } + case 169: { + WinderTension = input.ReadDouble(); + break; + } + case 178: + case 177: { + dispensersMotorsFrequency_.AddEntriesFrom(input, _repeated_dispensersMotorsFrequency_codec); + break; + } + case 186: + case 185: { + dispensersAngularEncoders_.AddEntriesFrom(input, _repeated_dispensersAngularEncoders_codec); + break; + } + case 194: + case 193: { + dispensersLinearPositions_.AddEntriesFrom(input, _repeated_dispensersLinearPositions_codec); + break; + } + case 202: + case 201: { + dispensersPressure_.AddEntriesFrom(input, _repeated_dispensersPressure_codec); + break; + } + case 209: { + FilterDeltaPressure = input.ReadDouble(); + break; + } + case 217: { + ChillerTemperature = input.ReadDouble(); + break; + } + case 225: { + Dispenser1MotorFrequency = input.ReadDouble(); + break; + } + case 233: { + Dispenser2MotorFrequency = input.ReadDouble(); + break; + } + case 241: { + Dispenser3MotorFrequency = input.ReadDouble(); + break; + } + case 249: { + Dispenser4MotorFrequency = input.ReadDouble(); + break; + } + case 257: { + Dispenser5MotorFrequency = input.ReadDouble(); + break; + } + case 265: { + Dispenser6MotorFrequency = input.ReadDouble(); + break; + } + case 273: { + Dispenser7MotorFrequency = input.ReadDouble(); + break; + } + case 281: { + Dispenser8MotorFrequency = input.ReadDouble(); + break; + } + case 289: { + HeadZone4Temperature = input.ReadDouble(); + break; + } + case 297: { + HeadZone5Temperature = input.ReadDouble(); + break; + } + case 305: { + HeadZone6Temperature = input.ReadDouble(); + break; + } + case 313: { + BlowerVoltage = input.ReadDouble(); + break; + } + case 321: { + Dispenser1Pressure = input.ReadDouble(); + break; + } + case 329: { + Dispenser2Pressure = input.ReadDouble(); + break; + } + case 337: { + Dispenser3Pressure = input.ReadDouble(); + break; + } + case 345: { + Dispenser4Pressure = input.ReadDouble(); + break; + } + case 353: { + Dispenser5Pressure = input.ReadDouble(); + break; + } + case 361: { + Dispenser6Pressure = input.ReadDouble(); + break; + } + case 369: { + Dispenser7Pressure = input.ReadDouble(); + break; + } + case 377: { + Dispenser8Pressure = input.ReadDouble(); + break; + } + case 385: { + MidTank1Level = input.ReadDouble(); + break; + } + case 393: { + MidTank2Level = input.ReadDouble(); + break; + } + case 401: { + MidTank3Level = input.ReadDouble(); + break; + } + case 409: { + MidTank4Level = input.ReadDouble(); + break; + } + case 417: { + MidTank5Level = input.ReadDouble(); + break; + } + case 425: { + MidTank6Level = input.ReadDouble(); + break; + } + case 433: { + MidTank7Level = input.ReadDouble(); + break; + } + case 441: { + MidTank8Level = input.ReadDouble(); + break; + } + case 449: { + DrierZone1HeaterCurrent = input.ReadDouble(); + break; + } + case 457: { + DrierZone2HeaterCurrent = input.ReadDouble(); + break; + } + case 465: { + HeadZone1HeaterCurrent = input.ReadDouble(); + break; + } + case 473: { + HeadZone2HeaterCurrent = input.ReadDouble(); + break; + } + case 481: { + HeadZone3HeaterCurrent = input.ReadDouble(); + break; + } + case 489: { + HeadZone4HeaterCurrent = input.ReadDouble(); + break; + } + case 497: { + HeadZone56HeaterCurrent = input.ReadDouble(); + break; + } + case 505: { + Mixer1HeaterCurrent = input.ReadDouble(); + break; + } + case 514: + case 513: { + dispensersInkLevel_.AddEntriesFrom(input, _repeated_dispensersInkLevel_codec); + break; + } + case 522: + case 521: { + midTanksInkLevel_.AddEntriesFrom(input, _repeated_midTanksInkLevel_codec); + break; + } + case 529: { + OverallTemperature = input.ReadDouble(); + break; + } + case 537: { + HeadZone7HeaterCurrent = input.ReadDouble(); + break; + } + case 545: { + HeadZone7Temperature = input.ReadDouble(); + break; + } + case 553: { + HeadZone8HeaterCurrent = input.ReadDouble(); + break; + } + case 561: { + HeadZone8Temperature = input.ReadDouble(); + break; + } + case 569: { + HeadZone9HeaterCurrent = input.ReadDouble(); + break; + } + case 577: { + HeadZone9Temperature = input.ReadDouble(); + break; + } + case 585: { + HeadZone10HeaterCurrent = input.ReadDouble(); + break; + } + case 593: { + HeadZone10Temperature = input.ReadDouble(); + break; + } + case 601: { + HeadZone11HeaterCurrent = input.ReadDouble(); + break; + } + case 609: { + HeadZone11Temperature = input.ReadDouble(); + break; + } + case 617: { + HeadZone12HeaterCurrent = input.ReadDouble(); + break; + } + case 625: { + HeadZone12Temperature = input.ReadDouble(); + break; + } + case 633: { + HeadBlowerVoltage1 = input.ReadDouble(); + break; + } + case 641: { + HeadBlowerVoltage2 = input.ReadDouble(); + break; + } + case 649: { + HeadCoverHeater1Current = input.ReadDouble(); + break; + } + case 657: { + HeadCoverHeater1Temperature = input.ReadDouble(); + break; + } + case 665: { + HeadCoverHeater2Current = input.ReadDouble(); + break; + } + case 673: { + HeadCoverHeater2Temperature = input.ReadDouble(); + break; + } + case 681: { + WHSBlower2Voltage = input.ReadDouble(); + break; + } + case 689: { + GasSensor = input.ReadDouble(); + break; + } + case 697: { + IncomingVoltage = input.ReadDouble(); + break; + } + case 705: { + WasteLevel = input.ReadDouble(); + break; + } + case 713: { + HeadBlower1AirFlow = input.ReadDouble(); + break; + } + case 721: { + HeadBlower2AirFlow = input.ReadDouble(); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/Software/Visual_Studio/Tango.PMR/Tango.PMR.csproj b/Software/Visual_Studio/Tango.PMR/Tango.PMR.csproj index 66c84cb0d..4ad2e6612 100644 --- a/Software/Visual_Studio/Tango.PMR/Tango.PMR.csproj +++ b/Software/Visual_Studio/Tango.PMR/Tango.PMR.csproj @@ -216,6 +216,7 @@ <Compile Include="Hardware\SystemResetResponse.cs" /> <Compile Include="Hardware\UploadHardwareConfigurationRequest.cs" /> <Compile Include="Hardware\UploadHardwareConfigurationResponse.cs" /> + <Compile Include="Insights\InsightsMonitors.cs" /> <Compile Include="Integration\ApplicationInformation.cs" /> <Compile Include="Integration\ColorProfileRequest.cs" /> <Compile Include="Integration\ColorProfileResponse.cs" /> @@ -464,7 +465,7 @@ </PropertyGroup> <ProjectExtensions> <VisualStudio> - <UserProperties BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_UseGlobalSettings="False" BuildVersion_StartDate="2000/1/1" /> + <UserProperties BuildVersion_StartDate="2000/1/1" BuildVersion_UseGlobalSettings="False" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" /> </VisualStudio> </ProjectExtensions> </Project>
\ No newline at end of file diff --git a/Software/Visual_Studio/Tango.sln b/Software/Visual_Studio/Tango.sln index 087dc86a4..8a35deaf7 100644 --- a/Software/Visual_Studio/Tango.sln +++ b/Software/Visual_Studio/Tango.sln @@ -405,6 +405,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tango.FSE.Publisher.UI", "F EndProject Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Tango.FSE.Procedures.Documentation", "FSE\Modules\Tango.FSE.Procedures.Documentation\Tango.FSE.Procedures.Documentation.shfbproj", "{12EC97A5-C3C2-40CB-B658-EC4018B89269}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tango.Insights", "Tango.Insights\Tango.Insights.csproj", "{4A55C185-3F8D-41B0-8815-C15F6213A14A}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -3792,6 +3794,26 @@ Global {12EC97A5-C3C2-40CB-B658-EC4018B89269}.Release|x64.Build.0 = Release|Any CPU {12EC97A5-C3C2-40CB-B658-EC4018B89269}.Release|x86.ActiveCfg = Release|Any CPU {12EC97A5-C3C2-40CB-B658-EC4018B89269}.Release|x86.Build.0 = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|ARM.ActiveCfg = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|ARM.Build.0 = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|ARM64.ActiveCfg = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|ARM64.Build.0 = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|x64.ActiveCfg = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|x64.Build.0 = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|x86.ActiveCfg = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Debug|x86.Build.0 = Debug|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|Any CPU.Build.0 = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|ARM.ActiveCfg = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|ARM.Build.0 = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|ARM64.ActiveCfg = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|ARM64.Build.0 = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|x64.ActiveCfg = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|x64.Build.0 = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|x86.ActiveCfg = Release|Any CPU + {4A55C185-3F8D-41B0-8815-C15F6213A14A}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -3932,12 +3954,12 @@ Global {12EC97A5-C3C2-40CB-B658-EC4018B89269} = {4EE6DBA1-71BC-49E2-8DC7-266487E61050} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {7986F7F4-A86A-4994-B1B6-0988D7F057B6} - BuildVersion_BuildVersioningStyle = None.None.Increment.DeltaBaseYearDayOfYear - BuildVersion_UpdateAssemblyVersion = True - BuildVersion_UpdateFileVersion = False - BuildVersion_StartDate = 2000/1/1 - BuildVersion_AssemblyInfoFilename = Properties\AssemblyInfo.cs BuildVersion_UseGlobalSettings = False + BuildVersion_AssemblyInfoFilename = Properties\AssemblyInfo.cs + BuildVersion_StartDate = 2000/1/1 + BuildVersion_UpdateFileVersion = False + BuildVersion_UpdateAssemblyVersion = True + BuildVersion_BuildVersioningStyle = None.None.Increment.DeltaBaseYearDayOfYear + SolutionGuid = {7986F7F4-A86A-4994-B1B6-0988D7F057B6} EndGlobalSection EndGlobal diff --git a/Software/Visual_Studio/Utilities/Tango.PMRGenerator.CLI/Program.cs b/Software/Visual_Studio/Utilities/Tango.PMRGenerator.CLI/Program.cs index c4c16b416..a86454e26 100644 --- a/Software/Visual_Studio/Utilities/Tango.PMRGenerator.CLI/Program.cs +++ b/Software/Visual_Studio/Utilities/Tango.PMRGenerator.CLI/Program.cs @@ -56,6 +56,7 @@ namespace Tango.PMRGenerator.CLI GenerateColorLabLiquidTypes(db, pmrFolder); GenerateDiagnosticsValueComponents(db, pmrFolder); GenerateDiagnosticsMonitors(db, pmrFolder); + GenerateInsightsMonitors(db, pmrFolder); GenerateEventTypes(db, pmrFolder); GenerateInterfaceIOs(db, pmrFolder); } @@ -641,7 +642,7 @@ namespace Tango.PMRGenerator.CLI private static void GenerateDiagnosticsMonitors(ObservablesContext db, String pmrFolder) { - Console.WriteLine("Generating Monitors..."); + Console.WriteLine("Generating Diagnostics Monitors..."); ProtoMessageFile messageFile = new ProtoMessageFile(); messageFile.Name = "DiagnosticsMonitors"; @@ -674,6 +675,34 @@ namespace Tango.PMRGenerator.CLI File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", messageFile.Name + ".proto"), messageString); } + private static void GenerateInsightsMonitors(ObservablesContext db, string pmrFolder) + { + Console.WriteLine("Generating Insights Monitors..."); + + ProtoMessageFile messageFile = new ProtoMessageFile(); + messageFile.Name = "InsightsMonitors"; + messageFile.Package = "Tango.PMR.Insights"; + + foreach (var monitor in db.TechMonitors.ToList().OrderBy(x => x.Code)) + { + var prop = new ProtoProperty(); + prop.Name = monitor.Name.Replace(" ", ""); + prop.Description = monitor.Description; + prop.Type = "double"; + + if (monitor.MultiChannel) + { + prop.Repeated = true; + } + + messageFile.Properties.Add(prop); + } + + String messageString = messageFile.GenerateCode(); + + File.WriteAllText(Path.Combine(pmrFolder, "Insights", messageFile.Name + ".proto"), messageString); + } + private static void GenerateInterfaceIOs(ObservablesContext db, String pmrFolder) { Console.WriteLine("Generating Interface IOs..."); |