Settings ui and service

Controllers/SettingsController.cs

@@ -0,0 +1,75 @@
+using Microsoft.AspNetCore.Mvc;
+using System.IO;
+using System.Text.Json;
+
+[ApiController]
+[Route("api/settings")]
+public class SettingsController : ControllerBase
+{
+    private const string SettingsFilePath = "settings.json";
+
+    [HttpGet]
+    public ActionResult<Settings> GetSettings()
+    {
+        if (!System.IO.File.Exists(SettingsFilePath))
+        {
+            return new Settings();
+        }
+
+        var json = System.IO.File.ReadAllText(SettingsFilePath);
+        return JsonSerializer.Deserialize<Settings>(json);
+    }
+
+    [HttpPost]
+    public IActionResult SaveSettings([FromBody] Settings settings)
+    {
+        var json = JsonSerializer.Serialize(settings);
+        System.IO.File.WriteAllText(SettingsFilePath, json);
+        return Ok();
+    }
+}
+
+public class Settings
+{
+    public Updating Updating { get; set; }
+    public Scanning Scanning { get; set; }
+    public Counting Counting { get; set; }
+    public Filtering Filtering { get; set; }
+    public Calibration Calibration { get; set; }
+}
+
+public class Updating
+{
+    public bool AutoUpdate { get; set; }
+    public bool PreRelease { get; set; }
+}
+
+public class Scanning
+{
+    public int? ForgetAfterMs { get; set; }
+}
+
+public class Counting
+{
+    public string IdPrefixes { get; set; }
+    public double? StartCountingDistance { get; set; }
+    public double? StopCountingDistance { get; set; }
+    public int? IncludeDevicesAge { get; set; }
+}
+
+public class Filtering
+{
+    public string IncludeIds { get; set; }
+    public string ExcludeIds { get; set; }
+    public double? MaxReportDistance { get; set; }
+    public double? EarlyReportDistance { get; set; }
+    public int? SkipReportAge { get; set; }
+}
+
+public class Calibration
+{
+    public int? RssiAt1m { get; set; }
+    public int? RssiAdjustment { get; set; }
+    public double? AbsorptionFactor { get; set; }
+    public int? IBeaconRssiAt1m { get; set; }
+}

src/Controllers/DeviceController.cs

@@ -19,22 +19,26 @@
             _state = state;
         }
 
-        [HttpGet("{id}")]
-        public DeviceSettingsDetails Get(string id)
+        [HttpGet("{id}/details")]
+        public async Task<IList<KeyValuePair<string, string>>> Details(string id)
         {
-            var deviceSettings = _deviceSettingsStore.Get(id);
-            var details = new List<KeyValuePair<string, string>>();
-            if (deviceSettings?.Id != null && _state.Devices.TryGetValue(deviceSettings.Id, out var device))
-                details.AddRange(device.GetDetails());
-            return new DeviceSettingsDetails(deviceSettings ?? new DeviceSettings { Id = id, OriginalId = id }, details);
+            if (_state.Devices.TryGetValue(id, out var device))
+                return device.GetDetails().ToList();
+            return new List<KeyValuePair<string, string>>();
         }
 
-        [HttpPut("{id}")]
+        [HttpGet("{id}/settings")]
+        public Task<DeviceSettings?> Get(string id)
+        {
+            var settings = _deviceSettingsStore.Get(id);
+            settings ??= new DeviceSettings { OriginalId = id, Id = id };
+            return Task.FromResult(settings);
+        }
+
+        [HttpPut("{id}/settings")]
         public async Task Set(string id, [FromBody] DeviceSettings value)
         {
             await _deviceSettingsStore.Set(id, value);
         }
     }
-
-    public readonly record struct DeviceSettingsDetails(DeviceSettings? settings, IList<KeyValuePair<string, string>> details);
 }

src/Controllers/NodeController.cs

@@ -8,18 +8,18 @@ namespace ESPresense.Controllers;
 [ApiController]
 public class NodeController(NodeSettingsStore nodeSettingsStore, State state) : ControllerBase
 {
-    [HttpGet("{id}")]
+    [HttpGet("{id}/settings")]
     public NodeSettingsDetails Get(string id)
     {
         var nodeSettings = nodeSettingsStore.Get(id);
         var details = new List<KeyValuePair<string, string>>();
         if (nodeSettings?.Id != null && state.Nodes.TryGetValue(id, out var node))
             details.AddRange(node.GetDetails());
-        return new NodeSettingsDetails(nodeSettings ?? new NodeSettings(id), details);
+        return new NodeSettingsDetails(nodeSettings ?? new Models.NodeSettings(id), details);
     }
 
-    [HttpPut("{id}")]
-    public Task Set(string id, [FromBody] NodeSettings ds)
+    [HttpPut("{id}/settings")]
+    public Task Set(string id, [FromBody] Models.NodeSettings ds)
     {
         return nodeSettingsStore.Set(id, ds);
     }
@@ -36,5 +36,5 @@ public async Task Restart(string id)
         await nodeSettingsStore.Restart(id);
     }
 
-    public readonly record struct NodeSettingsDetails(NodeSettings? settings, IList<KeyValuePair<string, string>> details);
+    public readonly record struct NodeSettingsDetails(Models.NodeSettings? settings, IList<KeyValuePair<string, string>> details);
 }

src/Controllers/StateController.cs

@@ -66,9 +66,9 @@
             {
                 var rxNs = _nsd.Get(rxId);
                 var rxM = txM.GetOrAdd(rx.Rx?.Name ?? rxId);
-                if (txNs.TxRefRssi is not null) rxM["tx_ref_rssi"] = txNs.TxRefRssi.Value;
-                if (rxNs.RxAdjRssi is not null) rxM["rx_adj_rssi"] = rxNs.RxAdjRssi.Value;
-                if (rxNs.Absorption is not null) rxM["absorption"] = rxNs.Absorption.Value;
+                if (txNs.Calibration.TxRefRssi is not null) rxM["tx_ref_rssi"] = txNs.Calibration.TxRefRssi.Value;
+                if (rxNs.Calibration.RxAdjRssi is not null) rxM["rx_adj_rssi"] = rxNs.Calibration.RxAdjRssi.Value;
+                if (rxNs.Calibration.Absorption is not null) rxM["absorption"] = rxNs.Calibration.Absorption.Value;
                 rxM["expected"] = rx.Expected;
                 rxM["actual"] = rx.Distance;
                 rxM["rssi"] = rx.Rssi;
@@ -145,9 +145,9 @@
             foreach (var node in _state.Nodes.Values)
             {
                 var nodeSettings = _nsd.Get(node.Id);
                 nodeSettings.TxRefRssi = null;
                 nodeSettings.RxAdjRssi = null;
                 nodeSettings.Absorption = null;
                 await _nsd.Set(node.Id, nodeSettings);
             }
 

src/Models/NodeSettings.cs

@@ -11,28 +11,62 @@ public class NodeSettings(string id)
     [StringLength(64)]
     public string? Id { get; set; } = id;
 
-    [JsonPropertyName("absorption")]
-    [JsonProperty("absorption")]
-    [Range(1, 10)]
-    public double? Absorption { get; set; }
+    public UpdatingSettings Updating { get; set; } = new UpdatingSettings();
+    public ScanningSettings Scanning { get; set; } = new ScanningSettings();
+    public CountingSettings Counting { get; set; } = new CountingSettings();
+    public FilteringSettings Filtering { get; set; } = new FilteringSettings();
+    public CalibrationSettings Calibration { get; set; } = new CalibrationSettings();
 
-    [JsonPropertyName("rx_adj_rssi")]
-    [JsonProperty("rx_adj_rssi")]
-    [Range(-127, 128)]
-    public int? RxAdjRssi { get; set; }
+    public NodeSettings Clone()
+    {
+        return new NodeSettings(id)
+        {
+            Updating = Updating.Clone(),
+            Scanning = Scanning.Clone(),
+            Counting = Counting.Clone(),
+            Filtering = Filtering.Clone(),
+            Calibration = Calibration.Clone()
+        };
+    }
+}
 
-    [JsonPropertyName("tx_ref_rssi")]
-    [JsonProperty("tx_ref_rssi")]
-    [Range(-127, 128)]
-    public int? TxRefRssi { get; set; }
+public class UpdatingSettings
+{
+    public bool? AutoUpdate { get; set; }
+    public bool? PreRelease { get; set; }
+    public UpdatingSettings Clone() => (UpdatingSettings)MemberwiseClone();
+}
 
-    [JsonPropertyName("max_distance")]
-    [JsonProperty("max_distance")]
-    [Range(0, 100)]
+public class ScanningSettings
+{
+    public int? ForgetAfterMs { get; set; }
+    public ScanningSettings Clone() => (ScanningSettings)MemberwiseClone();
+}
+
+public class CountingSettings
+{
+    public string? IdPrefixes { get; set; }
+    public double? StartCountingDistance { get; set; }
+    public double? StopCountingDistance { get; set; }
+    public int? IncludeDevicesAge { get; set; }
+    public CountingSettings Clone() => (CountingSettings)MemberwiseClone();
+}
+
+public class FilteringSettings
+{
+    public string? IncludeIds { get; set; }
+    public string? ExcludeIds { get; set; }
     public double? MaxDistance { get; set; }
+    public double? EarlyReportDistance { get; set; }
+    public int? SkipReportAge { get; set; }
+    public FilteringSettings Clone() => (FilteringSettings)MemberwiseClone();
+}
 
-    public NodeSettings Clone()
-    {
-        return (NodeSettings)MemberwiseClone();
-    }
+public class CalibrationSettings
+{
+    public int? RssiAt1m { get; set; }
+    public int? RxAdjRssi { get; set; }
+    public double? Absorption { get; set; }
+    public int? TxRefRssi { get; set; }
+    public CalibrationSettings Clone() => (CalibrationSettings)MemberwiseClone();
 }

src/Models/OptimizationResults.cs

@@ -20,9 +20,9 @@ public double Evaluate(List<OptimizationSnapshot> oss, NodeSettingsStore nss)
                 var rx = nss.Get(m.Rx.Id);
 
                 RxNodes.TryGetValue(m.Rx.Id, out var pv);
-                double rxAdjRssi = pv?.RxAdjRssi ?? rx.RxAdjRssi ?? 0;
-                double txPower = tx.TxRefRssi ?? -59;
-                double pathLossExponent = pv?.Absorption ?? rx.Absorption ?? 3;
+                double rxAdjRssi = pv?.RxAdjRssi ?? rx.Calibration.RxAdjRssi ?? 0;
+                double txPower = tx.Calibration.TxRefRssi ?? -59;
+                double pathLossExponent = pv?.Absorption ?? rx.Calibration.Absorption ?? 3;
                 double distance = m.Rx.Location.DistanceTo(m.Tx.Location);
                 double predictedRssi = txPower + rxAdjRssi - 10 * pathLossExponent * Math.Log10(distance);
 

src/Optimizers/OptimizationRunner.cs

@@ -74,8 +74,8 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
                         Log.Information("Optimizer set {0,-20} to Absorption: {1:0.00} RxAdj: {2:00} Error: {3}", id, result.Absorption, result.RxAdjRssi, result.Error);
                         var a = _nsd.Get(id);
                         if (optimization == null) continue;
-                        if (result.Absorption != null && result.Absorption > optimization.AbsorptionMin && result.Absorption < optimization.AbsorptionMax) a.Absorption = result.Absorption;
-                        if (result.RxAdjRssi != null && result.RxAdjRssi > optimization.RxAdjRssiMin && result.RxAdjRssi < optimization.RxAdjRssiMax) a.RxAdjRssi = result.RxAdjRssi == null ? 0 : (int?)Math.Round(result.RxAdjRssi.Value);
+                        if (result.Absorption != null && result.Absorption > optimization.AbsorptionMin && result.Absorption < optimization.AbsorptionMax) a.Calibration.Absorption = result.Absorption;
+                        if (result.RxAdjRssi != null && result.RxAdjRssi > optimization.RxAdjRssiMin && result.RxAdjRssi < optimization.RxAdjRssiMax) a.Calibration.RxAdjRssi = result.RxAdjRssi == null ? 0 : (int?)Math.Round(result.RxAdjRssi.Value);
                         await _nsd.Set(id, a);
                     }
 

src/Services/NodeSettingsStore.cs

@@ -5,22 +5,23 @@
 {
     public class NodeSettingsStore(MqttCoordinator mqtt, ILogger<NodeSettingsStore> logger) : BackgroundService
     {
-        private readonly ConcurrentDictionary<string, NodeSettings> _storeById = new();
+        private readonly ConcurrentDictionary<string, Models.NodeSettings> _storeById = new();
 
-        public NodeSettings Get(string id)
+        public Models.NodeSettings Get(string id)
         {
-            return _storeById.TryGetValue(id, out var ns) ? ns.Clone() : new NodeSettings(id);
+            return _storeById.TryGetValue(id, out var ns) ? ns.Clone() : new Models.NodeSettings(id);
         }
 
-        public async Task Set(string id, NodeSettings ds)
+        public async Task Set(string id, Models.NodeSettings ns)
         {
-            var old = Get(id);
-            if (ds.Absorption == null || ds.Absorption != old.Absorption)
-                await mqtt.EnqueueAsync($"espresense/rooms/{id}/absorption/set", $"{ds.Absorption:0.00}");
-            if (ds.RxAdjRssi == null || ds.RxAdjRssi != old.RxAdjRssi)
-                await mqtt.EnqueueAsync($"espresense/rooms/{id}/rx_adj_rssi/set", $"{ds.RxAdjRssi}");
-            if (ds.TxRefRssi == null || ds.TxRefRssi != old.TxRefRssi)
-                await mqtt.EnqueueAsync($"espresense/rooms/{id}/tx_ref_rssi/set", $"{ds.TxRefRssi}");
+            var oCs = Get(id).Calibration;
+            var nCs = ns.Calibration;
+            if (nCs.Absorption != null && nCs.Absorption != oCs.Absorption)
+                await mqtt.EnqueueAsync($"espresense/rooms/{id}/absorption/set", $"{nCs.Absorption:0.00}");
+            if (nCs.RxAdjRssi != null && nCs.RxAdjRssi != oCs.RxAdjRssi)
+                await mqtt.EnqueueAsync($"espresense/rooms/{id}/rx_adj_rssi/set", $"{nCs.RxAdjRssi}");
+            if (nCs.TxRefRssi != null && nCs.TxRefRssi != oCs.TxRefRssi)
+                await mqtt.EnqueueAsync($"espresense/rooms/{id}/tx_ref_rssi/set", $"{nCs.TxRefRssi}");
         }
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -29,20 +30,20 @@
             {
                 try
                 {
                     var ns = Get(arg.NodeId);
                     switch (arg.Setting)
                     {
                         case "absorption":
-                            ns.Absorption = double.Parse(arg.Payload);
+                            ns.Calibration.Absorption = double.Parse(arg.Payload);
                             break;
                         case "rx_adj_rssi":
-                            ns.RxAdjRssi = int.Parse(arg.Payload);
+                            ns.Calibration.RxAdjRssi = int.Parse(arg.Payload);
                             break;
                         case "tx_ref_rssi":
-                            ns.TxRefRssi = int.Parse(arg.Payload);
+                            ns.Calibration.TxRefRssi = int.Parse(arg.Payload);
                             break;
                         case "max_distance":
-                            ns.MaxDistance = double.Parse(arg.Payload);
+                            ns.Filtering.MaxDistance = double.Parse(arg.Payload);
                             break;
                         default:
                             return Task.CompletedTask;