mirror of
https://gitee.com/js-yhsec/energy_storage.git
synced 2026-05-27 18:59:26 +08:00
762 lines
32 KiB
C++
762 lines
32 KiB
C++
#include "Station.h"
|
||
#include "database/DAO.h"
|
||
#include "database/SQL.h"
|
||
#include "common/fields.h"
|
||
#include "app/Device.h"
|
||
#include "common/Spdlogger.h"
|
||
#include "common/Utils.h"
|
||
#include "protocol/MqttEntity.h"
|
||
#include "common/JsonN.h"
|
||
#include "app/Config.h"
|
||
#include "common/Snowflake.h"
|
||
#include "app/DataStruct.h"
|
||
#include "app/Application.h"
|
||
|
||
Station::Station() : stationId(0)
|
||
{
|
||
mqttCli = std::make_shared<MqttClient>();
|
||
predictStorageIn = vector<int>(144, 0);
|
||
predictStorageOut = vector<int>(144, 0);
|
||
predictCharge = vector<int>(144, 0);
|
||
}
|
||
|
||
void Station::setFields(Fields& fields)
|
||
{
|
||
this->stationId = fields.get<int>(DMStation::STATION_ID);
|
||
this->name = fields.value(DMStation::NAME);
|
||
this->capacity = fields.get<double>(DMStation::CAPACITY);
|
||
this->workMode = fields.get<int>(DMStation::WORK_MODE);
|
||
this->code = fields.value(DMStation::CODE);
|
||
this->status = fields.get<int>(DMStation::STATUS);
|
||
|
||
this->operationDate = fields.value(DMStation::OPERATION_DATE);
|
||
this->launchDate = fields.value("operation_date");
|
||
//this->policy.setFields(fields);
|
||
}
|
||
|
||
void Station::addDevice(int deviceId, std::shared_ptr<Device> device)
|
||
{
|
||
mapDevice[deviceId] = device;
|
||
}
|
||
|
||
void Station::addDevice(Fields& fields)
|
||
{
|
||
int deviceId = fields.get<int>(DMDevice::DEVICE_ID);
|
||
int stationId = fields.get<int>(DMDevice::STATION_ID);
|
||
if (mapDevice.find(deviceId) != mapDevice.end())
|
||
{
|
||
mapDevice[deviceId]->setFields(fields);
|
||
}
|
||
else
|
||
{
|
||
auto device = Device::create(fields);
|
||
mapDevice[deviceId] = device;
|
||
}
|
||
}
|
||
|
||
std::shared_ptr<Device> Station::getDevice(int deviceId)
|
||
{
|
||
auto iter = mapDevice.find(deviceId);
|
||
if (iter!=mapDevice.end())
|
||
{
|
||
return iter->second;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
void Station::groupDevice()
|
||
{
|
||
for (auto iter = mapDevice.begin(); iter!=mapDevice.end(); ++iter)
|
||
{
|
||
auto& device = iter->second;
|
||
char key[20] = {};
|
||
sprintf(key, "%03d_%03d_%04d", device->stationId, device->sortNo, device->deviceId);
|
||
mapDeviceGroup[device->category][key] = device;
|
||
}
|
||
}
|
||
|
||
std::shared_ptr<Device> Station::getDeviceByType(int deviceType, std::string code)
|
||
{
|
||
for (auto iter = mapDevice.begin(); iter!=mapDevice.end(); ++iter)
|
||
{
|
||
auto device = iter->second;
|
||
if (device->type == deviceType && device->code == code)
|
||
{
|
||
return device;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
void Station::getDeviceByType(int deviceType, std::vector<std::shared_ptr<Device>>& res)
|
||
{
|
||
for (auto iter = mapDevice.begin(); iter!=mapDevice.end(); ++iter)
|
||
{
|
||
auto device = iter->second;
|
||
if (device->type == deviceType)
|
||
{
|
||
res.push_back(device);
|
||
}
|
||
}
|
||
}
|
||
|
||
int Station::getDeviceCount(int category)
|
||
{
|
||
auto iter = mapDeviceGroup.find(category);
|
||
if (iter != mapDeviceGroup.end())
|
||
{
|
||
return iter->second.size();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void Station::getDeviceByCategory(int category, std::vector<std::shared_ptr<Device>>& res)
|
||
{
|
||
auto iter = mapDeviceGroup.find(category);
|
||
if (iter != mapDeviceGroup.end())
|
||
{
|
||
res.resize(iter->second.size());
|
||
int i = 0;
|
||
for (auto& item: iter->second)
|
||
{
|
||
res[i++] = item.second;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Station::setWorkMode(int modeId)
|
||
{
|
||
this->workMode = modeId;
|
||
std::string sql = SQL(SQL::TYPE::update).table(DMStation::TABLENAME)
|
||
.update(DMStation::WORK_MODE, std::to_string(modeId))
|
||
.where(DMStation::STATION_ID + "=" + std::to_string(stationId)).str();
|
||
Errcode err = DAO::exec(NULL, sql);
|
||
if (err != Errcode::OK)
|
||
{
|
||
spdlog::error("set station work mode failed.");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
void Station::initMqtt()
|
||
{
|
||
if (status!=0 && mqttCli)
|
||
{
|
||
auto& optionMqtt = Config::option.mqtt;
|
||
mqttCli->init(optionMqtt.host, code, optionMqtt.username, optionMqtt.password);
|
||
}
|
||
}
|
||
|
||
void Station::polling()
|
||
{
|
||
if (status > 0 && mqttCli)
|
||
{
|
||
if (mqttCli->isConnected)
|
||
{
|
||
mqttCli->polling();
|
||
}
|
||
//else
|
||
//{
|
||
// // 该函数检查连接状态，若已经连接，则无操作；若未连接，则进行连接操作
|
||
// this->initMqtt();
|
||
//}
|
||
}
|
||
}
|
||
|
||
int64_t Station::getPollingTS()
|
||
{
|
||
return (mqttCli != nullptr) ? mqttCli->tsPolling : 0;
|
||
}
|
||
|
||
void Station::setGarewayWorkMode()
|
||
{
|
||
if (!mqttCli) { return; }
|
||
|
||
auto policy = Application::data().getPolicyByType(this->workMode);
|
||
njson json;
|
||
json["ts"] = Utils::time();
|
||
json["no"] = 1; // 设备编号
|
||
json["40001"] = this->workMode;
|
||
|
||
if (policy)
|
||
{
|
||
if (policy->type == 1)
|
||
{
|
||
json["40002"] = njson::array(); // 峰谷套利
|
||
policy->getGatewayJsonPeriods(json["40002"]);
|
||
}
|
||
else if (policy->type == 5)
|
||
{
|
||
json["40021"] = njson::array(); // 自定时段
|
||
policy->getGatewayJsonPeriods(json["40021"]);
|
||
}
|
||
}
|
||
|
||
std::string text = json.dump();
|
||
spdlog::info("[station] set gateway workmode [Gateway_YT], stationId={}, text={}", stationId, text);
|
||
mqttCli->publish("Gateway_YT", text);
|
||
}
|
||
|
||
void Station::setGarewayParams()
|
||
{
|
||
if (!mqttCli) { return; }
|
||
njson json;
|
||
json["ts"] = Utils::time();
|
||
json["no"] = 1; // 设备编号
|
||
json["40038"] = {gatewayParam.socMin, gatewayParam.socMax, gatewayParam.capacity, gatewayParam.powerSafe, gatewayParam.powerDischarge, gatewayParam.powerCharge};
|
||
json["40058"] = {gatewayParam.backflow, gatewayParam.overload};
|
||
|
||
std::string text = json.dump();
|
||
spdlog::info("[station] set gateway params, stationId={}, text={}", stationId, text);
|
||
mqttCli->publish("Gateway_YT", text);
|
||
}
|
||
|
||
string Station::getGatewayMode()
|
||
{
|
||
// 0：手动，1：峰谷套利，2：增网配容，3：应急供电，4：并网保电，5：自定时段
|
||
if (gatewayParam.mode == 0) { return "手动"; }
|
||
else if (gatewayParam.mode == 1) { return "峰谷套利"; }
|
||
else if (gatewayParam.mode == 2) { return "增网配容"; }
|
||
else if (gatewayParam.mode == 3) { return "应急供电"; }
|
||
else if (gatewayParam.mode == 4) { return "并网保电"; }
|
||
else if (gatewayParam.mode == 5) { return "自定时段"; }
|
||
else { return "--"; };
|
||
}
|
||
|
||
static map<int, string> mapPeriodType =
|
||
{
|
||
{1, "谷"}, {2, "平"}, {3, "峰"}, {4, "尖"}
|
||
};
|
||
static map<int, string> mapPeriodOper =
|
||
{
|
||
{0, "停"}, {1, "充"}, {2, "充"}, {3, "放"}, {4, "放"}
|
||
};
|
||
|
||
string Station::getGatewayParam()
|
||
{
|
||
stringstream ss;
|
||
std::string str1 = "峰谷套利时段：<br>";
|
||
{
|
||
njson json;
|
||
if (JSON::parse(gatewayParam.param1, json))
|
||
{
|
||
for (int i = 0; i<json.size(); ++i)
|
||
{
|
||
str1 += "    " + std::to_string(i+1) + "月: ";
|
||
|
||
ss.str("");
|
||
for (auto& jsonitem : json[i])
|
||
{
|
||
ss << "(" << setw(2) << setfill('0') << jsonitem[0].get<int>();
|
||
ss << ":" << setw(2) << setfill('0') << jsonitem[1].get<int>() << " ";
|
||
ss << mapPeriodType[jsonitem[2].get<int>()] << ") ";
|
||
}
|
||
str1 += ss.str() + "<br>";
|
||
}
|
||
}
|
||
}
|
||
std::string str2 = "自定时段：<br>";
|
||
{
|
||
njson json;
|
||
if (JSON::parse(gatewayParam.param2, json))
|
||
{
|
||
for (int i = 0; i<json.size(); ++i)
|
||
{
|
||
str2 += "    时段" + std::to_string(i+1) + ": ";
|
||
ss.str("");
|
||
for (auto& jsonitem : json[i])
|
||
{
|
||
ss << "(" << setw(2) << setfill('0') << jsonitem[0].get<int>();
|
||
ss << ":" << setw(2) << setfill('0') << jsonitem[1].get<int>() << " ";
|
||
ss << mapPeriodOper[jsonitem[2].get<int>()] << ") ";
|
||
}
|
||
str2 += ss.str() + "<br>";
|
||
}
|
||
}
|
||
}
|
||
std::string str3 = "其它参数：<br>";
|
||
{
|
||
njson json;
|
||
if (JSON::parse(gatewayParam.param3, json))
|
||
{
|
||
for (int i = 0; i<json.size(); ++i)
|
||
{
|
||
int val = json[i].get<int>();
|
||
if (i==0) { str3 += "    储能放电下限值SOC: " + std::to_string(val) + "<br>"; } //储能放电下限值 SOC : 40038 (%:0-99 且小于充电上限值)
|
||
else if (i==1) { str3 += "    储能充电上限值SOC: " + std::to_string(val) + "<br>"; }//储能充电上限值 SOC : 40039 (%:1-100 且大于放电下限值)
|
||
else if (i==2) { str3 += "    台区变压器容量: " + std::to_string(val) + "<br>"; }//台区变压器容量 : 40040 (KVVA 160-1600)
|
||
else if (i==3) { str3 += "    安全输入功率: " + std::to_string(val) + "<br>"; }//安全输入功率 : 40041 (KW 0-400)
|
||
else if (i==4) { str3 += "    储能最大放电功率: " + std::to_string(val) + "<br>"; }//储能最大放电功率 : 40042 (1KW0-150)
|
||
else if (i==5) { str3 += "    储能最大充电功率: " + std::to_string(val) + "<br>"; }//储能最大充电功率::40043 (1KW0-150)
|
||
else if (i==6) { str3 += "    运行状态: " + std::to_string(val) + "<br>"; }//运行状态 : 40044 (只读不写，0:无 1:高峰放电 2:低谷充电)
|
||
else if (i==7) { str3 += "    台区电表变比: " + std::to_string(val) + "<br>"; }//台区电表变比:40045
|
||
//else if (i==8) { str3 += "    对时(年): " + std::to_string(val) + "<br>"; }//对时(年) : 40051
|
||
//else if (i==9) { str3 += "    对时(月): " + std::to_string(val) + "<br>"; }//对时(月) : 40052
|
||
//else if (i==10) { str3 += "    对时(日): " + std::to_string(val) + "<br>"; }//对时(日) : 40053
|
||
//else if (i==11) { str3 += "    对时(时): " + std::to_string(val) + "<br>"; }//对时(时) : 40054
|
||
//else if (i==12) { str3 += "    对时(分): " + std::to_string(val) + "<br>"; }//对时(分) : 40055
|
||
//else if (i==13) { str3 += "    对时(秒): " + std::to_string(val) + "<br>"; }//对时(秒) : 40056
|
||
//else if (i==19) { str3 += "    时间段月份: " + std::to_string(val) + "<br>"; }//时间段月份 : 40057(1-12 对应1月-12月)
|
||
else if (i==20) { str3 += "    防逆流回差: " + std::to_string(val) + "<br>"; }//防逆流回差 : 40058(1KW 10-300)
|
||
else if (i==21) { str3 += "    防过载回差: " + std::to_string(val) + "<br>"; }//防过载回差 : 40059(1KW 10-300)
|
||
}
|
||
}
|
||
}
|
||
return str1 + "<br/>" + str2 + "<br/>" + str3;
|
||
}
|
||
|
||
void Station::checkDevice()
|
||
{
|
||
for (auto& item: mapDevice)
|
||
{
|
||
auto& device = item.second;
|
||
if (device)
|
||
{
|
||
if (Utils::time() - device->ts > 60*6)
|
||
{
|
||
device->online = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void Station::readAlert(std::shared_ptr<Device> device, std::string addr, int v, std::string text)
|
||
{
|
||
int64_t ts = Utils::time();
|
||
std::string alertId = std::to_string(device->deviceId) + "_" + addr;
|
||
int tsCache = mapAlertCache[alertId];
|
||
if (ts - tsCache > 60*30)
|
||
{
|
||
Fields fields;
|
||
fields.set("log_id", Snowflake::instance().getIdStr());
|
||
if (device) { fields.set("device_id", device->deviceId); }
|
||
fields.set("type", int(EAlertType::DEVICE));
|
||
fields.set("content", text + ":故障(" + std::to_string(v) + ")");
|
||
fields.set("status", 1);
|
||
auto dao = DaoEntity::create("log_alert");
|
||
dao->insertFields(fields);
|
||
mapAlertCache[alertId] = ts;
|
||
}
|
||
}
|
||
|
||
void Station::readRuntimeData(int deviceNo, string addr, int val)
|
||
{
|
||
if (deviceNo == 1)
|
||
{
|
||
if (addr == "0x000B") { this->voltage = val; } // A相电压 R uint32 1V 0x000B
|
||
if (addr == "0x0011") { this->current = val; } // A相电流 R int32 1A 0x0011
|
||
if (addr == "0x0023") { this->power = val; } // 三相总有功 R int32 1kW 0x0023
|
||
}
|
||
else if (deviceNo == 2)
|
||
{
|
||
statData.ts = Utils::time();
|
||
if (addr == "0x002F") { statData.dayElectIn = val; } //日充电电量 R uint32 1kWh 0x002F
|
||
else if (addr == "0x0031") { statData.dayElectOut = val; } //日放电电量 R uint32 1kWh 0x0031
|
||
else if (addr == "0x0033") { statData.dayFeeIn = val; } //日充电费用 R uint32 1RMB 0x0033
|
||
else if (addr == "0x0035") { statData.dayFeeOut = val; } //日放电费用 R uint32 1RMB 0x0035
|
||
else if (addr == "0x0037") { statData.dayIncome = val; } //日收益 R int32 1RMB 0x0037
|
||
else if (addr == "0x004D") { statData.totalElectIn = val; } //总充电电量 R uint32 1kWh 0x004D
|
||
else if (addr == "0x004F") { statData.totalElectOut = val; } //总放电电量 R uint32 1kWh 0x004F
|
||
else if (addr == "0x0051") { statData.totalFeeIn = val; } //总充电费用 R uint32 1RMB 0x0051
|
||
else if (addr == "0x0053") { statData.totalFeeOut = val; } //总放电费用 R uint32 1RMB 0x0053
|
||
else if (addr == "0x0055") { statData.totalIncome = val; } //总收益 R int32 1RMB 0x0055
|
||
|
||
else if (addr == "0x0039") { statData.dayElectIn_J = val; } //日正向尖有功电能 R uint32 1kWh 0x0039
|
||
else if (addr == "0x003B") { statData.dayElectIn_F = val; } //日正向峰有功电能 R uint32 1kWh 0x003B
|
||
else if (addr == "0x003D") { statData.dayElectIn_P = val; } //日正向平有功电能 R uint32 1kWh 0x003D
|
||
else if (addr == "0x003F") { statData.dayElectIn_G = val; } //日正向谷有功电能 R uint32 1kWh 0x003F
|
||
else if (addr == "0x0041") { statData.dayElectIn_Total = val; } //日正向总有功电能 R uint32 1kWh 0x0041
|
||
|
||
else if (addr == "0x0043") { statData.dayElectOut_J = val; } //日反向尖有功电能 R uint32 1kWh 0x0043
|
||
else if (addr == "0x0045") { statData.dayElectOut_F = val; } //日反向峰有功电能 R uint32 1kWh 0x0045
|
||
else if (addr == "0x0047") { statData.dayElectOut_P = val; } //日反向平有功电能 R uint32 1kWh 0x0047
|
||
else if (addr == "0x0049") { statData.dayElectOut_G = val; } //日反向谷有功电能 R uint32 1kWh 0x0049
|
||
else if (addr == "0x004B") { statData.dayElectOut_Total = val; } //日反向总有功电能 R uint32 1kWh 0x004B
|
||
|
||
else if (addr == "0x0057") { statData.totalElectIn_J = val; } //总正向尖有功电能 R uint32 1kWh 0x0057
|
||
else if (addr == "0x0059") { statData.totalElectIn_F = val; } //总正向峰有功电能 R uint32 1kWh 0x0059
|
||
else if (addr == "0x005B") { statData.totalElectIn_P = val; } //总正向平有功电能 R uint32 1kWh 0x005B
|
||
else if (addr == "0x005D") { statData.totalElectIn_G = val; } //总正向谷有功电能 R uint32 1kWh 0x005D
|
||
else if (addr == "0x005F") { statData.totalElectIn_Total = val; } //总正向总有功电能 R uint32 1kWh 0x005F
|
||
else if (addr == "0x0061") { statData.totalElectOut_J = val; } //总反向尖有功电能 R uint32 1kWh 0x0061
|
||
else if (addr == "0x0063") { statData.totalElectOut_F = val; } //总反向峰有功电能 R uint32 1kWh 0x0063
|
||
else if (addr == "0x0065") { statData.totalElectOut_P = val; } //总反向平有功电能 R uint32 1kWh 0x0065
|
||
else if (addr == "0x0067") { statData.totalElectOut_G = val; } //总反向谷有功电能 R uint32 1kWh 0x0067
|
||
else if (addr == "0x0069") { statData.totalElectOut_Total = val; } //总反向总有功电能 R uint32 1kWh 0x0069
|
||
}
|
||
}
|
||
|
||
void Station::readTHData(int deviceNo, string addr, int val)
|
||
{
|
||
auto& unit = mapTempHumUnit[deviceNo];
|
||
if (addr == "0x0001") { ; } //所属通道号 R uint16 1 0x0001
|
||
else if (addr == "0x0002") { ; } //所属温湿度号 R uint16 1~10 0x0002
|
||
else if (addr == "0x0003") //温度 R int16 0.1℃ 0x0003
|
||
{
|
||
unit.temp = float(val) * 0.1;
|
||
if (deviceNo == 1) temperature = unit.temp;
|
||
}
|
||
else if (addr == "0x0004") //湿度 R int16 0.1℃ 0x0004
|
||
{
|
||
unit.hum = float(val) * 0.1;
|
||
if (deviceNo == 1) humidity = unit.hum;
|
||
}
|
||
}
|
||
|
||
void Station::readFire40Data(int deviceNo, string addr, int val)
|
||
{
|
||
auto& unit = mapFire40Unit[deviceNo];
|
||
|
||
if (addr == "0x0001") { ; } //所属通道号 R uint16 1~10 0x0001
|
||
else if (addr == "0x0002") { ; } //主控数量 R uint16 1 0x0002
|
||
else if (addr == "0x0003") { ; } //主控ID R uint16 1 0x0003
|
||
else if (addr == "0x0004") { unit.statusMain = val; } //主控状态 R uint16 0：正常 1：预警 2：火警 0x0004
|
||
else if (addr == "0x0005") { ; } //主控硬件版本 R uint16[2] 主控硬件版本 0x0005
|
||
else if (addr == "0x0007") { ; } //主控软件版本 R uint16[2] 主控软件版本 0x0007
|
||
else if (addr == "0x0009") { ; } //主电状态 R uint16 0：使用市电 1：使用备电 0x0009
|
||
else if (addr == "0x000A") { ; } //备电电流 R uint32 0.1A 0x000A
|
||
else if (addr == "0x000C") { ; } //备电电压 R uint32 0.1V 0x000C
|
||
else if (addr == "0x000E") { ; } //可用容量 R uint32 0.01Ah 0x000E
|
||
else if (addr == "0x0010") { ; } //可充放容量 R uint32 0.01Ah 0x0010
|
||
else if (addr == "0x0012") { unit.usedAlarm = val; } //警铃是否使用 R uint16 0x0012
|
||
else if (addr == "0x0013") { unit.statusAlarm = val; } //警铃状态 R uint16 0：无效 1：掉线 2：正常 3：启动 0x0013
|
||
else if (addr == "0x0014") { unit.usedValve = val; } //瓶头阀是否使用 R uint16 0x0014
|
||
else if (addr == "0x0015") { unit.statusValve = val; } //瓶头阀状态 R uint16 0：无效 1：掉线 2：正常 3：启动 0x0015
|
||
else if (addr == "0x0016") { unit.usedMCP = val; } //手报是否使用 R uint16 0x0016
|
||
else if (addr == "0x0017") { unit.statusMCP = val; } //手报状态 R uint16 0：无效 1：掉线 2：正常 3：启动 0x0017
|
||
else if (addr == "0x0018") { ; } //簇控制器数量 R uint16 0x0018
|
||
else if (addr == "0x0019") { ; } //复合探测器总数量 R uint16 0x0019
|
||
else if (addr == "0x001A") { ; } //烟雾探测器总数量 R uint16 0x001A
|
||
else if (addr == "0x001B") { ; } //压力探测器总数量 R uint16 0x001B
|
||
else if (addr == "0x001C") { ; } //吸气式探测器总数量 R uint16 0x001C
|
||
else if (addr == "0x001D") { ; } //PACK探测器总数量 R uint16 0x001D
|
||
else if (addr == "0x001E") { ; } //电池总数量 R uint16 0x001E
|
||
}
|
||
|
||
|
||
void Station::readCoolingData(int deviceNo, string addr, int val)
|
||
{
|
||
auto& unit = mapCoolingUnit[deviceNo];
|
||
|
||
if (addr == "0x1001") { ; } //所属通道号 R uint16 1 0x1001
|
||
else if (addr == "0x1002") { ; }// 所属冷机号 R uint16 1~10 0x1002
|
||
else if (addr == "0x1003") { coolingStatus = unit.powerOn = val; }// 开关 R uint16 0：关机，1：开机 0x1003
|
||
else if (addr == "0x1004") { unit.mode = val; }// 采样模式 R uint16 0-出水温度 1-电芯温度 0x1004
|
||
else if (addr == "0x1005") { unit.cooling = val; }// 制冷状态 R uint16 0：关闭, 1：启动 0x1005
|
||
else if (addr == "0x1006") { unit.heating = val; }// 制热状态 R uint16 0：关闭, 1：启动 0x1006
|
||
else if (addr == "0x1007") { unit.highTemp = val; }// 高温告警 R uint16 0：正常，1：告警 0x1007
|
||
else if (addr == "0x1008") { unit.lowTemp = val; }// 低温告警 R uint16 0：正常，1：告警 0x1008
|
||
else if (addr == "0x1009") { unit.highPressure = val; }// 高压告警 R uint16 0：正常，1：告警 0x1009
|
||
else if (addr == "0x100A") { unit.lowPressure = val; }// 低压告警 R uint16 0：正常，1：告警 0x100A
|
||
else if (addr == "0x100B") { ; }// 进水温度传感器 R uint16 0：正常，1：告警 0x100B
|
||
else if (addr == "0x100C") { ; }// 出水温度传感器 R uint16 0：正常，1：告警 0x100C
|
||
else if (addr == "0x100D") { ; }// 进水压力传感器 R uint16 0：正常，1：告警 0x100D
|
||
else if (addr == "0x100E") { ; }// 出水压力传感器 R uint16 0：正常，1：告警 0x100E
|
||
}
|
||
|
||
static void JSONReadArrayItem(njson& json, int i, int& v)
|
||
{
|
||
if (json.is_array() && i < json.size())
|
||
{
|
||
v = json[i].get<int>();
|
||
}
|
||
}
|
||
|
||
void Station::readGatewayMode(int deviceNo, int mode, string p1, string p2, string p3)
|
||
{
|
||
auto device = this->getDeviceByType(int(EDeviceType::GATEWAY), Utils::toStr(deviceNo));
|
||
if (device)
|
||
{
|
||
device->online = true;
|
||
device->ts = Utils::time();
|
||
}
|
||
if (mode != -1) { this->gatewayParam.mode = mode; }
|
||
if (!p1.empty()) { this->gatewayParam.param1 = p1; }
|
||
if (!p2.empty()) { this->gatewayParam.param2 = p2; }
|
||
if (!p3.empty()) { this->gatewayParam.param3 = p3; }
|
||
|
||
njson json;
|
||
if (JSON::parse(gatewayParam.param3, json))
|
||
{
|
||
JSONReadArrayItem(json, 0, gatewayParam.socMin); //储能放电下限值 SOC : 40038 (%:0-99 且小于充电上限值)
|
||
JSONReadArrayItem(json, 1, gatewayParam.socMax); //储能充电上限值 SOC : 40039 (%:1-100 且大于放电下限值)
|
||
JSONReadArrayItem(json, 2, gatewayParam.capacity); //台区变压器容量 : 40040 (KVVA 160-1600)
|
||
JSONReadArrayItem(json, 3, gatewayParam.powerSafe); //安全输入功率 : 40041 (KW 0-400)
|
||
JSONReadArrayItem(json, 4, gatewayParam.powerDischarge); //储能最大放电功率 : 40042 (1KW0-150)
|
||
JSONReadArrayItem(json, 5, gatewayParam.powerCharge); //储能最大充电功率::40043 (1KW0-150)
|
||
JSONReadArrayItem(json, 6, gatewayParam.status); //运行状态 : 40044 (只读不写，0:无 1:高峰放电 2:低谷充电)
|
||
JSONReadArrayItem(json, 7, gatewayParam.vtRatio); //台区电表变比:40045
|
||
JSONReadArrayItem(json, 20, gatewayParam.backflow); //防逆流回差 : 40058(1KW 10-300)
|
||
JSONReadArrayItem(json, 21, gatewayParam.overload); //防过载回差 : 40059(1KW 10-300)
|
||
}
|
||
}
|
||
|
||
void Station::readGatewayStatus(int deviceNo, int cdzStatus, int emuStatus)
|
||
{
|
||
auto device = this->getDeviceByType(int(EDeviceType::GATEWAY), Utils::toStr(deviceNo));
|
||
if (device)
|
||
{
|
||
device->online = true;
|
||
device->ts = Utils::time();
|
||
}
|
||
|
||
//充电桩 1：在线，0：离线
|
||
if (cdzStatus >= 0)
|
||
{
|
||
if (cdzStatus != this->cdzStatus)
|
||
{
|
||
std::string text = "场站[" + name + "(" + std::to_string(stationId) + ")]充电桩状态变化：" + (cdzStatus>0 ? "在线" : "离线");
|
||
if (this->cdzStatus < 0) { text = "系统启动，" + text; }
|
||
DAO::insertSystemLogDevice(stationId, 0, text, cdzStatus);
|
||
this->cdzStatus = cdzStatus;
|
||
}
|
||
}
|
||
//储能 1：在线，0：离线
|
||
if (emuStatus >= 0)
|
||
{
|
||
if (emuStatus != this->emuStatus)
|
||
{
|
||
std::string text = "场站[" + name + "(" + std::to_string(stationId) + ")]储能EMU状态变化：" + (emuStatus>0 ? "在线" : "离线");
|
||
if (this->emuStatus < 0) { text = "系统启动，" + text; }
|
||
DAO::insertSystemLogDevice(stationId, 0, text, emuStatus);
|
||
this->emuStatus = emuStatus;
|
||
}
|
||
}
|
||
}
|
||
|
||
static std::string MapValueToJson(int npos, std::map<int, float>& mapV)
|
||
{
|
||
njson jsonarray = njson::array();
|
||
for (int i = 0; i<=npos; i++)
|
||
{
|
||
jsonarray.push_back(int(mapV[i]));
|
||
}
|
||
return jsonarray.dump();
|
||
}
|
||
void Station::setCache(int datatype, std::vector<float>& vd)
|
||
{
|
||
std::map<int, float>* mapptr = NULL;
|
||
if (datatype == 1) { mapptr = &mapCacheElectIn; }
|
||
else if (datatype == 2) { mapptr = &mapCacheElectOut; }
|
||
else if (datatype == 3) { mapptr = &mapCacheElectCharger; }
|
||
if (mapptr)
|
||
{
|
||
const int step = 600;
|
||
const int N = 86400/step;
|
||
int64_t tsSeconds = Utils::timeDaySeconds();
|
||
int npos = tsSeconds / step;
|
||
for (int i = 0; i<N; ++i)
|
||
{
|
||
if (i < vd.size()) { (*mapptr)[i] = vd[i]; }
|
||
else if (i <= npos) { (*mapptr)[i] = 0; }
|
||
}
|
||
}
|
||
}
|
||
void Station::cache()
|
||
{
|
||
int64_t tDaySeconds = Utils::timeDaySeconds();
|
||
int npos = tDaySeconds / 600;
|
||
int offset = tDaySeconds % 600;
|
||
bool save = false;
|
||
if (offset >= (600-180) && npos + 1 < 144)
|
||
{
|
||
npos += 1;
|
||
save = true;
|
||
}
|
||
else if (offset <= 180 && posCache < npos)
|
||
{
|
||
save = true;
|
||
posCache = npos;
|
||
}
|
||
if (save)
|
||
{
|
||
mapCacheElectIn[npos] = Utils::random(100, 800); // dayElectIn
|
||
mapCacheElectOut[npos] = Utils::random(100, 800); // dayElectOut
|
||
mapCacheElectCharger[npos] = Utils::random(100, 800); // 暂无数据源
|
||
}
|
||
}
|
||
|
||
void Station::writeStatistic()
|
||
{
|
||
auto dao = DaoEntity::create("history_day");
|
||
std::string dt = Utils::dateStr();
|
||
int64_t tTime = Utils::time();
|
||
int64_t tDate = Utils::date();
|
||
int64_t tDelta = tTime - tDate;
|
||
int npos = (tTime-tDate) / 600;
|
||
int tOffset = tDelta % 600;
|
||
|
||
for (auto iter = mapDevice.begin(); iter!=mapDevice.end(); ++iter)
|
||
{
|
||
auto device = iter->second;
|
||
if (device->cache(npos))
|
||
{
|
||
Fields fields;
|
||
fields.set("dt", dt);
|
||
fields.set("station_id", this->stationId);
|
||
fields.set("device_id", device->deviceId);
|
||
fields.set("datatype", 1);
|
||
fields.set("value", MapValueToJson(npos, device->mapCacheVoltage));
|
||
DAO::insertRuntimeData(dao, fields);
|
||
|
||
fields.set("datatype", 2);
|
||
fields.set("value", MapValueToJson(npos, device->mapCacheCurrent));
|
||
DAO::insertRuntimeData(dao, fields);
|
||
|
||
fields.set("datatype", 3);
|
||
fields.set("value", MapValueToJson(npos, device->mapCachePower));
|
||
DAO::insertRuntimeData(dao, fields);
|
||
//spdlog::info("[device] write runtime date to database, deviceId={}", device->deviceId);
|
||
}
|
||
}
|
||
|
||
if (statData.ts > 0)
|
||
{
|
||
{ // stat_day
|
||
Fields fields;
|
||
fields.set("dt", Utils::dateStr(statData.ts));
|
||
fields.set("station_id", this->stationId);
|
||
fields.set("storage_elect_in", statData.dayElectIn);
|
||
fields.set("storage_elect_out", statData.dayElectOut);
|
||
fields.set("income_elect", statData.dayIncome);
|
||
DAO::insertStatDay(dao, fields);
|
||
}
|
||
{
|
||
Fields fields;
|
||
fields.set("dt", Utils::dateStr(statData.ts));
|
||
fields.set("station_id", this->stationId);
|
||
fields.set("E_in", statData.totalElectIn);
|
||
fields.set("E_in_J", statData.totalElectIn_J);
|
||
fields.set("E_in_F", statData.totalElectIn_F);
|
||
fields.set("E_in_P", statData.totalElectIn_P);
|
||
fields.set("E_in_G", statData.totalElectIn_G);
|
||
fields.set("E_out", statData.totalElectOut);
|
||
fields.set("E_out_J", statData.totalElectOut_J);
|
||
fields.set("E_out_F", statData.totalElectOut_F);
|
||
fields.set("E_out_P", statData.totalElectOut_P);
|
||
fields.set("E_out_G", statData.totalElectOut_G);
|
||
fields.set("fee_in", statData.totalFeeIn);
|
||
fields.set("fee_Out", statData.totalFeeOut);
|
||
fields.set("income", statData.totalIncome);
|
||
dao->setTableName("stat_total");
|
||
|
||
dao->duplicateUpdate(fields, {
|
||
"E_in", "E_in_J", "E_in_F", "E_in_P", "E_in_G",
|
||
"E_out", "E_out_J", "E_out_F", "E_out_P", "E_out_G",
|
||
"fee_in", "fee_Out", "income"
|
||
});
|
||
}
|
||
{
|
||
Fields fields;
|
||
fields.set("dt", Utils::dateStr(statData.ts));
|
||
fields.set("station_id", this->stationId);
|
||
fields.set("E_in", statData.dayElectIn);
|
||
fields.set("E_in_J", statData.dayElectIn_J);
|
||
fields.set("E_in_F", statData.dayElectIn_F);
|
||
fields.set("E_in_P", statData.dayElectIn_P);
|
||
fields.set("E_in_G", statData.dayElectIn_G);
|
||
fields.set("E_out", statData.dayElectOut);
|
||
fields.set("E_out_J", statData.dayElectOut_J);
|
||
fields.set("E_out_F", statData.dayElectOut_F);
|
||
fields.set("E_out_P", statData.dayElectOut_P);
|
||
fields.set("E_out_G", statData.dayElectOut_G);
|
||
fields.set("fee_in", statData.dayFeeIn);
|
||
fields.set("fee_Out", statData.dayFeeOut);
|
||
fields.set("income", statData.dayIncome);
|
||
dao->setTableName("stat_total_day");
|
||
|
||
dao->duplicateUpdate(fields, {
|
||
"E_in", "E_in_J", "E_in_F", "E_in_P", "E_in_G",
|
||
"E_out", "E_out_J", "E_out_F", "E_out_P", "E_out_G",
|
||
"fee_in", "fee_Out", "income"
|
||
});
|
||
}
|
||
}
|
||
|
||
{
|
||
int pos = npos;
|
||
if (tOffset > 20) { pos += 1; }
|
||
mapCacheElectIn[pos] = (pos == 0) ? 0 : statData.dayElectIn;
|
||
mapCacheElectOut[pos] = (pos == 0) ? 0 : statData.dayElectOut;
|
||
mapCacheElectCharger[pos] = 0;
|
||
|
||
// 预测数据源记录
|
||
dao->setTableName("predict_day");
|
||
|
||
Fields fields;
|
||
fields.set("dt", dt);
|
||
fields.set("station_id", stationId);
|
||
fields.set("datatype", 1); // 1：储能充电，2：储能放电，3：充电桩充电，4：发电
|
||
fields.set("value", MapValueToJson(pos, mapCacheElectIn));
|
||
dao->duplicateUpdate(fields, {"value"});
|
||
|
||
fields.set("datatype", 2); // 1：储能充电，2：储能放电，3：充电桩充电，4：发电
|
||
fields.set("value", MapValueToJson(pos, mapCacheElectOut));
|
||
dao->duplicateUpdate(fields, {"value"});
|
||
|
||
fields.set("datatype", 3); // 1：储能充电，2：储能放电，3：充电桩充电，4：发电
|
||
fields.set("value", MapValueToJson(pos, mapCacheElectCharger));
|
||
dao->duplicateUpdate(fields, {"value"});
|
||
}
|
||
}
|
||
|
||
|
||
void Station::predict()
|
||
{
|
||
int64_t tNow = Utils::time();
|
||
int days = 7;
|
||
string dt1 = Utils::dateStr(tNow-86400*days);
|
||
string dt2 = Utils::dateStr(tNow-86400);
|
||
|
||
/// 预测实现方案：
|
||
// 查询前7天的历史数据(不包含今天)，根据历史数据计算今日数据，每10分钟一个数据，一天共144个数据点
|
||
string sql = "SELECT * FROM predict_day pd WHERE pd.station_id='" + std::to_string(stationId)
|
||
+ "' AND dt>='" + dt1 + " AND dt<'" + dt2 + "';";
|
||
|
||
vector<Fields> result;
|
||
DAO::exec(NULL, sql, result);
|
||
|
||
// 数据源的每个时刻数据点的个数
|
||
vector<int> countStorageIn(predictStorageIn.size(), 0);
|
||
vector<int> countStorageOut(predictStorageOut.size(), 0);
|
||
vector<int> countCharge(predictCharge.size(), 0);
|
||
|
||
for (int row=0; row<result.size(); ++row)
|
||
{
|
||
// 如果数据全是0，则不参与计算
|
||
auto& fields = result[row];
|
||
|
||
vector<int>* vdptr = NULL;
|
||
int datatype = fields.get<int>("datatype"); // 1：储能充电，2：储能放电，3：充电桩充电，4：发电
|
||
if (datatype == 1) { vdptr = &predictStorageIn; }
|
||
else if (datatype == 2) { vdptr = &predictStorageOut; }
|
||
else if (datatype == 3) { vdptr = &predictCharge; }
|
||
|
||
if (vdptr)
|
||
{
|
||
string& strval = fields.value("value");
|
||
std::vector<int> vec;
|
||
JSON::parseArray(strval, vec);
|
||
for (int i = 0; i<vdptr->size() && i<vec.size(); ++i)
|
||
{
|
||
auto& v0 = vec[i];
|
||
if (v0 > 0)
|
||
{
|
||
(*vdptr)[i] += v0;
|
||
if (datatype == 1) { countStorageIn[i]++; }
|
||
else if (datatype == 2) { countStorageOut[i]++; }
|
||
else if (datatype == 3) { countCharge[i]++; }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i<predictStorageIn.size(); ++i)
|
||
{
|
||
if (countStorageIn[i] > 0) { predictStorageIn[i] = predictStorageIn[i] / countStorageIn[i]; }
|
||
if (countStorageOut[i] > 0) { predictStorageOut[i] = predictStorageOut[i] / countStorageOut[i]; }
|
||
if (countCharge[i] > 0) { predictCharge[i] = predictCharge[i] / countCharge[i]; }
|
||
}
|
||
|
||
} |