4013 lines
186 KiB
C#
4013 lines
186 KiB
C#
using CsvHelper.Configuration;
|
||
using HslCommunication;
|
||
using HslCommunication.ModBus;
|
||
using OrpaonEMS.App.Com;
|
||
using OrpaonEMS.App.Models;
|
||
using OrpaonEMS.App.PrismEvent;
|
||
using OrpaonEMS.Core.Enums;
|
||
using OrpaonEMS.Model.Enums;
|
||
using OrpaonEMS.Model.MasterSlave;
|
||
using Prism.Events;
|
||
using Prism.Mvvm;
|
||
using Stateless;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using System.Windows;
|
||
|
||
namespace OrpaonEMS.App.Services
|
||
{
|
||
/// <summary>
|
||
/// 月浦储能柜运行模型
|
||
/// </summary>
|
||
public class YuePuRunModelService : BindableBase
|
||
{
|
||
///////
|
||
/////怎么认定为晚上，光伏发电功率低于一个阈值时可认为是晚上
|
||
public YuePuRunModelService(ILogService logService, ConfigDataService configDataService,BmsDataService bmsDataService,FFService fFService, InPowerPCSDataService inPowerPCSDataService,
|
||
IEventAggregator eventAggregator)
|
||
{
|
||
ConfigDataService = configDataService;
|
||
BmsDataService = bmsDataService;
|
||
FFService = fFService;
|
||
InPowerPCSDataService = inPowerPCSDataService;
|
||
LogService = logService;
|
||
|
||
//CurNightChargEleModel = new NightChargEleModel(ConfigDataService);
|
||
|
||
if (ConfigDataService.IsMaster)
|
||
{
|
||
_eventAggregator = eventAggregator;
|
||
_eventAggregator.GetEvent<PeakValleyTimeEvent>().Subscribe(OnPeakValleyTimeEventMsgReceived);
|
||
|
||
MeterMdDrive?.Close();
|
||
MeterMdDrive = new ModbusRtu();
|
||
MeterMdDrive.AddressStartWithZero = true;//华为光伏逆变器从0开始的
|
||
MeterMdDrive.IsStringReverse = false;
|
||
MeterMdDrive.DataFormat = HslCommunication.Core.DataFormat.ABCD;
|
||
MeterMdDrive.ReceiveTimeOut = 500;
|
||
try
|
||
{
|
||
MeterMdDrive.SerialPortInni(sp =>
|
||
{
|
||
sp.PortName = "COM2";
|
||
//sp.PortName = "COM10";
|
||
sp.BaudRate = 9600;
|
||
sp.DataBits = 8;
|
||
sp.StopBits = System.IO.Ports.StopBits.One;
|
||
sp.Parity = System.IO.Ports.Parity.None;
|
||
});
|
||
|
||
var result = MeterMdDrive.Open();
|
||
if (!result.IsSuccess)
|
||
{
|
||
MessageBox.Show("Meter仪表连接失败");
|
||
}
|
||
|
||
MeterScanDeviceStart();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show(ex.Message);
|
||
}
|
||
|
||
//SolarMdDrive
|
||
SolarMdDrive?.Close();
|
||
SolarMdDrive = new ModbusRtu();
|
||
SolarMdDrive.AddressStartWithZero = false;//跟ModbusPull一样的地址
|
||
SolarMdDrive.IsStringReverse = false;
|
||
SolarMdDrive.DataFormat = HslCommunication.Core.DataFormat.ABCD;
|
||
SolarMdDrive.ReceiveTimeOut = 500;
|
||
try
|
||
{
|
||
SolarMdDrive.SerialPortInni(sp =>
|
||
{
|
||
sp.PortName = "COM8";
|
||
//sp.PortName = "COM10";
|
||
sp.BaudRate = 9600;
|
||
sp.DataBits = 8;
|
||
sp.StopBits = System.IO.Ports.StopBits.One;
|
||
sp.Parity = System.IO.Ports.Parity.None;
|
||
});
|
||
|
||
var result = SolarMdDrive.Open();
|
||
if (!result.IsSuccess)
|
||
{
|
||
MessageBox.Show("光伏连接失败");
|
||
}
|
||
|
||
SolarLinkTrigTimeModel = new TrigTimeModel(1, 10);//trigThValue 参数无所谓，因为不用这个参数 ，bool类型
|
||
SolarLinkTrigTimeModel.TrigTimeOutHandler += SolarLinkTrigTimeModel_TrigTimeOutHandler;
|
||
|
||
SolarScanDeviceStart();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show(ex.Message);
|
||
}
|
||
|
||
ModbusTcpNetDrive = new ModbusTcpNet("192.0.3.200", 502);
|
||
//ModbusTcpNetDrive = new ModbusTcpNet("127.0.0.1", 502);
|
||
//为了方便和ModbusPull及手册的地址能对应的话，设置从1开始
|
||
ModbusTcpNetDrive.AddressStartWithZero = false;
|
||
ModbusTcpNetDrive.SetPersistentConnection();
|
||
var DATA = ModbusTcpNetDrive.ConnectServer();
|
||
if (!DATA.IsSuccess)
|
||
{
|
||
MessageBox.Show("远程IO 连接失败");
|
||
}
|
||
|
||
QFSwitch1 = new SwitchModel("17", "18", ModbusTcpNetDrive);
|
||
QFSwitch2 = new SwitchModel("19", "20", ModbusTcpNetDrive);
|
||
QFSwitch3 = new SwitchModel("21", "22", ModbusTcpNetDrive);
|
||
QFSwitch4 = new SwitchModel("23", "24", ModbusTcpNetDrive);
|
||
|
||
ReIOScanDeviceStart();
|
||
|
||
//初始的设置，防止上一次的残留导致状态和开关的IO的不同步
|
||
//CurESChargInfo = ESChargInfo.Master;
|
||
//Thread.Sleep(1000);
|
||
//QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
//QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
//QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
//QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
|
||
// 放电时间模型初始化：基于配置的 DisChargeModel 列表与 SelectedDisChargeModel
|
||
try
|
||
{
|
||
var list = ConfigDataService.GetDisChargeModel();
|
||
int selectedId = 1;
|
||
try
|
||
{
|
||
selectedId = ConfigDataService.ControlConfigValue?.SelectedDisChargeModel ?? 1;
|
||
}
|
||
catch { selectedId = 1; }
|
||
|
||
DisChargeModelItem? selected = null;
|
||
if (list != null && list.Count > 0)
|
||
{
|
||
foreach (var it in list)
|
||
{
|
||
if (it != null && it.Model == selectedId)
|
||
{
|
||
selected = it;
|
||
break;
|
||
}
|
||
}
|
||
if (selected == null)
|
||
{
|
||
selected = list[0];
|
||
}
|
||
}
|
||
|
||
// 映射到旧的枚举（如可用），否则回退到 DischargeA
|
||
var enumValue = DisChargeType.DischargeA;
|
||
if (selected != null && System.Enum.IsDefined(typeof(DisChargeType), selected.Model))
|
||
{
|
||
enumValue = (DisChargeType)selected.Model;
|
||
}
|
||
|
||
CurDischargeTimeModel = new DischargeTimeModel(enumValue);
|
||
|
||
// 设置具体时间（优先使用配置时间），格式期望 HH:mm
|
||
if (selected != null && !string.IsNullOrWhiteSpace(selected.DisChargeTime) && TimeSpan.TryParse(selected.DisChargeTime, out var ts))
|
||
{
|
||
CurDischargeTimeModel.CurDischargeTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, ts.Hours, ts.Minutes, 0);
|
||
}
|
||
else
|
||
{
|
||
// 解析失败使用默认 08:00
|
||
CurDischargeTimeModel.CurDischargeTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 8, 0, 0);
|
||
LogService.Warn("DisChargeModel 配置时间缺失或格式非法，已使用默认 08:00");
|
||
}
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
// 失败时初始化为默认模式与时间
|
||
CurDischargeTimeModel = new DischargeTimeModel(DisChargeType.DischargeA)
|
||
{
|
||
CurDischargeTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 8, 0, 0)
|
||
};
|
||
LogService.Error($"初始化放电时间模型失败: {ex.Message}");
|
||
}
|
||
|
||
StateMachineInitial();
|
||
LogicScan();
|
||
|
||
SolarCurBackFlow = new TrigTimeModel(-5, 10);
|
||
SolarCurBackFlow.TrigTimeOutHandler += SolarCurBackFlow_TrigTimeOutHandler;
|
||
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 削峰填谷的时间信息
|
||
/// </summary>
|
||
/// <param name="enum"></param>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void OnPeakValleyTimeEventMsgReceived(ElePVEnum data)
|
||
{
|
||
PeakValleySglModel = data;
|
||
}
|
||
|
||
private ElePVEnum _PeakValleySglModel = ElePVEnum.Peak;
|
||
/// <summary>
|
||
/// 削峰填谷的信号模型
|
||
/// 由其他的线程轮训赋值监控
|
||
/// </summary>
|
||
public ElePVEnum PeakValleySglModel
|
||
{
|
||
get { return _PeakValleySglModel; }
|
||
set
|
||
{
|
||
//if (_PeakValleySglModel != value)//监听线程不停的赋值，变化时触发执行
|
||
//{
|
||
_PeakValleySglModel = value;//削峰填谷不使用状态机
|
||
|
||
//}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 当前的放电时间模型
|
||
/// </summary>
|
||
public DischargeTimeModel CurDischargeTimeModel { get; set; }
|
||
|
||
/// <summary>
|
||
/// 税务大楼光伏逆流触发模型
|
||
/// </summary>
|
||
public TrigTimeModel SolarCurBackFlow { get; set; }
|
||
|
||
/// <summary>
|
||
/// 事件聚合器
|
||
/// </summary>
|
||
private readonly IEventAggregator _eventAggregator;
|
||
|
||
/// <summary>
|
||
/// 光伏通信失败触发
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void SolarLinkTrigTimeModel_TrigTimeOutHandler(object? sender, EventArgs e)
|
||
{
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 光伏通信失败 ");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 税务大楼光伏通信失败触发模型
|
||
/// </summary>
|
||
public TrigTimeModel SolarLinkTrigTimeModel { get; set; }
|
||
|
||
/// <summary>
|
||
/// 税务大楼的光伏逆流触发事件
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void SolarCurBackFlow_TrigTimeOutHandler(object? sender, EventArgs e)
|
||
{
|
||
//关闭光伏
|
||
CloseSolar();
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 软件检测到光伏逆流，关闭光伏逆变器 ");
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-软件检测到光伏逆流，关闭光伏逆变器");
|
||
|
||
}
|
||
|
||
|
||
|
||
#region 系统运行状态机
|
||
|
||
/// <summary>
|
||
/// 系统运行的状态机
|
||
/// </summary>
|
||
public StateMachine<ESChargInfo, ESChargInfoTrig> SysRunStateMachine { get; set; }
|
||
|
||
///// <summary>
|
||
///// 夜间充电模型信息
|
||
///// 标记白天放电信息
|
||
///// </summary>
|
||
//public NightChargEleModel CurNightChargEleModel; /*= new NightChargEleModel();*/
|
||
|
||
/// <summary>
|
||
/// 系统运行的状态机
|
||
/// </summary>
|
||
private void StateMachineInitial()
|
||
{
|
||
//初始状态是这个状态，不然同一个状态会重复进入导致状态机报错
|
||
CurESChargInfo = ESChargInfo.Inital;
|
||
|
||
SysRunStateMachine = new StateMachine<ESChargInfo, ESChargInfoTrig>(ESChargInfo.Inital);
|
||
|
||
//初始状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Inital)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Ignore(ESChargInfoTrig.InitalTrig);
|
||
|
||
//Master 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Ignore(ESChargInfoTrig.MasterTrig)
|
||
.OnEntry(() => EntryMaster())
|
||
.OnExit(() => ExitMaster());
|
||
|
||
//Slave 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Ignore(ESChargInfoTrig.SlaveTrig)
|
||
.OnEntry(() => EntrySlave())
|
||
.OnExit(() => ExitSlave());
|
||
|
||
//Night_Master 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Ignore(ESChargInfoTrig.Night_MasterTrig)
|
||
.OnEntry(() => EntryNight_Master())
|
||
.OnExit(() => ExitNight_Master());
|
||
|
||
//Night_Slave 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Ignore(ESChargInfoTrig.Night_SlaveTrig)
|
||
.OnEntry(() => EntryNight_Slave())
|
||
.OnExit(() => ExitNight_Slave());
|
||
|
||
//Wait 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.Wait)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.NoSolarTrig, ESChargInfo.NoSolar)
|
||
.Ignore(ESChargInfoTrig.WaitTrig)
|
||
.OnEntry(() => EntryWait())
|
||
.OnExit(() => ExitWait());
|
||
|
||
//NoSolar 状态
|
||
SysRunStateMachine.Configure(ESChargInfo.NoSolar)
|
||
.Permit(ESChargInfoTrig.MasterTrig, ESChargInfo.Master)
|
||
.Permit(ESChargInfoTrig.SlaveTrig, ESChargInfo.Slave)
|
||
.Permit(ESChargInfoTrig.Night_MasterTrig, ESChargInfo.Night_Master)
|
||
.Permit(ESChargInfoTrig.Night_SlaveTrig, ESChargInfo.Night_Slave)
|
||
.Permit(ESChargInfoTrig.WaitTrig, ESChargInfo.Wait)
|
||
.Ignore(ESChargInfoTrig.NoSolarTrig)
|
||
.OnEntry(() => EntryNoSolar())
|
||
.OnExit(() => ExitNoSolar());
|
||
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 进入 NoSolar
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntryNoSolar()
|
||
{
|
||
CurESChargInfo = ESChargInfo.NoSolar;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【NoSolar】模式 ");
|
||
NoSolarTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntryNoSolar】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.NoSolar)
|
||
{
|
||
try
|
||
{
|
||
Thread.Sleep(1000);
|
||
if (NoSolarTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//关闭光伏
|
||
if (CheckSolarState() == true)
|
||
{
|
||
CloseSolar();
|
||
}
|
||
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
|
||
//循环执行方法
|
||
//让储能给管理大楼放电，腾出空间，让光伏参与进来
|
||
//优先让主储能给管理大楼供电，因为涉及到电操，让主储能柜体放电 1 4 ON 2 3OFF
|
||
if (MasterClient.IsCanDisCharg())
|
||
{
|
||
///////////////////Master主控制柜给管理大楼供电
|
||
//注意方向
|
||
//主储能箱体放电的控制
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
{
|
||
//Master 主储能箱根据负载情况给管理大楼放电
|
||
//可以放电的话，则
|
||
if (MasterClient.IsCanDisCharg())
|
||
{
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
if (ManageDifLoad < MasterClient.ClientInfo.MaxDisChargPw)
|
||
{
|
||
//储能发送功率 补全总功率数据
|
||
//DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
MasterClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】放电补全目标差值，【主储能】正常放电";
|
||
}
|
||
else //储能不能满足总的差值
|
||
{
|
||
//满功率放电
|
||
//储能全功率放电，不足的部分电网自动补全
|
||
MasterClient.ServerCmd.CmdPw = (MasterClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】全功率放电无法补全差值，【主储能】全功率放电";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//储能处于待机状态，防止其他的状态残留
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】无法放电，【主储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
MasterClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【主储能】不动作";
|
||
}
|
||
|
||
//只能一个放电，另一个停止放电
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
}
|
||
else
|
||
{
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
|
||
/////////////////////Slave从控制柜给管理大楼供电
|
||
////注意方向
|
||
////从储能箱体放电的控制
|
||
//ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
//if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
//{
|
||
// //Slave 从储能箱根据负载情况给管理大楼放电
|
||
// //可以放电的话，则
|
||
// if (SlaveClient.IsCanDisCharg())
|
||
// {
|
||
// SlaveClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
// ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
// if (ManageDifLoad < SlaveClient.ClientInfo!.MaxDisChargPw)
|
||
// {
|
||
// //储能发送功率 补全总功率数据
|
||
// //DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
// SlaveClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
// SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】放电补全目标差值，【从储能】正常放电";
|
||
// }
|
||
// else //储能不能满足总的差值
|
||
// {
|
||
// //满功率放电
|
||
// //储能全功率放电，不足的部分电网自动补全
|
||
// SlaveClient.ServerCmd.CmdPw = (SlaveClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
// SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】全功率放电无法补全差值，【从储能】全功率放电";
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// //储能处于待机状态，防止其他的状态残留
|
||
// SlaveClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
// SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
// SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】无法放电，【从储能】不动作";
|
||
// }
|
||
//}
|
||
//else
|
||
//{
|
||
// //真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
// SlaveClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
// SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
// SlaveControlMsg = "【从储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【从储能】不动作";
|
||
//}
|
||
|
||
////只能一个放电，另一个停止放电
|
||
//MasterClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryNoSolar】-{ex.Message}");
|
||
}
|
||
}
|
||
}, NoSolarTokenSource.Token);
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 推出 NoSolar
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitNoSolar()
|
||
{
|
||
NoSolarTokenSource.Cancel();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-离开【EntryNoSolar】模式");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 进入 Wait 等待状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntryWait()
|
||
{
|
||
CurESChargInfo = ESChargInfo.Wait;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【Wait】模式 ");
|
||
WaitTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntryWait】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.Wait)
|
||
{
|
||
try
|
||
{
|
||
if (WaitTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//等待期间 关闭两个储能柜的输出
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
//等待期间 两个储能柜关闭液冷
|
||
SlaveClient.ServerCmd.CoolOnOffCmd = false;
|
||
MasterClient.ServerCmd.CoolOnOffCmd = false;
|
||
|
||
Thread.Sleep(30000);
|
||
|
||
//WaitEnvActionResult
|
||
|
||
//循环执行方法
|
||
// 1） 关闭光伏输出，为了确保安全，防止光伏这个时候比较还输出导致逆流产生
|
||
//确认光伏是否立刻断开
|
||
//当通信失败时,则认为光伏关闭，不需要通信确认光伏关闭
|
||
if (CheckSolarState() == false && GetTotalRtSolarPw() < 5)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【Wait】状态-确认光伏是否立刻断开，确认等待光伏结果值是OK的");
|
||
WaitSolarActionResult = true;
|
||
}
|
||
else
|
||
{
|
||
WaitSolarActionResult = false;
|
||
//不满足条件的话，可能还在动作中，功率还没有降低到快为0,需要判断是否关闭，如果关闭了就需要等待，不需要再关闭了
|
||
if (CheckSolarState() == true)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【Wait】状态-光伏不满足条件，关闭光伏");
|
||
CloseSolar();
|
||
}
|
||
}
|
||
|
||
// 2） 监控开关状态和合闸 确保电闸符合要求
|
||
//先检查状态
|
||
if (CheckSwitchState(PreESChargInfo))
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【Wait】状态-检查电闸状态，状态符合要求");
|
||
WaitEleSwitchActionResult = true;
|
||
|
||
}
|
||
else//不满足状态，则先关闭电操，然后开启对应的电操
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【Wait】状态-检查电闸状态，不状态符合要求，关闭所有电操，重新合闸需要的电操");
|
||
//关电操
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
|
||
//等待2秒
|
||
Thread.Sleep(3000);
|
||
|
||
SetControlModelNoBeforClose(PreESChargInfo);
|
||
}
|
||
|
||
//准备满足条件，可以切换状态
|
||
if (WaitSolarActionResult && WaitEleSwitchActionResult)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【Wait】状态-所有的状态都满足，开始进行预设的模式切换");
|
||
|
||
switch (PreESChargInfo)
|
||
{
|
||
case ESChargInfo.Inital:
|
||
break;
|
||
case ESChargInfo.Master:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.MasterTrig);
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.SlaveTrig);
|
||
break;
|
||
case ESChargInfo.Night_Master:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.Night_MasterTrig);
|
||
break;
|
||
case ESChargInfo.Night_Slave:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.Night_SlaveTrig);
|
||
break;
|
||
case ESChargInfo.Wait:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
break;
|
||
case ESChargInfo.NoSolar:
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.NoSolarTrig);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryWait】-{ex.Message}");
|
||
}
|
||
}
|
||
}, WaitTokenSource.Token);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 等待的光伏动作结果值
|
||
/// </summary>
|
||
private bool WaitSolarActionResult { get; set; } = false;
|
||
|
||
/// <summary>
|
||
/// 等待环境切换结果值 PCS 液冷
|
||
/// 先关掉PCS和液冷
|
||
/// 直接切换电操长时间会导致PCS和液冷报错。
|
||
/// </summary>
|
||
private bool WaitEnvActionResult { get; set; } = false;
|
||
|
||
/// <summary>
|
||
/// 等待的电操动作结果值
|
||
/// </summary>
|
||
private bool WaitEleSwitchActionResult { get; set; } = false;
|
||
|
||
/// <summary>
|
||
/// 退出 Wait 等待状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitWait()
|
||
{
|
||
WaitTokenSource.Cancel();
|
||
|
||
//开启液冷
|
||
SlaveClient.ServerCmd.CoolOnOffCmd = true;
|
||
MasterClient.ServerCmd.CoolOnOffCmd = true;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-离开【EntryWait】模式");
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 进入 Night_Slave
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntryNight_Slave()
|
||
{
|
||
CurESChargInfo = ESChargInfo.Night_Slave;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【Night_Slave】模式 ");
|
||
Night_SlaveTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntryNight_Slave】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
double? lastSlaveNightTargetSoc = null;
|
||
bool? lastSlaveShouldCharge = null;
|
||
bool? lastSlaveInWeekendTime = null;
|
||
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.Night_Slave)
|
||
{
|
||
try
|
||
{
|
||
Thread.Sleep(1000);
|
||
if (Night_SlaveTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
////打开光伏
|
||
//if (CheckSolarState() == false)
|
||
//{
|
||
// OpenSolar();
|
||
//}
|
||
|
||
bool inWeekendTime = IsInWeekendTime();
|
||
var slaveNightTargetSoc = Math.Min(NightSlave_ToSlaveFullSoc, ConfigDataService.energyStorageRunConfig.BMSSocUpSignLimitValue);
|
||
bool shouldCharge = !inWeekendTime && SlaveClient.ClientInfo!.SOC < slaveNightTargetSoc;
|
||
|
||
if (lastSlaveNightTargetSoc == null
|
||
|| Math.Abs(lastSlaveNightTargetSoc.Value - slaveNightTargetSoc) > 0.0001
|
||
|| lastSlaveInWeekendTime == null
|
||
|| lastSlaveInWeekendTime.Value != inWeekendTime)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电目标】-模式:Night_Slave，从储能SOC:{SlaveClient.ClientInfo!.SOC:0.##}，配置目标SOC:{NightSlave_ToSlaveFullSoc:0.##}，BMS上限:{ConfigDataService.energyStorageRunConfig.BMSSocUpSignLimitValue:0.##}，采用目标SOC:{slaveNightTargetSoc:0.##}，是否周末禁充:{inWeekendTime}");
|
||
lastSlaveNightTargetSoc = slaveNightTargetSoc;
|
||
lastSlaveInWeekendTime = inWeekendTime;
|
||
}
|
||
|
||
if (lastSlaveShouldCharge == null || lastSlaveShouldCharge.Value != shouldCharge)
|
||
{
|
||
if (shouldCharge)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电开始】-模式:Night_Slave，从储能SOC:{SlaveClient.ClientInfo!.SOC:0.##}，目标SOC:{slaveNightTargetSoc:0.##}");
|
||
}
|
||
else
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电停止】-模式:Night_Slave，从储能SOC:{SlaveClient.ClientInfo!.SOC:0.##}，目标SOC:{slaveNightTargetSoc:0.##}，是否周末禁充:{inWeekendTime}");
|
||
}
|
||
lastSlaveShouldCharge = shouldCharge;
|
||
}
|
||
|
||
if (!inWeekendTime)
|
||
{
|
||
//展示用
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
|
||
//循环执行方法
|
||
//从储能箱充满为止
|
||
if (SlaveClient.ClientInfo!.SOC < slaveNightTargetSoc)
|
||
{
|
||
//主储能箱充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = SlaveClient.ClientInfo!.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio;
|
||
|
||
}
|
||
else
|
||
{
|
||
//从储能箱充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
|
||
//主储能箱不运行
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
//周五或者周六
|
||
//主从都不充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
//MasterControlMsg = "【主储能】周五周六晚上不充电，【主储能】不动作";
|
||
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
//SlaveControlMsg = "【从储能】周五周六晚上不充电，【从储能】不动作";
|
||
}
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryAlarm】-{ex.Message}");
|
||
}
|
||
}
|
||
}, Night_SlaveTokenSource.Token);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 退出 Night_Slave
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitNight_Slave()
|
||
{
|
||
Night_SlaveTokenSource.Cancel();
|
||
//退出Night_Slave状态，关闭输出
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-离开【EntryNight_Slave】模式");
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 进入 Night_Master状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntryNight_Master()
|
||
{
|
||
CurESChargInfo = ESChargInfo.Night_Master;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【Night_Master】模式 ");
|
||
Night_MasterTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntryNight_Master】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
double? lastMasterNightTargetSoc = null;
|
||
bool? lastMasterShouldCharge = null;
|
||
bool? lastMasterInWeekendTime = null;
|
||
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.Night_Master)
|
||
{
|
||
try
|
||
{
|
||
Thread.Sleep(1000);
|
||
if (Night_MasterTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
////打开光伏
|
||
//if (CheckSolarState() == false)
|
||
//{
|
||
// OpenSolar();
|
||
//}
|
||
|
||
bool inWeekendTime = IsInWeekendTime();
|
||
var masterNightTargetSoc = Math.Min(NightMaster_ToMasterFullSoc, ConfigDataService.energyStorageRunConfig.BMSSocUpSignLimitValue);
|
||
bool shouldCharge = !inWeekendTime && MasterClient.ClientInfo!.SOC < masterNightTargetSoc;
|
||
|
||
if (lastMasterNightTargetSoc == null
|
||
|| Math.Abs(lastMasterNightTargetSoc.Value - masterNightTargetSoc) > 0.0001
|
||
|| lastMasterInWeekendTime == null
|
||
|| lastMasterInWeekendTime.Value != inWeekendTime)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电目标】-模式:Night_Master，主储能SOC:{MasterClient.ClientInfo!.SOC:0.##}，配置目标SOC:{NightMaster_ToMasterFullSoc:0.##}，BMS上限:{ConfigDataService.energyStorageRunConfig.BMSSocUpSignLimitValue:0.##}，采用目标SOC:{masterNightTargetSoc:0.##}，是否周末禁充:{inWeekendTime}");
|
||
lastMasterNightTargetSoc = masterNightTargetSoc;
|
||
lastMasterInWeekendTime = inWeekendTime;
|
||
}
|
||
|
||
if (lastMasterShouldCharge == null || lastMasterShouldCharge.Value != shouldCharge)
|
||
{
|
||
if (shouldCharge)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电开始】-模式:Night_Master，主储能SOC:{MasterClient.ClientInfo!.SOC:0.##}，目标SOC:{masterNightTargetSoc:0.##}");
|
||
}
|
||
else
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now}-【夜间充电停止】-模式:Night_Master，主储能SOC:{MasterClient.ClientInfo!.SOC:0.##}，目标SOC:{masterNightTargetSoc:0.##}，是否周末禁充:{inWeekendTime}");
|
||
}
|
||
lastMasterShouldCharge = shouldCharge;
|
||
}
|
||
|
||
if (!inWeekendTime)
|
||
{
|
||
//展示用
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
|
||
//循环执行方法
|
||
//主储能箱充满为止
|
||
if (MasterClient.ClientInfo!.SOC < masterNightTargetSoc)
|
||
{
|
||
//主储能箱充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = MasterClient.ClientInfo!.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio;
|
||
|
||
}
|
||
else
|
||
{
|
||
//主储能箱充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
|
||
//从储能箱不运行
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
}
|
||
else
|
||
{
|
||
//周五或者周六
|
||
//主从都不充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
//MasterControlMsg = "【主储能】周五周六晚上不充电，【主储能】不动作";
|
||
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
//SlaveControlMsg = "【从储能】周五周六晚上不充电，【从储能】不动作";
|
||
}
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryAlarm】-{ex.Message}");
|
||
}
|
||
}
|
||
}, Night_MasterTokenSource.Token);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 推出 Night_Master状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitNight_Master()
|
||
{
|
||
Night_MasterTokenSource.Cancel();
|
||
//退出Night_Master状态，关闭输出
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-离开【EntryNight_Master】模式");
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 进入 Slave状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntrySlave()
|
||
{
|
||
CurESChargInfo = ESChargInfo.Slave;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【Slave】模式 ");
|
||
SlaveTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntrySlave】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.Slave)
|
||
{
|
||
try
|
||
{
|
||
Thread.Sleep(1000);
|
||
if (SlaveTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//打开光伏
|
||
if (CheckSolarState() == false)
|
||
{
|
||
OpenSolar();
|
||
}
|
||
|
||
//循环执行方法
|
||
|
||
//在峰的时候放电
|
||
//if (PeakValleySglModel == ElePVEnum.TopPeak || PeakValleySglModel == ElePVEnum.Peak)
|
||
if (ConfigDataService.IsTimeCanDischarge())
|
||
{
|
||
///////////////////Slave从控制柜给管理大楼供电
|
||
//注意方向
|
||
//从储能箱体放电的控制
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
{
|
||
//Slave 从储能箱根据负载情况给管理大楼放电
|
||
//可以放电的话，则
|
||
if (SlaveClient.IsCanDisCharg())
|
||
{
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
if (ManageDifLoad < SlaveClient.ClientInfo!.MaxDisChargPw)
|
||
{
|
||
//储能发送功率 补全总功率数据
|
||
//DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
SlaveClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】放电补全目标差值，【从储能】正常放电";
|
||
}
|
||
else //储能不能满足总的差值
|
||
{
|
||
//满功率放电
|
||
//储能全功率放电，不足的部分电网自动补全
|
||
SlaveClient.ServerCmd.CmdPw = (SlaveClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】全功率放电无法补全差值，【从储能】全功率放电";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//储能处于待机状态，防止其他的状态残留
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】无法放电，【从储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【从储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//展示用
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：当前未处于峰和尖峰时刻，【从储能】不动作";
|
||
}
|
||
|
||
|
||
///////////////主储能箱体充电 吸收光伏能量的控制
|
||
//注意方向
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
TotalSolarPw = Math.Abs(SolarEleMeter2.AvePw + SolarEleMeter3.AvePw);
|
||
|
||
//调节储能吸收光伏能量来调节光伏到税务大楼的能量，根据真实负载的值来判断是否调控介入
|
||
if (TaxRealPw > TaxTargetPwBigSmallUp)
|
||
{
|
||
////////////////////调节使光伏尽可能满足税务大楼////////////////////
|
||
|
||
if (MasterClient.IsCanCharg())
|
||
{
|
||
//差值 这个差值是3号电表已经补充进去之后差值
|
||
TaxDifLoad = TaxRealPw - TaxTargetPw;
|
||
|
||
//*************** 储能和光伏综合调节达到这个差值 TaxDifLoad ***************
|
||
if (TaxDifLoad < TotalSolarPw)//光伏的现在能力能达到这个差值，就是可以调节
|
||
{
|
||
//差值
|
||
var difValue1 = TotalSolarPw - TaxDifLoad;
|
||
// 储能吸收这个差值，剩余的TaxDifLoad 光伏值给税务大楼，以达到要求
|
||
MasterClient.ServerCmd.CmdPw = difValue1;
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】充电满足差值，【主储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//当前光伏的所有能量无法满足需要这个差值，那么全部光伏给税务大楼，储能不进行充电
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】不需要充电，把光伏都给税务大楼，【主储能】不动作";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】无法充电，【主储能】停止工作";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
/////////////真实的负载小于目标值
|
||
//让主储能尽力充电吸走光伏的能力，为了防止逆流，
|
||
|
||
if (MasterClient.IsCanCharg())
|
||
{
|
||
if (TotalSolarPw < MasterClient.ClientInfo!.MaxChargPw)
|
||
{
|
||
//光伏发电能力小于储能充电的能力，储能把光伏吸收完全
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = TotalSolarPw;
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】完全吸收光伏电能，【主储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//光伏发电能力大于储能充电能力，则储能尽可能充电吧，存在逆流可能了，储能尽力了 【存在逆流的可能性】
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = (MasterClient.ClientInfo!.MaxChargPw * ConfigDataService.energyStorageRunConfig.MaxBatChargRatio);
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：税务大楼负载小，【主储能】最大功率充电吸收光伏电能，存在【逆流】可能性!!!!!!!!!!!!!!!!!!";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】无法充电，【主储能】停止工作";
|
||
}
|
||
|
||
}
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryAlarm】-{ex.Message}");
|
||
}
|
||
}
|
||
}, SlaveTokenSource.Token);
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 退出 Slave状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitSlave()
|
||
{
|
||
SlaveTokenSource.Cancel();
|
||
//退出Slave状态，关闭输出
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-离开【EntrySlave】模式");
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 进入 Master状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void EntryMaster()
|
||
{
|
||
CurESChargInfo = ESChargInfo.Master;
|
||
Console.WriteLine($"时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}-【月浦】- 运行进入【Master】模式 ");
|
||
MasterTokenSource = new CancellationTokenSource();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-进入【EntryMaster】模式");
|
||
|
||
Task.Run(() =>
|
||
{
|
||
//判断状态是否正确
|
||
while (CurESChargInfo == ESChargInfo.Master)
|
||
{
|
||
try
|
||
{
|
||
Thread.Sleep(1000);
|
||
if (MasterTokenSource.IsCancellationRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//打开光伏
|
||
if (CheckSolarState() == false)
|
||
{
|
||
OpenSolar();
|
||
}
|
||
|
||
//循环执行方法
|
||
|
||
//在峰的时候放电
|
||
//if (PeakValleySglModel == ElePVEnum.TopPeak || PeakValleySglModel == ElePVEnum.Peak)
|
||
if (ConfigDataService.IsTimeCanDischarge())
|
||
{
|
||
///////////////////Master主控制柜给管理大楼供电
|
||
//注意方向
|
||
//主储能箱体放电的控制
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
{
|
||
//Master 主储能箱根据负载情况给管理大楼放电
|
||
//可以放电的话，则
|
||
if (MasterClient.IsCanDisCharg())
|
||
{
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
if (ManageDifLoad < MasterClient.ClientInfo.MaxDisChargPw)
|
||
{
|
||
//储能发送功率 补全总功率数据
|
||
//DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
MasterClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】放电补全目标差值，【主储能】正常放电";
|
||
}
|
||
else //储能不能满足总的差值
|
||
{
|
||
//满功率放电
|
||
//储能全功率放电，不足的部分电网自动补全
|
||
MasterClient.ServerCmd.CmdPw = (MasterClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】全功率放电无法补全差值，【主储能】全功率放电";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//储能处于待机状态，防止其他的状态残留
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】无法放电，【主储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
MasterClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【主储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
|
||
MasterClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：当前未处于峰和尖峰时刻，【主储能】不放电";
|
||
}
|
||
|
||
|
||
|
||
|
||
///////////////从储能箱体充电 吸收光伏能量的控制
|
||
//注意方向
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
TotalSolarPw = Math.Abs(SolarEleMeter2.AvePw + SolarEleMeter3.AvePw);
|
||
|
||
//调节储能吸收光伏能量来调节光伏到税务大楼的能量，根据真实负载的值来判断是否调控介入
|
||
//税务真实的负载比较大的时候，储能参与调控吸收能量，真实的负载比较小的时候，则调动储能吸收全部光伏能量。
|
||
//这个点的判断跟其他的标准的不一样
|
||
if (TaxRealPw >= TaxTargetPwBigSmallUp)//TaxTargetPwBigSmall则是认为税务负载大和小的值
|
||
{
|
||
//有负载，并且认为负载较大，则参与调控
|
||
////////////////////调节使光伏尽可能满足税务大楼////////////////////
|
||
|
||
if (SlaveClient.IsCanCharg())
|
||
{
|
||
//差值 这个差值是3号电表已经补充进去之后差值
|
||
TaxDifLoad = TaxRealPw - TaxTargetPw;
|
||
|
||
//*************** 储能和光伏综合调节使3号电表给税务大楼供电达到这个差值 TaxDifLoad ***************
|
||
if (TaxDifLoad < TotalSolarPw)//光伏的现在能力能达到这个差值，就是可以调节
|
||
{
|
||
//差值
|
||
var difValue1 = TotalSolarPw - TaxDifLoad;
|
||
// 储能吸收这个差值，剩余的TaxDifLoad 光伏值给税务大楼，以达到要求
|
||
SlaveClient.ServerCmd.CmdPw = difValue1;
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】充电满足差值1，【从储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//当前光伏的所有能量无法满足需要这个差值，那么全部光伏给税务大楼，储能不进行充电
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】不需要充电，把光伏都给税务大楼2，【从储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//从储能无法充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】无法充电3，【从储能】停止工作";
|
||
}
|
||
}
|
||
else//真实的负载比较小的时候，认为负载很小，则考虑调动储能吸收光伏能量。
|
||
{
|
||
//观测3号电表的情况，维持3号电表的数据就相当于控制光伏输出到税务大楼的能量
|
||
//这样控制会比较直接，否则波动有点大
|
||
|
||
if (SlaveClient.IsCanCharg())
|
||
{
|
||
if (TotalSolarPw < SlaveClient.ClientInfo!.MaxChargPw)
|
||
{
|
||
//光伏发电能力小于储能充电的能力，储能把光伏吸收完全
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = TotalSolarPw;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】完全吸收光伏电能4，【从储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//光伏发电能力大于储能充电能力，则储能尽可能充电吧，存在逆流可能了，储能尽力了 【存在逆流的可能性】
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = (SlaveClient.ClientInfo!.MaxChargPw * ConfigDataService.energyStorageRunConfig.MaxBatChargRatio);
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：税务大楼负载小5，【从储能】最大功率充电吸收光伏电能，存在【逆流】可能性";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//从储能无法充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】无法充电，【从储能】停止工作";
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【EntryAlarm】-{ex.Message}");
|
||
}
|
||
}
|
||
}, MasterTokenSource.Token);
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 退出 Master状态
|
||
/// </summary>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
private void ExitMaster()
|
||
{
|
||
MasterTokenSource.Cancel();
|
||
//退出Master状态，关闭输出
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-推出【EntryMaster】模式");
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取运行状态
|
||
/// </summary>
|
||
private void GetRunState()
|
||
{
|
||
|
||
///////////////////确认控制模式////////////////////////////////////////
|
||
//在白天的情况下，主储能箱和从储能储能箱切换的标准：以不浪费光伏为主
|
||
//依据当前的状态判断是否需要切换到其他状态
|
||
switch (CurESChargInfo)
|
||
{
|
||
case ESChargInfo.Master:
|
||
//判断从储能箱是否被光伏充满，以不浪费光伏为主
|
||
if (SlaveClient.ClientInfo!.SOC >= 85)
|
||
{
|
||
//从储能箱充满，那么具备切换的条件，还需要判断一下，主储能箱体是否被消耗掉
|
||
if (MasterClient.ClientInfo!.SOC <= 80)
|
||
{
|
||
if (PreCheckIsESChargInfoChange(ESChargInfo.Slave))
|
||
{
|
||
if (!IsESChargInfoChange)
|
||
{
|
||
//模式改变的话，先关闭输出，继续下一个循环，给开关动作预留时间
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
IsESChargInfoChange = true;
|
||
return;
|
||
}
|
||
}
|
||
|
||
//从储能箱充满，主储能箱未满，则可以切换
|
||
CurESChargInfo = ESChargInfo.Slave;
|
||
IsESChargInfoChange = false;
|
||
//SetControlModel(CurESChargInfo);
|
||
}
|
||
else
|
||
{
|
||
//从储能箱充满，主储能箱并没有完全释放完毕，即是两个储能箱体都满了，
|
||
//从储能箱停止光伏充电，直到主储能箱释放能量后再切换
|
||
//那么此时如果光伏发电很大，税务大楼负载很小，触发光伏并网柜的逆流保护，切换光伏并网柜的市电，光伏停止输出，从储能箱PCS无市电会报错（交流欠压）。
|
||
//还能切换回来吗？如何恢复？
|
||
//当主储能继续放电，那么后面可以切换，
|
||
// 1）从储能箱体切到管理大楼（从储能箱从刚才的报错中恢复正常），主储能箱切换到税务大楼并网柜（已经停止市电连接了），也会PCS无市电主储能箱报错（交流欠压），需要人过来切换3号电表附近的那个开关
|
||
// 2) 切到晚上了，主储能没有影响，从储能本身就满了，然后继续无市电，报错
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//以不浪费光伏为主
|
||
//从储能箱光伏没有充满，维持当前的状态，可能主储能箱在放电中或者放电到SOC低后停止放电
|
||
|
||
}
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
//判断主储能箱是否被光伏充满，以不浪费光伏为主
|
||
if (MasterClient.ClientInfo!.SOC >= 85)
|
||
{
|
||
//主储能箱充满，那么具备切换的条件，还需要判断一下，从储能箱体是否被消耗掉
|
||
if (SlaveClient.ClientInfo!.SOC <= 80)
|
||
{
|
||
if (PreCheckIsESChargInfoChange(ESChargInfo.Master))
|
||
{
|
||
if (!IsESChargInfoChange)
|
||
{
|
||
//模式改变的话，先关闭输出，继续下一个循环，给开关动作预留时间
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
IsESChargInfoChange = true;
|
||
return;
|
||
}
|
||
}
|
||
//主储能箱充满，从储能箱未满，则可以切换
|
||
CurESChargInfo = ESChargInfo.Master;
|
||
IsESChargInfoChange = false;
|
||
//SetControlModel(CurESChargInfo);
|
||
}
|
||
else
|
||
{
|
||
//主储能箱充满，从储能箱并没有完全释放完毕，即是两个储能箱体都满了，
|
||
//主储能箱停止光伏充电，直到从储能箱释放能量后再切换
|
||
// 那么此时如果光伏发电很大，税务大楼负载很小，触发光伏并网柜的逆流保护，切换光伏并网柜的市电，光伏停止输出，主储能箱PCS无市电会报错（交流欠压）。
|
||
//还能切换回来吗？如何恢复？
|
||
//当从储能继续放电，那么后面可以切换，
|
||
// 1）主储能箱体切到管理大楼（主储能箱从刚才的报错中恢复正常），从储能箱切换到税务大楼并网柜（已经停止市电连接了），也会PCS无市电从储能箱报错，需要人过来切换3号电表附近的那个开关
|
||
// 2) 切到晚上了，主储能切换到管理大楼，无市电导致PCS报错消失，正常运行，但是已经满了，晚上也不会充电了，从储能开始无市电，PCS报错（交流欠压）
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//主储能箱光伏没有充满，维持当前的状态
|
||
}
|
||
break;
|
||
//为什么白天有Night_Master的判断，因为从晚上切换到白天时，需要由晚上作为旧的基础模型然后切换到Master或者Slaver
|
||
//先判断白天晚上，然后再具体操作模式，从晚上到白天后，具体模式还是晚上，需要从晚上的模式到白天的Master或者Slaver模式
|
||
case ESChargInfo.Night_Master:
|
||
//从晚上切换到白天切换，默认晚上给主储能箱充电满了，直接到Master模式
|
||
//判断主储能箱是否被光伏充满，以不浪费光伏为主
|
||
//还需要判断吗？直接到Master不就行了嘛
|
||
if (MasterClient.ClientInfo!.SOC >= 70)
|
||
{
|
||
//主储能箱充满，那么具备切换的条件，还需要判断一下，从储能箱体是否被消耗掉
|
||
if (SlaveClient.ClientInfo!.SOC <= 60)
|
||
{
|
||
if (PreCheckIsESChargInfoChange(ESChargInfo.Master))
|
||
{
|
||
if (!IsESChargInfoChange)
|
||
{
|
||
//模式改变的话，先关闭输出，继续下一个循环，给开关动作预留时间
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
IsESChargInfoChange = true;
|
||
return;
|
||
}
|
||
}
|
||
//主储能箱充满，从储能箱未满，则可以切换
|
||
CurESChargInfo = ESChargInfo.Master;
|
||
IsESChargInfoChange = false;
|
||
//SetControlModel(CurESChargInfo);
|
||
}
|
||
else
|
||
{
|
||
//主储能箱充满，从储能箱并没有完全释放完毕，即是两个储能箱体都满了，
|
||
//主储能箱停止光伏充电，直到从储能箱释放能量后再切换
|
||
// 那么此时如果光伏发电很大，税务大楼负载很小，触发光伏并网柜的逆流保护，切换光伏并网柜的市电，光伏停止输出，主储能箱PCS无市电会报错（交流欠压）。
|
||
//还能切换回来吗？如何恢复？
|
||
//当从储能继续放电，那么后面可以切换，
|
||
// 1）主储能箱体切到管理大楼（主储能箱从刚才的报错中恢复正常），从储能箱切换到税务大楼并网柜（已经停止市电连接了），也会PCS无市电从储能箱报错，需要人过来切换3号电表附近的那个开关
|
||
// 2) 切到晚上了，主储能切换到管理大楼，无市电导致PCS报错消失，正常运行，但是已经满了，晚上也不会充电了，从储能开始无市电，PCS报错（交流欠压）
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//主储能箱光伏没有充满，维持当前的状态
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 手动运行模式切换
|
||
/// </summary>
|
||
public void HandRunModel(ESChargInfo Value)
|
||
{
|
||
switch (Value)
|
||
{
|
||
case ESChargInfo.Inital:
|
||
break;
|
||
case ESChargInfo.Master:
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
PreESChargInfo = ESChargInfo.Slave;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
break;
|
||
case ESChargInfo.Night_Master:
|
||
PreESChargInfo = ESChargInfo.Night_Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
break;
|
||
case ESChargInfo.Wait:
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Master的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource MasterTokenSource { get; set; }
|
||
|
||
/// <summary>
|
||
/// Slave的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource SlaveTokenSource { get; set; }
|
||
|
||
/// <summary>
|
||
/// Night_Master的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource Night_MasterTokenSource { get; set; }
|
||
|
||
/// <summary>
|
||
/// Night_Slave的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource Night_SlaveTokenSource { get; set; }
|
||
|
||
|
||
/// <summary>
|
||
/// Wait的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource WaitTokenSource { get; set; }
|
||
|
||
/// <summary>
|
||
/// NoSolar的线程取消操作
|
||
/// </summary>
|
||
private CancellationTokenSource NoSolarTokenSource { get; set; }
|
||
|
||
/// <summary>
|
||
/// 关闭系统：停止线程循环并断开所有通信连接
|
||
/// </summary>
|
||
public void CloseSystem()
|
||
{
|
||
// 先关闭扫描线程使能，令 while(ThreadEnable) 循环尽快退出
|
||
try { ThreadEnable = false; } catch { }
|
||
try { MasterTokenSource?.Cancel(); } catch { }
|
||
try { SlaveTokenSource?.Cancel(); } catch { }
|
||
try { Night_MasterTokenSource?.Cancel(); } catch { }
|
||
try { Night_SlaveTokenSource?.Cancel(); } catch { }
|
||
try { WaitTokenSource?.Cancel(); } catch { }
|
||
try { NoSolarTokenSource?.Cancel(); } catch { }
|
||
|
||
// 停止输出，置零功率
|
||
try { if (SlaveClient != null) { SlaveClient.ServerCmd.CmdPw = 0; } } catch { }
|
||
try { if (MasterClient != null) { MasterClient.ServerCmd.CmdPw = 0; } } catch { }
|
||
|
||
// 断开设备通信
|
||
try { SolarMdDrive?.Close(); } catch { }
|
||
try { MeterMdDrive?.Close(); } catch { }
|
||
try { ModbusTcpNetDrive?.ConnectClose(); } catch { }
|
||
try { BmsDataService.CloseDrive(); } catch { }
|
||
try { FFService.CloseDrive(); } catch { }
|
||
try { InPowerPCSDataService.CloseModbusRtu(); } catch { }
|
||
|
||
}
|
||
/// <summary>
|
||
/// 预先状态
|
||
/// 就是确定目标状态，先进入准备状态时这个预先的状态信息，等条件具备后再进行操作
|
||
/// </summary>
|
||
private ESChargInfo PreESChargInfo { get; set; }
|
||
|
||
#endregion
|
||
|
||
private bool _YuPuAutoHand = true;
|
||
/// <summary>
|
||
/// 手自动信息
|
||
/// 0未手动 false
|
||
/// 1为自动 true
|
||
/// </summary>
|
||
public bool YuPuAutoHand
|
||
{
|
||
get { return _YuPuAutoHand; }
|
||
set { _YuPuAutoHand = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 客户端集合
|
||
/// </summary>
|
||
public List<DistClient> ListDistClients { get; set; }
|
||
|
||
/// <summary>
|
||
/// 主客户端
|
||
/// </summary>
|
||
public DistClient MasterClient { get; set; }
|
||
|
||
/// <summary>
|
||
/// Slave客户端
|
||
/// </summary>
|
||
public DistClient SlaveClient { get; set; }
|
||
|
||
/// <summary>
|
||
/// 扫描线程
|
||
/// </summary>
|
||
private void MeterScanDeviceStart()
|
||
{
|
||
ScanDeviceTask = Task.Run(async () =>
|
||
{
|
||
while (ThreadEnable)
|
||
{
|
||
await Task.Delay(20);
|
||
|
||
//DiagnosticsTime.Reset();
|
||
//DiagnosticsTime.Start();
|
||
try
|
||
{
|
||
//1号电表 站号1
|
||
OperateResultBytes1 = MeterMdDrive.Read($"s=1;0", 35);
|
||
if (OperateResultBytes1.IsSuccess)
|
||
{
|
||
//有符号功率 二次有功功率数据，单位 W，转换成一次功率需乘上电流、电压变比 地址 07H
|
||
//转换成Kw /1000 CT=80
|
||
EsEleMeter1.RtPw = MeterMdDrive.ByteTransform.TransInt16(OperateResultBytes1.Content, 14) * 80.0 / 1000.0;//
|
||
EsEleMeter1.EleQ_P = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes1.Content, 58) * 80.0 / 100.0;//
|
||
EsEleMeter1.EleQ_N = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes1.Content, 62) * 80.0 / 100.0;//
|
||
|
||
//通信正常
|
||
EsEleMeter1.MeterLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信正常
|
||
EsEleMeter1.MeterLinkState = false;
|
||
}
|
||
|
||
//2号电表 站号2
|
||
OperateResultBytes2 = MeterMdDrive.Read($"s=2;0", 35);
|
||
if (OperateResultBytes2.IsSuccess)
|
||
{
|
||
//有符号功率 二次有功功率数据，单位 W，转换成一次功率需乘上电流、电压变比 地址 07H
|
||
//转换成Kw /1000 CT=20
|
||
SolarEleMeter2.RtPw = MeterMdDrive.ByteTransform.TransInt16(OperateResultBytes2.Content, 14) * 20.0 / 1000.0;//
|
||
SolarEleMeter2.EleQ_P = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes2.Content, 58) * 20.0 / 100.0;//
|
||
SolarEleMeter2.EleQ_N = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes2.Content, 62) * 20.0 / 100.0;//
|
||
|
||
//通信正常
|
||
SolarEleMeter2.MeterLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信正常
|
||
SolarEleMeter2.MeterLinkState = false;
|
||
}
|
||
|
||
//3号电表 站号3
|
||
OperateResultBytes3 = MeterMdDrive.Read($"s=3;0", 35);
|
||
if (OperateResultBytes3.IsSuccess)
|
||
{
|
||
//有符号功率 二次有功功率数据，单位 W，转换成一次功率需乘上电流、电压变比 地址 07H
|
||
//转换成Kw /1000 CT=80
|
||
SolarEleMeter3.RtPw = MeterMdDrive.ByteTransform.TransInt16(OperateResultBytes3.Content, 14) * 80.0 / 1000.0;//
|
||
SolarEleMeter3.EleQ_P = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes3.Content, 58) * 80.0 / 100.0;//
|
||
SolarEleMeter3.EleQ_N = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes3.Content, 62) * 80.0 / 100.0;//
|
||
|
||
//通信正常
|
||
SolarEleMeter3.MeterLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信正常
|
||
SolarEleMeter3.MeterLinkState = false;
|
||
}
|
||
|
||
//4号电表 站号4
|
||
OperateResultBytes4 = MeterMdDrive.Read($"s=4;0", 35);
|
||
if (OperateResultBytes4.IsSuccess)
|
||
{
|
||
//有符号功率 二次有功功率数据，单位 W，转换成一次功率需乘上电流、电压变比 地址 07H
|
||
//转换成Kw /1000 CT=80
|
||
EsEleMeter4.RtPw = MeterMdDrive.ByteTransform.TransInt16(OperateResultBytes4.Content, 14) * 80.0 / 1000.0;//
|
||
EsEleMeter4.EleQ_P = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes4.Content, 58) * 80.0 / 100.0;//
|
||
EsEleMeter4.EleQ_N = MeterMdDrive.ByteTransform.TransUInt32(OperateResultBytes4.Content, 62) * 80.0 / 100.0;//
|
||
|
||
//通信正常
|
||
EsEleMeter4.MeterLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信正常
|
||
EsEleMeter4.MeterLinkState = false;
|
||
}
|
||
|
||
//5号电表 站号5
|
||
OperateResultBytes5 = MeterMdDrive.Read($"s=5;x=3;2048", 28);
|
||
if (OperateResultBytes5.IsSuccess)
|
||
{
|
||
//081AH 总有功功率 4 R 081CH A 相无功功
|
||
//本身单位Kw
|
||
SolarEleMeter5.RtPw = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes5.Content, 52);//
|
||
|
||
//Psum = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 52);//BaseIndex1 + 0x81A
|
||
//Qsum = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 68);//BaseIndex1 + 0x822
|
||
//Ua = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 0);//BaseIndex1 + 0x800
|
||
//Ub = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 4);//BaseIndex1 + 0x802
|
||
//Uc = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 8);//BaseIndex1 + 0x804
|
||
//Ia = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 24);//BaseIndex1 + 0x80C
|
||
//Ib = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 28);//BaseIndex1 + 0x80E
|
||
//Ic = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 32);//BaseIndex1 + 0x810
|
||
|
||
//cosQ = MeterMdDrive.ByteTransform.TransSingle(OperateResultBytes1.Content, 100);//BaseIndex1 + 0x832
|
||
|
||
//通信正常
|
||
SolarEleMeter5.MeterLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信正常
|
||
SolarEleMeter5.MeterLinkState = false;
|
||
}
|
||
|
||
//两个合并的电能减去晚上储能空调的电能
|
||
SolarTotalPw = SolarEleMeter3.EleQ_N + SolarEleMeter2.EleQ_N - SolarEleMeter3.EleQ_P;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
|
||
}
|
||
|
||
|
||
//DiagnosticsTime.Stop();
|
||
//ScanRtTimeinfo = $"电表：{DiagnosticsTime.Elapsed.TotalMilliseconds.ToString()}";
|
||
}
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// 远程IO扫描线程
|
||
/// </summary>
|
||
private void ReIOScanDeviceStart()
|
||
{
|
||
ReIOScanDeviceTask = Task.Run(async () =>
|
||
{
|
||
while (ThreadEnable)
|
||
{
|
||
await Task.Delay(100);
|
||
|
||
//DiagnosticsTime.Reset();
|
||
//DiagnosticsTime.Start();
|
||
try
|
||
{
|
||
ReIOOperateResultBytes1 = ModbusTcpNetDrive.ReadBool($"x=1;1", 8);
|
||
if (ReIOOperateResultBytes1.IsSuccess)
|
||
{
|
||
QFSwitch1.CurSwtichState = GetSwitch(ReIOOperateResultBytes1.Content[0]);//DI1
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.On)
|
||
{
|
||
QFSwitch1.CurSwitchStateInfo = SwitchStateInfo.On;
|
||
}
|
||
else
|
||
{
|
||
QFSwitch1.CurSwitchStateInfo = SwitchStateInfo.Off;
|
||
}
|
||
QFSwitch2.CurSwtichState = GetSwitch(ReIOOperateResultBytes1.Content[2]);//DI3
|
||
if (QFSwitch2.CurSwtichState == SwitchEm.On)
|
||
{
|
||
QFSwitch2.CurSwitchStateInfo = SwitchStateInfo.On;
|
||
}
|
||
else
|
||
{
|
||
QFSwitch2.CurSwitchStateInfo = SwitchStateInfo.Off;
|
||
}
|
||
QFSwitch3.CurSwtichState = GetSwitch(ReIOOperateResultBytes1.Content[4]);//DI5
|
||
if (QFSwitch3.CurSwtichState == SwitchEm.On)
|
||
{
|
||
QFSwitch3.CurSwitchStateInfo = SwitchStateInfo.On;
|
||
}
|
||
else
|
||
{
|
||
QFSwitch3.CurSwitchStateInfo = SwitchStateInfo.Off;
|
||
}
|
||
QFSwitch4.CurSwtichState = GetSwitch(ReIOOperateResultBytes1.Content[6]);//DI7
|
||
if (QFSwitch4.CurSwtichState == SwitchEm.On)
|
||
{
|
||
QFSwitch4.CurSwitchStateInfo = SwitchStateInfo.On;
|
||
}
|
||
else
|
||
{
|
||
QFSwitch4.CurSwitchStateInfo = SwitchStateInfo.Off;
|
||
}
|
||
|
||
|
||
QFSwitch1.CurSwtichErrInfo = GetSwitchErr(ReIOOperateResultBytes1.Content[1]);//DI2
|
||
if (QFSwitch1.CurSwtichErrInfo == SwitchErr.NG)
|
||
{
|
||
QFSwitch1.CurSwitchStateInfo = SwitchStateInfo.Err;
|
||
}
|
||
QFSwitch2.CurSwtichErrInfo = GetSwitchErr(ReIOOperateResultBytes1.Content[3]);//DI4
|
||
if (QFSwitch2.CurSwtichErrInfo == SwitchErr.NG)
|
||
{
|
||
QFSwitch2.CurSwitchStateInfo = SwitchStateInfo.Err;
|
||
}
|
||
QFSwitch3.CurSwtichErrInfo = GetSwitchErr(ReIOOperateResultBytes1.Content[5]);//DI6
|
||
if (QFSwitch3.CurSwtichErrInfo == SwitchErr.NG)
|
||
{
|
||
QFSwitch3.CurSwitchStateInfo = SwitchStateInfo.Err;
|
||
}
|
||
QFSwitch4.CurSwtichErrInfo = GetSwitchErr(ReIOOperateResultBytes1.Content[7]);//DI8
|
||
if (QFSwitch4.CurSwtichErrInfo == SwitchErr.NG)
|
||
{
|
||
QFSwitch4.CurSwitchStateInfo = SwitchStateInfo.Err;
|
||
}
|
||
|
||
|
||
//通信正常
|
||
ReIOLinkState = true;
|
||
}
|
||
else
|
||
{
|
||
//通信失败
|
||
ReIOLinkState = false;
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
|
||
}
|
||
|
||
|
||
//DiagnosticsTime.Stop();
|
||
//ScanRtTimeinfo = $"电表：{DiagnosticsTime.Elapsed.TotalMilliseconds.ToString()}";
|
||
}
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// 光伏设备的扫描 YuPuSolarTask
|
||
/// </summary>
|
||
private void SolarScanDeviceStart()
|
||
{
|
||
YuPuSolarTask = Task.Run(async () =>
|
||
{
|
||
while (ThreadEnable)
|
||
{
|
||
await Task.Delay(400);
|
||
|
||
//DiagnosticsTime.Reset();
|
||
//DiagnosticsTime.Start();
|
||
try
|
||
{
|
||
SolarOperateResultBytes1 = SolarMdDrive.Read($"s=2;x=4;5000", 35);
|
||
if (SolarOperateResultBytes1.IsSuccess)
|
||
{
|
||
SolarRtPw1 = SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes1.Content, 62) * 1.0 / 1000;//
|
||
//通信正常
|
||
SolarLinkState = true;
|
||
SolarLinkTrigTimeModel.UpdateByBool(true);
|
||
}
|
||
else
|
||
{
|
||
//通信失败
|
||
SolarLinkState = false;
|
||
SolarLinkTrigTimeModel.UpdateByBool(false);
|
||
}
|
||
|
||
SolarOperateResultBytes2 = SolarMdDrive.Read($"s=3;x=4;5000", 35);
|
||
if (SolarOperateResultBytes2.IsSuccess)
|
||
{
|
||
//跟手册不太一样 TransUInt32
|
||
SolarRtPw2 = SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes2.Content, 62) * 1.0 / 1000;//
|
||
//通信正常
|
||
SolarLinkState = true;
|
||
SolarLinkTrigTimeModel.UpdateByBool(true);
|
||
|
||
|
||
SolarTotalRt = SolarRtPw1 + SolarRtPw2;
|
||
}
|
||
else
|
||
{
|
||
//通信失败
|
||
SolarLinkState = false;
|
||
SolarLinkTrigTimeModel.UpdateByBool(false);
|
||
|
||
//同时
|
||
SolarTotalRt = 0;
|
||
}
|
||
|
||
SolarOperateResultBytes3 = SolarMdDrive.Read($"s=2;5000", 10);
|
||
if (SolarOperateResultBytes3.IsSuccess)
|
||
{
|
||
if (SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes3.Content, 12) == 0xCE)
|
||
{
|
||
SolarRtState1 = false;
|
||
}
|
||
else if (SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes3.Content, 12) == 0xCF)
|
||
{
|
||
SolarRtState1 = true;
|
||
}
|
||
|
||
//通信正常
|
||
SolarLinkState = true;
|
||
SolarLinkTrigTimeModel.UpdateByBool(true);
|
||
}
|
||
else
|
||
{
|
||
//通信失败
|
||
SolarLinkState = false;
|
||
SolarLinkTrigTimeModel.UpdateByBool(false);
|
||
}
|
||
|
||
|
||
SolarOperateResultBytes4 = SolarMdDrive.Read($"s=3;5000", 10);
|
||
if (SolarOperateResultBytes4.IsSuccess)
|
||
{
|
||
if (SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes4.Content, 12) == 0xCE)
|
||
{
|
||
SolarRtState2 = false;
|
||
}
|
||
else if (SolarMdDrive.ByteTransform.TransUInt16(SolarOperateResultBytes4.Content, 12) == 0xCF)
|
||
{
|
||
SolarRtState2 = true;
|
||
}
|
||
|
||
//通信正常
|
||
SolarLinkState = true;
|
||
SolarLinkTrigTimeModel.UpdateByBool(true);
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
//通信失败
|
||
SolarLinkState = false;
|
||
SolarLinkTrigTimeModel.UpdateByBool(false);
|
||
}
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
|
||
}
|
||
|
||
|
||
//DiagnosticsTime.Stop();
|
||
//ScanRtTimeinfo = $"电表：{DiagnosticsTime.Elapsed.TotalMilliseconds.ToString()}";
|
||
}
|
||
});
|
||
}
|
||
|
||
|
||
|
||
private double _EsSoc1;
|
||
/// <summary>
|
||
/// 储能1的SOC
|
||
/// </summary>
|
||
public double EsSoc1
|
||
{
|
||
get { return _EsSoc1; }
|
||
set { _EsSoc1 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _EsSoc2;
|
||
/// <summary>
|
||
/// 储能2的SOC
|
||
/// </summary>
|
||
public double EsSoc2
|
||
{
|
||
get { return _EsSoc2; }
|
||
set { _EsSoc2 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _EsSoe2;
|
||
/// <summary>
|
||
/// 储能2的SOE
|
||
/// </summary>
|
||
public double EsSoe2
|
||
{
|
||
get { return _EsSoe2; }
|
||
set { _EsSoe2 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _EsSoe1;
|
||
/// <summary>
|
||
/// 储能1的SOE
|
||
/// </summary>
|
||
public double EsSoe1
|
||
{
|
||
get { return _EsSoe1; }
|
||
set { _EsSoe1 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _EsSoh1;
|
||
/// <summary>
|
||
/// 储能1的SOH
|
||
/// </summary>
|
||
public double EsSoh1
|
||
{
|
||
get { return _EsSoh1; }
|
||
set { _EsSoh1 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _EsSoh2;
|
||
/// <summary>
|
||
/// 储能2的SOH
|
||
/// </summary>
|
||
public double EsSoh2
|
||
{
|
||
get { return _EsSoh2; }
|
||
set { _EsSoh2 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _SolarRtPw1;
|
||
/// <summary>
|
||
/// 光伏1 实时功率
|
||
/// 来自于光伏
|
||
/// </summary>
|
||
public double SolarRtPw1
|
||
{
|
||
get { return _SolarRtPw1; }
|
||
set { _SolarRtPw1 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _SolarRtPw2;
|
||
/// <summary>
|
||
/// 光伏1 实时功率
|
||
/// 来自于光伏
|
||
/// </summary>
|
||
public double SolarRtPw2
|
||
{
|
||
get { return _SolarRtPw2; }
|
||
set { _SolarRtPw2 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private bool _SolarRtState1;
|
||
/// <summary>
|
||
/// 光伏1的状态
|
||
/// 开关的状态
|
||
/// True 开 False 关
|
||
/// </summary>
|
||
public bool SolarRtState1
|
||
{
|
||
get { return _SolarRtState1; }
|
||
set { _SolarRtState1 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private bool _SolarRtState2;
|
||
/// <summary>
|
||
/// 光伏2的状态
|
||
/// 开关的状态
|
||
/// True 开 False 关
|
||
/// </summary>
|
||
public bool SolarRtState2
|
||
{
|
||
get { return _SolarRtState2; }
|
||
set { _SolarRtState2 = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _SolarTotalPw;
|
||
/// <summary>
|
||
///光伏总电能
|
||
///两个仪表合并得到
|
||
/// </summary>
|
||
public double SolarTotalPw
|
||
{
|
||
get { return _SolarTotalPw; }
|
||
set { _SolarTotalPw = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _SolarTotalRt;
|
||
/// <summary>
|
||
///光伏的实时功率
|
||
///两个仪表合并得到
|
||
/// </summary>
|
||
public double SolarTotalRt
|
||
{
|
||
get { return _SolarTotalRt; }
|
||
set { _SolarTotalRt = value; RaisePropertyChanged(); }
|
||
|
||
}
|
||
/// <summary>
|
||
/// 关闭光伏
|
||
/// 两个光伏
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool CloseSolar()
|
||
{
|
||
var result1 = SolarMdDrive.Write("s=2;5006", (ushort)0xCE);
|
||
var result2 = SolarMdDrive.Write("s=3;5006", (ushort)0xCE);
|
||
if (result1.IsSuccess && result2.IsSuccess)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 开启光伏
|
||
/// 两个光伏
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool OpenSolar()
|
||
{
|
||
var result1 = SolarMdDrive.Write("s=2;5006", (ushort)0xCF);
|
||
var result2 = SolarMdDrive.Write("s=3;5006", (ushort)0xCF);
|
||
if (result1.IsSuccess && result2.IsSuccess)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置光伏输出百分比
|
||
/// 两个光伏
|
||
/// ratio是比值，1.1 0.5 0.1等
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool SetSolarRatioValue(double ratio)
|
||
{
|
||
if (ratio > 1.1)
|
||
{
|
||
ratio = 1.1;
|
||
}
|
||
else if (ratio < 0)
|
||
{
|
||
ratio = 0;
|
||
}
|
||
|
||
//好像两个光伏板的功率不一样
|
||
short Value = (short)(ratio * 1000);
|
||
|
||
var result1 = SolarMdDrive.Write("s=2;5008", Value);
|
||
var result2 = SolarMdDrive.Write("s=3;5008", Value);
|
||
if (result1.IsSuccess && result2.IsSuccess)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取光伏的运行状态
|
||
/// True 是开
|
||
/// False 是关
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool CheckSolarState()
|
||
{
|
||
if (!SolarLinkState)//通信失败，则认为光伏关闭了
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (SolarRtState1 && SolarRtState2)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取光伏的实时功率
|
||
/// 来自于光伏
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public double GetTotalRtSolarPw()
|
||
{
|
||
if (SolarLinkState)//如果通信正常，则可以使用光伏的数据
|
||
{
|
||
return SolarRtPw1 + SolarRtPw2;
|
||
}
|
||
//否则使用电表的数据
|
||
return Math.Abs(SolarEleMeter3.RtPw);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取状态值
|
||
/// </summary>
|
||
/// <param name="value"></param>
|
||
/// <returns></returns>
|
||
private SwitchEm GetSwitch(bool value)
|
||
{
|
||
if (value)
|
||
{
|
||
return SwitchEm.On;
|
||
}
|
||
return SwitchEm.Off;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取Err信息
|
||
/// </summary>
|
||
/// <param name="value"></param>
|
||
/// <returns></returns>
|
||
private SwitchErr GetSwitchErr(bool value)
|
||
{
|
||
if (value)
|
||
{
|
||
return SwitchErr.NG;
|
||
}
|
||
return SwitchErr.OK;
|
||
}
|
||
|
||
private double _ManageRealPw;
|
||
/// <summary>
|
||
/// 管理大楼真实的负载
|
||
/// </summary>
|
||
public double ManageRealPw
|
||
{
|
||
get { return _ManageRealPw; }
|
||
set { _ManageRealPw = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _TaxRealPw;
|
||
/// <summary>
|
||
/// 税务大楼的真实的负载
|
||
/// </summary>
|
||
public double TaxRealPw
|
||
{
|
||
get { return _TaxRealPw; }
|
||
set { _TaxRealPw = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 管理大楼 实际负载和目标值的差值
|
||
/// </summary>
|
||
public double ManageDifLoad { get; set; }
|
||
|
||
|
||
private string _CurESChargMsg = "Master";
|
||
/// <summary>
|
||
/// 消息内容
|
||
/// </summary>
|
||
public string CurESChargMsg
|
||
{
|
||
get { return _CurESChargMsg; }
|
||
set { _CurESChargMsg = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
|
||
private ESChargInfo _CurESChargInfo;
|
||
/// <summary>
|
||
///两个储能箱体选择切换的功能状态
|
||
///两个储能箱在管理大楼和税务大楼切换
|
||
/// </summary>
|
||
public ESChargInfo CurESChargInfo
|
||
{
|
||
get { return _CurESChargInfo; }
|
||
set
|
||
{
|
||
if (_CurESChargInfo != value)//状态改变，进行切换
|
||
{
|
||
//改变后进行开关控制操作
|
||
//SetControlModel(value);
|
||
_CurESChargInfo = value;
|
||
CurESChargMsg = value.ToString();
|
||
}
|
||
_CurESChargInfo = value;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 预先检查状态是否会改变
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool PreCheckIsESChargInfoChange(ESChargInfo value)
|
||
{
|
||
if (value != _CurESChargInfo)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否改变模式
|
||
/// </summary>
|
||
public bool IsESChargInfoChange { get; set; } = false;
|
||
|
||
private double _TotalSolarPw;
|
||
/// <summary>
|
||
/// 光伏的总的输出功率
|
||
/// </summary>
|
||
public double TotalSolarPw
|
||
{
|
||
get { return _TotalSolarPw; }
|
||
set { _TotalSolarPw = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载介入的阈值 上限值
|
||
/// </summary>
|
||
public double TaxTargetPwUp { get; set; } = 10;
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载介入的阈值 中间值
|
||
/// </summary>
|
||
public double TaxTargetPwMid { get; set; } = 10;
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载介入的阈值 中间值
|
||
/// </summary>
|
||
public double TaxTargetPw { get; set; } = 6;
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载介入的阈值 下限值
|
||
/// </summary>
|
||
public double TaxTargetPwDown { get; set; } = 18;
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载是大还是小的判断值
|
||
/// </summary>
|
||
public double TaxTargetPwBigSmallUp { get; set; } = 8;
|
||
|
||
/// <summary>
|
||
/// 税务大楼根据真实负载是大还是小的判断值
|
||
/// </summary>
|
||
public double TaxTargetPwBigSmallDown { get; set; } = 15;
|
||
|
||
/// <summary>
|
||
/// 管理大楼根据真实负载介入的阈值
|
||
/// </summary>
|
||
public double ManageTargetPw { get; set; } = 8;
|
||
|
||
|
||
/// <summary>
|
||
/// 逆流的阀值
|
||
/// </summary>
|
||
public double TaxCurBackFlow { get; set; }
|
||
|
||
/// <summary>
|
||
/// 税务大楼 负载和目标值的差值
|
||
/// </summary>
|
||
public double TaxDifLoad { get; set; }
|
||
|
||
|
||
private string _MasterControlMsg;
|
||
/// <summary>
|
||
/// Master控制逻辑消息文本
|
||
/// </summary>
|
||
public string MasterControlMsg
|
||
{
|
||
get { return _MasterControlMsg; }
|
||
set { _MasterControlMsg = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private string _SlaveControlMsg;
|
||
/// <summary>
|
||
/// Slave控制逻辑消息文本
|
||
/// </summary>
|
||
public string SlaveControlMsg
|
||
{
|
||
get { return _SlaveControlMsg; }
|
||
set { _SlaveControlMsg = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _SolarToEsAsFullSoc = 97;
|
||
/// <summary>
|
||
/// 光伏给储能充电 作为满的比值
|
||
/// 90-97
|
||
/// </summary>
|
||
public double SolarToEsAsFullSoc
|
||
{
|
||
get { return _SolarToEsAsFullSoc; }
|
||
set { _SolarToEsAsFullSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _Master_ToSlaveByMasterSoc = 5;
|
||
/// <summary>
|
||
/// Master模式，切换到Slave模式时MasterSOC的阀值
|
||
/// 两个同时考虑
|
||
/// </summary>
|
||
public double Master_ToSlaveByMasterSoc
|
||
{
|
||
get { return _Master_ToSlaveByMasterSoc; }
|
||
set { _Master_ToSlaveByMasterSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _Master_ToSlaveBySlaveSoc = 15;
|
||
/// <summary>
|
||
/// Master模式，切换到Slave模式时Slave SOC的阀值
|
||
/// 两个同时考虑
|
||
/// </summary>
|
||
public double Master_ToSlaveBySlaveSoc
|
||
{
|
||
get { return _Master_ToSlaveBySlaveSoc; }
|
||
set { _Master_ToSlaveBySlaveSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _Master_SolarToSlaveEsFullByMasterSoc = 95;
|
||
/// <summary>
|
||
/// Master模式，光伏给从储能充满了，是否切换到Slave模式，但是此时需要判断主储能MasterSOC是否满了（主储能也满的话，也无法接收光伏的电），否则不切换
|
||
/// 主要考虑尽可能的不浪费光伏的电，主从储能只要有余量就要接受光伏的电，也要防止频繁的切换
|
||
/// < SolarToEsAsFullSoc
|
||
/// </summary>
|
||
public double Master_SolarToSlaveEsFullByMasterSoc
|
||
{
|
||
get { return _Master_SolarToSlaveEsFullByMasterSoc; }
|
||
set { _Master_SolarToSlaveEsFullByMasterSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
|
||
private double _Slave_ToMasterBySlaveSoc = 5;
|
||
/// <summary>
|
||
/// Slave模式，切换到Master模式时SOC的阀值
|
||
/// 两个同时考虑
|
||
/// </summary>
|
||
public double Slave_ToMasterBySlaveSoc
|
||
{
|
||
get { return _Slave_ToMasterBySlaveSoc; }
|
||
set { _Slave_ToMasterBySlaveSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _Slave_ToMasterByMasterSoc = 15;
|
||
/// <summary>
|
||
/// Slave模式，切换到Master模式时SOC的阀值
|
||
/// 两个同时考虑
|
||
/// </summary>
|
||
public double Slave_ToMasterByMasterSoc
|
||
{
|
||
get { return _Slave_ToMasterByMasterSoc; }
|
||
set { _Slave_ToMasterByMasterSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _Slave_SolarToMasterEsFullBySlaverSoc = 95;
|
||
/// <summary>
|
||
/// Slave模式，光伏给主储能充满了，是否切换到Master模式，但是此时需要判断从储能SOC是否满了（从储能也满的话，也无法接收光伏的电），否则不切换
|
||
/// 主要考虑尽可能的不浪费光伏的电，主从储能只要有余量就要接受光伏的电，也要防止频繁的切换
|
||
/// < SolarToEsAsFullSoc
|
||
/// </summary>
|
||
public double Slave_SolarToMasterEsFullBySlaverSoc
|
||
{
|
||
get { return _Slave_SolarToMasterEsFullBySlaverSoc; }
|
||
set { _Slave_SolarToMasterEsFullBySlaverSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private double _NightMaster_ToMasterFullSoc = 98;
|
||
/// <summary>
|
||
/// 晚上，主储能充满的标志，也是切换到从储能的控制标志
|
||
/// </summary>
|
||
public double NightMaster_ToMasterFullSoc
|
||
{
|
||
get { return _NightMaster_ToMasterFullSoc; }
|
||
set { _NightMaster_ToMasterFullSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private double _NightSlave_ToSlaveFullSoc = 98;
|
||
/// <summary>
|
||
/// 晚上，从储能充满的标志，也是切换到主储能的控制标志
|
||
/// </summary>
|
||
public double NightSlave_ToSlaveFullSoc
|
||
{
|
||
get { return _NightSlave_ToSlaveFullSoc; }
|
||
set { _NightSlave_ToSlaveFullSoc = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
|
||
private string _LogicMsg;
|
||
/// <summary>
|
||
/// 逻辑消息
|
||
/// </summary>
|
||
public string LogicMsg
|
||
{
|
||
get { return _LogicMsg; }
|
||
set
|
||
{
|
||
if (value != _LogicMsg)
|
||
{
|
||
RaisePropertyChanged();
|
||
_LogicMsg = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 逻辑扫描1
|
||
/// </summary>
|
||
private void LogicScanOld()
|
||
{
|
||
YuPuLogicScanTask = Task.Run(async () =>
|
||
{
|
||
await Task.Delay(5000);
|
||
//依据光伏发电为主要
|
||
while (ThreadEnable)
|
||
{
|
||
await Task.Delay(2000);
|
||
try
|
||
{
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
///////////////////////////获取当前的是白天还是夜晚,依据时间判断，留有余量，有可能实际已经晚上了，但是负载全部没有了
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
}
|
||
else
|
||
{
|
||
DayNight = DayNightEnum.Night;
|
||
//var SolarCur = SolarEleMeter3.RtPw + SolarEleMeter2.RtPw;
|
||
//根据日落和日出时间判断当前是晚上
|
||
}
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
switch (DayNight)
|
||
{
|
||
//白天
|
||
case DayNightEnum.Day:
|
||
|
||
///////////////////////////主从储能箱如何分配 依据光伏发电为主要,不浪费光伏发电为主线
|
||
|
||
//白天光伏发电：QF4断路器合闸(QF3分闸)，主储能箱给管理大楼供电。QF1断路器合闸，光伏给从储能箱充电（QF2分闸）
|
||
//若从储能箱满电后，QF2、QF3断路器合闸，QF1、QF4分闸，光伏给主储能箱充电，从储能箱给管理大楼供电。
|
||
|
||
///////////////////////根据控制模式进行储能输出信息/////////////////////////
|
||
if (CurESChargInfo == ESChargInfo.Master)//当前是主连接管理大楼作为放电使用，从作为充电吸收光伏
|
||
{
|
||
///////////////////Master主控制柜给管理大楼供电
|
||
//注意方向
|
||
//主储能箱体放电的控制
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
{
|
||
//Master 主储能箱根据负载情况给管理大楼放电
|
||
//可以放电的话，则
|
||
if (MasterClient.IsCanDisCharg())
|
||
{
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
if (ManageDifLoad < MasterClient.ClientInfo.MaxDisChargPw)
|
||
{
|
||
//储能发送功率 补全总功率数据
|
||
//DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
MasterClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】放电补全目标差值，【主储能】正常放电";
|
||
}
|
||
else //储能不能满足总的差值
|
||
{
|
||
//满功率放电
|
||
//储能全功率放电，不足的部分电网自动补全
|
||
MasterClient.ServerCmd.CmdPw = (MasterClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】全功率放电无法补全差值，【主储能】全功率放电";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//储能处于待机状态，防止其他的状态残留
|
||
MasterClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【主储能】无法放电，【主储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
MasterClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
|
||
MasterControlMsg = "【主储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【主储能】不动作";
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///////////////从储能箱体充电 吸收光伏能量的控制
|
||
//注意方向
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
TotalSolarPw = Math.Abs(SolarEleMeter2.AvePw + SolarEleMeter3.AvePw);
|
||
|
||
//调节储能吸收光伏能量来调节光伏到税务大楼的能量，根据真实负载的值来判断是否调控介入
|
||
//税务真实的负载比较大的时候，储能参与调控吸收能量，真实的负载比较小的时候，则调动储能吸收全部光伏能量。
|
||
//这个点的判断跟其他的标准的不一样
|
||
if (TaxRealPw >= TaxTargetPwBigSmallUp)//TaxTargetPwBigSmall则是认为税务负载大和小的值
|
||
{
|
||
//有负载，并且认为负载较大，则参与调控
|
||
////////////////////调节使光伏尽可能满足税务大楼////////////////////
|
||
|
||
if (SlaveClient.IsCanCharg())
|
||
{
|
||
//差值 这个差值是3号电表已经补充进去之后差值
|
||
TaxDifLoad = TaxRealPw - TaxTargetPw;
|
||
|
||
//*************** 储能和光伏综合调节使3号电表给税务大楼供电达到这个差值 TaxDifLoad ***************
|
||
if (TaxDifLoad < TotalSolarPw)//光伏的现在能力能达到这个差值，就是可以调节
|
||
{
|
||
//差值
|
||
var difValue1 = TotalSolarPw - TaxDifLoad;
|
||
// 储能吸收这个差值，剩余的TaxDifLoad 光伏值给税务大楼，以达到要求
|
||
SlaveClient.ServerCmd.CmdPw = difValue1;
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】充电满足差值1，【从储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//当前光伏的所有能量无法满足需要这个差值，那么全部光伏给税务大楼，储能不进行充电
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】不需要充电，把光伏都给税务大楼2，【从储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//从储能无法充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】无法充电3，【从储能】停止工作";
|
||
}
|
||
}
|
||
else//真实的负载比较小的时候，认为负载很小，则考虑调动储能吸收光伏能量。
|
||
{
|
||
//观测3号电表的情况，维持3号电表的数据就相当于控制光伏输出到税务大楼的能量
|
||
//这样控制会比较直接，否则波动有点大
|
||
|
||
if (SlaveClient.IsCanCharg())
|
||
{
|
||
if (TotalSolarPw < SlaveClient.ClientInfo!.MaxChargPw)
|
||
{
|
||
//光伏发电能力小于储能充电的能力，储能把光伏吸收完全
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = TotalSolarPw;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】完全吸收光伏电能4，【从储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//光伏发电能力大于储能充电能力，则储能尽可能充电吧，存在逆流可能了，储能尽力了 【存在逆流的可能性】
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = (SlaveClient.ClientInfo!.MaxChargPw * ConfigDataService.energyStorageRunConfig.MaxBatChargRatio);
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：税务大楼负载小5，【从储能】最大功率充电吸收光伏电能，存在【逆流】可能性";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
//从储能无法充电
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】充电吸收【光伏】电能：【从储能】无法充电，【从储能】停止工作";
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else//当前是从储能箱作为放电，主储能箱作为充电吸收光伏
|
||
{
|
||
///////////////////Slave从控制柜给管理大楼供电
|
||
//注意方向
|
||
//从储能箱体放电的控制
|
||
ManageRealPw = EsEleMeter4.AvePw - EsEleMeter1.AvePw;
|
||
if (ManageRealPw > ManageTargetPw)//真实的负载大于一个值的时候才介入，或者控制关口电表的数据维持在一个水平，两个不同的控制方式
|
||
{
|
||
//Slave 从储能箱根据负载情况给管理大楼放电
|
||
//可以放电的话，则
|
||
if (SlaveClient.IsCanDisCharg())
|
||
{
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg";
|
||
|
||
ManageDifLoad = ManageRealPw - ManageTargetPw;
|
||
if (ManageDifLoad < SlaveClient.ClientInfo!.MaxDisChargPw)
|
||
{
|
||
//储能发送功率 补全总功率数据
|
||
//DisChargPwCmd(AcrelMeters.Psum - EleMeterActionLimitValue.MidValue);
|
||
SlaveClient.ServerCmd.CmdPw = ManageDifLoad;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】放电补全目标差值，【从储能】正常放电";
|
||
}
|
||
else //储能不能满足总的差值
|
||
{
|
||
//满功率放电
|
||
//储能全功率放电，不足的部分电网自动补全
|
||
SlaveClient.ServerCmd.CmdPw = (SlaveClient.ClientInfo.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio);
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】全功率放电无法补全差值，【从储能】全功率放电";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//储能处于待机状态，防止其他的状态残留
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg";//功率为0，充放电的指令类型无所谓
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【从储能】无法放电，【从储能】不动作";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//真实的负载功率比较小，防止储能放电导致逆流，就不需要输出动作了，等真实的负载大于一个值后才开始介入
|
||
SlaveClient.ServerCmd.CmdType = "DisCharg"; //功率为0，充放电的指令类型无所谓
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
|
||
SlaveControlMsg = "【从储能】放电【管理大楼】：【管理大楼】负载较小，为防止放电导致逆流，【从储能】不动作";
|
||
}
|
||
|
||
///////////////主储能箱体充电 吸收光伏能量的控制
|
||
//注意方向
|
||
TaxRealPw = SolarEleMeter5.AvePw - SolarEleMeter3.AvePw;//光伏和市电供应给税务大楼的负载
|
||
TotalSolarPw = Math.Abs(SolarEleMeter2.AvePw + SolarEleMeter3.AvePw);
|
||
|
||
|
||
//调节储能吸收光伏能量来调节光伏到税务大楼的能量，根据真实负载的值来判断是否调控介入
|
||
if (TaxRealPw > TaxTargetPwBigSmallUp)
|
||
{
|
||
////////////////////调节使光伏尽可能满足税务大楼////////////////////
|
||
|
||
if (MasterClient.IsCanCharg())
|
||
{
|
||
//差值 这个差值是3号电表已经补充进去之后差值
|
||
TaxDifLoad = TaxRealPw - TaxTargetPw;
|
||
|
||
//*************** 储能和光伏综合调节达到这个差值 TaxDifLoad ***************
|
||
if (TaxDifLoad < TotalSolarPw)//光伏的现在能力能达到这个差值，就是可以调节
|
||
{
|
||
//差值
|
||
var difValue1 = TotalSolarPw - TaxDifLoad;
|
||
// 储能吸收这个差值，剩余的TaxDifLoad 光伏值给税务大楼，以达到要求
|
||
MasterClient.ServerCmd.CmdPw = difValue1;
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】充电满足差值，【主储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//当前光伏的所有能量无法满足需要这个差值，那么全部光伏给税务大楼，储能不进行充电
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】不需要充电，把光伏都给税务大楼，【主储能】不动作";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】无法充电，【主储能】停止工作";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
/////////////真实的负载小于目标值
|
||
//让主储能尽力充电吸走光伏的能力，为了防止逆流，
|
||
|
||
if (MasterClient.IsCanCharg())
|
||
{
|
||
if (TotalSolarPw < MasterClient.ClientInfo!.MaxChargPw)
|
||
{
|
||
//光伏发电能力小于储能充电的能力，储能把光伏吸收完全
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = TotalSolarPw;
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】完全吸收光伏电能，【主储能】正常充电";
|
||
}
|
||
else
|
||
{
|
||
//光伏发电能力大于储能充电能力，则储能尽可能充电吧，存在逆流可能了，储能尽力了 【存在逆流的可能性】
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = (MasterClient.ClientInfo!.MaxChargPw * ConfigDataService.energyStorageRunConfig.MaxBatChargRatio);
|
||
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：税务大楼负载小，【主储能】最大功率充电吸收光伏电能，存在【逆流】可能性!!!!!!!!!!!!!!!!!!";
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
MasterControlMsg = "【主储能】充电吸收【光伏】电能：【主储能】无法充电，【主储能】停止工作";
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//从储能箱接受电量来自于光伏 从储能箱的光伏充电功率，采用逐步的方法，主要是吸收光伏的电量，不可以吸收税务大楼的电量过来，怎么分配
|
||
|
||
break;
|
||
|
||
//晚上
|
||
case DayNightEnum.Night:
|
||
//进来这个模式时有用，走出Night_Master模式时靠白天的那里的逻辑判断，切换到白天时这里就不走到这里了
|
||
CurESChargInfo = ESChargInfo.Night_Master;
|
||
//SetControlModel(ESChargInfo.Night_Master);
|
||
|
||
//主储能箱充满为止
|
||
var masterNightTargetSoc = Math.Min(NightMaster_ToMasterFullSoc, ConfigDataService.energyStorageRunConfig.BMSSocUpSignLimitValue);
|
||
if (MasterClient.ClientInfo!.SOC < masterNightTargetSoc)
|
||
{
|
||
//主储能箱充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = MasterClient.ClientInfo!.MaxDisChargPw * ConfigDataService.energyStorageRunConfig.MaxBatDisChargRatio;
|
||
|
||
}
|
||
else
|
||
{
|
||
//主储能箱充电
|
||
MasterClient.ServerCmd.CmdType = "Charg";
|
||
MasterClient.ServerCmd.CmdPw = 0;
|
||
}
|
||
|
||
//从储能箱不运行
|
||
SlaveClient.ServerCmd.CmdType = "Charg";
|
||
SlaveClient.ServerCmd.CmdPw = 0;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
|
||
}
|
||
|
||
}
|
||
|
||
});
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 逻辑扫描
|
||
/// 模式切换的模式更改的逻辑扫描
|
||
/// </summary>
|
||
private void LogicScan()
|
||
{
|
||
YuPuLogicScanTask = Task.Run(async () =>
|
||
{
|
||
await Task.Delay(5000);
|
||
//依据光伏发电为主要
|
||
while (ThreadEnable)
|
||
{
|
||
await Task.Delay(2000);
|
||
try
|
||
{
|
||
//实时把税务大楼的并网点的仪表数据给
|
||
SolarCurBackFlow.UpdateByCompareLess(SolarEleMeter5.RtPw);
|
||
|
||
|
||
if (MasterClient == null)//防止未加载导致错误
|
||
{
|
||
continue;
|
||
}
|
||
|
||
EsSoc1 = MasterClient.ClientInfo.SOC;
|
||
EsSoe1 = MasterClient.ClientInfo.SOE;
|
||
EsSoh1 = MasterClient.ClientInfo.SOH;
|
||
|
||
EsSoc2 = SlaveClient.ClientInfo.SOC;
|
||
EsSoe2 = SlaveClient.ClientInfo.SOE;
|
||
EsSoh2 = SlaveClient.ClientInfo.SOH;
|
||
|
||
if (!YuPuAutoHand)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//实时给当前的SOC数据给夜电白放的模型
|
||
//CurNightChargEleModel.MasterSoc = MasterClient.ClientInfo!.SOC;
|
||
//CurNightChargEleModel.SlaveSoc = SlaveClient.ClientInfo!.SOC;
|
||
|
||
///////////////////////////主从储能箱如何分配 依据光伏发电为主要,不浪费光伏发电为主线
|
||
|
||
///////////////////确认控制模式////////////////////////////////////////
|
||
//在白天的情况下，主储能箱和从储能储能箱切换的标准：以不浪费光伏为主
|
||
//依据当前的状态判断是否需要切换到其他状态
|
||
switch (CurESChargInfo)
|
||
{
|
||
case ESChargInfo.Master://当前是白天Master状态
|
||
|
||
///////////////////////////获取当前的是白天还是夜晚,依据时间判断，留有余量，有可能实际已经晚上了，但是负载全部没有了
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
}
|
||
else
|
||
{
|
||
//CurNightChargEleModel.SetDayEndState();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Master】-Master->Night_Master 白天Master 到晚上Night_Master的切换");
|
||
|
||
DayNight = DayNightEnum.Night;
|
||
|
||
PreESChargInfo = ESChargInfo.Night_Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
//var SolarCur = SolarEleMeter3.RtPw + SolarEleMeter2.RtPw;
|
||
//根据日落和日出时间判断当前是晚上
|
||
continue;
|
||
}
|
||
|
||
//?????? 如果昨晚充满了，今天的话，早上就要进入到无光伏的模式了，因为两个都满了 ，设置的数据不要太冲突 ？？？？？？？？
|
||
//从储能箱晚上充电的SOC NightSlave_ToSlaveFullSoc 90 > SolarToEsAsFullSoc 97
|
||
//
|
||
//能到这里说明是白天，也要判断光伏把储能是否充满，充满的话进入无光伏阶段 新策略 是否可以切换
|
||
if (SlaveClient.ClientInfo!.SOC >= SolarToEsAsFullSoc)
|
||
{
|
||
//光伏把从储能充满，此时需要判断主储能是否满，满的话就是都满了进入无光伏阶段
|
||
if (MasterClient.ClientInfo!.SOC >= Master_SolarToSlaveEsFullByMasterSoc)
|
||
{
|
||
//两个储能都满了，进行切换
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Master】-光伏把【从储能】充满SOC:{SlaveClient.ClientInfo!.SOC}，主储能也满了，充满的话进入无光伏阶段 新策略");
|
||
|
||
PreESChargInfo = ESChargInfo.NoSolar;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Master】-从储能箱体被光伏充满SOC:{SlaveClient.ClientInfo!.SOC}，主储能箱体还有余量:{MasterClient.ClientInfo!.SOC}，切换到Slave，让主储能箱接受光伏电量");
|
||
|
||
//主储能箱体放完，从储能箱体还有电，则可以切换
|
||
//先进入等待状态，为切换准备条件
|
||
PreESChargInfo = ESChargInfo.Slave;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
continue;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
//主储能箱体放完为止策略 新策略
|
||
if (MasterClient.ClientInfo!.SOC <= Master_ToSlaveByMasterSoc)
|
||
{
|
||
//此时切换到从储能箱体需要查看从储能箱体的SOC
|
||
if (SlaveClient.ClientInfo!.SOC >= Master_ToSlaveBySlaveSoc)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Master】-主储能箱体放完SOC:{MasterClient.ClientInfo!.SOC}，从储能箱体还有电SOC:{SlaveClient.ClientInfo!.SOC}，切换到Slave");
|
||
|
||
//主储能箱体放完，从储能箱体还有电，则可以切换
|
||
//先进入等待状态，为切换准备条件
|
||
PreESChargInfo = ESChargInfo.Slave;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
LogicMsg = "主储能箱电放完，从储能箱还有电，暂不切换，维持当前状态";
|
||
//主储能箱体放完，从储能箱体也没有电，维持当前状态
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//主储能箱维持当前的状态，
|
||
LogicMsg = "主储能箱电没有放完，维持当前状态";
|
||
}
|
||
|
||
|
||
|
||
////原有的Master逻辑判断
|
||
////判断从储能箱是否被光伏充满，以不浪费光伏为主
|
||
//if (SlaveClient.ClientInfo!.SOC >= 95)
|
||
//{
|
||
// //从储能箱充满，那么具备切换的条件，还需要判断一下，主储能箱体是否被消耗掉
|
||
// if (MasterClient.ClientInfo!.SOC <= 80)
|
||
// {
|
||
// //从储能箱充满，主储能箱未满，则可以切换
|
||
// //先进入等待状态，为切换准备条件
|
||
// PreESChargInfo = ESChargInfo.Slave;
|
||
// SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
// }
|
||
// else
|
||
// {
|
||
// //从储能箱充满，主储能箱并没有完全释放完毕，即是两个储能箱体都满了，
|
||
// //从储能箱停止光伏充电，直到主储能箱释放能量后再切换
|
||
|
||
// //两个储能箱都充满了，无论出于什么原因，都不应该让光伏发电了
|
||
// //1）可能储能报错，无法放电，2）可能节假日，负载很小
|
||
// PreESChargInfo = ESChargInfo.NoSolar;
|
||
// SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
// }
|
||
//}
|
||
//else
|
||
//{
|
||
// //以不浪费光伏为主
|
||
// //从储能箱光伏没有充满，维持当前的状态，可能主储能箱在放电中或者放电到SOC低后停止放电
|
||
|
||
//}
|
||
|
||
|
||
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
///////////////////////////获取当前的是白天还是夜晚,依据时间判断，留有余量，有可能实际已经晚上了，但是负载全部没有了
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
}
|
||
else
|
||
{
|
||
//CurNightChargEleModel.SetDayEndState();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Slave】-Slave->Night_Master 白天Slave 到晚上Night_Master的切换");
|
||
|
||
DayNight = DayNightEnum.Night;
|
||
|
||
PreESChargInfo = ESChargInfo.Night_Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
//var SolarCur = SolarEleMeter3.RtPw + SolarEleMeter2.RtPw;
|
||
//根据日落和日出时间判断当前是晚上
|
||
continue;
|
||
}
|
||
|
||
//判断光伏把主储能是否充满，充满的话进入无光伏阶段 新策略
|
||
if (MasterClient.ClientInfo!.SOC >= SolarToEsAsFullSoc)
|
||
{
|
||
//判断从储能箱放电程度
|
||
if (SlaveClient.ClientInfo!.SOC >= Slave_SolarToMasterEsFullBySlaverSoc)
|
||
{
|
||
//主从储能箱都充满了，无论出于什么原因，都不应该让光伏发电了，进入无光伏阶段
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Slave】-光伏把主储能充满SOC:{MasterClient.ClientInfo!.SOC}，充满的话进入无光伏阶段 新策略");
|
||
|
||
PreESChargInfo = ESChargInfo.NoSolar;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Slave】-主储能箱体被光伏充满SOC:{MasterClient.ClientInfo!.SOC}，从储能箱体还有余量:{SlaveClient.ClientInfo!.SOC}，切换到Master，让从储能箱接受光伏电量");
|
||
|
||
//主储能箱体放完，从储能箱体还有电，则可以切换
|
||
//先进入等待状态，为切换准备条件
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
continue;
|
||
}
|
||
}
|
||
|
||
|
||
//从储能箱体放完为止策略 新策略
|
||
if (SlaveClient.ClientInfo!.SOC <= Slave_ToMasterBySlaveSoc)
|
||
{
|
||
//此时切换到从储能箱体需要查看从储能箱体的SOC
|
||
if (MasterClient.ClientInfo!.SOC >= Slave_ToMasterByMasterSoc)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Slave】-从储能箱体放完SOC:{SlaveClient.ClientInfo!.SOC}，主储能箱体还有电SOC:{MasterClient.ClientInfo!.SOC}，切换到Master");
|
||
|
||
//主储能箱体放完，从储能箱体还有电，则可以切换
|
||
//先进入等待状态，为切换准备条件
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
//主储能箱体放完，从储能箱体也没有电，维持当前状态
|
||
LogicMsg = "从储能箱电放完，主储能箱还有电，暂不切换，维持当前状态";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//主储能箱维持当前的状态
|
||
LogicMsg = "从储能箱电没有放完，维持当前状态";
|
||
}
|
||
|
||
|
||
////原有的Slave逻辑判断
|
||
////判断主储能箱是否被光伏充满，以不浪费光伏为主
|
||
//if (MasterClient.ClientInfo!.SOC >= 95)
|
||
//{
|
||
// //主储能箱充满，那么具备切换的条件，还需要判断一下，从储能箱体是否被消耗掉
|
||
// if (SlaveClient.ClientInfo!.SOC <= 80)
|
||
// {
|
||
// //主储能箱充满，从储能箱未满，则可以切换
|
||
// PreESChargInfo = ESChargInfo.Master;
|
||
// SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
// }
|
||
// else
|
||
// {
|
||
// //主储能箱充满，从储能箱并没有完全释放完毕，即是两个储能箱体都满了，
|
||
// //主储能箱停止光伏充电，直到从储能箱释放能量后再切换
|
||
// // 那么此时如果光伏发电很大，税务大楼负载很小，触发光伏并网柜的逆流保护，切换光伏并网柜的市电，光伏停止输出，主储能箱PCS无市电会报错（交流欠压）。
|
||
|
||
// //两个储能箱都充满了，无论出于什么原因，都不应该让光伏发电了
|
||
// //1）可能储能报错，无法放电，2）可能节假日，负载很小
|
||
// PreESChargInfo = ESChargInfo.NoSolar;
|
||
// SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
// }
|
||
//}
|
||
//else
|
||
//{
|
||
// //主储能箱光伏没有充满，维持当前的状态
|
||
//}
|
||
|
||
|
||
break;
|
||
//为什么白天有Night_Master的判断，因为从晚上切换到白天时，需要由晚上作为旧的基础模型然后切换到Master或者Slaver
|
||
//先判断白天晚上，然后再具体操作模式，从晚上到白天后，具体模式还是晚上，需要从晚上的模式到白天的Master或者Slaver模式
|
||
case ESChargInfo.Night_Master:
|
||
///////////////////////////获取当前的是白天还是夜晚,依据时间判断，留有余量，有可能实际已经晚上了，但是负载全部没有了
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Night_Master】-Night_Master->Master 晚上Night_Master切换到白天的Master");
|
||
|
||
//晚上转到白天，标记每天初始没有完成
|
||
//CurNightChargEleModel.MasterCheck = DischargInfo.NoComplete;
|
||
//CurNightChargEleModel.SlaveCheck = DischargInfo.NoComplete;
|
||
|
||
//CurNightChargEleModel.SetDayInitState(MasterClient.ClientInfo!.SOC, SlaveClient.ClientInfo!.SOC);
|
||
|
||
//晚上切换到白天的话，直接到Master模式
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
//可能转到Night_Slave模式，本身充满，Night没有充满
|
||
if (MasterClient.ClientInfo!.SOC >= NightMaster_ToMasterFullSoc && SlaveClient.ClientInfo!.SOC <= (NightSlave_ToSlaveFullSoc - 10))
|
||
{
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Night_Master】-主储能箱体充满SOC:{MasterClient.ClientInfo!.SOC}，从储能箱体SOC:{SlaveClient.ClientInfo!.SOC}，切换到Night_Slave");
|
||
|
||
//切换到Night_Slave模式
|
||
PreESChargInfo = ESChargInfo.Night_Slave;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
//继续维持当前的状态
|
||
MasterControlMsg = "【主储能】夜晚充电";
|
||
SlaveControlMsg = "【从储能】夜晚待机";
|
||
|
||
LogicMsg = "【主储能】夜晚充电，【从储能】夜晚待机";
|
||
}
|
||
}
|
||
|
||
break;
|
||
case ESChargInfo.Night_Slave:
|
||
///////////////////////////获取当前的是白天还是夜晚,依据时间判断，留有余量，有可能实际已经晚上了，但是负载全部没有了
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Night_Slave】-Night_Slave->Master 晚上Night_Slave切换到白天的Master");
|
||
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
|
||
//晚上转到白天，标记每天初始没有完成
|
||
//CurNightChargEleModel.MasterCheck = DischargInfo.NoComplete;
|
||
//CurNightChargEleModel.SlaveCheck = DischargInfo.NoComplete;
|
||
|
||
//CurNightChargEleModel.SetDayInitState(MasterClient.ClientInfo!.SOC, SlaveClient.ClientInfo!.SOC);
|
||
|
||
//晚上切换到白天的话，直接到Master模式
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
}
|
||
else
|
||
{
|
||
//可能转到Night_Master模式，本身充到SOC=60算充满
|
||
if (SlaveClient.ClientInfo!.SOC >= NightSlave_ToSlaveFullSoc && MasterClient.ClientInfo!.SOC <= (NightMaster_ToMasterFullSoc - 10))
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【Night_Slave】-从储能箱体充满SOC:{SlaveClient.ClientInfo!.SOC}，主储能箱体SOC:{MasterClient.ClientInfo!.SOC}，切换到Night_Master");
|
||
//切换到Night_Slave模式
|
||
PreESChargInfo = ESChargInfo.Night_Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
}
|
||
else
|
||
{
|
||
//继续维持当前的状态
|
||
MasterControlMsg = "【主储能】夜晚待机";
|
||
SlaveControlMsg = "【从储能】夜晚充电";
|
||
|
||
LogicMsg = "【主储能】夜晚待机，【从储能】夜晚充电";
|
||
}
|
||
}
|
||
break;
|
||
case ESChargInfo.Wait:
|
||
LogicMsg = "模式切换中";
|
||
//切换中
|
||
break;
|
||
case ESChargInfo.NoSolar:
|
||
//无光伏参与
|
||
//其中一个储能柜没有满就可以投入到Master/Slave中间
|
||
if (IsBetweenTime(DateTime.Now.ToString(), SunriseTimeStr, SunsetTimeStr))
|
||
{
|
||
//根据日落和日出时间判断当前是白天
|
||
DayNight = DayNightEnum.Day;
|
||
}
|
||
else
|
||
{
|
||
//CurNightChargEleModel.SetDayEndState();
|
||
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【NoSolar】-NoSolar->Night_Master， NoSolar切换晚上Night_Master");
|
||
|
||
DayNight = DayNightEnum.Night;
|
||
|
||
PreESChargInfo = ESChargInfo.Night_Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
|
||
//var SolarCur = SolarEleMeter3.RtPw + SolarEleMeter2.RtPw;
|
||
//根据日落和日出时间判断当前是晚上
|
||
continue;
|
||
}
|
||
|
||
//用Soc小的吸收光伏能量
|
||
|
||
if (SlaveClient.ClientInfo!.SOC <= (SolarToEsAsFullSoc - 10))
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【NoSolar】-从储能箱体SOC:{SlaveClient.ClientInfo!.SOC}，主储能箱体SOC:{MasterClient.ClientInfo!.SOC}，切换到Master");
|
||
|
||
//主给管理大楼放电，从吸收光伏
|
||
PreESChargInfo = ESChargInfo.Master;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
|
||
if (MasterClient.ClientInfo!.SOC <= (SolarToEsAsFullSoc - 10))
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-当前是【NoSolar】-从储能箱体SOC:{SlaveClient.ClientInfo!.SOC}，主储能箱体SOC:{MasterClient.ClientInfo!.SOC}，切换到Slave");
|
||
|
||
//从给管理大楼放电，主吸收光伏
|
||
PreESChargInfo = ESChargInfo.Slave;
|
||
SysRunStateMachine.Fire(ESChargInfoTrig.WaitTrig);
|
||
continue;
|
||
}
|
||
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogService.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
|
||
}
|
||
|
||
}
|
||
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置控制模式
|
||
/// 电操操作之后 要进行储能的状态检查，因为极短时间内储能是断电的
|
||
/// 12 34不能同时合闸，互锁的功能，切换开关时先断然后合闸，中间有时间差
|
||
///因为有互锁的功能，在一组里面所以要先动作要关闭的电操，然后再操作打开的电操
|
||
/// </summary>
|
||
public void SetControlModel(ESChargInfo value)
|
||
{
|
||
switch (value)
|
||
{
|
||
case ESChargInfo.Master:
|
||
SetSwitchClose();
|
||
//主储能给管理大楼供电
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
SetSwitchClose();
|
||
//从储能给管理大楼供电
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch3.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.Night_Master:
|
||
SetSwitchClose();
|
||
//晚上，给主储能箱供电
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置模式
|
||
/// 无先关后设置的命令
|
||
/// </summary>
|
||
/// <param name="value"></param>
|
||
public void SetControlModelNoBeforClose(ESChargInfo value)
|
||
{
|
||
switch (value)
|
||
{
|
||
case ESChargInfo.Master:
|
||
//主储能给管理大楼供电
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.Slave:
|
||
//从储能给管理大楼供电
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch3.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.Night_Master:
|
||
//晚上，给主储能箱供电
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.Night_Slave:
|
||
//晚上，给从储能箱供电
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch3.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
case ESChargInfo.NoSolar:
|
||
//主储能给管理大楼供电
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.On);
|
||
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch1.SetRtSwitch(SwitchEm.On);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 关闭所有的开关
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool SetSwitchClose()
|
||
{
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
|
||
Thread.Sleep(2000);
|
||
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.Off
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 只关闭所有的电操
|
||
/// </summary>
|
||
public void OnlyCloseSwitch()
|
||
{
|
||
QFSwitch1.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch2.SetRtSwitch(SwitchEm.Off);
|
||
|
||
QFSwitch3.SetRtSwitch(SwitchEm.Off);
|
||
QFSwitch4.SetRtSwitch(SwitchEm.Off);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查电操的状态
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool CheckSwitchState(ESChargInfo ESChargInfoData)
|
||
{
|
||
switch (ESChargInfoData)
|
||
{
|
||
case ESChargInfo.Inital:
|
||
return true;
|
||
case ESChargInfo.Master:
|
||
// 1 4ON / 2 3OFF
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.On
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
case ESChargInfo.Slave:
|
||
// 1 4Off / 2 3ON
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.Off
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
case ESChargInfo.Night_Master:
|
||
// 1 4ON / 2 3OFF
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.On
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
case ESChargInfo.Night_Slave:
|
||
// 1 4Off / 2 3ON
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.Off
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
case ESChargInfo.Wait:
|
||
return true;
|
||
case ESChargInfo.NoSolar:
|
||
// 1 4ON / 2 3OFF
|
||
if (QFSwitch1.CurSwtichState == SwitchEm.On &&
|
||
QFSwitch2.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch3.CurSwtichState == SwitchEm.Off &&
|
||
QFSwitch4.CurSwtichState == SwitchEm.On
|
||
)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
default:
|
||
return true;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 检查PCS的状态
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool CheckPCSState()
|
||
{
|
||
return true;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 是周五还是周六
|
||
/// 在晚上判断是周五晚上还是周六晚上，腾出储能给光伏充电用
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool IsSpecialWeekDay()
|
||
{
|
||
return (DateTime.Now.DayOfWeek == DayOfWeek.Friday && IsPm()) || (DateTime.Now.DayOfWeek == DayOfWeek.Saturday && IsPm());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是周五还是周六
|
||
/// 在晚上判断是周五晚上还是周六晚上，腾出储能给光伏充电用
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool IsInWeekendTime()
|
||
{
|
||
DateTime now = DateTime.Now;
|
||
DayOfWeek currentDay = now.DayOfWeek;
|
||
TimeSpan currentTime = now.TimeOfDay;
|
||
|
||
// 周五情况：时间 >= 23:00
|
||
if (currentDay == DayOfWeek.Friday && currentTime.Hours >= 23)
|
||
{
|
||
return true;
|
||
}
|
||
// 周六情况：全天有效
|
||
else if (currentDay == DayOfWeek.Saturday)
|
||
{
|
||
return true;
|
||
}
|
||
// 周日情况：时间 < 07:00
|
||
else if (currentDay == DayOfWeek.Sunday && currentTime.Hours < 7)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否时下午
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool IsPm()
|
||
{
|
||
return DateTime.Now.Hour >= 23;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// 1号电表
|
||
/// </summary>
|
||
public OperateResult<byte[]> OperateResultBytes1 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// 2号电表
|
||
/// </summary>
|
||
public OperateResult<byte[]> OperateResultBytes2 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// 3号电表
|
||
/// </summary>
|
||
public OperateResult<byte[]> OperateResultBytes3 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// 4号电表
|
||
/// </summary>
|
||
public OperateResult<byte[]> OperateResultBytes4 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// 5号电表
|
||
/// </summary>
|
||
public OperateResult<byte[]> OperateResultBytes5 { get; set; }
|
||
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// </summary>
|
||
public OperateResult<bool[]> ReIOOperateResultBytes1 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// </summary>
|
||
public OperateResult<byte[]> SolarOperateResultBytes1 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// </summary>
|
||
public OperateResult<byte[]> SolarOperateResultBytes2 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// </summary>
|
||
public OperateResult<byte[]> SolarOperateResultBytes3 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 读取的字节数据集合
|
||
/// </summary>
|
||
public OperateResult<byte[]> SolarOperateResultBytes4 { get; set; }
|
||
|
||
/// <summary>
|
||
/// ScanDevice扫描Task
|
||
/// </summary>
|
||
static Task ScanDeviceTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// ScanDevice扫描Task
|
||
/// </summary>
|
||
static Task ReIOScanDeviceTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// YuPuLogicScanTask扫描Task
|
||
/// </summary>
|
||
static Task YuPuLogicScanTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// YuPuSolarTask扫描Task
|
||
/// 光伏通信的任务
|
||
/// </summary>
|
||
static Task YuPuSolarTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// Meter 电表通信连接状态
|
||
/// </summary>
|
||
public bool MeterLinkState { get; set; } = true;
|
||
|
||
/// <summary>
|
||
/// ReIO通信连接状态
|
||
/// </summary>
|
||
public bool ReIOLinkState { get; set; } = true;
|
||
|
||
/// <summary>
|
||
/// Solar 电表通信连接状态
|
||
/// 这个状态很重要，很多状态判断使用
|
||
/// </summary>
|
||
public bool SolarLinkState { get; set; } = true;
|
||
|
||
/// <summary>
|
||
/// 扫描线程使能
|
||
/// </summary>
|
||
public bool ThreadEnable { get; set; } = true;
|
||
|
||
/// <summary>
|
||
/// 仪表数据驱动
|
||
/// </summary>
|
||
public ModbusRtu MeterMdDrive { set; get; }
|
||
|
||
/// <summary>
|
||
/// 光伏数据驱动
|
||
/// </summary>
|
||
public ModbusRtu SolarMdDrive { set; get; }
|
||
|
||
/// <summary>
|
||
/// 远程IO ModbusTcp驱动
|
||
/// </summary>
|
||
private ModbusTcpNet ModbusTcpNetDrive { get; set; } = new ModbusTcpNet();
|
||
|
||
/// <summary>
|
||
/// 日出
|
||
/// </summary>
|
||
private string SunriseTimeStr { get; set; } = "5:00";
|
||
|
||
/// <summary>
|
||
/// 日落
|
||
/// </summary>
|
||
private string SunsetTimeStr { get; set; } = "23:00";
|
||
|
||
|
||
//public DayNightEnum DayNight { get; set; }
|
||
|
||
private DayNightEnum _DayNight;
|
||
/// <summary>
|
||
/// 白天和晚上
|
||
/// Day
|
||
/// Night
|
||
/// </summary>
|
||
public DayNightEnum DayNight
|
||
{
|
||
get { return _DayNight; }
|
||
set
|
||
{
|
||
if (_DayNight != value)
|
||
{
|
||
LogService.Info($"时间:{DateTime.Now.ToString()}-【动作】-【DayNight】-【{_DayNight.ToString()}】->【{value.ToString()}】 白天和晚上的切换");
|
||
_DayNight = value;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 开关1
|
||
/// </summary>
|
||
public SwitchModel QFSwitch1 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 开关2
|
||
/// </summary>
|
||
public SwitchModel QFSwitch2 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 开关3
|
||
/// </summary>
|
||
public SwitchModel QFSwitch3 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 开关4
|
||
/// </summary>
|
||
public SwitchModel QFSwitch4 { get; set; }
|
||
|
||
/// <summary>
|
||
/// 光伏并网柜 5号
|
||
/// 税务大楼的负载
|
||
/// 注意方向
|
||
/// </summary>
|
||
public EleMeter SolarEleMeter5 { get; set; } = new EleMeter();
|
||
|
||
/// <summary>
|
||
/// 光伏并网柜 2号
|
||
/// 并网到储能并网柜
|
||
/// 注意方向
|
||
/// </summary>
|
||
public EleMeter SolarEleMeter2 { get; set; } = new EleMeter();
|
||
|
||
/// <summary>
|
||
/// 光伏并网柜 3号
|
||
/// 输出到税务大楼
|
||
/// 注意方向
|
||
/// </summary>
|
||
public EleMeter SolarEleMeter3 { get; set; } = new EleMeter();
|
||
|
||
/// <summary>
|
||
/// 储能并网柜 1号
|
||
/// 输出到管理大楼
|
||
/// 注意方向
|
||
/// </summary>
|
||
public EleMeter EsEleMeter1 { get; set; } = new EleMeter();
|
||
|
||
/// <summary>
|
||
/// 储能并网柜 4号
|
||
/// 管理大楼的市电
|
||
/// 无论电量来自于主储能柜还是来自于从储能柜，都是输出或者输入到管理大楼的的能量
|
||
/// 注意方向
|
||
/// </summary>
|
||
public EleMeter EsEleMeter4 { get; set; } = new EleMeter();
|
||
|
||
///// <summary>
|
||
///// 光伏并网柜 5号
|
||
///// 税务大楼的市电
|
||
///// 注意方向
|
||
///// </summary>
|
||
//public EleMeter EsEleMeter5 { get; set; } = new EleMeter();
|
||
|
||
/// <summary>
|
||
/// 日志服务
|
||
/// </summary>
|
||
public ILogService LogService { get; }
|
||
|
||
/// <summary>
|
||
/// 配置服务信息
|
||
/// </summary>
|
||
public ConfigDataService ConfigDataService { get; }
|
||
public BmsDataService BmsDataService { get; }
|
||
public FFService FFService { get; }
|
||
public InPowerPCSDataService InPowerPCSDataService { get; }
|
||
|
||
|
||
/// <summary>
|
||
/// 判断时间是否在预定的时间区间内
|
||
/// </summary>
|
||
/// <param name="timeStr"></param>
|
||
/// <param name="startTime"></param>
|
||
/// <param name="endTime"></param>
|
||
/// <returns></returns>
|
||
public static bool IsBetweenTime(string timeStr, string startTime, string endTime)
|
||
{
|
||
//判断当前时间是否在工作时间段内
|
||
try
|
||
{
|
||
TimeSpan startSpan = DateTime.Parse(startTime).TimeOfDay;
|
||
TimeSpan endSpan = DateTime.Parse(endTime).TimeOfDay;
|
||
|
||
//string time1 = "2017-2-17 8:10:00";
|
||
DateTime t1 = Convert.ToDateTime(timeStr);
|
||
|
||
|
||
TimeSpan dspNow = t1.TimeOfDay;
|
||
if (dspNow > startSpan && dspNow < endSpan)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 白天还是晚上
|
||
/// </summary>
|
||
public enum DayNightEnum
|
||
{
|
||
Day = 1,
|
||
Night = 2
|
||
}
|
||
|
||
public enum ESChargInfo
|
||
{
|
||
/// <summary>
|
||
/// 初始状态
|
||
/// </summary>
|
||
Inital = 111,
|
||
|
||
/// <summary>
|
||
/// 主储能箱体放电给管理大楼
|
||
/// 从储能接受光伏的充电
|
||
/// </summary>
|
||
Master = 1,
|
||
|
||
/// <summary>
|
||
/// 从储能箱体放电给管理大楼
|
||
/// 主储能接受光伏的充电
|
||
/// </summary>
|
||
Slave = 2,
|
||
|
||
/// <summary>
|
||
/// 晚上
|
||
/// 主储能箱体从管理大楼充电
|
||
/// </summary>
|
||
Night_Master = 3,
|
||
|
||
/// <summary>
|
||
/// 晚上
|
||
/// 从储能箱体从管理大楼充电
|
||
/// </summary>
|
||
Night_Slave = 31,
|
||
|
||
/// <summary>
|
||
/// 等待
|
||
/// 各个状态切换时中间的等待状态
|
||
/// </summary>
|
||
Wait = 4,
|
||
|
||
/// <summary>
|
||
/// 无光伏参与
|
||
/// 负载很小，光伏比较大，并且两个储能柜体已经充满时停止光伏的参与发电，让储能给负载放电
|
||
/// </summary>
|
||
NoSolar = 5,
|
||
}
|
||
|
||
|
||
public enum ESChargInfoTrig
|
||
{
|
||
/// <summary>
|
||
/// 初始状态
|
||
/// </summary>
|
||
InitalTrig = 111,
|
||
|
||
/// <summary>
|
||
/// 主储能箱体放电给管理大楼 触发
|
||
/// 从储能接受光伏的充电
|
||
/// </summary>
|
||
MasterTrig = 1,
|
||
|
||
/// <summary>
|
||
/// 从储能箱体放电给管理大楼 触发
|
||
/// 主储能接受光伏的充电
|
||
/// </summary>
|
||
SlaveTrig = 2,
|
||
|
||
/// <summary>
|
||
/// 晚上 触发
|
||
/// 主储能箱体从管理大楼充电
|
||
/// </summary>
|
||
Night_MasterTrig = 3,
|
||
|
||
/// <summary>
|
||
/// 晚上 触发
|
||
/// 从储能箱体从管理大楼充电
|
||
/// </summary>
|
||
Night_SlaveTrig = 31,
|
||
|
||
/// <summary>
|
||
/// 等待
|
||
/// 各个状态切换时中间的等待状态
|
||
/// </summary>
|
||
WaitTrig = 4,
|
||
|
||
/// <summary>
|
||
/// 无光伏参与
|
||
/// 负载很小，光伏比较大，并且两个储能柜体已经充满时停止光伏的参与发电，让储能给负载放电
|
||
/// </summary>
|
||
NoSolarTrig = 5,
|
||
}
|
||
|
||
/// <summary>
|
||
/// 手自动
|
||
/// </summary>
|
||
public enum YuPuAutoHand
|
||
{
|
||
Hand = 0,
|
||
Auto = 1
|
||
}
|
||
}
|