WIP

TestApp/Program.cs

@@ -1,55 +1,118 @@
-using NModbus;
-using System.Net.Sockets;
+using System.Reflection;
+using TestApp.Configuration;
+using TestApp.Driver;
 
 namespace TestApp
 {
     internal class Program
     {
+        private static ConfigurationManager _ConfigurationManager;
+        private static IChargerDriver? _Driver;
         private static EnergyManager _EnergyManager;
+        private static ProcessVariable _ProcessVariable;
+        private static PidController _PidController;
 
 
         static async Task Main(string[] args)
         {
+            _ConfigurationManager = new ConfigurationManager();
+            _ConfigurationManager.SettingsChanged += OnSettingsChanged;
+            try
+            {
+                OnSettingsChanged(_ConfigurationManager, _ConfigurationManager.Settings);
+            } catch (Exception ex)
+            {
+                Console.WriteLine($"Error applying settings: {ex.Message}");
+            }
+
             _EnergyManager = await EnergyManager.Create();
 
             while (true)
             {
                 try
                 {
-                    ConnectToModBus();
-                }
-                catch (Exception ex)
+                    // TODO I1, I2, I3 von Wallbox mit I1-3 von Zähler per Kombinatorik max vom Haus ausrechnen
+                    // newLoadingCurrent = maxSicherung - maxHaus
+                    var measurement = _EnergyManager.GetValue(_ProcessVariable);
+                    var newLoadingCurrent = _PidController.Update(measurement);
+                    //if (newLoadingCurrent < 6) { newLoadingCurrent = 0; }
+                    _Driver?.SetLoadingCurrent(newLoadingCurrent);
+                } catch (Exception ex)
                 {
-                    Console.WriteLine($"Error connecting to ModBus slave: {ex.Message}");
-                    Thread.Sleep(5000);
+                    Console.WriteLine($"Error in main loop: {ex.Message}");
                 }
+                Thread.Sleep(1000);
             }
         }
 
-        private static void ConnectToModBus()
+        private static void OnSettingsChanged(object? sender, Settings settings)
         {
-            var factory = new ModbusFactory();
-            var tcpClient = new TcpClient("192.168.188.21", 502);
-            var master = factory.CreateMaster(tcpClient);
-            Console.WriteLine("ModBus TCP Connection established!");
+            UpdateDriverSettings(settings);
+            UpdateControllerSettings(settings);
+        }
 
-            while (tcpClient.Connected)
+        private static void UpdateDriverSettings(Settings settings) {
+            var dirverName = settings.ChargerDriver ?? Settings.DEFAULT_CHARGER_DRIVER;
+
+            var fullDriverTypeName = "TestApp.Driver." + dirverName;
+            var driverType = Assembly.GetExecutingAssembly().GetType(fullDriverTypeName);
+            if (driverType is null)
             {
-                try
-                {
-                    var currentWirkleistung = _EnergyManager.ActivePowerPositive; 
-
-                    ushort input = master.ReadHoldingRegisters(1, 1000, 1)[0];
-                    ushort output = (ushort)(input + currentWirkleistung);
-                    master.WriteMultipleRegisters(1, 1100, new ushort[] { output });
-                    Thread.Sleep(100);
-                }
-                catch (Exception e)
-                {
-                    Console.WriteLine($"Error updating ModBus registers: {e.Message}");
-                    Thread.Sleep(1000);
-                }
+                throw new ArgumentException($"Charger driver type '{dirverName}' not found!");
             }
+
+            if (_Driver is null || !_Driver.GetType().Equals(driverType))
+            {
+                var newDriverObject = Activator.CreateInstance(driverType);
+                if (newDriverObject is null)
+                {
+                    throw new InvalidOperationException("Could not instantiate driver!");
+                }
+                if (newDriverObject is not IChargerDriver newDriver)
+                {
+                    throw new InvalidOperationException("New driver does not implement IChargerDriver!");
+                }
+
+                if (_Driver is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+                _Driver = newDriver;
+            }
+
+            _Driver.HostAddress = settings.ChargerAddress ?? Settings.DEFAULT_CHARGER_ADDRESS;
+            _Driver.Port = settings.ChargerPort ?? Settings.DEFAULT_CHARGER_PORT;
+        }
+
+        private static void UpdateControllerSettings(Settings settings)
+        {
+            var allModeSettings = settings.ModeSettings ?? Array.Empty<ModeSettings>();
+            if (!allModeSettings.Any()) {
+                allModeSettings = new ModeSettings[]{
+                    new ModeSettings() {
+                        ProcessVariable = ProcessVariable.ActivePowerPositive,
+                        SetPoint = 0,
+                        PositivePid = new PidSetting(),
+                        NegativePid = new PidSetting(),
+                    }
+                };
+            }
+
+            var mode = settings.Mode;
+            if (mode < 0) { mode = 0; }
+            if (mode >= allModeSettings.Length) { mode = allModeSettings.Length - 1; }
+
+            var modeSetting = allModeSettings[mode];
+
+            if (_ProcessVariable != modeSetting.ProcessVariable)
+            {
+                _PidController = new PidController();
+                _ProcessVariable = modeSetting.ProcessVariable;
+            }
+
+            _PidController.SetPoint = modeSetting.SetPoint;
+            _PidController.PositiveSettings = modeSetting.PositivePid ?? new PidSetting();
+            _PidController.NegativeSettings = modeSetting.NegativePid ?? new PidSetting();
         }
     }
 }