Innovenergy_trunk/csharp/App/SaliMax/src/Program.cs

using System.Runtime.InteropServices;
using Flurl.Http;
using InnovEnergy.App.SaliMax.Ess;
using InnovEnergy.App.SaliMax.SaliMaxRelays;
using InnovEnergy.App.SaliMax.System;
using InnovEnergy.App.SaliMax.SystemConfig;
using InnovEnergy.App.SaliMax.VirtualDevices;
using InnovEnergy.Lib.Devices.AMPT;
using InnovEnergy.Lib.Devices.Battery48TL;
using InnovEnergy.Lib.Devices.EmuMeter;
using InnovEnergy.Lib.Devices.Trumpf.SystemControl;
using InnovEnergy.Lib.Devices.Trumpf.SystemControl.DataTypes;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertAc;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertAc.DataTypes;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertDc;
using InnovEnergy.Lib.Protocols.Modbus.Channels;
using InnovEnergy.Lib.Time.Unix;
using InnovEnergy.Lib.Units;
using InnovEnergy.Lib.Units.Power;
using InnovEnergy.Lib.Utils;
using static InnovEnergy.Lib.Devices.Trumpf.SystemControl.DataTypes.SystemConfig;
using AcPower = InnovEnergy.Lib.Units.Composite.AcPower;
using Exception = System.Exception;

#pragma warning disable IL2026

namespace InnovEnergy.App.SaliMax;

internal static class Program
{
    [DllImport("libsystemd.so.0")]
    private static extern Int32 sd_notify(Int32 unsetEnvironment, String state);
    
    private const UInt32 UpdateIntervalSeconds = 2;
    
    private static readonly Byte[] BatteryNodes = { 2, 3, 4, 5, 6 };
    private const String BatteryTty     = "/dev/ttyUSB0";
    
    // private const String RelaysIp       = "10.0.1.1"; // "192.168.1.242";  
    // private const String TruConvertAcIp = "10.0.2.1"; // "192.168.1.2";    
    // private const String TruConvertDcIp = "10.0.3.1"; // "192.168.1.3";    
    // private const String GridMeterIp    = "10.0.4.1"; // "192.168.1.241";  
    // private const String InternalMeter  = "10.0.4.2"; // "192.168.1.241";  
    // private const String AmptIp         = "10.0.5.1"; // "192.168.1.249";  
    
    
    private static readonly TcpChannel TruConvertAcChannel = new TcpChannel("localhost", 5001);
    private static readonly TcpChannel TruConvertDcChannel = new TcpChannel("localhost", 5002);
    private static readonly TcpChannel GridMeterChannel    = new TcpChannel("localhost", 5003);
    private static readonly TcpChannel AcOutLoadChannel    = new TcpChannel("localhost", 5004);
    private static readonly TcpChannel AmptChannel         = new TcpChannel("localhost", 5005);
    private static readonly TcpChannel RelaysChannel       = new TcpChannel("localhost", 5006);
    private static readonly TcpChannel BatteriesChannel    = new TcpChannel("localhost", 5007);

    
    private static readonly S3Config S3Config = new S3Config
    {
        Bucket      = "saliomameiringen",
        Region      = "sos-ch-dk-2",
        Provider    = "exo.io",
        ContentType = "text/plain; charset=utf-8",
        Key         = "EXO2bf0cbd97fbfa75aa36ed46f",
        Secret      = "Bn1CDPqOG-XpDSbYjfIJxojcHTm391vZTc8z8l_fEPs"
    };
        
    public static async Task Main(String[] args)
    {
        while (true)
        {
            try
            {
                await Run();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }    
        }
    }

    private static async Task Run()
    {
        Console.WriteLine("Starting SaliMax");
        
        // Send the initial "service started" message to systemd
        var sdNotifyReturn = sd_notify(0, "READY=1");

        var battery48TlDevices = BatteryNodes
                                .Select(n => new Battery48TlDevice(BatteriesChannel, n))
                                .ToList();
        
        var batteryDevices      = new Battery48TlDevices(battery48TlDevices);
        var acDcDevices         = new TruConvertAcDcDevices(TruConvertAcChannel);
        var dcDcDevices         = new TruConvertDcDcDevices(TruConvertDcChannel);
        var gridMeterDevice     = new EmuMeterDevice(GridMeterChannel);
        var acIslandLoadMeter   = new EmuMeterDevice(AcOutLoadChannel); 
        var amptDevice          = new AmptDevices(AmptChannel);
        var saliMaxRelaysDevice = new RelaysDevice(RelaysChannel);

        StatusRecord ReadStatus()
        {
            var acDc           = acDcDevices.Read();
            var dcDc           = dcDcDevices.Read();
            var battery        = batteryDevices.Read();
            var relays         = saliMaxRelaysDevice.Read();
            var loadOnAcIsland = acIslandLoadMeter.Read();
            var gridMeter      = gridMeterDevice.Read();
            var pvOnDc         = amptDevice.Read();

            
            var pvOnAcGrid   = AcDevicePower.Null; 
            var pvOnAcIsland = AcDevicePower.Null;
            var loadOnAcGrid = pvOnAcGrid.Power +
                               pvOnAcIsland.Power +
                               (gridMeter is null ? AcPower.Null : gridMeter.Ac.Power) +
                               (loadOnAcIsland is null ? AcPower.Null : loadOnAcIsland.Ac.Power);


            var dcPowers = new[]
            {
                acDc?.Dc.Power.Value,
                pvOnDc?.Dc?.Power.Value,
                dcDc?.Dc.Link.Power.Value
            };

            var loadOnDc = dcPowers.Any(p => p is null)
                         ? null
                         : new DcDevicePower { Power = dcPowers.Sum(p => p)!} ;
            
            
            return new StatusRecord
            {
                AcDc           = acDc ?? AcDcDevicesRecord.Null,
                DcDc           = dcDc ?? DcDcDevicesRecord.Null,
                Battery        = battery ?? Battery48TlRecords.Null,
                Relays         = relays,
                GridMeter      = gridMeter,
                
                PvOnAcGrid     = pvOnAcGrid,
                PvOnAcIsland   = pvOnAcIsland,
                PvOnDc         = pvOnDc ?? AmptStatus.Null,
                
                LoadOnAcGrid   = new AcDevicePower { Power = -loadOnAcGrid },
                LoadOnAcIsland = loadOnAcIsland,
                LoadOnDc       = loadOnDc,
                
                Config         = Config.Load() // load from disk every iteration, so config can be changed while running
            };
        }
        
        void WriteControl(StatusRecord r)
        {
            if (r.Relays is not null)
                saliMaxRelaysDevice.Write(r.Relays);
            
            acDcDevices.Write(r.AcDc);
            dcDcDevices.Write(r.DcDc);
        }


        Console.WriteLine("press ctrl-C to stop");
        
        while (true)
        {
            sd_notify(0, "WATCHDOG=1");
            
            var t = UnixTime.FromTicks(UnixTime.Now.Ticks / 2 * 2);
            
            //t.ToUtcDateTime().WriteLine();
            
            var record = ReadStatus();
            
            PrintTopology(record);

            if (record.Relays is not null)
                record.Relays.ToCsv().WriteLine();    
            
            
            record.ControlConstants();

            record.ControlSystemState();

            Console.WriteLine($"{record.StateMachine.State}: {record.StateMachine.Message}");

            var essControl = record.ControlEss().WriteLine();

            record.EssControl = essControl;

            record.AcDc.SystemControl.ApplyDefaultSettingsAc();
            record.DcDc.SystemControl.ApplyDefaultSettingsDc();
            
            DistributePower(record, essControl);

            WriteControl(record);
            
            await UploadCsv(record, t);

            record.Config.Save();
      
            "===========================================".WriteLine();
        }
        // ReSharper disable once FunctionNeverReturns
    }

    private static void PrintTopology(StatusRecord s)
    {
        // Power Measurement Values
        var gridPower            = s.GridMeter!.Ac.Power.Active;
        var inverterPower        = s.AcDc.Ac.Power.Active;
        var islandLoadPower      = s.LoadOnAcIsland is null ? 0 : s.LoadOnAcIsland.Ac.Power.Active;
        var dcBatteryPower       = s.DcDc.Dc.Battery.Power;
        var dcdcPower            = s.DcDc.Dc.Link.Power;
        var pvOnDcPower          = s.PvOnDc.Dc!.Power.Value;
        
        // Power Calculated Values
        var islandToGridBusPower = inverterPower + islandLoadPower;
        var gridLoadPower        = gridPower     - islandToGridBusPower; 
    
         var gridPowerByPhase          = s.GridMeter.Ac.L1.Power.Active.ToString()+ "," + s.GridMeter.Ac.L2.Power.Active + s.GridMeter.Ac.L3.Power.Active;
        //var inverterPowerByPhase     = new ActivePower[(Int32)s.AcDc.Ac.L1.Power.Active, (Int32)s.AcDc.Ac.L2.Power.Active, (Int32)s.AcDc.Ac.L3.Power.Active];
       
        // Voltage Measurement Values
        //var inverterVoltage             = new Voltage [(Int32)s.AcDc.Ac.L1.Voltage, (Int32)s.AcDc.Ac.L2.Voltage, (Int32)s.AcDc.Ac.L3.Voltage]; 
        //var dcLinkVoltage               = s.DcDc.Dc.Link.Voltage;
        var dc48Voltage               = s.DcDc.Dc.Battery.Voltage;
        var batteryVoltage            = s.Battery.Dc.Voltage;
        var batterySoc                = s.Battery.Soc;
        var batteryCurrent            = s.Battery.Dc.Current;
        var batteryTemp               = s.Battery.Temperature;

        gridPowerByPhase.Split(",");
        var gridBusColumn           =  ColumnBox("Pv", "Grid Bus",   "Load"  , "Voltage", gridLoadPower); 
        var islandBusColumn         =  ColumnBox("Pv", "Island Bus", "Load"  , "Voltage", islandLoadPower);
        var dcBusColumn             =  ColumnBox("Pv", "Dc Bus",     "Load"  , "DC Link V", 0, pvOnDcPower);
        var gridBusFlow             = Flow.Horizontal(gridPower);
        var flowGridBusToIslandBus  = Flow.Horizontal((ActivePower)islandToGridBusPower);
        var flowIslandBusToInverter = Flow.Horizontal(inverterPower);
        var flowInverterToDcBus     = Flow.Horizontal(inverterPower);
        var flowDcBusToDcDc         = Flow.Horizontal(-dcdcPower);
        var flowDcDcToBattery       = Flow.Horizontal(-dcBatteryPower);

        var gridBox     = TextBlock.AlignLeft("none","none", "none").TitleBox("Grid");
        var inverterBox = TextBlock.AlignLeft("none","none", "none").TitleBox("Inverter");
        var dcDcBox     = TextBlock.AlignLeft(dc48Voltage).TitleBox("DC/DC");
        var batteryBox  = TextBlock.AlignLeft(batteryVoltage, batterySoc, batteryCurrent, batteryTemp).TitleBox("Battery");


        
        var totalBoxes = TextBlock.CenterVertical(gridBox,
                                                  gridBusFlow,
                                                  gridBusColumn, 
                                                  flowGridBusToIslandBus, 
                                                  islandBusColumn, 
                                                  flowIslandBusToInverter, 
                                                  inverterBox,
                                                  flowInverterToDcBus,
                                                  dcBusColumn,
                                                  flowDcBusToDcDc,
                                                  dcDcBox,
                                                  flowDcDcToBattery,
                                                  batteryBox);

        totalBoxes.WriteLine();
    }

    private static TextBlock ColumnBox(String pvTitle, String busTitle, String loadTitle, String dataBox)
    {
        return ColumnBox(pvTitle, busTitle, loadTitle, dataBox, 0);
    }

    private static TextBlock ColumnBox(String pvTitle, String busTitle, String loadTitle, String dataBox, ActivePower loadPower)
    {
        return ColumnBox(pvTitle, busTitle, loadTitle, dataBox, loadPower, 0);
    }

    private static TextBlock ColumnBox(String pvTitle, String busTitle, String loadTitle, String dataBox,  ActivePower loadPower, ActivePower pvPower)
    {
        var pvBox     = TextBlock.AlignLeft("").TitleBox(pvTitle);
        var pvToBus   = Flow.Vertical(pvPower);
        var busBox    = TextBlock.AlignLeft(dataBox).TitleBox(busTitle);
        var busToLoad = Flow.Vertical(loadPower);
        var loadBox   = TextBlock.AlignLeft("").TitleBox(loadTitle);

        return TextBlock.CenterHorizontal(pvBox, pvToBus, busBox, busToLoad, loadBox);
    }

    private static async Task<T?> ResultOrNull<T>(this Task<T> task)
    {
        if (task.Status == TaskStatus.RanToCompletion)
            return await task;

        return default;
    }

    private static void ControlConstants(this StatusRecord r)
    {
        var inverters = r.AcDc.Devices;
        
        inverters.ForEach(d => d.Control.Dc.MaxVoltage       = r.Config.MaxDcBusVoltage);
        inverters.ForEach(d => d.Control.Dc.MinVoltage       = r.Config.MinDcBusVoltage);
        inverters.ForEach(d => d.Control.Dc.ReferenceVoltage = r.Config.ReferenceDcBusVoltage);
    }


    // why this is not in Controller?
    private static void DistributePower(StatusRecord record, EssControl essControl)
    {
        var nInverters = record.AcDc.Devices.Count;
        
        var powerPerInverterPhase = nInverters > 0
                                  ? AcPower.FromActiveReactive(essControl.PowerSetpoint / nInverters / 3, 0)
                                  : AcPower.Null;
        
        //var powerPerInverterPhase = AcPower.Null;
        
        record.AcDc.Devices.ForEach(d =>
        {
            d.Control.Ac.PhaseControl = PhaseControl.Asymmetric;
            d.Control.Ac.Power.L1 = powerPerInverterPhase;
            d.Control.Ac.Power.L2 = powerPerInverterPhase;
            d.Control.Ac.Power.L3 = powerPerInverterPhase;
        });
    }

    private static void ApplyDefaultSettingsAc(this SystemControlRegisters? sc)
    {
        if (sc is null)
            return;
        
        sc.ReferenceFrame          = ReferenceFrame.Consumer;
        sc.SystemConfig            = AcDcAndDcDc;

        #if DEBUG
        sc.CommunicationTimeout    = TimeSpan.FromMinutes(2);    
        #else
        sc.CommunicationTimeout    = TimeSpan.FromSeconds(20);
        #endif
        
        sc.PowerSetPointActivation = PowerSetPointActivation.Immediate;
        sc.UseSlaveIdForAddressing = true;
        sc.SlaveErrorHandling      = SlaveErrorHandling.Relaxed;
        sc.SubSlaveErrorHandling   = SubSlaveErrorHandling.Off;
        sc.ResetAlarmsAndWarnings  = true;
    }
    
    private static void ApplyDefaultSettingsDc(this SystemControlRegisters? sc)
    {
        if (sc is null)
            return;
        
        sc.SystemConfig            = DcDcOnly;

#if DEBUG
        sc.CommunicationTimeout    = TimeSpan.FromMinutes(2);    
#else
        sc.CommunicationTimeout    = TimeSpan.FromSeconds(20);
#endif
        
        sc.PowerSetPointActivation = PowerSetPointActivation.Immediate;
        sc.UseSlaveIdForAddressing = true;
        sc.SlaveErrorHandling      = SlaveErrorHandling.Relaxed;
        sc.SubSlaveErrorHandling   = SubSlaveErrorHandling.Off;
        sc.ResetAlarmsAndWarnings  = true;
    }

    private static async Task UploadCsv(StatusRecord status, UnixTime timeStamp)
    {
        timeStamp.WriteLine();
        
        var csv      = status.ToCsv();//.WriteLine();
        var s3Path   = timeStamp + ".csv";
        var request  = S3Config.CreatePutRequest(s3Path);
        var response = await request.PutAsync(new StringContent(csv));

        //csv.WriteLine();
        //timeStamp.Ticks.WriteLine();
        
        if (response.StatusCode != 200)
        {
            Console.WriteLine("ERROR: PUT");
            var error = response.GetStringAsync();
            Console.WriteLine(error);
        }
    }

}