802 lines
31 KiB
C#
802 lines
31 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Reactive.Linq;
|
|
using System.Reactive.Threading.Tasks;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using System.Text;
|
|
using Flurl.Http;
|
|
using InnovEnergy.App.SaliMax.Devices;
|
|
using InnovEnergy.App.SaliMax.Ess;
|
|
using InnovEnergy.App.SaliMax.MiddlewareClasses;
|
|
using InnovEnergy.App.SaliMax.SaliMaxRelays;
|
|
using InnovEnergy.App.SaliMax.System;
|
|
using InnovEnergy.App.SaliMax.SystemConfig;
|
|
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.Devices.Trumpf.TruConvertDc.Control;
|
|
using InnovEnergy.Lib.Protocols.Modbus.Channels;
|
|
using InnovEnergy.Lib.Units;
|
|
using InnovEnergy.Lib.Utils;
|
|
using System.Text.Json;
|
|
using RabbitMQ.Client;
|
|
using static System.Double;
|
|
using static InnovEnergy.Lib.Devices.Trumpf.SystemControl.DataTypes.SystemConfig;
|
|
using DeviceState = InnovEnergy.App.SaliMax.Devices.DeviceState;
|
|
|
|
|
|
#pragma warning disable IL2026
|
|
|
|
namespace InnovEnergy.App.SaliMax;
|
|
|
|
internal static class Program
|
|
{
|
|
private static readonly TimeSpan UpdateInterval = TimeSpan.FromSeconds(2);
|
|
|
|
private static readonly IReadOnlyList<Byte> BatteryNodes;
|
|
|
|
private static readonly Channel TruConvertAcChannel ;
|
|
private static readonly Channel TruConvertDcChannel ;
|
|
private static readonly Channel GridMeterChannel ;
|
|
private static readonly Channel IslandBusLoadChannel;
|
|
private static readonly Channel PvOnDc ;
|
|
private static readonly Channel PvOnAcGrid ;
|
|
private static readonly Channel PvOnAcIsland ;
|
|
private static readonly Channel RelaysChannel ;
|
|
private static readonly Channel BatteriesChannel ;
|
|
|
|
//private const String VpnServerIp = "194.182.190.208";
|
|
private const String VpnServerIp = "10.2.0.11";
|
|
|
|
private static IPAddress? _controllerIpAddress;
|
|
private static UdpClient _udpListener = null!;
|
|
private static ConnectionFactory? _factory ;
|
|
private static IConnection ? _connection;
|
|
private static IModel? _channel;
|
|
private static Boolean _subscribedToQueue = false;
|
|
private static Boolean _subscribeToQueueForTheFirstTime = false;
|
|
private static SalimaxAlarmState _prevSalimaxState = SalimaxAlarmState.Green;
|
|
private static Int32 _heartBitInterval = 0;
|
|
|
|
static Program()
|
|
{
|
|
var config = Config.Load();
|
|
var d = config.Devices;
|
|
|
|
Channel CreateChannel(SalimaxDevice device) => device.DeviceState == DeviceState.Disabled
|
|
? new NullChannel()
|
|
: new TcpChannel(device);
|
|
|
|
TruConvertAcChannel = CreateChannel(d.TruConvertAcIp);
|
|
TruConvertDcChannel = CreateChannel(d.TruConvertDcIp);
|
|
GridMeterChannel = CreateChannel(d.GridMeterIp);
|
|
IslandBusLoadChannel = CreateChannel(d.IslandBusLoadMeterIp);
|
|
PvOnDc = CreateChannel(d.PvOnDc);
|
|
PvOnAcGrid = CreateChannel(d.PvOnAcGrid);
|
|
PvOnAcIsland = CreateChannel(d.PvOnAcIsland);
|
|
RelaysChannel = CreateChannel(d.RelaysIp);
|
|
BatteriesChannel = CreateChannel(d.BatteryIp);
|
|
|
|
BatteryNodes = config
|
|
.Devices
|
|
.BatteryNodes
|
|
.Select(n => n.ConvertTo<Byte>())
|
|
.ToArray(config.Devices.BatteryNodes.Length);
|
|
}
|
|
|
|
public static async Task Main(String[] args)
|
|
{
|
|
//Do not await
|
|
HourlyDataAggregationManager();
|
|
InitializeCommunicationToMiddleware();
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
await Run();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
e.LogError();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void InitializeCommunicationToMiddleware()
|
|
{
|
|
_controllerIpAddress = FindVpnIp();
|
|
if (Equals(IPAddress.None, _controllerIpAddress))
|
|
{
|
|
Console.WriteLine("There is no VPN interface, exiting...");
|
|
}
|
|
|
|
const Int32 udpPort = 9000;
|
|
var endPoint = new IPEndPoint(_controllerIpAddress, udpPort);
|
|
|
|
_udpListener = new UdpClient();
|
|
_udpListener.Client.Blocking = false;
|
|
_udpListener.Client.Bind(endPoint);
|
|
}
|
|
|
|
private static async Task Run()
|
|
{
|
|
"Starting SaliMax".LogInfo();
|
|
|
|
Watchdog.NotifyReady();
|
|
|
|
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(IslandBusLoadChannel);
|
|
var pvOnDcDevice = new AmptDevices(PvOnDc);
|
|
var pvOnAcGridDevice = new AmptDevices(PvOnAcGrid);
|
|
var pvOnAcIslandDevice = new AmptDevices(PvOnAcIsland);
|
|
var saliMaxRelaysDevice = new RelaysDevice(RelaysChannel);
|
|
|
|
StatusRecord ReadStatus()
|
|
{
|
|
var config = Config.Load();
|
|
var devices = config.Devices;
|
|
var acDc = acDcDevices.Read();
|
|
var dcDc = dcDcDevices.Read();
|
|
var relays = saliMaxRelaysDevice.Read();
|
|
var loadOnAcIsland = acIslandLoadMeter.Read();
|
|
var gridMeter = gridMeterDevice.Read();
|
|
var pvOnDc = pvOnDcDevice.Read();
|
|
var battery = batteryDevices.Read();
|
|
|
|
var pvOnAcGrid = pvOnAcGridDevice.Read();
|
|
var pvOnAcIsland = pvOnAcIslandDevice.Read();
|
|
|
|
var gridBusToIslandBus = Topology.CalculateGridBusToIslandBusPower(pvOnAcIsland, loadOnAcIsland, acDc);
|
|
|
|
var gridBusLoad = devices.LoadOnAcGrid.DeviceState == DeviceState.Disabled
|
|
? new AcPowerDevice { Power = 0 }
|
|
: Topology.CalculateGridBusLoad(gridMeter, pvOnAcGrid, gridBusToIslandBus);
|
|
|
|
var dcLoad = devices.LoadOnDc.DeviceState == DeviceState.Disabled
|
|
? new DcPowerDevice { Power = 0 }
|
|
: Topology.CalculateDcLoad(acDc, pvOnDc, dcDc);
|
|
|
|
var acDcToDcLink = devices.LoadOnDc.DeviceState == DeviceState.Disabled ?
|
|
Topology.CalculateAcDcToDcLink(pvOnDc, dcDc, acDc)
|
|
: new DcPowerDevice{ Power = acDc.Dc.Power};
|
|
|
|
return new StatusRecord
|
|
{
|
|
AcDc = acDc,
|
|
DcDc = dcDc,
|
|
Battery = battery,
|
|
Relays = relays,
|
|
GridMeter = gridMeter,
|
|
PvOnAcGrid = pvOnAcGrid,
|
|
PvOnAcIsland = pvOnAcIsland,
|
|
PvOnDc = pvOnDc,
|
|
AcGridToAcIsland = gridBusToIslandBus,
|
|
AcDcToDcLink = acDcToDcLink,
|
|
LoadOnAcGrid = gridBusLoad,
|
|
LoadOnAcIsland = loadOnAcIsland,
|
|
LoadOnDc = dcLoad,
|
|
|
|
StateMachine = StateMachine.Default,
|
|
EssControl = EssControl.Default,
|
|
Log = new SystemLog { SalimaxAlarmState = SalimaxAlarmState.Green, Message = null }, //TODO: Put real stuff
|
|
Config = config // 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)
|
|
{
|
|
await Observable
|
|
.Interval(UpdateInterval)
|
|
.Select(_ => RunIteration())
|
|
.SelectMany(r => UploadCsv(r, DateTime.Now.Round(UpdateInterval)))
|
|
.SelectError()
|
|
.ToTask();
|
|
}
|
|
|
|
|
|
StatusRecord RunIteration()
|
|
{
|
|
Watchdog.NotifyAlive();
|
|
|
|
var record = ReadStatus();
|
|
|
|
var currentSalimaxState = GetSalimaxStateAlarm(record);
|
|
|
|
SendSalimaxStateAlarm(currentSalimaxState,record);
|
|
|
|
record.ControlConstants();
|
|
record.ControlSystemState();
|
|
|
|
var essControl = record.ControlEss().WriteLine().LogInfo();
|
|
|
|
record.EssControl = essControl;
|
|
|
|
record.AcDc.SystemControl.ApplyAcDcDefaultSettings();
|
|
record.DcDc.SystemControl.ApplyDcDcDefaultSettings();
|
|
|
|
DistributePower(record, essControl);
|
|
|
|
WriteControl(record);
|
|
|
|
$"{DateTime.Now.Round(UpdateInterval).ToUnixTime()} : {record.StateMachine.State}: {record.StateMachine.Message}".WriteLine()
|
|
.LogInfo();
|
|
|
|
record.CreateTopologyTextBlock().WriteLine();
|
|
|
|
(record.Relays is null ? "No relay Data available" : record.Relays.FiWarning ? "Alert: Fi Warning Detected" : "No Fi Warning Detected").WriteLine();
|
|
(record.Relays is null ? "No relay Data available" : record.Relays.FiError ? "Alert: Fi Error Detected" : "No Fi Error Detected") .WriteLine();
|
|
|
|
//record.ApplyConfigFile(minSoc:22, gridSetPoint:1);
|
|
|
|
record.Config.Save();
|
|
|
|
"===========================================".LogInfo();
|
|
|
|
return record;
|
|
}
|
|
|
|
// ReSharper disable once FunctionNeverReturns
|
|
}
|
|
|
|
private static void SendSalimaxStateAlarm(StatusMessage currentSalimaxState, StatusRecord record)
|
|
{
|
|
var s3Bucket = Config.Load().S3?.Bucket;
|
|
|
|
//Every 15 iterations(30 seconds), the installation sends a heartbit message to the queue
|
|
_heartBitInterval++;
|
|
|
|
//When the controller boots, it tries to subscribe to the queue
|
|
if (_subscribeToQueueForTheFirstTime==false)
|
|
{
|
|
_subscribeToQueueForTheFirstTime = true;
|
|
SubscribeToQueue(currentSalimaxState, s3Bucket);
|
|
}
|
|
//If already subscribed to the queue and the status has been changed, update the queue
|
|
if (_subscribedToQueue && currentSalimaxState.Status != _prevSalimaxState)
|
|
{
|
|
_prevSalimaxState = currentSalimaxState.Status;
|
|
if (s3Bucket != null)
|
|
InformMiddleware(currentSalimaxState);
|
|
}
|
|
else if (_subscribedToQueue && _heartBitInterval>=15)
|
|
{
|
|
//Send a heartbit to the backend
|
|
Console.WriteLine("----------------------------------------Sending Heartbit----------------------------------------");
|
|
_heartBitInterval = 0;
|
|
currentSalimaxState.Type = MessageType.Heartbit;
|
|
|
|
if (s3Bucket != null)
|
|
InformMiddleware(currentSalimaxState);
|
|
}
|
|
|
|
//If there is an available message from the RabbitMQ Broker, apply the configuration file
|
|
if (_udpListener.Available > 0)
|
|
{
|
|
IPEndPoint? serverEndpoint = null;
|
|
|
|
var replyMessage = "ACK";
|
|
var replyData = Encoding.UTF8.GetBytes(replyMessage);
|
|
|
|
var udpMessage = _udpListener.Receive(ref serverEndpoint);
|
|
var message = Encoding.UTF8.GetString(udpMessage);
|
|
|
|
Configuration config = JsonSerializer.Deserialize<Configuration>(message);
|
|
|
|
Console.WriteLine($"Received a configuration message: GridSetPoint is "+config.GridSetPoint +", MinimumSoC is "+config.MinimumSoC+ " and ForceCalibrationCharge is "+config.ForceCalibrationCharge);
|
|
|
|
// Send the reply to the sender's endpoint
|
|
_udpListener.Send(replyData, replyData.Length, serverEndpoint);
|
|
Console.WriteLine($"Replied to {serverEndpoint}: {replyMessage}");
|
|
|
|
record.ApplyConfigFile(config);
|
|
|
|
}
|
|
}
|
|
|
|
private static void SubscribeToQueue(StatusMessage currentSalimaxState, String? s3Bucket)
|
|
{
|
|
try
|
|
{
|
|
//_factory = new ConnectionFactory { HostName = VpnServerIp };
|
|
|
|
_factory = new ConnectionFactory
|
|
{
|
|
HostName = VpnServerIp,
|
|
Port = 5672,
|
|
VirtualHost = "/",
|
|
UserName = "producer",
|
|
Password = "b187ceaddb54d5485063ddc1d41af66f",
|
|
|
|
};
|
|
|
|
_connection = _factory.CreateConnection();
|
|
_channel = _connection.CreateModel();
|
|
_channel.QueueDeclare(queue: "statusQueue", durable: true, exclusive: false, autoDelete: false, arguments: null);
|
|
|
|
Console.WriteLine("The controller sends its status to the middleware for the first time");
|
|
if (s3Bucket != null) InformMiddleware(currentSalimaxState);
|
|
|
|
_subscribedToQueue = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("An error occurred while connecting to the RabbitMQ queue: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static IPAddress FindVpnIp()
|
|
{
|
|
const String interfaceName = "innovenergy";
|
|
|
|
var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
|
|
|
|
foreach (var networkInterface in networkInterfaces)
|
|
{
|
|
if (networkInterface.Name == interfaceName)
|
|
{
|
|
var ipProps = networkInterface.GetIPProperties();
|
|
var uniCastIPs = ipProps.UnicastAddresses;
|
|
var controllerIpAddress = uniCastIPs[0].Address;
|
|
|
|
Console.WriteLine("VPN IP is: "+ uniCastIPs[0].Address);
|
|
return controllerIpAddress;
|
|
}
|
|
}
|
|
|
|
return IPAddress.None;
|
|
}
|
|
|
|
private static void InformMiddleware(StatusMessage status)
|
|
{
|
|
var message = JsonSerializer.Serialize(status);
|
|
var body = Encoding.UTF8.GetBytes(message);
|
|
|
|
_channel.BasicPublish(exchange: string.Empty,
|
|
routingKey: "statusQueue",
|
|
basicProperties: null,
|
|
body: body);
|
|
|
|
Console.WriteLine($"Producer sent message: {message}");
|
|
}
|
|
|
|
private static StatusMessage GetSalimaxStateAlarm(StatusRecord record)
|
|
{
|
|
var alarmCondition = record.DetectAlarmStates();
|
|
var s3Bucket = Config.Load().S3?.Bucket;
|
|
|
|
var alarmList = new List<AlarmOrWarning>();
|
|
var warningList = new List<AlarmOrWarning>();
|
|
|
|
if (alarmCondition is not null)
|
|
{
|
|
alarmCondition.LogInfo();
|
|
|
|
alarmList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "Salimax",
|
|
Description = alarmCondition
|
|
});
|
|
}
|
|
|
|
foreach (var alarm in record.AcDc.Alarms)
|
|
{
|
|
alarmList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "AcDc",
|
|
Description = alarm.ToString()
|
|
});
|
|
}
|
|
|
|
foreach (var alarm in record.DcDc.Alarms)
|
|
{
|
|
alarmList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "DcDc",
|
|
Description = alarm.ToString()
|
|
});
|
|
}
|
|
|
|
if (record.Battery != null)
|
|
{
|
|
var i = 0;
|
|
|
|
foreach (var battery in record.Battery.Devices)
|
|
{
|
|
i++;
|
|
foreach (var alarm in battery.Alarms)
|
|
{
|
|
alarmList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "Battery" + i,
|
|
Description = alarm
|
|
});
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
foreach (var warning in record.AcDc.Warnings)
|
|
{
|
|
warningList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "AcDc",
|
|
Description = warning.ToString()
|
|
});
|
|
}
|
|
|
|
foreach (var warning in record.DcDc.Warnings)
|
|
{
|
|
warningList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "DcDc",
|
|
Description = warning.ToString()
|
|
});
|
|
}
|
|
|
|
if (record.Battery != null)
|
|
{
|
|
foreach (var warning in record.Battery.Warnings)
|
|
{
|
|
warningList.Add(new AlarmOrWarning
|
|
{
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Time = DateTime.Now.ToString("HH:mm:ss"),
|
|
CreatedBy = "Battery",
|
|
Description = warning
|
|
});
|
|
}
|
|
}
|
|
|
|
var salimaxAlarmsState = (record.Battery is not null && record.Battery.Warnings.Any())
|
|
| record.AcDc.Warnings.Any()
|
|
| record.AcDc.SystemControl.Warnings.Any()
|
|
| record.DcDc.Warnings.Any()
|
|
? SalimaxAlarmState.Orange
|
|
: SalimaxAlarmState.Green; // this will be replaced by LedState
|
|
|
|
salimaxAlarmsState = (record.Battery is not null && record.Battery.Alarms.Any())
|
|
| record.AcDc.Alarms.Any()
|
|
| record.AcDc.SystemControl.Alarms.Any()
|
|
| record.DcDc.Alarms.Any()
|
|
| alarmCondition is not null
|
|
? SalimaxAlarmState.Red
|
|
: salimaxAlarmsState; // this will be replaced by LedState
|
|
|
|
int.TryParse(s3Bucket?.Split("-")[0], out var installationId);
|
|
|
|
var returnedStatus = new StatusMessage
|
|
{
|
|
InstallationId = installationId,
|
|
Status = salimaxAlarmsState,
|
|
Type = MessageType.AlarmOrWarning,
|
|
Alarms = alarmList,
|
|
Warnings = warningList
|
|
};
|
|
|
|
return returnedStatus;
|
|
}
|
|
|
|
private static String? DetectAlarmStates(this StatusRecord r) => r.Relays switch
|
|
{
|
|
{ K2ConnectIslandBusToGridBus: false, K2IslandBusIsConnectedToGridBus: true } => " Contradiction: R0 is opening the K2 but the K2 is still close ",
|
|
{ K1GridBusIsConnectedToGrid : false, K2IslandBusIsConnectedToGridBus: true } => " Contradiction: K1 is open but the K2 is still close ",
|
|
{ FiError: true, K2IslandBusIsConnectedToGridBus: true } => " Contradiction: Fi error occured but the K2 is still close ",
|
|
_ => null
|
|
};
|
|
|
|
private static void ControlConstants(this StatusRecord r)
|
|
{
|
|
var inverters = r.AcDc.Devices;
|
|
var dcDevices = r.DcDc.Devices;
|
|
var configFile = r.Config;
|
|
|
|
var devicesConfig = r.AcDc.Devices.All(d => d.Control.Ac.GridType == GridType.GridTied400V50Hz) ? configFile.GridTie : configFile.IslandMode; // TODO if any of the grid tie mode
|
|
|
|
inverters.ForEach(d => d.Control.Dc.MaxVoltage = devicesConfig.AcDc.MaxDcLinkVoltage);
|
|
inverters.ForEach(d => d.Control.Dc.MinVoltage = devicesConfig.AcDc.MinDcLinkVoltage);
|
|
inverters.ForEach(d => d.Control.Dc.ReferenceVoltage = devicesConfig.AcDc.ReferenceDcLinkVoltage);
|
|
|
|
inverters.ForEach(d => d.Control.Dc.PrechargeConfig = DcPrechargeConfig.PrechargeDcWithInternal);
|
|
|
|
dcDevices.ForEach(d => d.Control.DroopControl.UpperVoltage = devicesConfig.DcDc.UpperDcLinkVoltage);
|
|
dcDevices.ForEach(d => d.Control.DroopControl.LowerVoltage = devicesConfig.DcDc.LowerDcLinkVoltage);
|
|
dcDevices.ForEach(d => d.Control.DroopControl.ReferenceVoltage = devicesConfig.DcDc.ReferenceDcLinkVoltage);
|
|
|
|
dcDevices.ForEach(d => d.Control.CurrentControl.MaxBatteryChargingCurrent = configFile.MaxBatteryChargingCurrent);
|
|
dcDevices.ForEach(d => d.Control.CurrentControl.MaxBatteryDischargingCurrent = configFile.MaxBatteryDischargingCurrent);
|
|
dcDevices.ForEach(d => d.Control.MaxDcPower = configFile.MaxDcPower);
|
|
|
|
dcDevices.ForEach(d => d.Control.VoltageLimits.MaxBatteryVoltage = configFile.MaxChargeBatteryVoltage);
|
|
dcDevices.ForEach(d => d.Control.VoltageLimits.MinBatteryVoltage = configFile.MinDischargeBatteryVoltage);
|
|
dcDevices.ForEach(d => d.Control.ControlMode = DcControlMode.VoltageDroop);
|
|
|
|
r.DcDc.ResetAlarms();
|
|
r.AcDc.ResetAlarms();
|
|
}
|
|
|
|
|
|
// why this is not in Controller?
|
|
private static void DistributePower(StatusRecord record, EssControl essControl)
|
|
{
|
|
var nInverters = record.AcDc.Devices.Count;
|
|
|
|
var powerPerInverterPhase = nInverters > 0
|
|
? essControl.PowerSetpoint / nInverters / 3
|
|
: 0;
|
|
|
|
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 ApplyAcDcDefaultSettings(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 ApplyDcDcDefaultSettings(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<Boolean> UploadCsv(StatusRecord status, DateTime timeStamp)
|
|
{
|
|
var s3Config = status.Config.S3;
|
|
var csv = status.ToCsv().LogInfo();
|
|
if (s3Config is null)
|
|
return false;
|
|
|
|
var s3Path = timeStamp.ToUnixTime() + ".csv";
|
|
var request = s3Config.CreatePutRequest(s3Path);
|
|
var response = await request.PutAsync(new StringContent(csv));
|
|
|
|
// This is temporary for Wittman
|
|
//await File.WriteAllTextAsync("/var/www/html/status.csv", csv.SplitLines().Where(l => !l.Contains("Secret")).JoinLines());
|
|
|
|
if (response.StatusCode != 200)
|
|
{
|
|
Console.WriteLine("ERROR: PUT");
|
|
var error = await response.GetStringAsync();
|
|
Console.WriteLine(error);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static async Task HourlyDataAggregationManager()
|
|
{
|
|
DateTime currentDateTime = DateTime.Now;
|
|
DateTime nextRoundedHour = currentDateTime.AddHours(1).AddMinutes(-currentDateTime.Minute).AddSeconds(-currentDateTime.Second);
|
|
|
|
// Calculate the time until the next rounded hour
|
|
TimeSpan timeUntilNextHour = nextRoundedHour - currentDateTime;
|
|
|
|
// Output the current and next rounded hour times
|
|
Console.WriteLine("Current Date and Time: " + currentDateTime);
|
|
Console.WriteLine("Next Rounded Hour: " + nextRoundedHour);
|
|
|
|
// Output the time until the next rounded hour
|
|
Console.WriteLine("Waiting for " + timeUntilNextHour.TotalMinutes + " minutes...");
|
|
|
|
// Wait until the next rounded hour
|
|
await Task.Delay(timeUntilNextHour);
|
|
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
CreateHourlyAverage();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("An error has occured when calculating hourly aggregated data, exception is:\n" + e);
|
|
}
|
|
await Task.Delay(TimeSpan.FromHours(1));
|
|
}
|
|
}
|
|
|
|
private static void CreateHourlyAverage()
|
|
{
|
|
var myDirectory = "LogDirectory";
|
|
|
|
// Get all CSV files in the specified directory
|
|
var csvFiles = Directory.GetFiles(myDirectory, "*.csv");
|
|
|
|
var currentTimestamp = DateTime.Now.ToUnixTime();
|
|
Double socAverage = 0;
|
|
Double pvPowerAverage = 0;
|
|
Double batteryPowerAverage = 0;
|
|
|
|
Console.WriteLine("-----------------------------------------------------------------------------------------------------------------");
|
|
Console.WriteLine("File timestamp should start after "+ DateTime.Now.AddHours(-1));
|
|
|
|
foreach (var csvFile in csvFiles)
|
|
{
|
|
|
|
if (csvFile == "LogDirectory/log.csv")
|
|
{
|
|
continue;
|
|
}
|
|
var fileTimestamp = long.Parse(Path.GetFileNameWithoutExtension(csvFile).Replace("log_", ""));
|
|
var oneHourBefore = DateTime.Now.AddHours(-1).ToUnixTime();
|
|
|
|
|
|
if (fileTimestamp >= oneHourBefore && fileTimestamp <= currentTimestamp)
|
|
{
|
|
Console.WriteLine("Check file created at "+ DateTimeOffset.FromUnixTimeSeconds(fileTimestamp).DateTime);
|
|
using var reader = new StreamReader(csvFile);
|
|
|
|
while (!reader.EndOfStream)
|
|
{
|
|
var line = reader.ReadLine();
|
|
var lines = line?.Split(';');
|
|
|
|
// Assuming there are always three columns (variable name and its value)
|
|
if (lines is { Length: 3 })
|
|
{
|
|
var variableName = lines[0].Trim();
|
|
|
|
if (TryParse(lines[1].Trim(), out var value))
|
|
{
|
|
// Check if variableValue is a valid number
|
|
if (IsSoc(variableName))
|
|
{
|
|
if (socAverage == 0)
|
|
{
|
|
socAverage = value;
|
|
}
|
|
else
|
|
{
|
|
socAverage = (socAverage + value) / 2;
|
|
}
|
|
}
|
|
|
|
if (IsPvPower(variableName))
|
|
{
|
|
if (pvPowerAverage == 0)
|
|
{
|
|
pvPowerAverage = value;
|
|
}
|
|
else
|
|
{
|
|
pvPowerAverage = (pvPowerAverage + value) / 2;
|
|
}
|
|
}
|
|
|
|
if (IsBatteryPower(variableName))
|
|
{
|
|
if (batteryPowerAverage == 0)
|
|
{
|
|
batteryPowerAverage = value;
|
|
}
|
|
else
|
|
{
|
|
batteryPowerAverage = (batteryPowerAverage + value) / 2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Handle cases where variableValue is not a valid number
|
|
Console.WriteLine($"Invalid numeric value for variable {variableName}:{lines[1].Trim()}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Handle invalid column format
|
|
Console.WriteLine("Invalid format in column");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Print the stored CSV data for verification
|
|
|
|
Console.WriteLine($"SOC: {socAverage}");
|
|
Console.WriteLine($"PvPower: {pvPowerAverage}");
|
|
Console.WriteLine($"Battery: {batteryPowerAverage}");
|
|
|
|
Console.WriteLine("CSV data reading and storage completed.");
|
|
//Create a new file to folder "Hourly Aggregated Data and push it to S3"
|
|
Console.WriteLine("-----------------------------------------------------------------------------------------------------------------");
|
|
|
|
}
|
|
|
|
// Custom method to check if a string is numeric
|
|
private static bool IsSoc(string value)
|
|
{
|
|
return value == "/Battery/Soc";
|
|
}
|
|
|
|
private static bool IsPvPower(string value)
|
|
{
|
|
return value == "/PvOnDc/Dc/Power";
|
|
}
|
|
|
|
private static bool IsBatteryPower(string value)
|
|
{
|
|
return value == "/Battery/Dc/Power";
|
|
}
|
|
|
|
private static void ApplyConfigFile(this StatusRecord status, Configuration config)
|
|
{
|
|
status.Config.MinSoc = config.MinimumSoC;
|
|
status.Config.GridSetPoint = config.GridSetPoint * 1000; // converted from kW to W
|
|
status.Config.ForceCalibrationCharge = config.ForceCalibrationCharge;
|
|
}
|
|
|
|
} |