Merge develop into main for 1.5.0 release (#138)

* #115 updated installer project to Wix 5.0.2

* #116 updated license copyright year to 2025

* #117 updated to Wix Toolset 5.0.2

* #117 removed unnecessary instruction

* #93 finished removing console mode

* #117 use newer Wix feature for detecting .NET 4.8

* #117 restored missing file in project

* #92 added basic manual update check

* #92 updated to use Newtonsoft.Json and added to installer

* #124 intial GenAI implementation and tests. Not reviewed.

* #96 measure the rate at which resistance packets are collected and show in the test controller

* #96 update resistance packet rate display to once per second

* #55 prevent exception on disconnection

* #125 adjusted buttons list control

* #96 thread safety and UI adjustments

* #126 assembly metadata update

* #127 crank diagnostics tab and chart

* #128 added installer bitmaps and made it support per-use/per-machine installation scope

* #92 added button to go to the releases page when an update is detected

* #129 URL updates

* #129 URL update

* #91 removed midpoint option

* #130 fixed trip meter tests

* #118 only use the power table for power readings

* Update README.md

* #132 connect crank to flywheel in test controller.

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* #43 put crank calculations behind an interface and extension methods.

* #126 updated copyright year to 2026

* #126 package updates

* Update README.md

* #126 hide telemetry saving in release

* #129 readme update

* #78 some robustness regarding deltas and period length, and other alterations

* #93 removed reference to console app icon from installer code

Author: drmason789

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-2025 David Mason
+Copyright (c) 2021-2026 David Mason
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE.rtf

@@ -2,7 +2,7 @@
 {\*\generator Riched20 10.0.19041}\viewkind4\uc1 
 \pard\f0\fs22\lang2057 MIT License\par
 \par
-Copyright (c) 2021-2025 David Mason\par
+Copyright (c) 2021-2026 David Mason\par
 \par
 Permission is hereby granted, free of charge, to any person obtaining a copy\par
 of this software and associated documentation files (the "Software"), to deal\par

README.md

@@ -10,7 +10,7 @@ It is not necessary to use the diagnostic utility from this repository to utilis
 
 ---
 
-The "Trixter" company or companies that made this bike and the X-Dream mountain biking simulator are now dissolved.  
+The "Trixter" company or companies that made this bike and the X-Dream mountain biking simulator provided with the V1 bike are now dissolved.  
 This repository and the associated discussions / wikis are not associated with these companies or any that acquired them.
 
 ---
@@ -23,29 +23,45 @@ Help with the X-Dream mountain biking simulation software itself can be found in
 
 A .NET Standard 2.0 client API which provides classes to:
 - read status from and send resistance to a Trixter X-Dream Bike.
-- emulate a Trixter V1 X-Dream Bike.
+- emulate a Trixter X-Dream Bike.
 
 # Trixter.XDream.Diagnostics
 
 A replacement for the console and UI test applications that were supplied with the X-Dream software.
 
 So far the improvements over the originals are:
-- console and GUI options in a single application
+- graphic user interface
 - detects the COM port the bike is on
 - detects backpedalling and shows the crank RPM in the backwards direction
 - calculates flywheel and crank cumulative revolutions.
 - estimate of the power being applied to the flywheel from a power table of crank speed and resistance to power.
-- estimate of expended energy
+- estimate of energy expended by rider
+- shows an animated graph of crank positions covered to indicate sensor problems
 - is maintainable
 
-The default mode of the utility has a graphic user interface that shows the state of the various controls and a slider bar to set flywheel resistance.
+## Details Tab
+
+The utility has a graphic user interface that shows the state of the various controls and a slider bar to set flywheel resistance.
 Each brake applies 50% flywheel resistance.
 
-<img src="https://github.com/user-attachments/assets/d33ca02c-bf63-4199-a4d3-a1334d5d861a" align="center" width="550px"  ></a>
+![image](https://github.com/user-attachments/assets/ef9ad901-cbdc-49e5-85c2-0d8c1befb8f7)
+
+## Crank Tab
+
+The Crank tab shows information about activation from the crank position sensor, to show graphically if there is a problem with the crank sensor. 
+This could also be done by turning the crank very slowly and watching the crank position number on the Diagnostics tab or the test utility supplied with the X-Dream software.
+
+https://github.com/user-attachments/assets/91aed2b2-9df8-48e2-b423-215dfc9cc127
+
+## Driver Tab
+
+This tab provides an opinion on the state of the bike's driver.
+
+![image](https://github.com/user-attachments/assets/ebefb94b-fa13-4ba3-b6ae-a7533c6b3fac)
+
+
+
 
 
-The utility also has a console mode to provide a similar experience to the original.
-If the utility is invoked with the --console command line option, or through the program menu short cut for the console mode, it shows a console application.
 
-<img src="https://github.com/user-attachments/assets/3b6dfc6f-fbf2-4cc4-956c-261a198fb4f8" align="center" width="750px" ></a>
 

Scripts/version.txt

@@ -1 +1 @@
-1.4.1
+1.5.0

Trixter.XDream.API.Testing/Experimental/ActivationMonitor.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using Trixter.XDream.API.Filters;
+
+namespace Trixter.XDream.API.Testing.Experimental
+{
+    public class ActivationMonitor
+    {
+        private readonly Queue<Sample> samples = new Queue<Sample>();
+        private double activationThreshold = 0.7;
+        private double deactivationThreshold = 0.3;
+        private int samplingPeriod = 1000;
+        private bool isCurrentlyActive = false;
+
+        private int activeSampleCount = 0;  // Running sum of active samples
+
+
+        /// <summary>
+        /// Represents a sample with a timestamp and activation state.
+        /// </summary>
+        private class Sample
+        {
+            public long Timestamp { get; }
+            public bool IsActive { get; }
+            public Sample(long timestamp, bool isActive)
+            {
+                this.Timestamp = timestamp;
+                this.IsActive = isActive;
+            }
+        }
+
+        /// <summary>
+        /// Function used to get the current time in ticks. 
+        /// Defaults to DateTime.UtcNow.Ticks.
+        /// </summary>
+        private readonly Func<long> getTime;
+
+        protected virtual void OnActivationChanged(bool e) => ActivationChanged?.Invoke(this, e);
+
+        /// <summary>
+        /// Event triggered on activation or deactivation.
+        /// The bool parameter is true for activation and false for deactivation.
+        /// </summary>
+        public event EventHandler<bool> ActivationChanged;
+
+        /// <summary>
+        /// Gets the current activation state.
+        /// </summary>
+        public bool IsActive => this.isCurrentlyActive;
+
+        /// <summary>
+        /// Gets or sets the activation threshold.
+        /// </summary>
+        public double ActivationThreshold
+        {
+            get => this.activationThreshold;
+            set => this.activationThreshold = Clamp(value, this.deactivationThreshold, 1.0);
+        }
+
+        /// <summary>
+        /// Gets or sets the deactivation threshold.
+        /// </summary>
+        public double DeactivationThreshold
+        {
+            get => this.deactivationThreshold;
+            set => this.deactivationThreshold = Clamp(value, 0.0, this.activationThreshold);
+        }
+
+        /// <summary>
+        /// Gets or sets the sampling period in milliseconds.
+        /// </summary>
+        public int SamplingPeriod
+        {
+            get => (int)this.samplingPeriod;
+            private set => this.samplingPeriod = Math.Max(value, 1);
+        }
+
+        /// <summary>
+        /// Constructor with optional time provider for testing.
+        /// </summary>
+        /// <param name="samplingPeriod">The sample period in the unit of the <see cref="getTime"/> function.</param>
+        /// <param name="getTime">A function providing the current time in ticks (for testing purposes).</param>
+        public ActivationMonitor(int samplingPeriod, Func<long> getTime = null)
+        {
+            this.getTime = getTime ?? (() => DateTime.UtcNow.Ticks);
+            this.SamplingPeriod = samplingPeriod;
+        }
+
+        /// <summary>
+        /// Updates the activation state and triggers the event if thresholds are crossed.
+        /// </summary>
+        /// <param name="isActive">Indicates whether the flag is active.</param>
+        public void Update(bool isActive)
+        {
+            this.samples.Enqueue(new Sample(this.getTime(), isActive));
+
+            if (isActive)
+            {
+                this.activeSampleCount++;
+            }
+
+            this.CleanUpOldSamples();
+            double meanActivation = this.CalculateMeanActivation();
+
+            if (!this.isCurrentlyActive && meanActivation >= this.activationThreshold)
+            {
+                this.isCurrentlyActive = true;
+                this.OnActivationChanged(true);
+            }
+            else if (this.isCurrentlyActive && meanActivation < this.deactivationThreshold)
+            {
+                this.isCurrentlyActive = false;
+                this.OnActivationChanged(false);
+            }
+        }
+
+        /// <summary>
+        /// Removes outdated samples and adjusts the active sample count.
+        /// </summary>
+        private void CleanUpOldSamples()
+        {
+            long cutoffTicks = this.getTime() - this.samplingPeriod;
+
+            while (this.samples.Count > 0 && this.samples.Peek().Timestamp < cutoffTicks)
+            {
+                var expiredSample = this.samples.Dequeue();
+
+                if (expiredSample.IsActive)
+                {
+                    this.activeSampleCount--;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Calculates the mean activation over the current sample window.
+        /// </summary>
+        private double CalculateMeanActivation()
+        {
+            if (this.samples.Count == 0) return 0.0;
+
+            return (double)this.activeSampleCount / this.samples.Count;
+        }
+
+        /// <summary>
+        /// Clamps the value between the specified minimum and maximum.
+        /// </summary>
+        private static double Clamp(double value, double min, double max)
+        {
+            if (value < min) return min;
+            if (value > max) return max;
+            return value;
+        }
+    }
+}

Trixter.XDream.API.Testing/Experimental/ActivationMonitorTests.cs

@@ -0,0 +1,118 @@
+using NUnit.Framework;
+using System;
+using System.Threading;
+
+namespace Trixter.XDream.API.Testing.Experimental
+{
+    [TestFixture]
+    public class ActivationMonitorTests
+    {
+        private ActivationMonitor monitor;
+        private bool eventTriggered;
+        private bool eventState;
+
+        private long currentTime;
+
+        [SetUp]
+        public void Setup()
+        {
+            currentTime = 9834982; // Some arbitrary time
+
+            monitor = new ActivationMonitor(1000, () => currentTime)
+            {
+                ActivationThreshold = 0.6,
+                DeactivationThreshold = 0.4,
+            };
+
+            eventTriggered = false;
+            eventState = false;
+
+            monitor.ActivationChanged += (s, e) =>
+            {
+                eventTriggered = true;
+                eventState = e;
+            };
+        }
+
+        private void AdvanceTimeByMilliseconds(int milliseconds)
+        {
+            currentTime += TimeSpan.FromMilliseconds(milliseconds).Ticks;
+        }
+
+        [Test]
+        public void Update_TriggersActivation_WhenThresholdIsExceeded()
+        {
+            monitor.Update(true);
+            monitor.Update(true);
+            monitor.Update(true);
+
+            AdvanceTimeByMilliseconds(10);
+
+            Assert.That(eventTriggered, Is.True);
+            Assert.That(eventState, Is.True);
+            Assert.That(monitor.IsActive, Is.True);
+        }
+
+        [Test]
+        public void Update_TriggersDeactivation_WhenThresholdFallsBelow()
+        {
+            monitor.Update(true);
+            monitor.Update(true);
+            monitor.Update(true);
+
+            AdvanceTimeByMilliseconds(10);
+            Assert.That(monitor.IsActive, Is.True);
+
+            // Simulate deactivation by adding false samples
+            eventTriggered = false;
+            monitor.Update(false);
+            monitor.Update(false);
+            monitor.Update(false);
+
+            AdvanceTimeByMilliseconds(10);
+
+            Assert.That(eventTriggered, Is.True);
+            Assert.That(eventState, Is.False);
+            Assert.That(monitor.IsActive, Is.False);
+        }
+
+        [Test]
+        public void Update_DoesNotTriggerEvent_IfStateRemainsSame()
+        {
+            monitor.Update(true);
+            monitor.Update(true);
+
+            AdvanceTimeByMilliseconds(10);
+
+            Assert.That(eventTriggered, Is.True);
+            Assert.That(monitor.IsActive, Is.True);
+
+            eventTriggered = false;
+
+            monitor.Update(true);
+            monitor.Update(true);
+
+            AdvanceTimeByMilliseconds(10);
+
+            Assert.That(eventTriggered, Is.False);
+            Assert.That(monitor.IsActive, Is.True);
+        }
+
+        [Test]
+        public void IsActive_ReturnsFalse_Initially()
+        {
+            Assert.That(monitor.IsActive, Is.False);
+        }
+            
+        [Test]
+        public void Thresholds_CanBeModified()
+        {
+            monitor.ActivationThreshold = 0.8;
+            monitor.DeactivationThreshold = 0.2;
+
+            Assert.That(monitor.ActivationThreshold, Is.EqualTo(0.8));
+            Assert.That(monitor.DeactivationThreshold, Is.EqualTo(0.2));
+        }
+    }
+
+}

Trixter.XDream.API.Testing/Experimental/CrankMeterExperiments.cs

@@ -3,13 +3,16 @@
 using System.Collections.Generic;
 using System.Linq;
 using Trixter.XDream.API.Communications;
+using Trixter.XDream.API.Crank;
 using Trixter.XDream.API.Meters;
 
 namespace Trixter.XDream.API.Testing.Experimental
 {
     [TestFixture]
     public class CrankMeterExperiments
     {
+        private static readonly ICrankSpecification crankSpec = XDreamCrankSpecification.Default;
+
         [Explicit]
         [Test]
         public void BackAndForwardWithRealData()
@@ -44,7 +47,7 @@ public void CorrelateCrankSpeed1()
 
             HashSet<int>[] rpms = Enumerable.Range(0, 1000).Select(i => new HashSet<int>()).ToArray(); // If we get a calculated 1000RPM, something is unnatural
 
-            ICrankMeter cs = new PositionalCrankMeter();
+            ICrankMeter cs = new PositionalCrankMeter(crankSpec);
             XDreamState last = messages[0];
 
             cs.AddData(last);
@@ -74,7 +77,7 @@ public void CorrelateCrankSpeed2()
         {
             XDreamMessage[] messages = XDreamMessageIO.Read(Resources.flywheel_crank_messages);
 
-            StatisticsGatheringCrankMeter cm = new StatisticsGatheringCrankMeter(new PositionalCrankMeter(), 500);
+            StatisticsGatheringCrankMeter cm = new StatisticsGatheringCrankMeter(new PositionalCrankMeter(crankSpec), 500);
 
             Array.ForEach(messages, cm.AddData);