Implement neo pixel (#55)

* Implement neo pixel

* Update src/nf-telemetry-clients/Peripherals/NeoPixel.Peripheral/NeoPixelGauge.cs

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: mikmog

src/nf-telemetry-clients/Clients/RipTide.Nfirmware/Program.cs

@@ -1,4 +1,6 @@
+using NeoPixel.Peripheral;
 using System.Diagnostics;
+using System.Drawing;
 using System.Threading;
 using TelemetryStash.AdcSensor;
 
@@ -11,6 +13,9 @@ public static void Main()
         {
             Thread.Sleep(2000);
 
+            var gauge = new NeoPixelGauge(pixelsCount: 45, new[] { Color.Green, Color.Yellow, Color.Red }, pin: 11);
+            gauge.Initialize();
+
             var ss49e = new Ss49eHallSensor(new int[] { 0, 1 }, adcReadScale: 45, true);
             ss49e.CalibrateAdcChannelOffsets();
             while (true)
@@ -22,9 +27,11 @@ public static void Main()
                     continue;
                 }
 
-                Debug.WriteLine($"Value: {value}");
+                gauge.SetPosition(value);
             }
 
+
+
             Debug.WriteLine("Zzzz");
             Thread.Sleep(Timeout.Infinite);
         }

src/nf-telemetry-clients/Clients/RipTide.Nfirmware/RipTide.Nfirmware.nfproj

@@ -37,6 +37,9 @@
     <Reference Include="mscorlib">
       <HintPath>..\..\packages\nanoFramework.CoreLibrary.1.17.1\lib\mscorlib.dll</HintPath>
     </Reference>
+    <Reference Include="nanoFramework.Graphics.Core">
+      <HintPath>..\..\packages\nanoFramework.Graphics.Core.1.2.39\lib\nanoFramework.Graphics.Core.dll</HintPath>
+    </Reference>
     <Reference Include="nanoFramework.Runtime.Events">
       <HintPath>..\..\packages\nanoFramework.Runtime.Events.1.11.30\lib\nanoFramework.Runtime.Events.dll</HintPath>
     </Reference>

src/nf-telemetry-clients/Clients/RipTide.Nfirmware/packages.config

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="nanoFramework.CoreLibrary" version="1.17.1" targetFramework="netnano1.0" />
+  <package id="nanoFramework.Graphics.Core" version="1.2.39" targetFramework="netnano1.0" />
   <package id="nanoFramework.Runtime.Events" version="1.11.30" targetFramework="netnano1.0" />
 </packages>

src/nf-telemetry-clients/Peripherals/NeoPixel.Peripheral/NeoPixelGauge.cs

@@ -1,22 +1,25 @@
 using CCSWE.nanoFramework.NeoPixel;
 using CCSWE.nanoFramework.NeoPixel.Drivers;
+using System;
 using System.Drawing;
 using System.Threading;
 
 // https://docid81hrs3j1.cloudfront.net/medialibrary/2018/10/WS2812B_V1.4_EN_18090714224701.pdf
-// Enable LDO2 on UM FeatherS3
-//var gpioController = new GpioController();
-//gpioController.OpenPin(39, PinMode.Output).Write(PinValue.High);
 
 namespace NeoPixel.Peripheral
 {
     public class NeoPixelGauge
     {
         private readonly Color[] _colors;
         private readonly NeoPixelStrip _pixels;
+        private readonly Thread _gaugeThread;
+        
+        private volatile int _currentPosition;
+        private volatile int _requestedPosition;
 
         public NeoPixelGauge(ushort pixelsCount, Color[] gaugeColors, byte pin)
         {
+            // TODO: Decrease pulse transfer times
             _pixels = new NeoPixelStrip(pin, pixelsCount, new Ws2812B());
             _colors = new Color[pixelsCount];
 
@@ -40,25 +43,98 @@ public NeoPixelGauge(ushort pixelsCount, Color[] gaugeColors, byte pin)
                     _colors[index++] = color;
                 }
             }
+
+            _gaugeThread = new Thread(SetPosition);
         }
 
-        public void DemoRun()
+        public void Initialize()
         {
-            var delay = 500;
+            _gaugeThread.Start();
+            for (var i = 0; i < _pixels.Count; i++)
+            {
+                _pixels.SetLed(i, _colors[i]);
+                _pixels.Update();
+                Thread.Sleep(1);
+            }
+            
+            for (var i = 0; i < _pixels.Count; i++)
+            {
+                _pixels.SetLed(i, Color.Black);
+                _pixels.Update();
+                Thread.Sleep(1);
+            }
+        }
+
+        public void SetPosition(int position)
+        {
+            _requestedPosition = Math.Min(position, _colors.Length-1);
+        }
 
+        private void SetPosition()
+        {
             while (true)
             {
-                _pixels.Clear();
-                _pixels.Update();
+                if (_currentPosition == _requestedPosition)
+                {
+                    Thread.Sleep(1);
+                    continue;
+                }
+
+                var currentPosition = _currentPosition;
+                var requestedPosition = _requestedPosition;
 
-                for (var i = 0; i < _pixels.Count; i++)
+                var goingUp = currentPosition < requestedPosition;
+                if (goingUp)
                 {
-                    _pixels.SetLed(i, _colors[i]);
-                    _pixels.Update();
-                    Thread.Sleep(10);
+                    while (currentPosition < requestedPosition)
+                    {
+                        // Increase the speed of the gauge if the requested position is far away
+                        var increments = (requestedPosition - currentPosition) switch
+                        {
+                            > 10 => 3,
+                            > 5 => 2,
+                            _ => 1,
+                        };
+
+                        _pixels.SetLed(++currentPosition, _colors[currentPosition]);
+                        if (currentPosition % increments == 0 || currentPosition >= requestedPosition || requestedPosition != _requestedPosition)
+                        {
+                            _pixels.Update();
+                            Thread.Sleep(0);
+                        }
+                        if (requestedPosition != _requestedPosition)
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                // going down
+                else
+                {
+                    while (currentPosition > requestedPosition)
+                    {
+                        var increments = (currentPosition - requestedPosition) switch
+                        {
+                            > 5 => 2,
+                            _ => 1,
+                        };
+
+                        _pixels.SetLed(currentPosition--, Color.Black);
+                        if (currentPosition % increments == 0 || requestedPosition == currentPosition || requestedPosition != _requestedPosition)
+                        { 
+                            _pixels.Update();
+                            Thread.Sleep(0);
+                        }
+
+                        if (requestedPosition != _requestedPosition)
+                        {
+                            break;
+                        }
+                    }
                 }
 
-                Thread.Sleep(delay * 5);
+                _currentPosition = currentPosition;
             }
         }
     }

src/nf-telemetry-clients/Shared/Tests/Client.Services.Benchmarks/Client.Services.Benchmarks.nfproj

@@ -20,6 +20,8 @@
   <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
   <ItemGroup>
     <Compile Include="BufferedTelemetryServiceBenchmark.cs" />
+    <Compile Include="FrameworkBenchmark3.cs" />
+    <Compile Include="FrameworkBenchmark2.cs" />
     <Compile Include="FrameworkBenchmark.cs" />
     <Compile Include="JsonBenchmark.cs" />
     <Compile Include="LocalStorageBenchmark.cs" />

src/nf-telemetry-clients/Shared/Tests/Client.Services.Benchmarks/FrameworkBenchmark2.cs

@@ -0,0 +1,45 @@
+using nanoFramework.Benchmark;
+using nanoFramework.Benchmark.Attributes;
+using System;
+
+namespace TelemetryStash.Services.Benchmarks
+{
+    [ConsoleParser]
+    [IterationCount(10)]
+    public class FrameworkBenchmark2
+    {
+        const UInt16 About65k = UInt16.MaxValue;
+
+        [Benchmark, Baseline]
+        public void FillArray_Int32()
+        {
+            var until = (int)About65k;
+            var array = new int[until];
+            for (int j = 0; j < until; j++)
+            {
+                array[j] = j;
+            }
+        }
+
+        [Benchmark]
+        public void FillArray_UInt16()
+        {
+            var array = new UInt16[About65k];
+            for (UInt16 j = 0; j < About65k; j++)
+            {
+                array[j] = j;
+            }
+        }
+
+        [Benchmark]
+        public void FillArray_Int64()
+        {
+            var until = (Int64)About65k;
+            var array = new Int64[until];
+            for (long j = 0; j < until; j++)
+            {
+                array[j] = j;
+            }
+        }
+    }
+}

src/nf-telemetry-clients/Shared/Tests/Client.Services.Benchmarks/FrameworkBenchmark3.cs

@@ -0,0 +1,61 @@
+using nanoFramework.Benchmark;
+using nanoFramework.Benchmark.Attributes;
+using System;
+using System.Diagnostics;
+using TelemetryStash.NfClient.Services;
+using TelemetryStash.Shared;
+
+namespace TelemetryStash.Services.Benchmarks
+{
+    [ConsoleParser]
+    [IterationCount(1)]
+    public class FrameworkBenchmark3
+    {
+        const UInt16 About65k = UInt16.MaxValue;
+
+        [Benchmark, Baseline]
+        public void FillArray_Int32()
+        {
+            PrintMemoryMetrics("Pre FillArray_Int32");
+            var until = (int)About65k;
+            var array = new int[until];
+            for (int i = 0; i < until; i++)
+            {
+                array[i] = i;
+            }
+            PrintMemoryMetrics("Post FillArray_Int32");
+        }
+
+        [Benchmark]
+        public void FillArray_UInt16()
+        {
+            PrintMemoryMetrics("Pre FillArray_UInt16");
+            var array = new UInt16[About65k];
+            for (UInt16 i = 0; i < About65k; i++)
+            {
+                array[i] = i;
+            }
+            PrintMemoryMetrics("Post FillArray_UInt16");
+        }
+
+        [Benchmark]
+        public void FillArray_Int64()
+        {
+            PrintMemoryMetrics("Pre FillArray_Int64");
+            var until = About65k;
+            var array = new Int64[until];
+            for (Int64 i = 0; i < About65k; i++)
+            {
+                array[i] = i;
+            }
+            PrintMemoryMetrics("Post FillArray_Int64");
+        }
+
+        private static void PrintMemoryMetrics(string info)
+        {
+            var metrics = DeviceMetrics.GetDeviceMetrics();
+            var free = ((RegisterSet)metrics[2]).Registers[0].Value;
+            Debug.WriteLine($"[{info}] Free Memory: {free}");
+        }
+    }
+}

src/nf-telemetry-clients/Shared/Tests/Client.Services.Benchmarks/Program.cs

@@ -17,7 +17,9 @@ public static void Main()
             Debug.WriteLine("Running nanoFramework benchmarks...");
 
             //BenchmarkRunner.RunClass(typeof(FrameworkBenchmark));
-            BenchmarkRunner.RunClass(typeof(JsonBenchmark));
+            //BenchmarkRunner.RunClass(typeof(FrameworkBenchmark2));
+            BenchmarkRunner.RunClass(typeof(FrameworkBenchmark3));
+            //BenchmarkRunner.RunClass(typeof(JsonBenchmark));
             //BenchmarkRunner.RunClass(typeof(LocalStorageBenchmark));
             //BenchmarkRunner.RunClass(typeof(BufferedTelemetryServiceBenchmark));
             //BenchmarkRunner.RunClass(typeof(MqttClientBenchmark));