add mqtt and hwinfo integration

Author: mhwlng

README.md

@@ -1,7 +1,17 @@
 # fip-ha
 
-Now Playing Display for Logitech Flight Instrument Panel for Home Assistant Media Players
+Home Assistant integration with Logitech Flight Instrument Panel, HWINFO, MQTT
 
+- Now Playing Display for Home Assistant Media Players
+- [HWInfo](https://www.hwinfo.com) integration into Home Assistant, via MQTT
+
+If only the HWINFO integration with Home Assistant is needed, then NO Flight Instrument Panel needs to to be connected.
+
+If only the Now Playing Display is required, then no HWINFO or MQTT server needs to be set-up or running (in that case, remove mqtt.config).
+
+HWINFO Sensor Entities will be AUTOMATICALLY added to Home Assistant via the MQTT Discovery process.
+
+# Now Playing
 
 ![Screenshot 1](https://i.imgur.com/UNOTXH2.jpeg)
 
@@ -32,6 +42,42 @@ Also players that should be excluded can be defined
 </appSettings>
 ```
 
+# HWINFO
+
+When HWInfo64 is detected, ALL the available sensors will be written at startup to the data\hwinfo.json file.
+
+The HWINFO.inc file must be modified, to configure what will be sent to MQTT.
+The HWINFO.inc file has the same format as used by various [rainmeter](https://www.deviantart.com/pul53dr1v3r/art/Rainformer-2-9-3-HWiNFO-Edition-Rainmeter-789616481) skins.
+
+Note that you don't need to install rainmeter or any rainmeter plugin.
+
+A configuration tool, to link sensor ids to variables in the HWINFO.inc file, can be downloaded from the hwinfo website [here](https://www.hwinfo.com/beta/HWiNFOSharedMemoryViewer.exe.7z) :
+
+![hwinfo tool](https://i.imgur.com/Px6jvw4.png)
+
+The HWINFO sensor data can be sent to an MQTT server that is configured in mqtt.config (this file can be deleted if MQTT is not required)
+
+```
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <mqtt>
+    <add key="mqttURI" value="192.168.2.34" />
+    <add key="mqttUser" value="mqttusername" />
+    <add key="mqttPassword" value="secretpassword" />
+    <add key="mqttPort" value="1883" />
+    <add key="mqttSecure" value="False" />
+  </mqtt>
+</configuration>
+```
+
+![MQTT1](https://i.imgur.com/KackkpM.png)
+
+![MQTT2](https://i.imgur.com/p5S3FWw.png)
+
+![MQTT3](https://i.imgur.com/AJBazTy.png)
+
+![MQTT4](https://i.imgur.com/tkaNJDd.png)
+
 Works with these 64 bit Logitech Flight Instrument Panel Drivers (currently not with older saitek drivers) :
 
 https://support.logi.com/hc/en-us/articles/360024848713--Downloads-Flight-Instrument-Panel

fipha/App.xaml.cs

@@ -17,10 +17,13 @@
 using SharpDX.DirectInput;
 using System.Collections.Specialized;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Windows.Documents;
 using HADotNet.Core;
 using HADotNet.Core.Clients;
 using HADotNet.Core.Models;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 
 // ReSharper disable StringLiteralTypo
@@ -49,6 +52,9 @@ public partial class App : Application
         public static Task HaTask;
         private static CancellationTokenSource _haTokenSource = new CancellationTokenSource();
 
+        public static Task HWInfoTask;
+        private static CancellationTokenSource _hwInfoTokenSource = new CancellationTokenSource();
+
         private static Mutex _mutex;
 
         private TaskbarIcon _notifyIcon;
@@ -80,8 +86,7 @@ private static void RunProcess(string fileName)
             process.Start();
             process.WaitForExit();
         }
-
-
+        
         protected override void OnStartup(StartupEventArgs evtArgs)
         {
             const string appName = "fipha";
@@ -162,7 +167,16 @@ protected override void OnStartup(StartupEventArgs evtArgs)
                 {
                     Log.Info($"{mediaPlayer}");
                 }
-                
+
+                splashScreen.Dispatcher.Invoke(() => splashScreen.ProgressText.Text = "Getting sensor data from HWInfo...");
+
+                HWInfo.ReadMem("HWINFO.INC");
+ 
+                if (HWInfo.SensorData.Any())
+                {
+                    HWInfo.SaveDataToFile(@"Data\hwinfo.json");
+                }
+
                 Dispatcher.Invoke(() =>
                 {
                     var window = Current.MainWindow = new MainWindow();
@@ -235,6 +249,79 @@ protected override void OnStartup(StartupEventArgs evtArgs)
 
                 }, haToken);
 
+                var hwInfoToken = _hwInfoTokenSource.Token;
+
+                if (File.Exists(Path.Combine(App.ExePath, "mqtt.config")))
+                {
+
+                    HWInfoTask = Task.Run(async () =>
+                    {
+                        var result = await MQTT.Connect();
+
+                        Log.Info("HWInfo task started");
+
+                        if (HWInfo.SensorData.Any())
+                        {
+
+                            foreach (var sensor in HWInfo.SensorData)
+                            {
+                                foreach (var element in sensor.Value.Elements)
+                                {
+                                    var mqttValue = JsonConvert.SerializeObject(new HWInfo.MQTTDiscoveryObj
+                                    {
+                                        device_class = element.Value.DeviceClass,
+                                        name = element.Value.Name,
+                                        state_topic =
+                                            $"homeassistant/{element.Value.Component}/{element.Value.Node}/state",
+                                        unit_of_measurement = element.Value.Unit,
+                                        value_template = "{{ value_json.value}}",
+                                        unique_id = element.Value.Node,
+                                        state_class = "measurement"
+                                    }, new JsonSerializerSettings
+                                    {
+                                        NullValueHandling = NullValueHandling.Ignore
+                                    });
+
+                                    var task = Task.Run<bool>(async () =>
+                                        await MQTT.Publish(
+                                            $"homeassistant/{element.Value.Component}/{element.Value.Node}/config",
+                                            mqttValue));
+
+                                }
+                            }
+
+                            while (true)
+                            {
+                                if (hwInfoToken.IsCancellationRequested)
+                                {
+                                    hwInfoToken.ThrowIfCancellationRequested();
+                                }
+
+                                HWInfo.ReadMem("HWINFO.INC");
+ 
+                                foreach (var sensor in HWInfo.SensorData)
+                                {
+                                    foreach (var element in sensor.Value.Elements)
+                                    {
+                                        var mqttValue = JsonConvert.SerializeObject(new HWInfo.MQTTStateObj
+                                            {
+                                                value = element.Value.NumericValue
+                                            });
+
+                                        var task = Task.Run<bool>(async () => await MQTT.Publish($"homeassistant/{element.Value.Component}/{element.Value.Node}/state", mqttValue));
+                                    }
+
+                                }
+
+                                //!!!FipHandler.RefreshHWInfoPages();
+
+                                await Task.Delay(5 * 1000, _hwInfoTokenSource.Token); // repeat every 5 seconds
+                            }
+                        }
+
+                    }, hwInfoToken);
+                }
+
             });
 
         }
@@ -264,6 +351,24 @@ protected override void OnExit(ExitEventArgs e)
             }
 
 
+
+            _hwInfoTokenSource.Cancel();
+
+            var hwInfoToken = _hwInfoTokenSource.Token;
+
+            try
+            {
+                HWInfoTask?.Wait(hwInfoToken);
+            }
+            catch (OperationCanceledException)
+            {
+                Log.Info("HWINFO background task ended");
+            }
+            finally
+            {
+                _hwInfoTokenSource.Dispose();
+            }
+
             Log.Info("exiting");
 
             base.OnExit(e);

fipha/ChartCircularBuffer.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace fipha
+{
+    public class ChartCircularBuffer
+    {
+        private readonly LinkedList<float> _buffer = new LinkedList<float>();
+        private int _maxItemCount = 1000;
+        private HWInfo.SENSOR_TYPE _sensorType;
+        private string _unit;
+        private float _minv;
+        private float _maxv;
+
+        public ChartCircularBuffer(HWInfo.SENSOR_TYPE sensorType, string unit)
+        {
+            _sensorType = sensorType;
+            _unit = unit;
+        }
+
+        public void Put(float item)
+        {
+            lock (_buffer)
+            {
+                _buffer.AddFirst(item);
+                if (_buffer.Count > _maxItemCount)
+                {
+                    _buffer.RemoveLast();
+                }
+            }
+        }
+
+        public string MinV()
+        {
+            return _minv == _maxv ? "" : HWInfo.NumberFormat(_sensorType, _unit, _minv);
+        }
+
+        public string MaxV()
+        {
+            return _minv == _maxv ? "" : HWInfo.NumberFormat(_sensorType, _unit, _maxv);
+        }
+
+        public PointF[] Read(int chartImageDisplayWidth, int chartImageDisplayHeight)
+        {
+            lock (_buffer)
+            {
+                var c = _buffer.Count;
+                if (c > chartImageDisplayWidth)
+                {
+                    c = chartImageDisplayWidth;
+                }
+
+                var minv = (float)1e10;
+                var maxv = (float)-1e10;
+
+                var b = new PointF[c];
+
+                var node = _buffer.First;
+
+                for (var index = 0; index < c; index++)
+                {
+                    var y = node.Value;
+
+                    if (y < minv) minv = y;
+                    if (y > maxv) maxv = y;
+
+                    node = node.Next;
+                }
+
+                var range = maxv - minv;
+
+                if (range > 0)
+                {
+                    minv -= (float) (range * 0.1);
+                    maxv += (float) (range * 0.1);
+                }
+                else
+                {
+                    minv -= (float)(maxv * 0.1);
+                    maxv += (float)(maxv * 0.1);
+                }
+
+                if (minv < 0) minv = 0;
+
+                range = maxv - minv;
+
+                if (range > 0)
+                {
+                    var yFactor = chartImageDisplayHeight / range;
+
+                    node = _buffer.First;
+
+                    for (var index = 0; index < c; index++)
+                    {
+                        var y = node.Value;
+
+                        var x = chartImageDisplayWidth - 1 - index;
+
+                        b[index] = new PointF(x, chartImageDisplayHeight - (y - minv) * yFactor);
+
+                        node = node.Next;
+                    }
+
+                }
+
+                _minv = minv;
+                _maxv = maxv;
+
+                return b;
+            }
+        }
+    }
+}