From 55ae67632384f9067d48e3607f56e1adc15da23c Mon Sep 17 00:00:00 2001
From: garath001 <62758265+garath001@users.noreply.github.com>
Date: Fri, 31 Jul 2026 07:47:29 -0400
Subject: [PATCH 1/3] Reusable helper class to handle basic stats on streaming
 data

---
 Ares.Device.Drivers.slnx             |   1 +
 StreamHelper/SimpleStreamingStats.cs | 431 +++++++++++++++++++++++++++
 StreamHelper/StreamHelper.csproj     |  10 +
 3 files changed, 442 insertions(+)
 create mode 100644 StreamHelper/SimpleStreamingStats.cs
 create mode 100644 StreamHelper/StreamHelper.csproj

diff --git a/Ares.Device.Drivers.slnx b/Ares.Device.Drivers.slnx
index 9afe033..231764a 100644
--- a/Ares.Device.Drivers.slnx
+++ b/Ares.Device.Drivers.slnx
@@ -4,6 +4,7 @@
   <Project Path="FlirCM3Remastered/FlirCM3Remastered.csproj" />
   <Project Path="HerkulexDRS/HerkulexDRS.csproj" />
   <Project Path="LindbergFurnaceRemastered/LindbergFurnaceRemastered.csproj" />
+  <Project Path="StreamHelper/StreamHelper.csproj" Id="1e8f4da1-e33f-4820-af52-278a4ba357f8" />
   <Project Path="SyringePumpNE1000Remastered/SyringePumpNE1000Remastered.csproj" />
   <Project Path="TC0304Remastered/TC0304Remastered.csproj" />
   <Project Path="TicStepperController/TicStepperController.csproj" />
diff --git a/StreamHelper/SimpleStreamingStats.cs b/StreamHelper/SimpleStreamingStats.cs
new file mode 100644
index 0000000..851a7de
--- /dev/null
+++ b/StreamHelper/SimpleStreamingStats.cs
@@ -0,0 +1,431 @@
+using System;
+
+namespace StreamHelper
+{
+    /// <summary>
+    /// Calculates descriptive statistics incrementally without buffering
+    /// individual samples.
+    ///
+    /// Regression is performed against the zero-based sample index:
+    /// x = 0, 1, 2, ...
+    ///
+    /// This class uses constant memory regardless of the number of samples.
+    /// </summary>
+    public class SimpleStreamingStats
+    {
+        private readonly object _syncRoot = new();
+
+        private long _count;
+
+        // Online central moments.
+        private double _mean;
+        private double _m2;
+        private double _m3;
+        private double _m4;
+
+        // Sum of squares of raw values, used for RMS.
+        private double _sumSquares;
+
+        private double _minimum;
+        private double _maximum;
+
+        // Running regression values.
+        private double _meanX;
+        private double _meanY;
+        private double _sxx;
+        private double _syy;
+        private double _sxy;
+
+        /// <summary>
+        /// Adds one sample to the running statistics.
+        /// </summary>
+        public void AddValue(double value)
+        {
+            if (!double.IsFinite(value))
+                throw new ArgumentOutOfRangeException(
+                    nameof(value),
+                    "The sample must be a finite number.");
+
+            lock (_syncRoot)
+            {
+                long previousCount = _count;
+                _count++;
+
+                if (_count == 1)
+                {
+                    _minimum = value;
+                    _maximum = value;
+                }
+                else
+                {
+                    if (value < _minimum)
+                        _minimum = value;
+
+                    if (value > _maximum)
+                        _maximum = value;
+                }
+
+                _sumSquares += value * value;
+
+                UpdateMoments(value, previousCount);
+                UpdateRegression(value, previousCount);
+            }
+        }
+
+        /// <summary>
+        /// Clears all accumulated statistics.
+        /// </summary>
+        public void ResetStats()
+        {
+            lock (_syncRoot)
+            {
+                _count = 0;
+
+                _mean = 0.0;
+                _m2 = 0.0;
+                _m3 = 0.0;
+                _m4 = 0.0;
+
+                _sumSquares = 0.0;
+
+                _minimum = 0.0;
+                _maximum = 0.0;
+
+                _meanX = 0.0;
+                _meanY = 0.0;
+                _sxx = 0.0;
+                _syy = 0.0;
+                _sxy = 0.0;
+            }
+        }
+
+        public long GetCount()
+        {
+            lock (_syncRoot)
+                return _count;
+        }
+
+        public double GetMean()
+        {
+            lock (_syncRoot)
+                return _count > 0 ? _mean : double.NaN;
+        }
+
+        /// <summary>
+        /// Returns variance using N as the denominator.
+        /// </summary>
+        public double GetPopulationVariance()
+        {
+            lock (_syncRoot)
+                return _count > 0
+                    ? _m2 / _count
+                    : double.NaN;
+        }
+
+        /// <summary>
+        /// Returns variance using N - 1 as the denominator.
+        /// </summary>
+        public double GetSampleVariance()
+        {
+            lock (_syncRoot)
+                return _count > 1
+                    ? _m2 / (_count - 1)
+                    : double.NaN;
+        }
+
+        public double GetPopulationStandardDeviation()
+        {
+            lock (_syncRoot)
+            {
+                return _count > 0
+                    ? Math.Sqrt(Math.Max(0.0, _m2 / _count))
+                    : double.NaN;
+            }
+        }
+
+        public double GetSampleStandardDeviation()
+        {
+            lock (_syncRoot)
+            {
+                return _count > 1
+                    ? Math.Sqrt(Math.Max(0.0, _m2 / (_count - 1)))
+                    : double.NaN;
+            }
+        }
+
+        public double GetMinimum()
+        {
+            lock (_syncRoot)
+                return _count > 0 ? _minimum : double.NaN;
+        }
+
+        public double GetMaximum()
+        {
+            lock (_syncRoot)
+                return _count > 0 ? _maximum : double.NaN;
+        }
+
+        public double GetRange()
+        {
+            lock (_syncRoot)
+                return _count > 0
+                    ? _maximum - _minimum
+                    : double.NaN;
+        }
+
+        public double GetRootMeanSquare()
+        {
+            lock (_syncRoot)
+            {
+                return _count > 0
+                    ? Math.Sqrt(_sumSquares / _count)
+                    : double.NaN;
+            }
+        }
+
+        /// <summary>
+        /// Returns adjusted sample skewness.
+        /// Requires at least three samples.
+        /// </summary>
+        public double GetSkewness()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 3 || _m2 <= 0.0)
+                    return double.NaN;
+
+                double n = _count;
+
+                return Math.Sqrt(n * (n - 1.0))
+                       / (n - 2.0)
+                       * (_m3 / Math.Pow(_m2, 1.5));
+            }
+        }
+
+        /// <summary>
+        /// Returns bias-corrected excess kurtosis.
+        ///
+        /// A normal distribution has an excess kurtosis near zero.
+        /// Requires at least four samples.
+        /// </summary>
+        public double GetExcessKurtosis()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 4 || _m2 <= 0.0)
+                    return double.NaN;
+
+                double n = _count;
+
+                double rawKurtosis =
+                    n * _m4 / (_m2 * _m2);
+
+                return ((n - 1.0) /
+                        ((n - 2.0) * (n - 3.0)))
+                       *
+                       ((n + 1.0) * (rawKurtosis - 3.0) + 6.0);
+            }
+        }
+
+        /// <summary>
+        /// Returns the slope per sample interval.
+        ///
+        /// For example, if samples are one second apart, this is the slope
+        /// per second.
+        /// </summary>
+        public double GetSlope()
+        {
+            lock (_syncRoot)
+            {
+                return _count > 1 && _sxx > 0.0
+                    ? _sxy / _sxx
+                    : double.NaN;
+            }
+        }
+
+        /// <summary>
+        /// Returns the slope converted to a specified time unit.
+        ///
+        /// Example:
+        /// sampleIntervalSeconds = 0.1
+        /// returns units per second.
+        /// </summary>
+        public double GetSlopePerTime(double sampleInterval)
+        {
+            if (!double.IsFinite(sampleInterval) || sampleInterval <= 0.0)
+                throw new ArgumentOutOfRangeException(
+                    nameof(sampleInterval),
+                    "Sample interval must be finite and greater than zero.");
+
+            lock (_syncRoot)
+            {
+                return _count > 1 && _sxx > 0.0
+                    ? (_sxy / _sxx) / sampleInterval
+                    : double.NaN;
+            }
+        }
+
+        public double GetIntercept()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 2 || _sxx <= 0.0)
+                    return double.NaN;
+
+                double slope = _sxy / _sxx;
+
+                return _meanY - slope * _meanX;
+            }
+        }
+
+        public double GetCorrelation()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 2 || _sxx <= 0.0 || _syy <= 0.0)
+                    return double.NaN;
+
+                double denominator = Math.Sqrt(_sxx * _syy);
+
+                if (denominator <= 0.0)
+                    return double.NaN;
+
+                return Math.Clamp(
+                    _sxy / denominator,
+                    -1.0,
+                    1.0);
+            }
+        }
+
+        public double GetRSquared()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 2 || _sxx <= 0.0 || _syy <= 0.0)
+                    return double.NaN;
+
+                double denominator = _sxx * _syy;
+
+                if (denominator <= 0.0)
+                    return double.NaN;
+
+                double rSquared =
+                    (_sxy * _sxy) / denominator;
+
+                return Math.Clamp(rSquared, 0.0, 1.0);
+            }
+        }
+
+        /// <summary>
+        /// Returns the residual standard error around the linear fit.
+        /// Requires at least three samples.
+        /// </summary>
+        public double GetRegressionStandardError()
+        {
+            lock (_syncRoot)
+            {
+                if (_count < 3 || _sxx <= 0.0)
+                    return double.NaN;
+
+                double explainedSumSquares =
+                    (_sxy * _sxy) / _sxx;
+
+                double residualSumSquares =
+                    Math.Max(0.0, _syy - explainedSumSquares);
+
+                return Math.Sqrt(
+                    residualSumSquares / (_count - 2));
+            }
+        }
+
+        /// <summary>
+        /// Predicts the value at a zero-based sample index.
+        /// </summary>
+        public double GetPredictedValue(double sampleIndex)
+        {
+            if (!double.IsFinite(sampleIndex))
+                throw new ArgumentOutOfRangeException(
+                    nameof(sampleIndex));
+
+            lock (_syncRoot)
+            {
+                if (_count < 2 || _sxx <= 0.0)
+                    return double.NaN;
+
+                double slope = _sxy / _sxx;
+                double intercept = _meanY - slope * _meanX;
+
+                return intercept + slope * sampleIndex;
+            }
+        }
+
+        private void UpdateMoments(
+            double value,
+            long previousCount)
+        {
+            /*
+             * Online update of the first four central moments.
+             *
+             * This is an extension of Welford's algorithm and avoids
+             * subtracting two large, nearly equal raw sums.
+             */
+            double n = _count;
+            double delta = value - _mean;
+            double deltaOverN = delta / n;
+            double deltaOverNSquared =
+                deltaOverN * deltaOverN;
+
+            double term1 =
+                delta * deltaOverN * previousCount;
+
+            _mean += deltaOverN;
+
+            _m4 +=
+                term1
+                * deltaOverNSquared
+                * (n * n - 3.0 * n + 3.0)
+                +
+                6.0
+                * deltaOverNSquared
+                * _m2
+                -
+                4.0
+                * deltaOverN
+                * _m3;
+
+            _m3 +=
+                term1
+                * deltaOverN
+                * (n - 2.0)
+                -
+                3.0
+                * deltaOverN
+                * _m2;
+
+            _m2 += term1;
+        }
+
+        private void UpdateRegression(
+            double value,
+            long sampleIndex)
+        {
+            double x = sampleIndex;
+            double y = value;
+            double n = _count;
+
+            double deltaX = x - _meanX;
+            double deltaY = y - _meanY;
+
+            _meanX += deltaX / n;
+            _meanY += deltaY / n;
+
+            /*
+             * Use the updated means for the second part of the online
+             * covariance update.
+             */
+            _sxx += deltaX * (x - _meanX);
+            _syy += deltaY * (y - _meanY);
+            _sxy += deltaX * (y - _meanY);
+        }
+    }
+}
\ No newline at end of file
diff --git a/StreamHelper/StreamHelper.csproj b/StreamHelper/StreamHelper.csproj
new file mode 100644
index 0000000..a0bed63
--- /dev/null
+++ b/StreamHelper/StreamHelper.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+
+</Project>

From f72fbbed8e68ef006b4aa0b310f554057e0523c2 Mon Sep 17 00:00:00 2001
From: garath001 <62758265+garath001@users.noreply.github.com>
Date: Fri, 31 Jul 2026 15:47:06 -0400
Subject: [PATCH 2/3] Template of SerialStreamingDevice. Missing realtime hooks

---
 .../DelimitedStreamSensor.cs                  | 324 ++++++++++++++++++
 .../IDelimitedSteamSensor.cs                  |  15 +
 .../Models/StreamingField.cs                  |  28 ++
 .../SerialStreamingSensor.csproj              |  65 ++++
 .../UI/DelimitedStreamSensorControl.razor     | 154 +++++++++
 .../UI/DelimitedStreamSensorControl.razor.css |   1 +
 .../DelimitedStreamSensorControlViewModel.cs  | 119 +++++++
 .../UI/State/DelimitedStreamSensorState.cs    |  20 ++
 .../State/DelimitedStreamSensorStateMapper.cs |  47 +++
 SerialStreamingSensor/manifest.yaml           |  23 ++
 10 files changed, 796 insertions(+)
 create mode 100644 SerialStreamingSensor/DelimitedStreamSensor.cs
 create mode 100644 SerialStreamingSensor/IDelimitedSteamSensor.cs
 create mode 100644 SerialStreamingSensor/Models/StreamingField.cs
 create mode 100644 SerialStreamingSensor/SerialStreamingSensor.csproj
 create mode 100644 SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
 create mode 100644 SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
 create mode 100644 SerialStreamingSensor/UI/DelimitedStreamSensorControlViewModel.cs
 create mode 100644 SerialStreamingSensor/UI/State/DelimitedStreamSensorState.cs
 create mode 100644 SerialStreamingSensor/UI/State/DelimitedStreamSensorStateMapper.cs
 create mode 100644 SerialStreamingSensor/manifest.yaml

diff --git a/SerialStreamingSensor/DelimitedStreamSensor.cs b/SerialStreamingSensor/DelimitedStreamSensor.cs
new file mode 100644
index 0000000..36599d5
--- /dev/null
+++ b/SerialStreamingSensor/DelimitedStreamSensor.cs
@@ -0,0 +1,324 @@
+using Ares.Datamodel;
+using Ares.Datamodel.Device;
+using Ares.Datamodel.Extensions;
+using Ares.Datamodel.Factories;
+using Ares.Device;
+using Microsoft.AspNetCore.Components.Web;
+using SerialStreamingSensor.Models;
+using StreamHelper;
+using System.Linq.Expressions;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace SerialStreamingSensor
+{
+    public class DelimitedStreamSensor : AresDevice, IDelimitedSteamSensor
+    {
+        private readonly DeviceConnectionInfo _connectionInfo;
+        private readonly ILogger _logger;
+        private readonly string _dataFormat;
+        private readonly string[] _fields;
+        private readonly StreamingField[] _streamingFields;
+        private readonly IReadOnlyDictionary<string, StreamingField> _streamingFieldsByName;
+
+        private readonly BehaviorSubject<AresStruct> _stateSubject = new(new AresStruct());
+
+        public DelimitedStreamSensor(DeviceConnectionInfo info, ILogger logger) : base(info)
+        {
+            
+            _connectionInfo = info;
+            _logger = logger;
+            _dataFormat = info.DeviceSettings.Fields["DataFormat"].StringValue;
+            StateStream = _stateSubject.AsObservable();
+
+            _logger.LogInformation($"Parsing data format '{_dataFormat}'");
+
+            _fields = _dataFormat.Split(":,\t".ToCharArray(), StringSplitOptions.None).Select(field => field.Trim()).ToArray();
+
+            _streamingFields = _fields
+                .Select((fieldName, dataIndex) => new
+                {
+                    FieldName = fieldName,
+                    DataIndex = dataIndex
+                })
+                .Where(field => !string.IsNullOrWhiteSpace(field.FieldName))
+                .Select(field => new StreamingField
+                {
+                    Name = field.FieldName,
+                    DataIndex = field.DataIndex,
+                    StatsActive = false,
+                    Value = null
+                })
+                .ToArray();
+
+            _logger.LogInformation($"{_streamingFields.Length} fields parsed");
+
+            _streamingFieldsByName = _streamingFields.ToDictionary(field => field.Name, field => field, StringComparer.OrdinalIgnoreCase);
+
+            StateSchema = AresSchemaBuilder.Empty()
+                .AddEntry("Name", AresSchemaBuilder.StringEntry().Build())
+                .AddEntry("DataFormat", AresSchemaBuilder.StringEntry().Build())
+                .AddEntry("LiveData", AresSchemaBuilder.Entry(AresDataType.Struct)
+                    .WithStructSchema(liveData =>
+                    {
+                        foreach (var field in _streamingFields)
+                        {
+                            liveData.Fields.Add(field.Name, AresSchemaBuilder.NumberEntry().AsOptional().Build());
+                        }
+                    })
+                    .Build())
+                .Build();
+        }
+
+        private AresStruct BuildInitialState()
+        {
+            return AresStateBuilder.Create()
+                .Add("Name", Name)
+                .Add("DataFormat", _dataFormat)
+                .AddStruct("LiveData", liveData =>
+                {
+                    foreach (var field in _streamingFields)
+                    {
+                        /*
+                         * If AresStateBuilder does not support null numeric values,
+                         * use 0 initially and distinguish validity separately.
+                         */
+                        liveData.Add(field.Name, field.Value ?? 0.0);
+                    }
+                })
+                .Build();
+        }
+
+
+        public override IObservable<AresStruct> StateStream { get; }
+
+
+        public override Task<bool> Activate(CancellationToken ct)
+        {
+            _stateSubject.OnNext(BuildInitialState());
+
+            return Task.FromResult(true);
+        }
+
+        public Task BeginCollectingStats(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            field.Stats.ResetStats();
+            field.StatsActive = true;
+            return Task.CompletedTask;
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            //_stateWatchers.Dispose();
+            //await _stateGetterLoopTokenSource.CancelAsync();
+            //await _stateUpdater;
+            //_stateGetterLoopTokenSource.Dispose();
+            _stateSubject.OnCompleted();
+        }
+
+        public Task EndCollectingStats(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            field.StatsActive = false;
+            return Task.CompletedTask;
+        }
+
+        public override Task EnterSafeMode(CancellationToken ct)
+        {
+            // passive device. No action required
+            return Task.CompletedTask;
+        }
+
+        public async override Task<CommandResult> ExecuteCommand(string command, List<DeviceCommandArgument> arguments, CancellationToken token)
+        {
+            var result = new CommandResult { Success = true };
+            string? fieldName = null;
+
+            try
+            {
+                switch (command)
+                {
+                    case nameof(BeginCollectingStats):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(BeginCollectingStats), "fieldName", "string");
+                        await BeginCollectingStats(fieldName);
+                        break;
+
+                    case nameof(EndCollectingStats):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(EndCollectingStats), "fieldName", "string");
+                        await EndCollectingStats(fieldName);
+                        break;
+
+                    case nameof(ResetStatistics):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(ResetStatistics), "fieldName", "string");
+                        await ResetStatistics(fieldName);
+                        break;
+                    
+                    case nameof(getCollectionCount):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(getCollectionCount), "fieldName", "string");
+                        var collectionCount = await getCollectionCount(fieldName);
+                        result.Result=AresValueHelper.CreateNumber(collectionCount);
+                        break;
+                    
+                    case nameof(getVariance):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(getVariance), "fieldName", "string");
+                        var variance = await getVariance(fieldName);
+                        result.Result = AresValueHelper.CreateNumber(variance);
+                        break;
+                    
+                    case nameof(getMean):
+                        fieldName = arguments.FirstOrDefault(a => a.ArgName == "fieldName")?.ArgValue.StringValue;
+                        if (fieldName == null) return ArgumentError(nameof(getMean), "fieldName", "string");
+                        var mean = await getMean(fieldName) ;
+                        result.Result = AresValueHelper.CreateNumber(mean);
+                        break;
+                    
+                    default:
+                        result.Success = false;
+                        result.Error = $"Unrecognized command '{command}'";
+                        break;
+                }
+            }
+            catch (Exception err)
+            {
+                result.Success = false;
+                result.Error = err.Message;
+            }
+
+            return result;
+        }
+
+        private static CommandResult ArgumentError(string commandName, string paramName, string expectedType)
+        {
+            return new CommandResult
+            {
+                Success = false,
+                Error = $"The {commandName} command requires a valid {expectedType} for '{paramName}', but none was provided or the type was incorrect."
+            };
+        }
+
+        public Task<long> getCollectionCount(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            var count = field.Stats.GetCount();
+            return Task.FromResult(count);
+        }
+
+        public Task<double> getMean(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            var mean = field.Stats.GetMean();
+            return Task.FromResult(mean);
+        }
+
+        public override Task<AresStruct> GetSettings()
+        {
+            var response = new AresStruct().AddString("Mode", "Streaming senor");
+            return Task.FromResult(response);
+        }
+
+        public override Task<AresStruct> GetState() => Task.FromResult(_stateSubject.Value);
+
+        public Task<double> getVariance(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            var variance = field.Stats.GetSampleVariance();
+            return Task.FromResult(variance);
+        }
+
+        public Task ResetStatistics(string fieldName)
+        {
+            var field = getStreamingField(fieldName);
+            field.Stats.ResetStats();
+            return Task.CompletedTask;
+        }
+
+        StreamingField getStreamingField(string fieldName)
+        {
+            if (!_streamingFieldsByName.ContainsKey(fieldName))
+            {
+                throw new ArgumentOutOfRangeException($"'{fieldName}' not a recognized data field");
+            }
+            return _streamingFieldsByName[fieldName];
+        }
+
+
+        public override Task UpdateSettings(AresStruct settings)
+        {
+           return Task.CompletedTask;
+        }
+
+        protected override Task<List<DeviceCommandDescriptor>> BuildCommandDescriptorsAsync()
+        {
+
+            var descriptors = new List<DeviceCommandDescriptor>
+            {
+                new()
+                {
+                    Name = nameof(BeginCollectingStats),
+                    Description = "Starts calculating stats on streaming data",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build()
+                },
+                new()
+                {
+                    Name = nameof(EndCollectingStats),
+                    Description = "Ends calculating stats on streaming data",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build()
+                },
+                new()
+                {
+                    Name = nameof(getVariance),
+                    Description = "gets the calculated variance",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build(),
+                    OutputSchema = AresSchemaBuilder.NumberEntry()
+                        .WithDescription("variance")
+                        .Build()
+                },
+                new()
+                {
+                    Name = nameof(getMean),
+                    Description = "gets the calculated mean",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build(),
+                    OutputSchema = AresSchemaBuilder.NumberEntry()
+                        .WithDescription("mean")
+                        .Build()
+                },
+                new()
+                {
+                    Name = nameof(getCollectionCount),
+                    Description = "gets the number of samples in stats calculation",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build(),
+                    OutputSchema = AresSchemaBuilder.NumberEntry()
+                        .WithDescription("count")
+                        .Build()
+                },
+                new()
+                {
+                    Name = nameof(ResetStatistics),
+                    Description = "clears current stats data",
+                    InputSchema = AresSchemaBuilder.Empty()
+                        .AddEntry("fieldName", AresSchemaBuilder.StringEntry().Build())
+                        .Build()
+                },
+            };
+
+            return Task.FromResult(descriptors);
+
+        }
+    }
+}
diff --git a/SerialStreamingSensor/IDelimitedSteamSensor.cs b/SerialStreamingSensor/IDelimitedSteamSensor.cs
new file mode 100644
index 0000000..bd3120e
--- /dev/null
+++ b/SerialStreamingSensor/IDelimitedSteamSensor.cs
@@ -0,0 +1,15 @@
+namespace SerialStreamingSensor
+{
+    public interface IDelimitedSteamSensor: IAsyncDisposable
+    {
+
+
+        Task BeginCollectingStats(string fieldName);
+        Task EndCollectingStats(string fieldName);
+        Task<long> getCollectionCount(string fieldName);
+        Task<double> getMean(string fieldName);
+        Task<double> getVariance(string fieldName);
+        Task ResetStatistics(string fieldName);
+
+    }
+}
diff --git a/SerialStreamingSensor/Models/StreamingField.cs b/SerialStreamingSensor/Models/StreamingField.cs
new file mode 100644
index 0000000..add5fcf
--- /dev/null
+++ b/SerialStreamingSensor/Models/StreamingField.cs
@@ -0,0 +1,28 @@
+using StreamHelper;
+
+namespace SerialStreamingSensor.Models
+{
+    public sealed class StreamingField
+    {
+        public required string Name { get; init; }
+
+        /// <summary>
+        /// Position of this field in the incoming delimited data line.
+        /// Empty entries in the data format are counted when assigning
+        /// this index, even though they are not represented as fields.
+        /// </summary>
+        public int DataIndex { get; init; }
+
+        /// <summary>
+        /// Most recently parsed value.
+        /// </summary>
+        public double? Value { get; set; }
+
+        /// <summary>
+        /// Determines whether incoming values are added to Stats.
+        /// </summary>
+        public bool StatsActive { get; set; }
+
+        public SimpleStreamingStats Stats { get; } = new();
+    }
+}
\ No newline at end of file
diff --git a/SerialStreamingSensor/SerialStreamingSensor.csproj b/SerialStreamingSensor/SerialStreamingSensor.csproj
new file mode 100644
index 0000000..4cf115b
--- /dev/null
+++ b/SerialStreamingSensor/SerialStreamingSensor.csproj
@@ -0,0 +1,65 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="manifest.yaml" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="manifest.yaml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Ares.Toolkit.Device" Version="1.5.0" />
+    <PackageReference Include="ReactiveUI.SourceGenerators" Version="3.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.Reactive" Version="6.1.0" />
+    <PackageReference Include="UnitsNet" Version="5.75.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\StreamHelper\StreamHelper.csproj">
+      <Private>True</Private>
+      <EmbedInteropTypes>False</EmbedInteropTypes>
+    </ProjectReference>
+  </ItemGroup>
+
+  <Target Name="PackageAresDriver" AfterTargets="Build">
+    <PropertyGroup>
+      <StagingFolder>$(ProjectDir)obj\AresStaging\</StagingFolder>
+      <PackageName>$(ProjectDir)..\plugins\$(AssemblyName).ares</PackageName>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ScopedCssBundle Include="$(IntermediateOutputPath)scopedcss\bundle\$(AssemblyName).styles.css" Condition="Exists('$(IntermediateOutputPath)scopedcss\bundle\$(AssemblyName).styles.css')" />
+    </ItemGroup>
+
+    <Copy SourceFiles="@(ScopedCssBundle)" DestinationFolder="$(TargetDir)" SkipUnchangedFiles="true" Condition="'@(ScopedCssBundle)' != ''" />
+
+    <RemoveDir Directories="$(StagingFolder)" />
+    <MakeDir Directories="$(StagingFolder)" />
+    <MakeDir Directories="$(ProjectDir)..\plugins" />
+
+    <Copy SourceFiles="manifest.yaml" DestinationFolder="$(StagingFolder)" />
+
+    <ItemGroup>
+      <AllOutputFiles Include="$(TargetDir)**\*.*" Exclude="$(TargetDir)Ares.Device.dll;$(TargetDir)Ares.Datamodel.dll;$(TargetDir)obj\**\*.*" />
+    </ItemGroup>
+
+    <Copy SourceFiles="@(AllOutputFiles)" DestinationFiles="@(AllOutputFiles->'$(StagingFolder)%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" />
+
+    <ZipDirectory SourceDirectory="$(StagingFolder)" DestinationFile="$(PackageName)" Overwrite="true" />
+    <RemoveDir Directories="$(StagingFolder)" />
+  </Target>
+</Project>
+
diff --git a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
new file mode 100644
index 0000000..8fdd81d
--- /dev/null
+++ b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
@@ -0,0 +1,154 @@
+@using ReactiveUI
+@using SerialStreamingSensor.UI.State
+@implements IDisposable
+
+@if (ViewModel is null)
+{
+    <div class="streaming-sensor-message">
+        No sensor view model is available.
+    </div>
+}
+else
+{
+    <div class="streaming-sensor-header">
+        <div class="streaming-sensor-title">
+            @GetDisplayName()
+        </div>
+
+        <div class="@GetStatusClass()">
+            @GetStatusText()
+        </div>
+    </div>
+
+    @if (ViewModel.SensorState.LiveData.Count == 0)
+    {
+        <div class="streaming-sensor-message">
+            No live-data fields are defined.
+        </div>
+    }
+    else
+    {
+        <div class="streaming-sensor-live-data">
+            @foreach (var entry in ViewModel.SensorState.LiveData)
+            {
+                <div class="streaming-sensor-value-row"
+                     @key="entry.Name">
+
+                    <span class="streaming-sensor-label">
+                        @FormatName(entry.Name)
+                    </span>
+
+                    <span class="@GetValueClass(entry)">
+                        @FormatValue(entry.Value)
+                    </span>
+                </div>
+            }
+        </div>
+    }
+}
+
+@code {
+    private IDisposable? _viewModelSubscription;
+
+    [Parameter]
+    public DelimitedStreamSensorControlViewModel? ViewModel
+    {
+        get;
+        set;
+    }
+
+    protected override void OnParametersSet()
+    {
+        _viewModelSubscription?.Dispose();
+        _viewModelSubscription = null;
+
+        if (ViewModel is null)
+            return;
+
+        _viewModelSubscription = ViewModel
+            .Changed
+            .Subscribe(
+                _ => InvokeAsync(StateHasChanged));
+    }
+
+    private string GetDisplayName()
+    {
+        if (ViewModel is null)
+            return "Delimited Stream Sensor";
+
+        if (!string.IsNullOrWhiteSpace(
+                ViewModel.SensorState.Name))
+        {
+            return ViewModel.SensorState.Name;
+        }
+
+        return ViewModel.DeviceName;
+    }
+
+    private string GetStatusText()
+    {
+        if (ViewModel?.CapturingLiveData == true)
+            return "Live";
+
+        if (ViewModel?.HasValidData == true)
+            return "Connected";
+
+        return "Waiting for data";
+    }
+
+    private string GetStatusClass()
+    {
+        return ViewModel?.CapturingLiveData == true
+            ? "streaming-sensor-status active"
+            : "streaming-sensor-status waiting";
+    }
+
+    private static string GetValueClass(
+        DelimitedStreamSensorLiveDataEntry entry)
+    {
+        return entry.Value.HasValue
+            ? "streaming-sensor-value"
+            : "streaming-sensor-value unavailable";
+    }
+
+    private static string FormatValue(double? value)
+    {
+        return value.HasValue
+            ? value.Value.ToString("G6")
+            : "—";
+    }
+
+    private static string FormatName(string name)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+            return "Value";
+
+        var result =
+            new System.Text.StringBuilder(
+                name.Length + 8);
+
+        for (var index = 0;
+             index < name.Length;
+             index++)
+        {
+            var current = name[index];
+
+            if (index > 0 &&
+                char.IsUpper(current) &&
+                !char.IsUpper(name[index - 1]))
+            {
+                result.Append(' ');
+            }
+
+            result.Append(current);
+        }
+
+        return result.ToString();
+    }
+
+    public void Dispose()
+    {
+        _viewModelSubscription?.Dispose();
+        _viewModelSubscription = null;
+    }
+}
\ No newline at end of file
diff --git a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
new file mode 100644
index 0000000..5f28270
--- /dev/null
+++ b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/SerialStreamingSensor/UI/DelimitedStreamSensorControlViewModel.cs b/SerialStreamingSensor/UI/DelimitedStreamSensorControlViewModel.cs
new file mode 100644
index 0000000..3ff034f
--- /dev/null
+++ b/SerialStreamingSensor/UI/DelimitedStreamSensorControlViewModel.cs
@@ -0,0 +1,119 @@
+using Ares.Toolkit.Device.UI;
+using Microsoft.Extensions.Logging;
+using ReactiveUI;
+using SerialStreamingSensor.UI.State;
+using System.Reactive.Linq;
+
+namespace SerialStreamingSensor.UI
+{
+    public sealed class DelimitedStreamSensorControlViewModel
+        : DeviceUnitControlViewModel<DelimitedStreamSensor>,
+          IAsyncDisposable
+    {
+        private readonly ILogger<
+            DelimitedStreamSensorControlViewModel> _logger;
+
+        private IDisposable? _stateSubscription;
+
+        private DelimitedStreamSensorState _sensorState = new();
+        private bool _hasValidData;
+        private bool _capturingLiveData;
+        private bool _disposed;
+
+        public DelimitedStreamSensorControlViewModel(
+            DelimitedStreamSensor sensor,
+            ILogger<DelimitedStreamSensorControlViewModel> logger)
+            : base(sensor)
+        {
+            _logger = logger;
+
+            ViewType = typeof(DelimitedStreamSensorControl);
+            DefaultWidth = 19;
+
+            _stateSubscription = sensor.StateStream
+                .Select(
+                    DelimitedStreamSensorStateMapper.FromAresStruct)
+                .Subscribe(
+                    UpdateState,
+                    HandleStateStreamError,
+                    HandleStateStreamCompleted);
+        }
+
+        public DelimitedStreamSensorState SensorState
+        {
+            get => _sensorState;
+
+            private set =>
+                this.RaiseAndSetIfChanged(
+                    ref _sensorState,
+                    value);
+        }
+
+        public bool HasValidData
+        {
+            get => _hasValidData;
+
+            private set =>
+                this.RaiseAndSetIfChanged(
+                    ref _hasValidData,
+                    value);
+        }
+
+        public bool CapturingLiveData
+        {
+            get => _capturingLiveData;
+
+            private set =>
+                this.RaiseAndSetIfChanged(
+                    ref _capturingLiveData,
+                    value);
+        }
+
+        private void UpdateState(
+            DelimitedStreamSensorState? state)
+        {
+            if (state is null)
+            {
+                HasValidData = false;
+                CapturingLiveData = false;
+                return;
+            }
+
+            SensorState = state;
+            HasValidData = true;
+            CapturingLiveData = true;
+        }
+
+        private void HandleStateStreamError(
+            Exception exception)
+        {
+            _logger.LogError(
+                exception,
+                "State stream failed for {Name}",
+                DeviceName);
+
+            HasValidData = false;
+            CapturingLiveData = false;
+        }
+
+        private void HandleStateStreamCompleted()
+        {
+            CapturingLiveData = false;
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            if (_disposed)
+                return ValueTask.CompletedTask;
+
+            _disposed = true;
+
+            _stateSubscription?.Dispose();
+            _stateSubscription = null;
+
+            GC.SuppressFinalize(this);
+
+            return ValueTask.CompletedTask;
+        }
+    }
+}
\ No newline at end of file
diff --git a/SerialStreamingSensor/UI/State/DelimitedStreamSensorState.cs b/SerialStreamingSensor/UI/State/DelimitedStreamSensorState.cs
new file mode 100644
index 0000000..3b1d93a
--- /dev/null
+++ b/SerialStreamingSensor/UI/State/DelimitedStreamSensorState.cs
@@ -0,0 +1,20 @@
+namespace SerialStreamingSensor.UI.State
+{
+    public sealed class DelimitedStreamSensorState
+    {
+        public string Name { get; init; } = string.Empty;
+
+        public IReadOnlyList<DelimitedStreamSensorLiveDataEntry> LiveData
+        {
+            get;
+            init;
+        } = Array.Empty<DelimitedStreamSensorLiveDataEntry>();
+    }
+
+    public sealed class DelimitedStreamSensorLiveDataEntry
+    {
+        public string Name { get; init; } = string.Empty;
+
+        public double? Value { get; init; }
+    }
+}
\ No newline at end of file
diff --git a/SerialStreamingSensor/UI/State/DelimitedStreamSensorStateMapper.cs b/SerialStreamingSensor/UI/State/DelimitedStreamSensorStateMapper.cs
new file mode 100644
index 0000000..9e38949
--- /dev/null
+++ b/SerialStreamingSensor/UI/State/DelimitedStreamSensorStateMapper.cs
@@ -0,0 +1,47 @@
+using Ares.Datamodel;
+using Ares.Datamodel.Extensions;
+
+namespace SerialStreamingSensor.UI.State
+{
+    public static class DelimitedStreamSensorStateMapper
+    {
+        public static DelimitedStreamSensorState FromAresStruct(
+            AresStruct state)
+        {
+            var model = new DelimitedStreamSensorState
+            {
+
+                Name = state.Fields
+                    .GetValueOrDefault("Name")?
+                    .StringValue ?? string.Empty
+            };
+
+            if (state.Fields.TryGetValue(
+                    "LiveData",
+                    out var liveDataValue) &&
+                liveDataValue.StructValue is not null)
+            {
+                model = new DelimitedStreamSensorState
+                {
+                    Name = model.Name,
+
+                    LiveData = liveDataValue.StructValue.Fields
+                        .Where(field =>
+                            !string.IsNullOrWhiteSpace(field.Key))
+                        .Select(field =>
+                            new DelimitedStreamSensorLiveDataEntry
+                            {
+                                Name = field.Key,
+
+                                Value = field.Value.HasNumberValue
+                                    ? field.Value.NumberValue
+                                    : null
+                            })
+                        .ToArray()
+                };
+            }
+
+            return model;
+        }
+    }
+}
\ No newline at end of file
diff --git a/SerialStreamingSensor/manifest.yaml b/SerialStreamingSensor/manifest.yaml
new file mode 100644
index 0000000..5bd464b
--- /dev/null
+++ b/SerialStreamingSensor/manifest.yaml
@@ -0,0 +1,23 @@
+# ARES Device Driver Manifest
+# Target: Steaming Serial Sensor
+
+# Basic Metadata
+device_type_name: "Delimited Stream Sensor"
+driver_id: "delimited_stream_sensor_v1"
+connection_type: "Serial"
+
+# The DLL that contains the MassFlowController and ViewModel classes
+assembly_name: "SerialStreamingSensor.dll"
+
+# Serial connection specifics (Parsed only if connection_type is "Serial")
+serial_settings:
+  variable_baud_rate: true
+  allowed_baud_rates: [9600, 19200, 38400, 57600, 115200]
+  default_baud_rate: 115200 # Keeps the UI friendly by pre-filling
+
+# Settings required when adding the device through the ARES UI
+settings:
+  - key: "DataFormat"
+    display_name: "Data Format"
+    type: "string"
+    description: "streaming data line format."

From 9b41cb71c2b916f9c5731ac37d91efd4bcdbf3a3 Mon Sep 17 00:00:00 2001
From: garath001 <62758265+garath001@users.noreply.github.com>
Date: Mon, 3 Aug 2026 17:25:29 -0400
Subject: [PATCH 3/3] Library for sensor streaming delimited data over
 dedicated serial port. Validated function!

---
 Ares.Device.Drivers.slnx                      |   1 +
 .../Connection/ISerialSteramingConnection.cs  |   9 +
 .../Connection/SerialStreamingConnection.cs   |  19 +++
 .../DelimitedStreamSensor.cs                  | 154 +++++++++++++++++-
 .../SerialStreamingSensor.csproj              |   1 +
 .../UI/DelimitedStreamSensorControl.razor     |  88 +++++-----
 .../UI/DelimitedStreamSensorControl.razor.css |  69 +++++++-
 plugins/SerialStreamingSensor.ares.archive    | Bin 0 -> 74000 bytes
 8 files changed, 293 insertions(+), 48 deletions(-)
 create mode 100644 SerialStreamingSensor/Connection/ISerialSteramingConnection.cs
 create mode 100644 SerialStreamingSensor/Connection/SerialStreamingConnection.cs
 create mode 100644 plugins/SerialStreamingSensor.ares.archive

diff --git a/Ares.Device.Drivers.slnx b/Ares.Device.Drivers.slnx
index 231764a..67386e3 100644
--- a/Ares.Device.Drivers.slnx
+++ b/Ares.Device.Drivers.slnx
@@ -4,6 +4,7 @@
   <Project Path="FlirCM3Remastered/FlirCM3Remastered.csproj" />
   <Project Path="HerkulexDRS/HerkulexDRS.csproj" />
   <Project Path="LindbergFurnaceRemastered/LindbergFurnaceRemastered.csproj" />
+  <Project Path="SerialStreamingSensor/SerialStreamingSensor.csproj" Id="7bb0c602-2d45-4c2b-8e65-d71edef5a57d" />
   <Project Path="StreamHelper/StreamHelper.csproj" Id="1e8f4da1-e33f-4820-af52-278a4ba357f8" />
   <Project Path="SyringePumpNE1000Remastered/SyringePumpNE1000Remastered.csproj" />
   <Project Path="TC0304Remastered/TC0304Remastered.csproj" />
diff --git a/SerialStreamingSensor/Connection/ISerialSteramingConnection.cs b/SerialStreamingSensor/Connection/ISerialSteramingConnection.cs
new file mode 100644
index 0000000..5ac1265
--- /dev/null
+++ b/SerialStreamingSensor/Connection/ISerialSteramingConnection.cs
@@ -0,0 +1,9 @@
+using Ares.Toolkit.Serial;
+
+namespace SerialStreamingSensor.Connection
+{
+    public interface ISerialSteramingConnection: IAresSerialConnection
+    {
+
+    }
+}
diff --git a/SerialStreamingSensor/Connection/SerialStreamingConnection.cs b/SerialStreamingSensor/Connection/SerialStreamingConnection.cs
new file mode 100644
index 0000000..251a591
--- /dev/null
+++ b/SerialStreamingSensor/Connection/SerialStreamingConnection.cs
@@ -0,0 +1,19 @@
+using Ares.Toolkit.Serial;
+using Ares.Toolkit.Serial.Commands;
+using System.IO.Ports;
+
+namespace SerialStreamingSensor.Connection
+{
+    public class SerialStreamingConnection : AresHardwareConnection, ISerialSteramingConnection
+    {
+        public SerialStreamingConnection(SerialPortConnectionInfo connectionInfo, string portName, SerialConnectionOptions? connectionOptions = null) : base(connectionInfo, portName, connectionOptions)
+        {
+        }
+
+        public SerialStreamingConnection(string portName, int baudRate = 115200, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One, SerialConnectionOptions? options = null) : base(portName, baudRate, parity, dataBits, stopBits, options)
+        {
+            
+        }
+
+    }
+}
diff --git a/SerialStreamingSensor/DelimitedStreamSensor.cs b/SerialStreamingSensor/DelimitedStreamSensor.cs
index 36599d5..18d65f0 100644
--- a/SerialStreamingSensor/DelimitedStreamSensor.cs
+++ b/SerialStreamingSensor/DelimitedStreamSensor.cs
@@ -4,9 +4,12 @@
 using Ares.Datamodel.Factories;
 using Ares.Device;
 using Microsoft.AspNetCore.Components.Web;
+using Microsoft.AspNetCore.Mvc.Diagnostics;
+using SerialStreamingSensor.Connection;
 using SerialStreamingSensor.Models;
 using StreamHelper;
 using System.Linq.Expressions;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
@@ -20,6 +23,10 @@ public class DelimitedStreamSensor : AresDevice, IDelimitedSteamSensor
         private readonly string[] _fields;
         private readonly StreamingField[] _streamingFields;
         private readonly IReadOnlyDictionary<string, StreamingField> _streamingFieldsByName;
+        private readonly System.IO.Ports.SerialPort _serialConnection;
+        private CancellationTokenSource _stateGetterLoopTokenSource = new();
+        //private CompositeDisposable _stateWatchers = new();
+        private Task _stateUpdater = Task.CompletedTask;
 
         private readonly BehaviorSubject<AresStruct> _stateSubject = new(new AresStruct());
 
@@ -32,6 +39,19 @@ public DelimitedStreamSensor(DeviceConnectionInfo info, ILogger logger) : base(i
             StateStream = _stateSubject.AsObservable();
 
             _logger.LogInformation($"Parsing data format '{_dataFormat}'");
+            _serialConnection = new System.IO.Ports.SerialPort()
+            {
+                PortName = info.SerialConnectionInfo.PortName,
+                BaudRate = 115200,
+                Parity = System.IO.Ports.Parity.None,
+                StopBits = System.IO.Ports.StopBits.One,
+                DataBits = 8,
+                DtrEnable = true,
+                RtsEnable = true,
+                ReadTimeout=1000,
+            };
+
+
 
             _fields = _dataFormat.Split(":,\t".ToCharArray(), StringSplitOptions.None).Select(field => field.Trim()).ToArray();
 
@@ -68,6 +88,46 @@ public DelimitedStreamSensor(DeviceConnectionInfo info, ILogger logger) : base(i
                     })
                     .Build())
                 .Build();
+
+            //_stateWatchers = new CompositeDisposable
+            //    {
+            //      _serialConnection.GetTransactionStream<ReadLineResponse>().Select(transaction => transaction.Response).Subscribe(UpdateLiveData)
+            //    };
+
+            _logger.LogInformation($" Streaming device {Name} initialization completed");
+        }
+
+        private void UpdateLiveData(string response)
+        {
+            // TODO: move parsing into parser class (deliver key-value pairs instead of raw line)
+            //_logger.LogInformation($"Received line: {response}");
+            var fields = response.Split(":,\t".ToCharArray(), StringSplitOptions.None).Select(field => field.Trim()).ToArray();
+            foreach (var field in _streamingFields)
+            {
+                double value;
+                if (double.TryParse(fields[field.DataIndex], out value))
+                {
+                    field.Value = value;
+                    if (field.StatsActive) field.Stats.AddValue(value);    
+                }
+                else
+                {
+                    field.Value = null;
+                }
+            }
+
+            var next = AresStateBuilder
+                  .From(_stateSubject.Value)
+                  .AddStruct("LiveData", b =>
+                  {
+                      foreach (var field in _streamingFields)
+                      {
+                          b.Add(field.Name, field.Value ?? 0.0);
+                      }
+                  })
+                  .Build();
+
+            _stateSubject.OnNext(next);
         }
 
         private AresStruct BuildInitialState()
@@ -89,15 +149,97 @@ private AresStruct BuildInitialState()
                 .Build();
         }
 
-
         public override IObservable<AresStruct> StateStream { get; }
 
 
-        public override Task<bool> Activate(CancellationToken ct)
+        public async override Task<bool> Activate(CancellationToken ct)
+        {
+            bool activated = false;
+            _logger.LogInformation($"Activating streaming device {Name}...");
+            try
+            {
+                await Initialize();
+                activated = true;
+                Status = new DeviceOperationalStatus { OperationalState = OperationalState.Active, Message = $"Streaming device {Name} is active!" };
+                _logger.LogInformation($"Device {Name} activated");
+            }
+            catch (Exception e)
+            {
+                Status = new DeviceOperationalStatus { OperationalState = OperationalState.Error, Message = $"Failed to initialize: {e.Message}" };
+                _logger.LogError(e, $"Device {Name} activation failed");
+            }
+
+            return activated;
+        }
+
+        private async Task Initialize()
         {
+            if (_serialConnection is null)
+            {
+                _logger.LogError($"Serial device {Name}: Initialize was called, but connection was not set!");
+                return;
+            }
+
+            await StopUpdateLoop();
+
             _stateSubject.OnNext(BuildInitialState());
 
-            return Task.FromResult(true);
+            _ = Start();
+
+        }
+
+        public async Task Start()
+        {
+            await StopUpdateLoop();
+            await StartUpdateLoop(TimeSpan.FromMilliseconds(500));
+        }
+
+        public async Task StartUpdateLoop(TimeSpan interval)
+        {
+            await StopUpdateLoop();
+            await Task.Delay(150);
+            _stateGetterLoopTokenSource = new CancellationTokenSource();
+            _stateUpdater = Task.Factory.StartNew(async _ =>
+            {
+                Thread.CurrentThread.Name = $"Serial Device {Name} State Update Loop Thread";
+                try
+                {
+                    while (!_stateGetterLoopTokenSource.IsCancellationRequested)
+                    {
+                        try
+                        {
+                            if (!_serialConnection.IsOpen) _serialConnection.Open();
+                            //_logger.LogInformation($"Requesting live data at {DateTime.Now}");
+                            var liveData = _serialConnection.ReadLine();
+                            UpdateLiveData(liveData);
+                        }
+                        catch (TimeoutException)
+                        {
+                            _logger.LogError($"Get Live Data timed out at {DateTime.Now}");
+                            Status = new DeviceOperationalStatus { OperationalState = OperationalState.Active, Message = $"Get Live Data timed out at {DateTime.Now}" };
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.LogError(e, $"Get Live Data failed at {DateTime.Now}");
+                            await Task.Delay(150);
+                        }
+                    }
+                }
+                catch (ObjectDisposedException)
+                {
+                }
+                catch (Exception e)
+                {
+                    Status = new DeviceOperationalStatus { OperationalState = OperationalState.Error, Message = $"{e.Message}" };
+                }
+            },
+              _stateGetterLoopTokenSource.Token);
+        }
+
+        private async Task StopUpdateLoop()
+        {
+            _stateGetterLoopTokenSource?.Cancel();
+            await _stateUpdater;
         }
 
         public Task BeginCollectingStats(string fieldName)
@@ -111,9 +253,9 @@ public Task BeginCollectingStats(string fieldName)
         public async ValueTask DisposeAsync()
         {
             //_stateWatchers.Dispose();
-            //await _stateGetterLoopTokenSource.CancelAsync();
-            //await _stateUpdater;
-            //_stateGetterLoopTokenSource.Dispose();
+            await _stateGetterLoopTokenSource.CancelAsync();
+            await _stateUpdater;
+            _stateGetterLoopTokenSource.Dispose();
             _stateSubject.OnCompleted();
         }
 
diff --git a/SerialStreamingSensor/SerialStreamingSensor.csproj b/SerialStreamingSensor/SerialStreamingSensor.csproj
index 4cf115b..3ee1c0e 100644
--- a/SerialStreamingSensor/SerialStreamingSensor.csproj
+++ b/SerialStreamingSensor/SerialStreamingSensor.csproj
@@ -19,6 +19,7 @@
 
   <ItemGroup>
     <PackageReference Include="Ares.Toolkit.Device" Version="1.5.0" />
+    <PackageReference Include="Ares.Toolkit.Serial" Version="1.0.0" />
     <PackageReference Include="ReactiveUI.SourceGenerators" Version="3.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
index 8fdd81d..9b3c3eb 100644
--- a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
+++ b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor
@@ -10,41 +10,43 @@
 }
 else
 {
-    <div class="streaming-sensor-header">
-        <div class="streaming-sensor-title">
-            @GetDisplayName()
+    <div class="device-container m-0 p-0">
+        <div class="title-row">
+            <div class="device-name">
+                @GetDisplayName()
+            </div>
+
+            <div class="@GetStatusClass()">
+                @GetStatusText()
+            </div>
         </div>
 
-        <div class="@GetStatusClass()">
-            @GetStatusText()
-        </div>
+        @if (ViewModel.SensorState.LiveData.Count == 0)
+        {
+            <div class="streaming-sensor-message">
+                No live-data fields are defined.
+            </div>
+        }
+        else
+        {
+            <table class="parameter-table">
+                <tbody>
+                    @foreach (var entry in ViewModel.SensorState.LiveData)
+                    {
+                        <tr @key="entry.Name">
+                            <td class="parameter-name">
+                                @FormatName(entry.Name)
+                            </td>
+
+                            <td class="@GetValueClass(entry)">
+                                @FormatValue(entry.Value)
+                            </td>
+                        </tr>
+                    }
+                </tbody>
+            </table>
+        }
     </div>
-
-    @if (ViewModel.SensorState.LiveData.Count == 0)
-    {
-        <div class="streaming-sensor-message">
-            No live-data fields are defined.
-        </div>
-    }
-    else
-    {
-        <div class="streaming-sensor-live-data">
-            @foreach (var entry in ViewModel.SensorState.LiveData)
-            {
-                <div class="streaming-sensor-value-row"
-                     @key="entry.Name">
-
-                    <span class="streaming-sensor-label">
-                        @FormatName(entry.Name)
-                    </span>
-
-                    <span class="@GetValueClass(entry)">
-                        @FormatValue(entry.Value)
-                    </span>
-                </div>
-            }
-        </div>
-    }
 }
 
 @code {
@@ -88,27 +90,31 @@ else
     private string GetStatusText()
     {
         if (ViewModel?.CapturingLiveData == true)
-            return "Live";
+            return "LIVE";
 
         if (ViewModel?.HasValidData == true)
-            return "Connected";
+            return "CONNECTED";
 
-        return "Waiting for data";
+        return "INITIALIZING";
     }
 
     private string GetStatusClass()
     {
-        return ViewModel?.CapturingLiveData == true
-            ? "streaming-sensor-status active"
-            : "streaming-sensor-status waiting";
+        if (ViewModel?.CapturingLiveData == true)
+            return "device-state connected";
+
+        if (ViewModel?.HasValidData == true)
+            return "device-state connected";
+
+        return "device-state initializing";
     }
 
     private static string GetValueClass(
         DelimitedStreamSensorLiveDataEntry entry)
     {
         return entry.Value.HasValue
-            ? "streaming-sensor-value"
-            : "streaming-sensor-value unavailable";
+            ? "parameter-value"
+            : "parameter-value unavailable";
     }
 
     private static string FormatValue(double? value)
@@ -151,4 +157,4 @@ else
         _viewModelSubscription?.Dispose();
         _viewModelSubscription = null;
     }
-}
\ No newline at end of file
+}
diff --git a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
index 5f28270..17971f2 100644
--- a/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
+++ b/SerialStreamingSensor/UI/DelimitedStreamSensorControl.razor.css
@@ -1 +1,68 @@
-
\ No newline at end of file
+.device-container {
+    display: grid;
+    grid-template:
+        "header"
+        "state"
+        / minmax(0, 1fr);
+    justify-content: center;
+}
+
+.title-row {
+    grid-area: header;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+    min-width: 0;
+    padding: 8px 10px;
+    gap: 10px;
+    border-radius: 6px;
+    box-sizing: border-box;
+}
+
+.device-name {
+    flex: 1 1 auto;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size:larger;
+}
+
+.device-state {
+    flex: 0 0 auto;
+}
+
+.status-connected {
+    background-color: #28a745;
+}
+
+.status-initializing {
+    background-color: #f0ad4e;
+}
+
+.status-error {
+    background-color: #dc3545;
+}
+
+.parameter-table {
+    grid-area: state;
+    width: 95%;
+    min-width: 0;
+    border-collapse: collapse;
+    table-layout: auto;
+}
+
+.parameter-name {
+    min-width: 80px;
+    white-space: normal;
+    overflow-wrap: anywhere;
+    font-size: smaller;
+}
+
+.parameter-value {
+    width: 120px;
+    min-width: 90px;
+    white-space: nowrap;
+    font-size: smaller;
+}
diff --git a/plugins/SerialStreamingSensor.ares.archive b/plugins/SerialStreamingSensor.ares.archive
new file mode 100644
index 0000000000000000000000000000000000000000..bf966ba962611ce5ddc5b0a2b4fe4b6de1035740
GIT binary patch
literal 74000
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
F^j{4O!P@`;

literal 0
HcmV?d00001