energy_storage/src/app/Station.cpp

#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"

Station::Station() : stationId(0)
{
    mqttCli = std::make_shared<MqttClient>();

    // 测试，设置默认值
    for (int i = 1; i<=5; i++) {
        auto& unit = mapCoolingUnit[i];
        unit.powerOn = 1;
        unit.mode = i%2;
    }

    for (int i = 1; i<=5; i++) {
        auto& unit = mapAircUnit[i];
        unit.powerOn = 1;
        unit.temp = Utils::random(20, 40);
        unit.hum = Utils::random(20, 80);
    }
}

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->workModeId = 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->isOpen = fields.get<int>(DMStation::STATUS);

    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->workModeId = 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::setPolicy(int policyId)
{
    std::string sql = SQL(SQL::TYPE::update).table(DMStation::TABLENAME)
        .update(DMStation::POLICY_ID, std::to_string(policyId))
        .where(DMStation::STATION_ID + "=" + std::to_string(stationId)).str();
    Errcode err = DAO::exec(NULL, sql);
    if (err != Errcode::OK)
    {
        spdlog::error("set station policy failed.");
    }
}

static std::string MapValueToJson(int npos, std::map<int, double>& mapV)
{
    njson jsonarray = njson::array();
    for (int i = 0; i<=npos; i++)
    {
        jsonarray.push_back(mapV[i]);
    }
    return jsonarray.dump();
}

void Station::writeRuntimeData(std::string dt, int npos)
{
    auto dao = DaoEntity::create("history_day");
    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);
        }
    }
}

void Station::writeStatistic(std::string dt)
{
    Fields fields;
    fields.set("storage_elect_in", statData.totalElectIn);
    fields.set("storage_elect_out", statData.totalElectOut);
    //fields.set("storage_num_in", statData.totalElectIn);
    //fields.set("storage_num_out", 0);
    //fields.set("storage_num_err", 0);
    //fields.set("storage_t_in", 0);
    //fields.set("storage_t_out", 0);
    //fields.set("storage_usage", 0);
    //fields.set("solar_elect_gen", 0);
    //fields.set("solar_elect_grid", 0);
    //fields.set("solar_num_err", 0);
    //fields.set("solar_t", 0);
    //fields.set("solar_usage", 0);
    //fields.set("charge_elect", 0);
    //fields.set("charge_num", 0);
    //fields.set("charge_num_err", 0);
    //fields.set("charge_t", 0);
    //fields.set("charge_usage", 0);
    fields.set("income_elect", statData.totalIncome);
    //fields.set("income_charge", 0);
    //fields.set("usage_rate", 0);
}

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 (mqttCli)
    {
        mqttCli->polling();
    }
}

void Station::setGarewayWorkMode()
{
    if (!mqttCli)
    {
        return;
    }

    njson json;
    json["ts"] = Utils::time();
    json["no"] = 1; // 设备编号
    json["40001"] = this->workModeId;
   
    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(text);
    mqttCli->publish("Gateway_YT", text);
}


void Station::setRuntimeData(string addr, int val)
{
    if (addr == "0x110E") { statData.dayElectIn = val; }		//日充电电量	R	uint32	1kWh		0		0x110E
    else if (addr == "0x1110") { statData.dayElectOut = val; }	//日放电电量	R	uint32	1kWh		0		0x1110
    else if (addr == "0x1112") { statData.dayIncomeIn = val; }	//日充电费用	R	uint32	1RMB		0		0x1112
    else if (addr == "0x1114") { statData.dayIncomeOut = val; }	//日放电费用	R	uint32	1RMB		0		0x1114
    else if (addr == "0x1116") { statData.dayIncome = val; }	//日收益	R	int32	1RMB		0		0x1116
    else if (addr == "0x112C") { statData.totalElectIn = val; }	    //总充电电量	R	uint32	1kWh		6659(0x112D)		0x112C
    else if (addr == "0x112E") { statData.totalElectOut = val; }	//总放电电量	R	uint32	1kWh		4925(0x112F)		0x112E
    else if (addr == "0x1130") { statData.totalIncomeIn = val; }	//总充电费用	R	uint32	1RMB		6605(0x1131)		0x1130
    else if (addr == "0x1132") { statData.totalIncomeOut = val; }	//总放电费用	R	uint32	1RMB		4949(0x1133)		0x1132
    else if (addr == "0x1134") { statData.totalIncome = val; }	    //总收益	R	int32	1RMB		-1		0x1134
}

void Station::setTHData(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") { unit.temp = float(val) * 0.1; }     //温度	R	int16	0.1℃			0x0003
    else if (addr == "0x0004") { unit.hum = float(val) * 0.1; }     //湿度	R	int16	0.1℃			0x0004
}

void Station::setFire40Data(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::setCoolingData(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") { unit.powerOn = val; }//    开关	R	uint16		0：关机，1：开机		0x1003
    else if (addr == "0x1004") { ; }//    采样模式	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
}