TyroneGit/YuPu-OrpaonEMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加项目文件。

Browse Source
This commit is contained in:
Tyrone CT
2025-02-28 22:23:13 +08:00
parent d4ad2fe2de
commit 547a1b3bf6
416 changed files with 72830 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

778
OrpaonEMS.App/Services/YuPuPwAnalyzeService.cs Normal file
View File

@@ -0,0 +1,778 @@
using OrpaonEMS.App.Models;
using OrpaonEMS.Model;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
namespace OrpaonEMS.App.Services
{
/// <summary>
/// 月浦
/// 数据分析模型
/// 数据统计模型
/// </summary>
public class YuPuPwAnalyzeService : BindableBase
{
/// <summary>
/// 周期定时器
/// </summary>
private System.Timers.Timer CycleTimer { get; set; }
public ILogService LogService { get; }
/// <summary>
/// 实例化函数
/// </summary>
public YuPuPwAnalyzeService(ILogService logService,
IFreeSql freeSql,
ConfigDataService configDataService,
//SolarEnergyService solarEnergyService,
YuePuRunModelService yuePuRunModelService
)
{
LogService = logService;
this.freeSql = freeSql;
ConfigDataService = configDataService;
//SolarEnergyService = solarEnergyService;
YuePuRunModelService = yuePuRunModelService;
//InPowerPCSDataService = inPowerPCSDataService;
if (ConfigDataService.IsMaster)
{
//10秒触发一次
CycleTimer = new System.Timers.Timer(10000);
CycleTimer.Elapsed += CycleAction;
CycleTimer.AutoReset = true;
CycleTimer.Enabled = true;
LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-开始了");
_CurMinInfo = DateTime.Now.Minute;
LoadInitialYuPuHourDataByDb();
}
//LoadInitStartData();
}
/// <summary>
/// 周期调用这个方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <exception cref="NotImplementedException"></exception>
private void CycleAction(object? sender, ElapsedEventArgs e)
{
try
{
//如果Execute执行的是一个很耗时的方法，会导致方法未执行完毕，定时器又启动了一个线程来执行Execute方法
CycleTimer.Stop(); //先关闭定时器
////先给值
//CurHourInfo = DateTime.Now.Hour;
CurMinInfo = DateTime.Now.Minute;
CurDayInfo = DateTime.Now.Day;
CurMonthInfo = DateTime.Now.Month;
CurYearInfo = DateTime.Now.Year;
CycleTimer.Start(); //执行完毕后再开启器
}
catch (Exception ex)
{
CycleTimer.Start(); //执行完毕后再开启器
LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-CycleAction】-{ex.Message}");
}
}
private ObservableCollection<YuPuHourData> _ListLastYuPuHourData = new ObservableCollection<YuPuHourData>();
/// <summary>
/// 日小数数据集合
/// </summary>
public ObservableCollection<YuPuHourData> ListLastYuPuHourData
{
get { return _ListLastYuPuHourData; }
set { _ListLastYuPuHourData = value; RaisePropertyChanged(); }
}
#region 年月日 时分 触发动作
private int _CurMinInfo;
/// <summary>
/// 当前的分钟信息
/// 用分钟用于触发小时的数据
/// </summary>
private int CurMinInfo
{
get { return _CurMinInfo; }
set
{
EsManageAnalyse.TotalChargPw = YuePuRunModelService.EsEleMeter1.EleQ_P;
EsManageAnalyse.TotalDisChargPw = YuePuRunModelService.EsEleMeter1.EleQ_N;
//日充放电量
EsManageAnalyse.DayChargPw = YuePuRunModelService.EsEleMeter1.EleQ_P - EsManageAnalyse.DayStartPointChargPw;
EsManageAnalyse.DayDisChargPw = YuePuRunModelService.EsEleMeter1.EleQ_N - EsManageAnalyse.DayStartPointDisChargPw;
//月充放电量
EsManageAnalyse.MonthChargPw = EsManageAnalyse.TotalChargPw - EsManageAnalyse.MonthStartPointChargPw;
EsManageAnalyse.MonthDisChargPw = EsManageAnalyse.TotalDisChargPw - EsManageAnalyse.MonthStartPointDisChargPw;
//年充放电量
EsManageAnalyse.YearChargPw = EsManageAnalyse.TotalChargPw - EsManageAnalyse.YearStartPointChargPw;
EsManageAnalyse.YearDisChargPw = EsManageAnalyse.TotalDisChargPw - EsManageAnalyse.YearStartPointDisChargPw;
SolarTaxAnalyse.TotalChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
SolarTaxAnalyse.DayChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.DayStartPointPw;
SolarTaxAnalyse.MonthChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.MonthStartPointPw;
SolarTaxAnalyse.YearChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.YearStartPointPw;
SolarManageAnalyse.TotalChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
SolarManageAnalyse.DayChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.DayStartPointPw;
SolarManageAnalyse.MonthChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.MonthStartPointPw;
SolarManageAnalyse.YearChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.YearStartPointPw;
if (_CurMinInfo != value)
{
//DayChargPw = energyStorage.AcrelMeters.TotalInPWh - DayStartPointChargPw;
//DayDisChargPw = energyStorage.AcrelMeters.TotalOutPWh - DayStartPointDisChargPw;
_CurMinInfo = value;
//分钟改变和分钟数据为0那么需要触发小时保存数据
if (value == 59)
{
RecordYuPuHourData();
}
}
}
}
//private int _CurHourInfo;
///// <summary>
///// 当前的小时信息
///// 用户触发天的信息
///// </summary>
//private int CurHourInfo
//{
// get { return _CurHourInfo; }
// set
// {
// if (_CurHourInfo != value)
// {
// //小时改变和那么需要触发天的数据获取
// if (value == 0)
// {
// StartDayInfo();
// }
// _CurHourInfo = value;
// }
// }
//}
private int _CurDayInfo;
/// <summary>
/// 当前的天的信息
/// </summary>
private int CurDayInfo
{
get { return _CurDayInfo; }
set
{
if (_CurDayInfo != value)
{
var DayInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0);
if (DayInitData != null)
{
//不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
EsManageAnalyse.DayStartPointChargPw = DayInitData.EsManageHourPointChargValue;
EsManageAnalyse.DayStartPointDisChargPw = DayInitData.EsManageHourPointDisChargValue;
SolarTaxAnalyse.DayStartPointPw = DayInitData.SolarTaxHourPointValue;
SolarManageAnalyse.DayStartPointPw = DayInitData.SolarManageHourPointValue;
}
else
{
EsManageAnalyse.DayStartPointChargPw = GetEsAccChargPw();
EsManageAnalyse.DayStartPointDisChargPw = GetEsAccDisChargPw();
SolarTaxAnalyse.DayStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
SolarManageAnalyse.DayStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
}
_CurDayInfo = value;
}
}
}
private int _CurMonthInfo;
/// <summary>
/// 当前的月的信息
/// </summary>
private int CurMonthInfo
{
get { return _CurMonthInfo; }
set
{
if (_CurMonthInfo != value)
{
//月的改变和那么需要触月的数据获取
//需要获取当前月的第一天的数据信息
var MonthInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, 1, 0);
if (MonthInitData != null)
{
//不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
EsManageAnalyse.MonthStartPointChargPw = MonthInitData.EsManageHourPointChargValue;
EsManageAnalyse.MonthStartPointDisChargPw = MonthInitData.EsManageHourPointDisChargValue;
SolarTaxAnalyse.MonthStartPointPw = MonthInitData.SolarTaxHourPointValue;
SolarManageAnalyse.MonthStartPointPw = MonthInitData.SolarManageHourPointValue;
}
else
{
EsManageAnalyse.MonthStartPointChargPw = GetEsAccChargPw();
EsManageAnalyse.MonthStartPointDisChargPw = GetEsAccDisChargPw();
SolarTaxAnalyse.MonthStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
SolarManageAnalyse.MonthStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
}
_CurMonthInfo = value;
}
}
}
private int _CurYearInfo;
/// <summary>
/// 当前的年的信息
/// </summary>
private int CurYearInfo
{
get { return _CurYearInfo; }
set
{
if (_CurYearInfo != value)
{
//var data = new DateTime(DateTime.Now.Year, 1, 1, 0, 0, 1).ToString("yyyy-MM-dd");
//需要获取当前年的第一天的数据信息
var YearInitData = GetHistoryDataInfo(DateTime.Now.Year, 1, 1, 0);
if (YearInitData != null)
{
//不为空的话，则赋值。获取新年第一个小时的数据作为本年的初始数据信息
EsManageAnalyse.YearStartPointChargPw = YearInitData.EsManageHourPointChargValue;
EsManageAnalyse.YearStartPointDisChargPw = YearInitData.EsManageHourPointDisChargValue;
SolarTaxAnalyse.YearStartPointPw = YearInitData.SolarTaxHourPointValue;
SolarManageAnalyse.YearStartPointPw = YearInitData.SolarManageHourPointValue;
}
else
{
EsManageAnalyse.YearStartPointChargPw = GetEsAccChargPw();
EsManageAnalyse.YearStartPointDisChargPw = GetEsAccDisChargPw();
SolarTaxAnalyse.YearStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
SolarManageAnalyse.YearStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
}
_CurYearInfo = value;
}
}
}
/// <summary>
/// ConfigDbData Category数据
/// </summary>
private string Category { get; set; } = "PwAnalyze";
#endregion
/// <summary>
/// 上个小时保存的数据
/// 保存的上个小时的数据
/// </summary>
private YuPuHourData LastHourEnergyData { get; set; }
private IFreeSql freeSql { get; set; }
/// <summary>
/// 当前的配置服务
/// </summary>
public ConfigDataService ConfigDataService { get; }
//public SolarEnergyService SolarEnergyService { get; }
public YuePuRunModelService YuePuRunModelService { get; }
//public InPowerPCSDataService InPowerPCSDataService { get; }
/// <summary>
/// 记录小时数据
/// </summary>
private void RecordYuPuHourData()
{
try
{
var InsertData = freeSql.Insert<YuPuHourData>(new YuPuHourData()
{
WorkDay = DateTime.Now.Day,
Month = DateTime.Now.Month,
Year = DateTime.Now.Year,
HourInfo = DateTime.Now.Hour,
//正向代表给储能充电
//反向代表储能给管理大楼放电
EsManageHourPointChargValue = GetEsAccChargPw(),
EsManageHourPointDisChargValue = GetEsAccDisChargPw(),
EsManageHourCharg = GetEsHourCharg(),
EsManageHourDisCharg = GetEsHourDisCharg(),
//反向代表光伏给税务大楼的供能
SolarTaxHourPointValue = YuePuRunModelService.SolarEleMeter3.EleQ_N,
SolarTaxHourCharg = GetSolarHour(),
SolarManageHourPointValue = YuePuRunModelService.SolarEleMeter2.EleQ_N,
SolarManageHourCharg = GetSolarToManageHour(),
}).ExecuteInserted();
Console.WriteLine($"{DateTime.Now.ToString()}：小时数据触发");
//保存小时数据成功
if (InsertData.Count > 0)
{
LastHourEnergyData = InsertData.FirstOrDefault();
ListLastYuPuHourData = GetDayYuPuHourData();
}
}
catch (Exception ex)
{
LogService.Info($"时间:{DateTime.Now.ToString()}-【RecordYuPuHourData】-{ex.Message}");
}
}
/// <summary>
/// 获取小时数据
/// </summary>
public ObservableCollection<YuPuHourData> GetDayYuPuHourData()
{
try
{
//获取最近12个小时的数据
var Data = freeSql.Select<YuPuHourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();
return new ObservableCollection<YuPuHourData>(Data);
}
catch (Exception ex)
{
LogService.Info($"时间:{DateTime.Now.ToString()}-【ExitPeakValley】-{ex.Message}");
return new ObservableCollection<YuPuHourData>();
}
}
/// <summary>
/// 加载初始的数据
/// </summary>
/// <returns></returns>
public void LoadInitialYuPuHourDataByDb()
{
//如果程序中间中断了一天，那么最新的作为上一个一个小时的数据，那么这个小时的数据会比较大，这个也没有问题，确保总数对的上即可。
var FirstData = freeSql.Select<YuPuHourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();
if (FirstData.Count > 0)
{
LastHourEnergyData = FirstData!.FirstOrDefault();
ListLastYuPuHourData = new ObservableCollection<YuPuHourData>(FirstData);
}
else
{
LastHourEnergyData = new YuPuHourData();
}
}
#region 统计信息
/// <summary>
/// 获取储能的总充电数据
/// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
/// </summary>
/// <returns></returns>
private double GetEsAccChargPw()
{
return YuePuRunModelService.EsEleMeter1.EleQ_P;
}
/// <summary>
/// 获取储能的小时收益数据
/// </summary>
/// <returns></returns>
private double GetEsHourRevenue(double price)
{
return (GetEsHourCharg() - GetEsHourDisCharg()) * price;
}
/// <summary>
/// 获取储能的总放电数据
/// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
/// </summary>
/// <returns></returns>
private double GetEsAccDisChargPw()
{
return YuePuRunModelService.EsEleMeter1.EleQ_N;
}
/// <summary>
/// 获取储能的充电小时数据
/// </summary>
/// <returns></returns>
private double GetEsHourCharg()
{
return GetEsAccChargPw() - LastHourEnergyData.EsManageHourPointChargValue;
}
/// <summary>
/// 获取储能的放电小时数据
/// </summary>
/// <returns></returns>
private double GetEsHourDisCharg()
{
return GetEsAccDisChargPw() - LastHourEnergyData.EsManageHourPointDisChargValue;
}
/// <summary>
/// 获取光伏的放电小时数据
/// </summary>
/// <returns></returns>
private double GetSolarHour()
{
return YuePuRunModelService.SolarEleMeter3.EleQ_N - LastHourEnergyData.SolarTaxHourPointValue;
}
/// <summary>
/// 获取光伏到管理大楼的放电小时数据
/// </summary>
/// <returns></returns>
private double GetSolarToManageHour()
{
return YuePuRunModelService.SolarEleMeter2.EleQ_N - LastHourEnergyData.SolarManageHourPointValue;
}
///// <summary>
///// 新的一年，年的初始信息
///// </summary>
///// <returns></returns>
//private void LoadYearInit()
//{
// //获取今年第一天的数据历史信息
// freeSql.Select<YuPuHourData>().Where(a => a.Year == DateTime.Now.Year && a.Month ==)
//}
/// <summary>
/// 获取年月日的信息
/// </summary>
/// <returns></returns>
private YuPuHourData GetHistoryDataInfo(int Year, int Month, int Day, int hour)
{
//获取今年第一天的数据历史信息
var Data = freeSql.Select<YuPuHourData>().Where(a => a.Year == Year && a.Month == Month && a.WorkDay == Day && a.HourInfo == hour).ToList();
if (Data.Count > 0)
{
return Data.FirstOrDefault();
}
return null;
}
/// <summary>
/// 税务光伏统计模型
/// </summary>
public YuPuSolarTaxAnalyse SolarTaxAnalyse { get; set; } = new YuPuSolarTaxAnalyse();
/// <summary>
/// 管理大楼光伏统计模型
/// </summary>
public YuPuSolarManageAnalyse SolarManageAnalyse { get; set; } = new YuPuSolarManageAnalyse();
/// <summary>
/// 管理大楼储能统计模型
/// </summary>
public YuPuManageAnalyse EsManageAnalyse { get; set; } = new YuPuManageAnalyse();
///// <summary>
///// 液冷统计模型
///// </summary>
//public CoolAnalyse CoolAnalyse { get; set; } = new CoolAnalyse();
#endregion
}
public class YuPuManageAnalyse : BindableBase
{
/// <summary>
/// 一天的开始0时充电量数据
/// </summary>
public double DayStartPointChargPw { get; set; }
/// <summary>
/// 一天的开始0时放电量数据
/// </summary>
public double DayStartPointDisChargPw { get; set; }
/// <summary>
/// 月度的开始1号充电量数据
/// </summary>
public double MonthStartPointChargPw { get; set; }
/// <summary>
/// 月度的开始1号充电量数据
/// </summary>
public double MonthStartPointDisChargPw { get; set; }
/// <summary>
/// 年的开始1号充电量数据
/// </summary>
public double YearStartPointChargPw { get; set; }
/// <summary>
/// 年的开始1号充电量数据
/// </summary>
public double YearStartPointDisChargPw { get; set; }
/// <summary>
/// ////////////////////////////////////储能充电量////////////////////////////////////////////
/// </summary>
private double _DayChargPw;
/// <summary>
/// 储能 日充电量 kWh
/// </summary>
public double DayChargPw
{
get { return _DayChargPw; }
set { _DayChargPw = value; RaisePropertyChanged(); }
}
private double _MonthChargPw;
/// <summary>
/// 储能 月充电量 kWh
/// </summary>
public double MonthChargPw
{
get { return _MonthChargPw; }
set { _MonthChargPw = value; RaisePropertyChanged(); }
}
private double _YearChargPw;
/// <summary>
/// 储能 年充电量 kWh
/// </summary>
public double YearChargPw
{
get { return _YearChargPw; }
set { _YearChargPw = value; RaisePropertyChanged(); }
}
private double _TotalChargPw;
/// <summary>
/// 储能 总充电量 kWh
/// </summary>
public double TotalChargPw
{
get { return _TotalChargPw; }
set { _TotalChargPw = value; RaisePropertyChanged(); }
}
/// <summary>
/// ////////////////////////////////////储能放电量////////////////////////////////////////////
/// </summary>
private double _DayDisChargPw;
/// <summary>
/// 储能 日放电量 kWh
/// </summary>
public double DayDisChargPw
{
get { return _DayDisChargPw; }
set { _DayDisChargPw = value; RaisePropertyChanged(); }
}
private double _MonthDisChargPw;
/// <summary>
/// 储能 月放电量 kWh
/// </summary>
public double MonthDisChargPw
{
get { return _MonthDisChargPw; }
set { _MonthDisChargPw = value; RaisePropertyChanged(); }
}
private double _YearDisChargPw;
/// <summary>
/// 储能 年放电量 kWh
/// </summary>
public double YearDisChargPw
{
get { return _YearDisChargPw; }
set { _YearDisChargPw = value; RaisePropertyChanged(); }
}
private double _TotalDisChargPw;
/// <summary>
/// 储能 总放电量 kWh
/// </summary>
public double TotalDisChargPw
{
get { return _TotalDisChargPw; }
set { _TotalDisChargPw = value; RaisePropertyChanged(); }
}
}
/// <summary>
/// 光伏税务
/// </summary>
public class YuPuSolarTaxAnalyse : BindableBase
{
/// <summary>
/// 一天的开始0时发电量数据
/// </summary>
public double DayStartPointPw { get; set; }
/// <summary>
/// 月份的开始0时发电量数据
/// </summary>
public double MonthStartPointPw { get; set; }
/// <summary>
/// 年的开始0时发电量数据
/// </summary>
public double YearStartPointPw { get; set; }
private double _DayChargPw;
/// <summary>
/// 光伏 光伏日发电量 kWh
/// </summary>
public double DayChargPw
{
get { return _DayChargPw; }
set { _DayChargPw = value; RaisePropertyChanged(); }
}
private double _MonthChargPw;
/// <summary>
/// 光伏 光伏月发电量 kWh
/// </summary>
public double MonthChargPw
{
get { return _MonthChargPw; }
set { _MonthChargPw = value; RaisePropertyChanged(); }
}
private double _YearChargPw;
/// <summary>
/// 光伏 光伏年发电量 kWh
/// </summary>
public double YearChargPw
{
get { return _YearChargPw; }
set { _YearChargPw = value; RaisePropertyChanged(); }
}
private double _TotalChargPw;
/// <summary>
/// 光伏 光伏总发电量 kWh
/// </summary>
public double TotalChargPw
{
get { return _TotalChargPw; }
set { _TotalChargPw = value; RaisePropertyChanged(); }
}
}
/// <summary>
/// 光伏管理大楼
/// </summary>
public class YuPuSolarManageAnalyse : BindableBase
{
/// <summary>
/// 一天的开始0时发电量数据
/// </summary>
public double DayStartPointPw { get; set; }
/// <summary>
/// 月份的开始0时发电量数据
/// </summary>
public double MonthStartPointPw { get; set; }
/// <summary>
/// 年的开始0时发电量数据
/// </summary>
public double YearStartPointPw { get; set; }
private double _DayChargPw;
/// <summary>
/// 光伏 光伏日发电量 kWh
/// </summary>
public double DayChargPw
{
get { return _DayChargPw; }
set { _DayChargPw = value; RaisePropertyChanged(); }
}
private double _MonthChargPw;
/// <summary>
/// 光伏 光伏月发电量 kWh
/// </summary>
public double MonthChargPw
{
get { return _MonthChargPw; }
set { _MonthChargPw = value; RaisePropertyChanged(); }
}
private double _YearChargPw;
/// <summary>
/// 光伏 光伏年发电量 kWh
/// </summary>
public double YearChargPw
{
get { return _YearChargPw; }
set { _YearChargPw = value; RaisePropertyChanged(); }
}
private double _TotalChargPw;
/// <summary>
/// 光伏 光伏总发电量 kWh
/// </summary>
public double TotalChargPw
{
get { return _TotalChargPw; }
set { _TotalChargPw = value; RaisePropertyChanged(); }
}
}
}