/*
 * @Author: zchuo zhengchen.huo@lnxall.com
 * @Date: 2024-12-05 11:17:42
 * @LastEditors: zchuo zhengchen.huo@lnxall.com
 * @LastEditTime: 2025-05-13 10:13:02
 * @FilePath: /proto_forward/src/ems/microgridtopology_dc.c
 * @Description: 微网直流侧并网业务代码 在本环境中大部分功能均专用于本环境业务逻辑实现 并与其他业务逻辑区别隔离开来
 * 
 * Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. 
 */
#include "log_upper_data.h"
#include "microgridtopology.h"
#include "collector-api.h"
#include "deviceLayer.h" 
#include "emsctrlProc.h"
#include "discover.h"
#include "./jsonct.h"
#include "deviceLayer.h"
#include <sys/syslog.h>
#include <time.h>
#include <unistd.h>
#include "lnxall_buffer.h"


double xl_exp_power = 0;
current_stat_t state_machine_Micgp;
struct UD_log *micro_log;

/**
 * @description: 单个柜子的MPPT期望门限功率
 * @return {*}
 */
int mppt_exp_power_set(cabinet_inside_t *cab, void *mppt_power_all)
{
    cab->cab_ctrl.mppt_exp_power = cab->cab_ctrl.pcs_exp_power - cab->cab_ctrl.bms_exp_power;
    *(double *)mppt_power_all += cab->cab_ctrl.mppt_exp_power;

    return 0;
}

/**
 * @description: 对单个目标柜的PCS期望功率和MPPT的期望功率设置逻辑（仅限制于削峰填谷-充电逻辑、光储备电逻辑 属业务逻辑封装 勿随意调用）
 * @param {cabinet_inside_t} *cab
 * @return {*}
 */
int peakLoadShifting_pcs_mppt_exp_power(cabinet_inside_t *cab, void *arg)
{
    double BMS_power = cab->cab_ctrl.bms_exp_power;
        /**///ems_syslog(LOG_ERR,"连续log标志:SOC = %lf", microgrid_data.SOC_average);
        /**///ems_syslog(LOG_ERR,"连续log标志:pcs_exp_power = %lf", cab->cab_ctrl.pcs_exp_power);
    
    UD_log_sprintf(micro_log, "\n{单柜业务逻辑");
    
    if(BMS_power < 0)
    {
        /**///ems_syslog(LOG_ERR,"连续log标志:BMS充电");
        
        cab->cab_ctrl.mppt_exp_power = -BMS_power;

        cab->cab_ctrl.pcs_exp_power = -((-BMS_power) - cab->cab_data.mppt_out_power);        // PCS 补充剩余部分 尽快将

        /*限幅*/
        cab->cab_ctrl.pcs_exp_power = cab->cab_ctrl.pcs_exp_power > 0 ? 0 : cab->cab_ctrl.pcs_exp_power;
        UD_log_sprintf(micro_log, "\n<BMS期望充电\n策略逻辑: 光伏期望功率= %lf(BMS最大充电功率)\nPCS期望功率= %lf(BMS最大充电功率) - %lf(光伏实际输出)", cab->cab_ctrl.mppt_exp_power, -BMS_power, cab->cab_ctrl.pcs_exp_power);
        cab->cab_ctrl.pcs_exp_power = cab->cab_ctrl.pcs_exp_power < cab->cab_ctrl.pcs_charge_max_set ? cab->cab_ctrl.pcs_charge_max_set : cab->cab_ctrl.pcs_exp_power;
        UD_log_sprintf(micro_log, "\n充电限制: %lf PCS期望功率限制后: %lf  >\n", cab->cab_ctrl.pcs_charge_max_set, cab->cab_ctrl.pcs_exp_power);
    }
    // BMS过充 释放
    else if(BMS_power > 0)      // PCS放电
    {
        /**///ems_syslog(LOG_ERR,"连续log标志:BMS来放电");

        cab->cab_ctrl.pcs_discharge_max_set = cab->cab_ctrl.pcs_discharge_max_actual;
        cab->cab_ctrl.pcs_charge_max_set = 0;
        cab->cab_ctrl.mppt_exp_power = 0;     // 让BMS负荷所有功率
        UD_log_sprintf(micro_log, "\n<BMS期望放电\n策略逻辑: 光伏期望功率写0\nPCS期望功率: %lf>\n", cab->cab_ctrl.pcs_exp_power);
    }
    // BMS 逻辑静置 PCS输出 = 光伏实际输出 光伏门限输出为PCS期望功率
    else                        // PCS放电
    {
    
        cab->cab_ctrl.mppt_exp_power =  (cab->cab_ctrl.pcs_exp_power > cab->cab_cfg.mppt_power_max) ? cab->cab_cfg.mppt_power_max : cab->cab_ctrl.pcs_exp_power;        //限幅
        if(microgrid_cfg.en_photovoltaic)
            cab->cab_ctrl.pcs_exp_power = cab->cab_data.mppt_out_power;
        else
            cab->cab_ctrl.pcs_exp_power = 0;
        
        UD_log_sprintf(micro_log, "\n<BMS静置\n策略逻辑: 光伏门限期望功率: %lf\nPCS期望功率=%lf(光伏实际输出功率)>\n", cab->cab_ctrl.mppt_exp_power, cab->cab_ctrl.pcs_exp_power );

    }
    if(1 != microgrid_cfg.en_photovoltaic)
    {
        cab->cab_ctrl.mppt_exp_power = 0;
    }
    *(double *)arg += cab->cab_ctrl.mppt_exp_power;
    UD_log_sprintf(micro_log, "}\n");

    return 0;
}


/**
 * @description: ems_plan的静置逻辑，静置逻辑下 BMS仍然受光伏充电，但自身不参与放电（未过充情况下）
 * @param {cabinet_inside_t} *cab
 * @param {void} *arg
 * @return {*}
 */
int peakLoadShifting_stewing(cabinet_inside_t *cab, void *arg)
{
    double exp_power = *(double *)arg * cab->cab_cfg.scale;
    double BMS_power = cab->cab_ctrl.bms_exp_power;
    UD_log_sprintf(micro_log, "\n{单柜业务逻辑");
    if(microgrid_cfg.en_photovoltaic == 0 || cab->mppt.num <= 0)    // 没光伏不管
    {
        UD_log_sprintf(micro_log, "\n<未使能光伏 or 光伏设备为[%d] PCS期望功率设0>\n", cab->mppt.num);
        UD_log_sprintf(micro_log, "}\n");

        cab->cab_ctrl.pcs_exp_power = 0;
        return 0;
    }
    cab->cab_ctrl.pcs_discharge_max_set = microgrid_ctrl.discharge_max_set * cab->cab_cfg.scale;
    cab->cab_ctrl.pcs_charge_max_set = microgrid_ctrl.charge_max_set * cab->cab_cfg.scale;
    UD_log_sprintf(micro_log, "\n<业务逻辑: 基于上步计算PCS期望功率: %lf, BMS期望功率: %lf", exp_power, BMS_power);
    
    if(BMS_power > 0)
    {
        UD_log_sprintf(micro_log, "SOC超过归中算法阈值 期望放电, 设置MPPT门限为0 放电功率期望由BMS放出");

        cab->cab_ctrl.mppt_exp_power = 0;
        cab->cab_ctrl.pcs_exp_power = exp_power;
    }
    else 
    {

        cab->cab_ctrl.mppt_exp_power = exp_power - BMS_power;
        cab->cab_ctrl.mppt_exp_power = cab->cab_ctrl.mppt_exp_power < 0 ? 0 : cab->cab_ctrl.mppt_exp_power; 
        cab->cab_ctrl.pcs_exp_power = cab->cab_data.mppt_out_power + BMS_power;
        UD_log_sprintf(micro_log, "设置MPPT门限为: %lf = %lf(PCS期望功率) - %lf(BMS期望功率)", cab->cab_ctrl.mppt_exp_power,exp_power, BMS_power);
    }
    
    cab->cab_ctrl.pcs_exp_power = cab->cab_ctrl.pcs_exp_power > exp_power ? exp_power : cab->cab_ctrl.pcs_exp_power;
    cab->cab_ctrl.pcs_exp_power = cab->cab_ctrl.pcs_exp_power < 0 ? 0 : cab->cab_ctrl.pcs_exp_power; 
    UD_log_sprintf(micro_log, "基于实际MPPT输出功率: %lf 设置PCS 实际期望功率: %lf>\n",  cab->cab_data.mppt_out_power, cab->cab_ctrl.pcs_exp_power);
    UD_log_sprintf(micro_log, "}\n");

    return 0;
}
 
/**
 * @description: 削峰填谷
 * @param {double} *value_set: double[2] 的指针 获取功率
 * @return {*}
 */
static void peakLoadShifting()
{
    double tmp_charge_power_max = 0;
    double PCS_power = 0;
    double BMS_power = 0;
    double MPPT_power = 0;
    static enum ENERGY_DIRECTION status_last = 0; // 用于记录状态变化 若状态切换需要对相关数据回收

    if (microgrid_ctrl.plan_statu != status_last)
    {
        traverse_cab_dev_func(pcs_limit_reset); // 重置PCS充放电门限
        antiReflux(0, 0, 0, 0, 0, 0, 1);
        pcs_stop();
        mppt_stop();

        // 从放电切换至充电
        if (microgrid_ctrl.plan_statu == DISCHARGE_DIRECTION && status_last == CHARGE_DIRECTION)
        {
        }

        if (microgrid_ctrl.plan_statu ==  CHARGE_DIRECTION&& status_last == DISCHARGE_DIRECTION)
        {
        }

    }
    /**////**///ems_syslog(LOG_ERR,"GRID_data.GRID_POWER = %lf, PCS_data.out_power = %lf", Micro_data_buf->GRID_data.GRID_POWER, Micro_data_buf->PCS_data.out_power_get);
    /**////**///ems_syslog(LOG_ERR,"plan_statu = %d", microgrid_cfg.plan_statu);
    /**////**///ems_syslog(LOG_ERR,"ControlMode = %d", microgrid_ctrl.ControlMode);
    /**///ems_syslog(LOG_ERR,"连续log标志:削峰填谷策略");
    UD_log_sprintf(micro_log, "\n当前计划:[%d]  %d:放电 %d:充电 %d:静置\n", microgrid_ctrl.plan_statu, DISCHARGE_DIRECTION, CHARGE_DIRECTION, ENERGY_DEFAULT);
    switch(microgrid_ctrl.plan_statu) 
    {
        case DISCHARGE_DIRECTION/*放电*/:
        /**///ems_syslog(LOG_ERR,"连续log标志:放电模式");
            // BMS SOC上下限保护
            cabinet_bms_protect();
           
            // BMS_protect_to_ctrl_PCS(Micro_data_buf->BMS_data.SOC, microgrid_ctrl.SOC_min_combin, microgrid_ctrl.SOC_max_combin,  microgrid_ctrl.SOCminReturnDiff, microgrid_ctrl.SOCminReturnDiff, microgrid_cfg.plan_statu); 
            // 得到PCS需求功率
            if(microgrid_ctrl.EnTraceLoad)
            {
                UD_log_sprintf(micro_log, "\n<负荷跟踪模式>\n");
                double grid = dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power;

                if(microgrid_ctrl.en_anti_reflux)
                {
                    grid -= microgrid_ctrl.anti_reflux;
                    UD_log_sprintf(micro_log, "\n<使能防逆流 附带防逆流余量保护>\n");

                }
                else 
                {
                    UD_log_sprintf(micro_log, "\n<未使能防逆流 算法误差将可能在负载处于极低功率下导致些许逆流>\n");
                }
                PCS_power = antiReflux(
                    grid - (grid + microgrid_data.pcs_power) * (1 - microgrid_ctrl.TraceLoad), 
                    1,  
                    1,
                    microgrid_ctrl.plan_set_power, 
                    0, 
                    microgrid_data.pcs_power, 
                    0);
                UD_log_sprintf(micro_log, "\n<负荷跟踪算法期望功率: %lf>\n", PCS_power);

            }
            else if(microgrid_ctrl.en_anti_reflux)
            {
                UD_log_sprintf(micro_log, "\n<使能防逆流>\n");
                PCS_power = antiReflux(
                    dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power, 
                    microgrid_ctrl.anti_reflux,  
                    1, 
                    microgrid_ctrl.plan_set_power, 
                    0, 
                    microgrid_data.pcs_power, 
                    0);
                
                PCS_power = PCS_power > microgrid_ctrl.plan_set_power ? microgrid_ctrl.plan_set_power :PCS_power;
                UD_log_sprintf(micro_log, "\n<防逆流算法期望功率: %lf>\n", PCS_power);

            }
            else
            {
                PCS_power = microgrid_ctrl.plan_set_power;  // plan约束

                if (PCS_power > 0)
                    PCS_power = (PCS_power > microgrid_ctrl.dischargeMaxPower ? microgrid_ctrl.dischargeMaxPower : PCS_power);
                if(PCS_power < 0)
                    PCS_power = (PCS_power < microgrid_ctrl.chargeMaxPower ? microgrid_ctrl.chargeMaxPower : PCS_power);

                UD_log_sprintf(micro_log, "\n<未使能防逆流 将按照系统最大放电功率: %lf>\n", PCS_power);

            }
            /**///ems_syslog(LOG_ERR,"PCS期望功率:%lf", PCS_power);

            microgrid_ctrl.pcs_exp_power = PCS_power;   // 刷新期望功率
            traverse_cab_dev_func(cabinet_pcs_exp_power_set); 
            
            /**////**/ems_syslog(LOG_ERR,"滤波后得到预设功率 PCS_out_power = %lf", PCS_out_power);

            // 得到BMS需求功率
            BMS_power = cabinet_bms_centering();
            /**////**/ems_syslog(LOG_ERR,"连续log标志:BMS期望功率:%lf", BMS_power);

            // BMS_power = homingAlgorithmSOC(microgrid_ctrl.SOC_min_combin, microgrid_ctrl.SOC_max_combin, microgrid_ctrl.SOCmaxReturnDiff, Micro_data_buf->PCS_data.out_power_get, 1); // 归中算法 下方逻辑将随从调整
            /**////**/ems_syslog(LOG_ERR,"BMS期望功率 = %lf", BMS_power);

            /**////**/ems_syslog(LOG_ERR,"放电状态");

                // 得到光伏需求功率
            if(microgrid_cfg.en_photovoltaic)
            {
                microgrid_ctrl.mppt_exp_power = PCS_power - BMS_power;
                UD_log_sprintf(micro_log, "\n<光伏期望功率: %lf = PCS_power(%lf) - BMS_power(%lf) >\n", microgrid_ctrl.mppt_exp_power, PCS_power, BMS_power);

                microgrid_ctrl.mppt_exp_power = microgrid_ctrl.mppt_exp_power < 0 ? 0 : microgrid_ctrl.mppt_exp_power;
            /**////**/ems_syslog(LOG_ERR,"mppt期望功率:%lf", microgrid_ctrl.mppt_exp_power);

                traverse_cab_dev_func(cabinet_mppt_exp_power_set);
            }
            MPPT_power = PCS_power + BMS_power;
            break;
        case CHARGE_DIRECTION/*充电*/:
        
            
            tmp_charge_power_max = -fabs(microgrid_ctrl.plan_set_power < microgrid_ctrl.chargeMaxPower ? microgrid_ctrl.chargeMaxPower : microgrid_ctrl.plan_set_power);
            
            BMS_power = cabinet_bms_centering();
            if(BMS_power < 0)
            {
                UD_log_sprintf(micro_log, "\n<BMS 期望充电>\n");

                if (microgrid_ctrl.EnProtectTransf == 1){
                UD_log_sprintf(micro_log, "\n<使能变压器保护>\n");

                double _Pmlmax = (microgrid_ctrl.Pmlmax / 1.0) * ((double)microgrid_ctrl.K1 / 100.0);
                PCS_power = xl_antiReflux(  // 变压器保护，在保证不超变压器容量的前提下，尽可能靠近充电功率上限
                    microgrid_data.grid_appower, 
                    (double)g_usercfg_variant.Pmlmax,
                    1, 
                    0/* fabs(microgrid_ctrl.discharge_max_set)*/, 
                    tmp_charge_power_max,
                    microgrid_data.pcs_power, 
                    _Pmlmax,
                    0);

                }
                else if(g_usercfg_variant.EnProtectTransf == 2) // 最大需量
                {
                    double max_demand = microgrid_ctrl.MaxDemand;    // 门限
                    UD_log_sprintf(micro_log, "\n<使能最大需量>\n");
                    
                    max_demand = (double)g_usercfg_variant.Pmlmax  < max_demand ? g_usercfg_variant.Pmlmax : max_demand;
                    
                    double max_demand_limit = microgrid_ctrl.PmlmaxDiff;
                    max_demand_limit = max_demand - max_demand_limit;
                    max_demand_limit = max_demand_limit > 0 ? max_demand_limit : 0;

                    PCS_power = xl_antiReflux(
                        microgrid_data.grid_power, 
                        max_demand, 
                        1, 
                        0/*系统最大放电功率*/, 
                        tmp_charge_power_max, 
                        microgrid_data.pcs_power, 
                        max_demand_limit, 
                        0);
                }
                else {
                    UD_log_sprintf(micro_log, "\n<无充电保护 将按照系统最大充电功率: %lf>\n", tmp_charge_power_max);

                    PCS_power = tmp_charge_power_max;
                }

                if(microgrid_ctrl.EnProtectTrasLV == 1)
                {
                    double _Pmlmax = microgrid_ctrl.Pmlmax * microgrid_ctrl.k4 / 100.0;
                    UD_log_sprintf(micro_log, "\n<使能低压侧变压器保护>\n" );

                    double power_tmp = xl_LV_antiReflux(microgrid_data.grid_appower, 
                        microgrid_ctrl.PLVmlmax, 
                        1, 
                        0, 
                        tmp_charge_power_max, 
                        microgrid_data.pcs_power,
                         _Pmlmax,
                        0);
                    
                    PCS_power = PCS_power < power_tmp ? power_tmp : PCS_power;  // 按负充正放，此处按最小充电功率来
                }
                UD_log_sprintf(micro_log, "\n<期望功率: %lf>\n", PCS_power);
                
                traverse_cab_dev_func_arg(set_pcs_ctrl_chargepower, &PCS_power);


            }
            else {
                UD_log_sprintf(micro_log, "\n<BMS 充满, 将尝试将光伏功率放出>\n");
            
                if(microgrid_ctrl.EnTraceLoad)
                {
                UD_log_sprintf(micro_log, "\n<负荷跟踪模式>\n");

                    double grid = dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power;
                    if(microgrid_ctrl.en_anti_reflux)
                    {
                        grid -= microgrid_ctrl.anti_reflux;
                        UD_log_sprintf(micro_log, "\n<使能防逆流 附带防逆流余量保护>\n");

                    }
                    else 
                    {
                        UD_log_sprintf(micro_log, "\n<未使能防逆流 算法误差将可能在负载处于极低功率下导致些许逆流>\n");
                    }
                    
                    PCS_power = antiReflux(
                        grid - (grid + microgrid_data.pcs_power) * (1 - microgrid_ctrl.TraceLoad), 
                        1,  
                        1,
                        microgrid_ctrl.dischargeMaxPower, 
                        0, 
                        microgrid_data.pcs_power, 
                        0);
                    UD_log_sprintf(micro_log, "\n<负荷跟踪算法期望功率: %lf>\n", PCS_power);

                }
                else if(microgrid_ctrl.en_anti_reflux)  // 防逆流开启与否  
                {
                    UD_log_sprintf(micro_log, "\n<使能防逆流>\n");
                    PCS_power = antiReflux(
                        dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power, 
                        microgrid_ctrl.anti_reflux,  
                        1, 
                        microgrid_ctrl.discharge_max_set, 
                        0, 
                        microgrid_data.pcs_power, 
                        0);
                    UD_log_sprintf(micro_log, "\n<防逆流算法期望功率: %lf>\n", PCS_power);

                }
                else
                {
                    PCS_power = microgrid_ctrl.dischargeMaxPower;   // 按照最大放电功率作为放电期望
                    UD_log_sprintf(micro_log, "\n<未使能防逆流 将按照系统最大放电功率: %lf>\n", PCS_power);
                }
                
            }
            /**////**/ems_syslog(LOG_ERR,"PCS期望功率:%lf", PCS_power);
        /**///ems_syslog(LOG_ERR,"连续log标志:PCS期望功率:%lf", PCS_power);

            microgrid_ctrl.pcs_exp_power = PCS_power;   // 刷新期望功率
            traverse_cab_dev_func(cabinet_pcs_exp_power_set);   // 先分发期望功率 随后处理实际下发功率
            // double power_charge_cab = microgrid_ctrl.plan_set_power / dev_info_all.cabinet_info.num;
            // traverse_cab_dev_func_arg(set_cab_charge_max, &power_charge_cab);
            MPPT_power = 0;
            traverse_cab_dev_func_arg(peakLoadShifting_pcs_mppt_exp_power, &MPPT_power);
        /**///ems_syslog(LOG_ERR,"连续log标志:MPPT_power:%lf", MPPT_power);


            /*END*/

            break;
        case ENERGY_DEFAULT/*静置*/:
        
        tmp_charge_power_max = microgrid_ctrl.chargeMaxPower ;
        if(microgrid_ctrl.EnTraceLoad)
        {
            UD_log_sprintf(micro_log, "\n<负荷跟踪模式>\n");

            double grid = dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power;
            if(microgrid_ctrl.en_anti_reflux)
            {
                grid -= microgrid_ctrl.anti_reflux;
                UD_log_sprintf(micro_log, "\n<使能防逆流 附带防逆流余量保护>\n");

            }
            else 
            {
                UD_log_sprintf(micro_log, "\n<未使能防逆流 算法误差将可能在负载处于极低功率下导致些许逆流>\n");
            }
            PCS_power = antiReflux(
                grid - (grid + microgrid_data.pcs_power) * (1 - microgrid_ctrl.TraceLoad), 
                1,  
                1,
                microgrid_ctrl.dischargeMaxPower, 
                0, 
                microgrid_data.pcs_power, 
                0);

        }
        else if(microgrid_ctrl.en_anti_reflux)  // 防逆流开启与否  
        {
            UD_log_sprintf(micro_log, "\n<使能防逆流 附带防逆流余量保护>\n");
            PCS_power = antiReflux(
                dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power, 
                microgrid_ctrl.anti_reflux,  
                1, 
                microgrid_ctrl.discharge_max_set, 
                0, 
                microgrid_data.pcs_power, 
                0);
            UD_log_sprintf(micro_log, "\n<防逆流算法期望功率: %lf>\n", PCS_power);
        }
        else
        {
            PCS_power = microgrid_ctrl.dischargeMaxPower;   // 按照最大放电功率作为放电期望
            UD_log_sprintf(micro_log, "\n<未使能防逆流 将按照系统最大放电功率: %lf>\n", PCS_power);
        }

        BMS_power = cabinet_bms_centering();
        traverse_cab_dev_func_arg(peakLoadShifting_stewing, &PCS_power);


            break;
        default:
            UD_log_sprintf(micro_log, "\n<未注册策略!>\n");
            stop_power_allocation();
            break;
    }
    status_last = microgrid_ctrl.plan_statu;
    PCS_set_power(PCS_power, 0);
    MPPT_set_power(MPPT_power, 0);

}


/**
 * @description: 光伏消纳
 * @param {double} *value_set: double[2] 的指针 获取功率
 * @return {*}
 */
static void PhotovoltaicAbsorption()
{
    /*直接设置plan模式为放电模式*/
    microgrid_ctrl.plan_statu = DISCHARGE_DIRECTION;
    if(0 == microgrid_cfg.en_photovoltaic)   
    {
        /**///ems_syslog(LOG_ERR,"en_photovoltaic is 0! return PhotovoltaicAbsorption set_power = 0");
        // stop_power_allocation();
        return;
    }
    double PCS_power = 0; 
    double BMS_power = 0; 
    double MPPT_power = 0;
    cabinet_bms_protect();

    // 得到PCS需求功率
    if(microgrid_ctrl.EnTraceLoad)
    {
        UD_log_sprintf(micro_log, "\n<负荷跟踪模式>\n");
        double grid = dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power;
        if(microgrid_ctrl.en_anti_reflux)
        {
            grid -= microgrid_ctrl.anti_reflux;
            UD_log_sprintf(micro_log, "\n<使能防逆流 附带防逆流余量保护>\n");

        }
        else 
        {
            UD_log_sprintf(micro_log, "\n<未使能防逆流 算法误差将可能在负载处于极低功率下导致些许逆流>\n");
        }
        PCS_power = antiReflux(
            grid - (grid + microgrid_data.pcs_power) * (1 - microgrid_ctrl.TraceLoad), 
            1,  
            1,
            microgrid_ctrl.dischargeMaxPower, 
            0, 
            microgrid_data.pcs_power, 
            0);
        UD_log_sprintf(micro_log, "\n<负荷跟踪算法期望功率: %lf>\n", PCS_power);


    }
    else if(microgrid_ctrl.en_anti_reflux)
    {
        

        PCS_power = antiReflux(
            dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power, 
            microgrid_ctrl.anti_reflux,  
            1, 
            microgrid_ctrl.dischargeMaxPower, 
            0, 
            microgrid_data.pcs_power, 
            0);
        UD_log_sprintf(micro_log, " \n<使能防逆流,算法推导PCS期望功率:%lf>\n", PCS_power);
    }
    else
    {
        PCS_power = microgrid_ctrl.dischargeMaxPower;  // plan约束
        UD_log_sprintf(micro_log, "\n<未使能防逆流 将按照系统最大放电功率: %lf>\n", PCS_power);

    }
    microgrid_ctrl.pcs_exp_power = PCS_power;   // 刷新期望功率
    traverse_cab_dev_func(cabinet_pcs_exp_power_set); 
    /**////**///ems_syslog(LOG_ERR,"滤波后得到预设功率 PCS_out_power = %lf", PCS_out_power);

    // 得到BMS需求功率
    BMS_power = cabinet_bms_centering();
    UD_log_sprintf(micro_log, " \n<BMS 期望功率:%lf>\n", BMS_power);

    // BMS_power = homingAlgorithmSOC(microgrid_ctrl.SOC_min_combin, microgrid_ctrl.SOC_max_combin, microgrid_ctrl.SOCmaxReturnDiff, Micro_data_buf->PCS_data.out_power_get, 1); // 归中算法 下方逻辑将随从调整
    /**////**///ems_syslog(LOG_ERR,"BMS期望功率 = %lf", BMS_power);

    /**////**///ems_syslog(LOG_ERR,"放电状态");

        // 得到光伏需求功率
    if(microgrid_cfg.en_photovoltaic)
    {
        microgrid_ctrl.mppt_exp_power = microgrid_data.pcs_power - BMS_power;
        microgrid_ctrl.mppt_exp_power = microgrid_ctrl.mppt_exp_power < 0 ? 0 : microgrid_ctrl.mppt_exp_power;
        microgrid_ctrl.mppt_exp_power = microgrid_ctrl.mppt_exp_power > microgrid_ctrl.pvMax ? microgrid_ctrl.pvMax : microgrid_ctrl.mppt_exp_power;

        traverse_cab_dev_func(cabinet_mppt_exp_power_set);
    }
    MPPT_power =   PCS_power - BMS_power;
    PCS_set_power(PCS_power, 0);
    MPPT_set_power(MPPT_power, 0);
}

/**
 * @description: 应急备电
 * @return {*}
 */
void Emergency_backup_power()
{
    double BMS_power = 0,PCS_power = 0,MPPT_power = 0,tmp_charge_power_max = 0;
    tmp_charge_power_max = microgrid_ctrl.chargeMaxPower ;
    
    BMS_power = cabinet_bms_centering();
    if(BMS_power < 0)
    {
        
        if (microgrid_ctrl.EnProtectTransf == 1){
        double _Pmlmax = (microgrid_ctrl.Pmlmax / 1.0) * ((double)microgrid_ctrl.K1 / 100.0);
        PCS_power = xl_antiReflux(  // 变压器保护，在保证不超变压器容量的前提下，尽可能靠近充电功率上限
            microgrid_data.grid_power, 
            (double)g_usercfg_variant.Pmlmax,
            1, 
            0/* fabs(microgrid_ctrl.discharge_max_set)*/, 
            tmp_charge_power_max,
            microgrid_data.pcs_power, 
            _Pmlmax,
            0);
        }
        else if(g_usercfg_variant.EnProtectTransf == 2) // 最大需量
        {
            double max_demand = microgrid_ctrl.MaxDemand;    // 门限
                    
            max_demand = (double)g_usercfg_variant.Pmlmax  < max_demand ? g_usercfg_variant.Pmlmax : max_demand;
            
            double max_demand_limit = microgrid_ctrl.PmlmaxDiff;
            max_demand_limit = max_demand - max_demand_limit;
            max_demand_limit = max_demand_limit > 0 ? max_demand_limit : 0;

            PCS_power = xl_antiReflux(
                microgrid_data.grid_power, 
                max_demand, 
                1, 
                0/*系统最大放电功率*/, 
                tmp_charge_power_max, 
                microgrid_data.pcs_power, 
                max_demand_limit, 
                0);
        }
        else
        {
            PCS_power = tmp_charge_power_max;
        }

        if(microgrid_ctrl.EnProtectTrasLV == 1)
        {
            double _Pmlmax = microgrid_ctrl.Pmlmax * microgrid_ctrl.k4 / 100.0;
            double power_tmp = xl_LV_antiReflux(microgrid_data.grid_appower, 
                microgrid_ctrl.PLVmlmax, 
                1, 
                0, 
                tmp_charge_power_max, 
                microgrid_data.pcs_power,
                    _Pmlmax,
                0);
            
            PCS_power = PCS_power < power_tmp ? power_tmp : PCS_power;  // 按负充正放，此处按最小充电功率来
        }


        traverse_cab_dev_func_arg(set_pcs_ctrl_chargepower, &PCS_power);
    }
    else {
        if(microgrid_ctrl.EnTraceLoad)
        {
            double grid = dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power;
            PCS_power = antiReflux(
                grid - (grid + microgrid_data.pcs_power) * ( 1 - microgrid_ctrl.TraceLoad), 
                1,  
                1,
                microgrid_ctrl.dischargeMaxPower, 
                0, 
                microgrid_data.pcs_power, 
                0);
        }
        else if(microgrid_ctrl.en_anti_reflux)  // 防逆流开启与否  
            PCS_power = antiReflux(
                dev_info_all.meter_grid.meter_grid_param[0].info.meter_grid_data.act_power, 
                microgrid_ctrl.anti_reflux,  
                1, 
                microgrid_ctrl.discharge_max_set, 
                0, 
                microgrid_data.pcs_power, 
                0);
        else
        {
            PCS_power = microgrid_ctrl.dischargeMaxPower;   // 按照最大放电功率作为放电期望
        }
    }
    /**////**/ems_syslog(LOG_ERR,"PCS期望功率:%lf", PCS_power);
/**///ems_syslog(LOG_ERR,"连续log标志:PCS期望功率:%lf", PCS_power);

    microgrid_ctrl.pcs_exp_power = PCS_power;   // 刷新期望功率
    traverse_cab_dev_func(cabinet_pcs_exp_power_set);   // 先分发期望功率 随后处理实际下发功率
    // double power_charge_cab = microgrid_ctrl.plan_set_power / dev_info_all.cabinet_info.num;
    // traverse_cab_dev_func_arg(set_cab_charge_max, &power_charge_cab);
    MPPT_power = 0;
    traverse_cab_dev_func_arg(peakLoadShifting_pcs_mppt_exp_power, &MPPT_power);
    
    PCS_set_power(PCS_power, 0);
    MPPT_set_power(MPPT_power, 0);

    /*END*/
}


/**
 * @description: 把PCS实际输出作为该柜的PCS期望功率 便于后续mppt功率计算
 * @param {cabinet_inside_t} *cab
 * @return {*}
 */
int off_grid_set_pcs_power(cabinet_inside_t *cab)
{
    cab->cab_ctrl.pcs_exp_power = cab->cab_data.pcs_output_power;
    return 0;
}

/**
 * @description: 离网模式
 * @param {double} *power_all_devs
 * @return {*}
 */
static void off_grid_mode()
{
    double BMS_power = cabinet_bms_centering();// 得到BMS期望功率
    microgrid_ctrl.bms_exp_power = BMS_power;

    microgrid_ctrl.pcs_exp_power = microgrid_data.pcs_power;   // 将PCS实际输出功率作为PCS的期望功率便于后续计算
    microgrid_ctrl.mppt_exp_power = BMS_power + microgrid_ctrl.pcs_exp_power;
    microgrid_ctrl.mppt_exp_power = microgrid_ctrl.mppt_exp_power < 0 ? 0 : microgrid_ctrl.mppt_exp_power; 
    traverse_cab_dev_func(off_grid_set_pcs_power);  // 针对单个柜 PCS 期望功率刷新
    traverse_cab_dev_func(off_grid_mppt_exp_power_func);  // 根据BMS和PCS期望功率可得到 针对单个柜 mppt 期望功率 并刷新
    MPPT_set_power(microgrid_ctrl.mppt_exp_power, 0);
}

/**
 * @description: 直流模式
 * @return {*}
 */
static int Grid_connected_mode()
{
    UD_log_sprintf(micro_log, "\n<策略：[%d]   %d:计划功率 %d:动态增容 %d:自发自用 %d:光储备电>\n", microgrid_ctrl.choose_func, STRATAGY_TYPE_PERIOD_CTRL, STRATAGY_TYPE_DEMAND_FIXED, STRATAGY_TYPE_PV_STORAGE, STRATAGY_TYPE_STANDBY);

    switch(microgrid_ctrl.choose_func) // 业务逻辑选择
    {
        case STRATAGY_TYPE_PERIOD_CTRL/*削峰填谷模式*/:
            peakLoadShifting();

        break;
        case STRATAGY_TYPE_DEMAND_FIXED/*变压器增容*/:
        return 0;
        break;
        case STRATAGY_TYPE_PV_STORAGE/*光伏消纳*/:
            PhotovoltaicAbsorption();
        break;
        case STRATAGY_TYPE_STANDBY/*光储备电*/:
            Emergency_backup_power();
        return 0;
    
        default:
        break;
    }
    return 0;

}



RELEVANCE_STATE init_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    /**///ems_syslog(LOG_ERR,"init_init");  // TODO 进异常
    sleep(5);   // 等待三秒获取数据
    Relevant_data_refresh();
    // 如果没能使能光伏 尝试将光伏关掉 没关掉也没事 也许就没光伏这设备 
    if(1 == microgrid_cfg.en_photovoltaic && 1 == mppt_stop())
    {
        ems_syslog(LOG_ERR,"Err: MPPT power does not write 0!!!!");  // TODO 进异常
    }

    return state;
}

RELEVANCE_STATE init_handover_detect(RELEVANCE_STATE state)
{
    
    Relevant_data_refresh();        // 刷新数据源
    RELEVANCE_STATE state_set = resolve_state();

    /*TODO: 增加DIDO校验 DIDO优先级更高*/
   
    return state_set;
}

int init_behaviour_func(RELEVANCE_STATE state_self)
{
    sleep(1);
    return 0;
}




/**
 * @description: 进入待机模式:
                必然动作:PCS关机、MPPT停止
                
 * @param {RELEVANCE_STATE} last_state
 * @param {RELEVANCE_STATE} state
 * @return {*}
 */
RELEVANCE_STATE await_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
        /**///ems_syslog(LOG_ERR,"await_init");  // TODO 进异常

    /*MPPT写0功率*/
    int ret = 0;

    if(microgrid_cfg.en_photovoltaic && mppt_stop())
    {   // TODO: 修改光伏功率下发接口
        ems_syslog(LOG_ERR,"Err: MPPT power does not write 0!!!!");  // TODO 进异常

    }
    ret |= set_pcs_onoff(0);

    if(ret)
        return STATE_ABNORMAL;
    /* PCS 关机 */

    return state;
}

RELEVANCE_STATE await_handover_detect(RELEVANCE_STATE state)
{
    Relevant_data_refresh();        // 刷新数据源
    
    RELEVANCE_STATE state_set = resolve_state();
    struct _dido_t *dido = &dev_info_all.dido.dido_param[0];
    if((microgrid_cfg.en_sts == 0 && dido->info.dido_data.conn_sign == 0) || (microgrid_cfg.en_sts && microgrid_data.grid_statu == 0))    // 离网状态的待机 尝试启动柴发
    {
        if(microgrid_cfg.en_diesel_generator)
        {
            set_dg_statu(1, 0);
        }
        
    }



    if(microgrid_data.SOC_average >= microgrid_ctrl.SOC_max_netdead) // 充满电了先关光伏
    {
        mppt_stop();
    }

    /*否则等SOC充满切回离网  条件判定基于上一状态是否为离网状态 否则其他状态嵌入本状态将导致需要充满电才能切出 */
    if((state_set == STATE_OFF_GRID || state_set == STATE_AWAIT) && microgrid_data.SOC_average < microgrid_ctrl.SOC_max_netdead && state_machine_Micgp.last_state == STATE_OFF_GRID)
    {
        
        state_set = state;
    }

    if(state_set == state && ((microgrid_cfg.en_sts == 0 && dido->info.dido_data.conn_sign == 1) || (microgrid_cfg.en_sts && microgrid_data.grid_statu == 1)))    // 并网待机模式保持 icb 闭合
    {
        dido_set_icb(1, 0);
    }

    
    pcs_stop();
    set_pcs_onoff(0);

    return state_set;
}

/*待机策略中 若长期处于待机状态 可支持使用光伏对BMS充电*/
int await_behaviour_func(RELEVANCE_STATE state_self)
{
    if(Relevant_data_refresh())
    {
        return 0;
    }

    double BMS_power = cabinet_bms_centering();
    double MPPT_power = microgrid_data.pcs_power + BMS_power;

    MPPT_power = microgrid_ctrl.mppt_exp_power < 0 ? 0 : microgrid_ctrl.mppt_exp_power;
    if(microgrid_cfg.en_photovoltaic)
    {
        traverse_cab_dev_func(cabinet_mppt_exp_power_set);
        MPPT_set_power(MPPT_power, 0);
    }

    return 0;
}



RELEVANCE_STATE connect_grid_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    /**///ems_syslog(LOG_ERR,"connect_grid_init");  // TODO 进异常
    int ret = 0;
    if(0 == microgrid_cfg.en_sts && STATE_AWAIT == last_state)   // 如果上一状态是待机状态 PCS就视为关机状态 
    {
        /* PCS 并网 */
        if(pcs_check_connect(1))    // 校验并离网状态
        {
            ret |= set_pcs_onoff(0);
            ret |= set_pcs_connect(1);
        }
    }
     /* PCS 开机 */
    ret |= set_pcs_onoff(1);

    if(ret)
        return  STATE_ABNORMAL;

    return STATE_CONNECT_GRID;

}

RELEVANCE_STATE connect_grid_handover_detect(RELEVANCE_STATE state)
{

    Relevant_data_refresh();
    RELEVANCE_STATE state_set = resolve_state();

    int ret = 0;
    if(microgrid_cfg.en_diesel_generator && get_dg_statu())
    {
        set_dg_statu(0, 0);    // 柴发关掉
    }

    dido_set_icb(1, 0);

    if(0 == microgrid_cfg.en_sts && pcs_check_connect(1))    // 校验并离网状态
    {
        mppt_stop();            // 先停光伏 将PCS切并网再loop
        ret |= set_pcs_onoff(0);
        ret |= set_pcs_connect(1);
    }
     /* PCS 开机 */
    ret |= set_pcs_onoff(1);

    if (ret)
        return STATE_ABNORMAL;
    
    return state_set;
}


int connect_grid_behaviour_func(RELEVANCE_STATE state_self)
{

    /**///ems_syslog(LOG_ERR,"connect_grid_behaviour_func");  // TODO 进异常

    if(Relevant_data_refresh())
    {
        return 0;
    }

    Grid_connected_mode();
   
    return 0;
}


RELEVANCE_STATE off_grid_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    int ret = 0;
    Relevant_data_refresh();
    if(1 != microgrid_cfg.en_sts)
    {
        set_pcs_onoff(0);
        ret |= set_pcs_connect(0);
    }
    ret |= set_pcs_onoff(1);

    if(ret)
    {
        return STATE_ABNORMAL;
    }
  
    return state;

}

RELEVANCE_STATE off_handover_detect(RELEVANCE_STATE state)
{
    int ret = 0;
    Relevant_data_refresh();
    RELEVANCE_STATE state_set = resolve_state();
    
    if(microgrid_data.SOC_average <= microgrid_ctrl.SOC_min_netdead) // SOC低阈值 切待机模式
    {
        mppt_stop();        
        return STATE_AWAIT; // 直接切入待机
    }

    if(microgrid_cfg.en_diesel_generator)
    {
        if(microgrid_ctrl.dg_boot_soc > microgrid_data.SOC_average)
        {
            set_dg_statu(1, 0);
        }
        else 
        {
            if(get_dg_statu())
                set_dg_statu(0, 0);
        }
    }

    dido_set_icb(0, 0);     // 内置使能检查

    if(0 == microgrid_cfg.en_sts)
    {
        if(pcs_check_connect(0))
        {
            ret |= set_pcs_onoff(0);
            ret |= set_pcs_connect(0);
        }
    }

    ret |= set_pcs_onoff(1);

    if(ret)
        return STATE_ABNORMAL;  // 进异常

    return state_set;
}


int off_grid_behaviour_func(RELEVANCE_STATE state_self)
{
    /**///ems_syslog(LOG_ERR,"off_grid_behaviour_func");  // TODO 进异常
    off_grid_mode();

    return 0;
}

RELEVANCE_STATE dg_mode_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    if(1 != microgrid_cfg.en_diesel_generator)  // 柴发使能开关校验
    {
        return STATE_INIT;
    }
   
    int ret = 0;
    mppt_stop();            // 先停光伏
    if(microgrid_cfg.en_sts)
    {
        
    }
    else 
    {
        if(microgrid_cfg.en_photovoltaic)   // 具备光伏条件下，储能采取光伏充电 避开市电
        {
            ret |= set_pcs_onoff(0);
            
        }
        else
        {   if(pcs_check_connect(1))        //并离网切换
            {
                ret |= set_pcs_onoff(0);
                ret |= set_pcs_connect(1);
            }
            ret |= set_pcs_onoff(1);
        }
        
    
    }

    if(microgrid_cfg.en_icb)        // 断路器合闸
    {
        ret |= dido_set_icb(1, 1);
    }

    if(ret)
        return STATE_ABNORMAL;  // 开关机操作不了 去异常处理

    return state;

}

RELEVANCE_STATE dg_mode_handover_detect(RELEVANCE_STATE state)
{
    Relevant_data_refresh();
    int ret = 0;

    enum _STATE_MICROGRID state_set = resolve_state();
    dido_set_icb(1, 0);
    set_dg_statu(1, 0);
    
    if(microgrid_ctrl.DG_cap_pro)   // 使能容量保护 将采用柴发充电 且优先光伏
    {
        if(0 == microgrid_cfg.en_sts && pcs_check_connect(1))    // 校验并离网状态
        {
            
            ret |= set_pcs_onoff(0);
            ret |= set_pcs_connect(1);
        }
        /* PCS 开机 */
        ret |= set_pcs_onoff(1);

    }
    else 
    {
        ret |= set_pcs_onoff(0);
    }

    if(ret)
    {
        return STATE_ABNORMAL;
    }

    return state_set;
}

int dg_mode_behaviour_func(RELEVANCE_STATE state_self)
{
    Relevant_data_refresh();

    double BMS_power = 0,PCS_power = 0,MPPT_power = 0;
    BMS_power = cabinet_bms_centering();        // 回调会设置 cab->bms_exp_power 
    if(microgrid_ctrl.DG_cap_pro)   // 使能容量保护 将采用柴发充电 且优先光伏
    {
        if(BMS_power < 0)
        {
            double _Pmlmax = microgrid_ctrl.dg_rated_power;
            PCS_power = xl_antiReflux(  // 变压器保护，在保证不超变压器容量的前提下，尽可能靠近充电功率上限
                microgrid_data.grid_power, 
                _Pmlmax,
                1, 
                0/* fabs(microgrid_ctrl.discharge_max_set)*/, 
                microgrid_ctrl.chargeMaxPower,
                microgrid_data.pcs_power, 
                _Pmlmax - microgrid_ctrl.DgDiff,
                0);
            traverse_cab_dev_func_arg(set_pcs_ctrl_chargepower, &PCS_power);

        }
        else { 
            PCS_power = 0;
        }

        microgrid_ctrl.pcs_exp_power = PCS_power;   // 刷新期望功率
        traverse_cab_dev_func(cabinet_pcs_exp_power_set);   // 先分发期望功率 随后处理实际下发功率
        MPPT_power = 0;
        traverse_cab_dev_func_arg(peakLoadShifting_pcs_mppt_exp_power, &MPPT_power);
    }
    else
    {
        if(microgrid_cfg.en_photovoltaic)
        {
            PCS_power = 0;
            microgrid_ctrl.pcs_exp_power = 0;
            traverse_cab_dev_func_arg(set_pcs_ctrl_chargepower, &PCS_power);

            traverse_cab_dev_func_arg(mppt_exp_power_set, &MPPT_power);  // 处理单柜期望功率
        }
    }

    PCS_set_power(PCS_power, 0);
    MPPT_set_power(MPPT_power, 0);

    return 0;
}

/**
 * @description: 异常处理
 * @param {RELEVANCE_STATE} last_state
 * @param {RELEVANCE_STATE} state
 * @return {*}
 */
RELEVANCE_STATE ABNORMAL_init(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    
    set_pcs_onoff(0);
    mppt_stop();

    return state;
}

RELEVANCE_STATE ABNORMAL_handover_detect(RELEVANCE_STATE state)
{
    static int en = 0;
    static struct lnxall_buff buff;
    buff.bufptr = "";

    if(0 == en)
    {
        lbuff_init(&buff, 10);
        lbuff_sprintf(&buff, "%s", micro_log->prt_buf.bufptr);
        en = 1;
    }
    else
    {
        UD_log_sprintf(micro_log, " \n%s\n", buff.bufptr);
    }
    UD_log_sprintf(micro_log, " \n<ERROR 微网业务异常 请排查 本状态不会退出, 需退出请重启EMS进程>\n");
    set_pcs_onoff(0);
    mppt_stop();

    return state;
}


int ABNORMAL_behaviour_func(RELEVANCE_STATE state_self)
{
  
    return 0;
}


static RELEVANCE_STATE states_exit(RELEVANCE_STATE last_state, RELEVANCE_STATE state)
{
    PCS_set_power(0, 1);
    MPPT_set_power(0,1);
    mppt_stop();
    return state;
}

int set_micro_log_en(struct UD_log *self)
{
    // return ud_log_Level & UD_LOG_MICRO ? TRUE : FALSE;

    return ud_log_Level & 0x002 ? TRUE : FALSE;
}

/**
 * @description: 微网并离网状态机初始化
 * @return {*} -1 指针悬空状态机初始化失败  0 空
 */
int state_machine_Init()
{
    /*待开发完善*/
    state_machine_Micgp.state[STATE_INIT].handover_detect = init_handover_detect;
    state_machine_Micgp.state[STATE_INIT].behaviour_func = init_behaviour_func;
    state_machine_Micgp.state[STATE_INIT].init = init_init;
    state_machine_Micgp.state[STATE_INIT].state_self = STATE_INIT;

    state_machine_Micgp.state[STATE_AWAIT].handover_detect = await_handover_detect;
    state_machine_Micgp.state[STATE_AWAIT].behaviour_func = await_behaviour_func;
    state_machine_Micgp.state[STATE_AWAIT].init = await_init;
    state_machine_Micgp.state[STATE_AWAIT].state_self = STATE_AWAIT;

    state_machine_Micgp.state[STATE_CONNECT_GRID].handover_detect = connect_grid_handover_detect;
    state_machine_Micgp.state[STATE_CONNECT_GRID].behaviour_func = connect_grid_behaviour_func;
    state_machine_Micgp.state[STATE_CONNECT_GRID].init = connect_grid_init;
    state_machine_Micgp.state[STATE_CONNECT_GRID].state_self = STATE_CONNECT_GRID;

    state_machine_Micgp.state[STATE_OFF_GRID].handover_detect = off_handover_detect;
    state_machine_Micgp.state[STATE_OFF_GRID].behaviour_func = off_grid_behaviour_func;
    state_machine_Micgp.state[STATE_OFF_GRID].init = off_grid_init;
    state_machine_Micgp.state[STATE_OFF_GRID].state_self = STATE_OFF_GRID;

    /*柴发并网暂时不参与*/
    state_machine_Micgp.state[STATE_CF_CONNECT_GRID].handover_detect = dg_mode_handover_detect;
    state_machine_Micgp.state[STATE_CF_CONNECT_GRID].behaviour_func = dg_mode_behaviour_func;
    state_machine_Micgp.state[STATE_CF_CONNECT_GRID].init = dg_mode_init;
    state_machine_Micgp.state[STATE_CF_CONNECT_GRID].state_self = STATE_CF_CONNECT_GRID;

    /*未定义状态无法确定逻辑*/
    state_machine_Micgp.state[STATE_ABNORMAL].handover_detect = ABNORMAL_handover_detect;
    state_machine_Micgp.state[STATE_ABNORMAL].behaviour_func = ABNORMAL_behaviour_func;
    state_machine_Micgp.state[STATE_ABNORMAL].init = ABNORMAL_init;
    state_machine_Micgp.state[STATE_ABNORMAL].state_self = STATE_ABNORMAL;

    state_machine_Micgp.states_exit = states_exit;
 
    Relevant_data_refresh();        // 刷新数据源


    state_switch(&state_machine_Micgp, STATE_INIT);      // 初始状态 
    
    pthread_t pid;// 微网状态机线程
    micro_log = UD_log_creat("micro.log", set_micro_log_en);
    pthread_create(&pid, NULL, state_machine_pthread, &state_machine_Micgp);
    if (pthread_setname_np(pid, "Microgrid")) 
    { 
        ems_syslog(LOG_ERR,"Error setting thread name\n"); 
        return 1; 
    }
    return 0;

}