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

321 lines
12 KiB
C#
Raw Normal View History

2023-02-16 12:57:06 +00:00
using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using Flurl.Http;
using InnovEnergy.Lib.Devices.EmuMeter;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertAc;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertDc;
using InnovEnergy.Lib.Devices.Ampt;
using InnovEnergy.Lib.Devices.Battery48TL;
using InnovEnergy.Lib.Utils;
using InnovEnergy.SaliMax.Controller;
using InnovEnergy.SaliMax.Log;
using InnovEnergy.SaliMax.SaliMaxRelays;
using InnovEnergy.SaliMax.SystemConfig;
using InnovEnergy.Time.Unix;
#pragma warning disable IL2026
namespace InnovEnergy.SaliMax;
internal static class Program
{
private const UInt32 UpdateIntervalSeconds = 2;
public static async Task Main(String[] args)
{
try
{
await Run();
}
catch (Exception e)
{
await File.AppendAllTextAsync(Config.LogSalimaxLog, String.Join(Environment.NewLine, UnixTime.Now + " \n" + e));
throw;
}
}
private static async Task Run()
{
Console.WriteLine("Starting SaliMax");
var 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"
};
#if DEBUG
var inverterDevice = new TruConvertAcDevice("127.0.0.1", 5001);
var dcDcDevice = new TruConvertDcDevice("127.0.0.1", 5002);
var gridMeterDevice = new EmuMeterDevice("127.0.0.1", 5003);
var saliMaxRelaysDevice = new SaliMaxRelaysDevice("127.0.0.1", 5004);
var amptDevice = new AmptCommunicationUnit("127.0.0.1", 5005);
var acInToAcOutMeterDevice = new EmuMeterDevice("127.0.0.1", 5003); // TODO: use real device
var battery48TlDevice = Battery48TlDevice.Fake();
var salimaxConfig = new SalimaxConfig();
#else
var battery48TlDevice = new Battery48TlDevice("/dev/ttyUSB0", 3);
var inverterDevice = new TruConvertAcDevice("192.168.1.2");
var dcDcDevice = new TruConvertDcDevice("192.168.1.3");
var gridMeterDevice = new EmuMeterDevice("192.168.1.241");
var acInToAcOutMeterDevice = new EmuMeterDevice("192.168.1.241"); // TODO: use real device
var amptDevice = new AmptCommunicationUnit("192.168.1.249");
var saliMaxRelaysDevice = new SaliMaxRelaysDevice("192.168.1.242");
var salimaxConfig = new SalimaxConfig();
#endif
StatusRecord ReadStatus()
{
return new StatusRecord
{
InverterStatus = inverterDevice.ReadStatus(),
DcDcStatus = dcDcDevice.ReadStatus(),
BatteryStatus = battery48TlDevice.ReadStatus(),
AcInToAcOutMeterStatus = acInToAcOutMeterDevice.ReadStatus(),
GridMeterStatus = gridMeterDevice.ReadStatus(),
SaliMaxRelayStatus = saliMaxRelaysDevice.ReadStatus(),
AmptStatus = amptDevice.ReadStatus(),
SalimaxConfig = salimaxConfig.Load().Result,
};
}
var startTime = UnixTime.Now;
const Int32 delayTime = 10;
ReleaseWriteTopology(startTime);
DebugWriteTopology(startTime);
Console.WriteLine("press ctrl-C to stop");
while (true)
{
var t = UnixTime.Now;
while (t.Ticks % UpdateIntervalSeconds != 0)
{
await Task.Delay(delayTime);
t = UnixTime.Now;
}
var status = ReadStatus();
//var jsonLog = status.ToLog(t);
//await UploadTimeSeries(s3Config, jsonLog, t);
var controlRecord = Controller.Controller.SaliMaxControl(status);
Controller.Controller.WriteControlRecord(controlRecord, inverterDevice, dcDcDevice, saliMaxRelaysDevice);
// JsonSerializer.Serialize(jsonLog, JsonOptions).WriteLine(ConsoleColor.DarkBlue);
//ReleaseWriteLog(jsonLog, t);
PrintTopology(status);
while (UnixTime.Now == t)
await Task.Delay(delayTime);
}
// ReSharper disable once FunctionNeverReturns
}
private static void PrintTopology(StatusRecord s)
{
const String chargingSeparator = ">>>>>>>>>>";
const String dischargingSeparator = "<<<<<<<<<";
const Int32 height = 25;
var boxSize = chargingSeparator.Length / 2;
var pwr = s.InverterStatus!.PowerAcL1 + s.InverterStatus.PowerAcL2 + s.InverterStatus.PowerAcL3;
var pvPower = (s.AmptStatus!.Voltage1 * s.AmptStatus.Current1 + s.AmptStatus!.Voltage2 * s.AmptStatus.Current2).Round0();
var loadPower = (s.GridMeterStatus!.ActivePowerL123 + pwr).Round3(); // it's a + because the pwr is inverted
var gridSeparator = s.GridMeterStatus!.ActivePowerL123 > 0 ? chargingSeparator : dischargingSeparator;
var inverterSeparator = -pwr > 0 ? chargingSeparator : dischargingSeparator;
var dcSeparator = -s.DcDcStatus!.DcPower > 0 ? chargingSeparator : dischargingSeparator;
var batterySeparator = s.BatteryStatus!.Power > 0 ? chargingSeparator : dischargingSeparator;
////////////////// Grid //////////////////////
var boxGrid = AsciiArt.CreateBox
(
"Grid",
s.GridMeterStatus.VoltageL1N.V(),
s.GridMeterStatus.VoltageL2N.V(),
s.GridMeterStatus.VoltageL3N.V()
).AlignCenterVertical(height);
//var gridBox = CreateRect(0, boxGrid).AlignBottom(height);
var gridAcBusArrow = AsciiArt.CreateHorizontalArrow(s.GridMeterStatus!.ActivePowerL123.Round0(), gridSeparator).AlignCenterVertical(height);
////////////////// Ac Bus //////////////////////
var boxAcBus = AsciiArt.CreateBox
(
"AC Bus",
s.InverterStatus.GridVoltageL1.V(),
s.InverterStatus.GridVoltageL2.V(),
s.InverterStatus.GridVoltageL3.V()
);
var boxLoad = AsciiArt.CreateBox
(
"",
"LOAD",
""
);
var loadRect = CreateRect(loadPower, boxAcBus, boxLoad).AlignBottom(height);
var acBusInvertArrow = AsciiArt.CreateHorizontalArrow(-pwr.Round0(), inverterSeparator).AlignCenterVertical(height);
//////////////////// Inverter /////////////////////////
var inverterBox = AsciiArt.CreateBox
(
"",
"Inverter",
""
).AlignCenterVertical(height);
var inverterArrow = AsciiArt.CreateHorizontalArrow(-pwr.Round0(), inverterSeparator).AlignCenterVertical(height);
//////////////////// DC Bus /////////////////////////
var dcBusBox = AsciiArt.CreateBox
(
"DC Bus",
(s.InverterStatus.ActualDcLinkVoltageLowerHalfExt + s.InverterStatus.ActualDcLinkVoltageUpperHalfExt).V(),
""
);
var pvBox = AsciiArt.CreateBox
(
"",
"MPPT",
""
);
var pvRect = CreateRect(pvPower, pvBox, dcBusBox).AlignTop(height);
var dcBusArrow = AsciiArt.CreateHorizontalArrow(-s.DcDcStatus!.DcPower.Round0(), dcSeparator).AlignCenterVertical(height);
//////////////////// Dc/Dc /////////////////////////
var dcBox = AsciiArt.CreateBox
(
"",
"Dc/Dc",
""
).AlignCenterVertical(height);
var dcArrow = AsciiArt.CreateHorizontalArrow(s.BatteryStatus!.Power.Round0(), batterySeparator).AlignCenterVertical(height);
//////////////////// Battery /////////////////////////
var batteryBox = AsciiArt.CreateBox
(
"Battery",
s.BatteryStatus!.Voltage.V(),
""
).AlignCenterVertical(height);
var batteryDegree = AsciiArt.CreateTransitionPadLeft(s.BatteryStatus!.Soc.Percent(), s.BatteryStatus!.BatteryTemperature.Celsius()).AlignCenterVertical(height);
// var loadLength = boxSize * 6;
// var mpptLength = boxSize * 14;
//
// var mpptBox = AsciiArt.CreateVerticalPad(pvPower.W(),(Int16)mpptLength, true, "MPPT") + "\n";
// var loadBox = AsciiArt.CreateVerticalPad(loadPower.W(), (Int16)loadLength, false, "Load");
var topology = boxGrid.SideBySideWith(gridAcBusArrow,"")
.SideBySideWith(loadRect,"")
.SideBySideWith(acBusInvertArrow,"")
.SideBySideWith(inverterBox,"")
.SideBySideWith(inverterArrow,"")
.SideBySideWith(pvRect,"")
.SideBySideWith(dcBusArrow,"")
.SideBySideWith(dcBox,"")
.SideBySideWith(dcArrow,"")
.SideBySideWith(batteryBox,"")
.SideBySideWith(batteryDegree, "") + "\n";
// var topology = mpptBox + boxSide11 + loadBox;
Console.WriteLine(topology);
// Console.WriteLine(loadRect);
// Console.WriteLine(pvRect);
}
private static String CreateRect(Decimal loadPower, String boxAcBus, String boxLoad = "")
{
var loadAcBusArrow = AsciiArt.CreateVerticalArrow(loadPower);
var boxes = new[] { boxAcBus, loadAcBusArrow, boxLoad };
var maxWidth = boxes.Max(l => l.Width());
var rect = boxes.Select(l => l.AlignCenterHorizontal(maxWidth)).JoinLines();
return rect;
}
[Conditional("RELEASE")]
private static void ReleaseWriteLog(JsonObject jsonLog, UnixTime timestamp)
{
WriteToFile(jsonLog, "/home/debian/DataSaliMax/" + timestamp);
}
[Conditional("RELEASE")]
private static void ReleaseWriteTopology(UnixTime timestamp)
{
var topologyJson = Salimax.TopologyToLog(timestamp);
WriteToFile(topologyJson, "/home/debian/DataSaliMax/topology" + timestamp);
}
[Conditional("DEBUG")]
private static void DebugWriteTopology(UnixTime timestamp)
{
var topologyJson = Salimax.TopologyToLog(timestamp);
WriteToFile(topologyJson, "/home/atef/JsonData/topology" + timestamp);
}
[Conditional("DEBUG")]
private static void DebugWriteLog(JsonObject jsonLog, UnixTime timestamp)
{
WriteToFile(jsonLog, "/home/atef/JsonData/" + timestamp);
}
private static void WriteToFile(Object obj, String fileName)
{
var jsonString = JsonSerializer.Serialize(obj, JsonOptions);
File.WriteAllText(fileName, jsonString);
}
private static readonly JsonSerializerOptions JsonOptions = new()
{
WriteIndented = true,
IgnoreReadOnlyProperties = false,
Converters = { new JsonStringEnumConverter() },
NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals,
//TODO
};
private static async Task UploadTimeSeries(S3Config config, JsonObject json, UnixTime unixTime)
{
var payload = JsonSerializer.Serialize(json, JsonOptions);
var s3Path = unixTime.Ticks + ".json";
var request = config.CreatePutRequest(s3Path);
var response = await request.PutAsync(new StringContent(payload));
if (response.StatusCode != 200)
{
Console.WriteLine("ERROR: PUT");
var error = response.GetStringAsync();
Console.WriteLine(error);
}
}
}