ctnd/appl/ems/ems.c

#include "ems.h"
#include "plt.h"
#include "ems.h"
struct ems_t ems;
/* ms */
static double ems_get_timeofday()
{
    struct timeval tv;
    struct timezone tz;

    gettimeofday(&tv, &tz);
    return (double)tv.tv_sec * 1000 + (double)tv.tv_usec / 1000;
}

static int ems_dbcb_0(void *para, int ncolumn, char **columnvalue, char *columnname[])
{
    int i;
    struct dbcbparam_t *pcbparam = (struct dbcbparam_t *)para;
    struct ems_t *dev = &ems;

    pcbparam->nrow++;
    log_dbg("%s, ++, row:%d; col:%d", __func__, pcbparam->nrow, ncolumn);

    for (i = 0; i < ncolumn; i++)
    {
        if (strcmp("reg_lo", columnname[i]) == 0)
        {
            dev->pow_reg.low = atof(columnvalue[i]);
        }
        else if (strcmp("reg_hi", columnname[i]) == 0)
        {
            dev->pow_reg.high = atof(columnvalue[i]);
        }
        else if (strcmp("reg_intv", columnname[i]) == 0)
        {
            dev->pow_reg.intv = atoi(columnvalue[i]);
        }
        else if (strcmp("pcurv_idx", columnname[i]) == 0)
        {
            dev->pcurv_idx = atoi(columnvalue[i]);
        }
        else if (strcmp("transf_conm_model", columnname[i]) == 0)
        {
            strcpy(dev->sztransf_conm_model, columnvalue[i]);
            dev->transf_conm_model = plt_devm_str2nbr(dev->sztransf_conm_model);
        }
        else if (strcmp("transf_conm_idx", columnname[i]) == 0)
        {
            dev->transf_conm_idx = atoi(columnvalue[i]);
        }
        else if (strcmp("transf_loadm_model", columnname[i]) == 0)
        {
            strcpy(dev->sztransf_loadm_model, columnvalue[i]);
            dev->transf_loadm_model = plt_devm_str2nbr(dev->sztransf_loadm_model);
        }
        else if (strcmp("transf_loadm_idx", columnname[i]) == 0)
        {
            dev->transf_loadm_idx = atoi(columnvalue[i]);
        }
        else if (strcmp("factory_conm_model", columnname[i]) == 0)
        {
            strcpy(dev->szfactory_conm_model, columnvalue[i]);
            dev->factory_conm_model = plt_devm_str2nbr(dev->szfactory_conm_model);
        }
        else if (strcmp("factory_conm_idx", columnname[i]) == 0)
        {
            dev->factory_conm_idx = atoi(columnvalue[i]);
        }
        else if (strcmp("factory_loadm_model", columnname[i]) == 0)
        {
            strcpy(dev->szfactory_loadm_model, columnvalue[i]);
            dev->factory_loadm_model = plt_devm_str2nbr(dev->szfactory_loadm_model);
        }
        else if (strcmp("factory_loadm_idx", columnname[i]) == 0)
        {
            dev->factory_loadm_idx = atoi(columnvalue[i]);
        }
    }

    pcbparam->ret = 0;
    log_dbg("%s, --,ret:%d", __func__, pcbparam->ret);
    return 0;
}

// int ems_get_con_ap()
// {
//     struct ems_t* dev = &ems;
//     return dev->con_ap;
// }

// int ems_get_load_ap()
// {
//     struct ems_t* dev = &ems;
//     return dev->load_ap;
// }

// double ems_get_load_com_ae()
// {
//     struct ems_t* e = &ems;
//     return e->loadm_com_ae;
// }

// double ems_get_load_pos_ae()
// {
//     struct ems_t* e = &ems;
//     return e->loadm_pos_ae;
// }

// double ems_get_load_neg_ae()
// {
//     struct ems_t* e = &ems;
//     return e->loadm_neg_ae;
// }

static int ems_update_cur_timeseg_type()
{
    int ret = -1;
    struct ems_t *dev = &ems;
    int tsidx = dev->timeseg_idx;
    struct timeseg_t *ts = &dev->timeseg;
    time_t timep;
    struct tm *tsp;
    int hh, nn;

    if (tsidx >= 1 && tsidx <= TIMESEG_NBR_MAX && ts->status == TIMESEGST_VALID)
    {
        time(&timep);
        tsp = localtime(&timep);
        hh = tsp->tm_hour;
        nn = tsp->tm_min / (int)5 * (int)5;
        dev->cur_timeseg_type = ts->seg_type[hh][nn];
        ret = 0;
    }

    return ret;
}

static void ems_update()
{
    struct ems_t *dev = &ems;
    static double ts_last_update_timeseg = 0.0;
    double ts = ems_get_timeofday();

    if (ts - ts_last_update_timeseg > 1000)
    { // 1s
        ts_last_update_timeseg = ts;
        ems_update_cur_timeseg_type();
    }

    if (dev->transf_conm_idx > 0 && dev->transf_loadm_idx > 0)
    {
        dev->transf_con_ap = meter_get_com_ap(dev->transf_conm_model, dev->transf_conm_idx);
        // prepare meter data
        dev->transf_conm_com_ap = dev->transf_con_ap;
        dev->transf_conm_com_ae = meter_get_com_ae(dev->transf_conm_model, dev->transf_conm_idx);
        dev->transf_conm_pos_ae = meter_get_pos_ae(dev->transf_conm_model, dev->transf_conm_idx);
        dev->transf_conm_neg_ae = meter_get_neg_ae(dev->transf_conm_model, dev->transf_conm_idx);

        dev->transf_load_ap = meter_get_com_ap(dev->transf_loadm_model, dev->transf_loadm_idx);
        // prepare meter data
        dev->transf_loadm_com_ap = dev->transf_load_ap;
        dev->transf_loadm_com_ae = meter_get_com_ae(dev->transf_loadm_model, dev->transf_loadm_idx);
        dev->transf_loadm_pos_ae = meter_get_pos_ae(dev->transf_loadm_model, dev->transf_loadm_idx);
        dev->transf_loadm_neg_ae = meter_get_neg_ae(dev->transf_loadm_model, dev->transf_loadm_idx);
    }
    else if (dev->transf_conm_idx == 0 && dev->transf_loadm_idx > 0)
    {
        dev->transf_load_ap = meter_get_com_ap(dev->transf_loadm_model, dev->transf_loadm_idx);
        // prepare meter data
        dev->transf_loadm_com_ap = dev->transf_load_ap;
        dev->transf_loadm_com_ae = meter_get_com_ae(dev->transf_loadm_model, dev->transf_loadm_idx);
        dev->transf_loadm_pos_ae = meter_get_pos_ae(dev->transf_loadm_model, dev->transf_loadm_idx);
        dev->transf_loadm_neg_ae = meter_get_neg_ae(dev->transf_loadm_model, dev->transf_loadm_idx);

        dev->transf_con_ap = ems_get_transf_load_com_ap() - ess_get_ap();
        // prepare meter data
        dev->transf_conm_com_ap = dev->transf_con_ap;
        if (ts - dev->transf_ts_last_m_integ > 5000)
        { // 5s
            dev->transf_ts_last_m_integ = ts;
            if (dev->transf_conm_com_ap > 0)
            {
                dev->transf_conm_pos_ae += dev->transf_conm_com_ap * (double)5.0 / (double)3600.0;
            }
            else if (dev->transf_conm_com_ap < 0)
            {
                dev->transf_conm_neg_ae += (0 - dev->transf_conm_com_ap) * (double)5.0 / (double)3600.0;
            }
            dev->transf_loadm_com_ae = dev->transf_loadm_pos_ae + dev->transf_loadm_neg_ae;
        }
    }
    else if (dev->transf_conm_idx > 0 && dev->transf_loadm_idx == 0)
    {
        dev->transf_con_ap = meter_get_com_ap(dev->transf_conm_model, dev->transf_conm_idx);
        // prepare meter data
        dev->transf_conm_com_ap = dev->transf_con_ap;
        dev->transf_conm_com_ae = meter_get_com_ae(dev->transf_conm_model, dev->transf_conm_idx);
        dev->transf_conm_pos_ae = meter_get_pos_ae(dev->transf_conm_model, dev->transf_conm_idx);
        dev->transf_conm_neg_ae = meter_get_neg_ae(dev->transf_conm_model, dev->transf_conm_idx);

        dev->transf_load_ap = ems_get_transf_con_com_ap() + ess_get_ap();
        // prepare meter data
        dev->transf_loadm_com_ap = dev->transf_load_ap;
        if (ts - dev->transf_ts_last_m_integ > 5000)
        { // 5s
            dev->transf_ts_last_m_integ = ts;
            if (dev->transf_loadm_com_ap > 0)
            {
                dev->transf_loadm_pos_ae += dev->transf_loadm_com_ap * (double)5.0 / (double)3600.0;
            }
            else if (dev->transf_loadm_com_ap < 0)
            {
                dev->transf_loadm_neg_ae += (0 - dev->transf_loadm_com_ap) * (double)5.0 / (double)3600.0;
            }
            dev->transf_loadm_com_ae = dev->transf_loadm_pos_ae + dev->transf_loadm_neg_ae;
        }
    }
    else
    {
        // should not goto here
    }

    if (dev->factory_conm_idx > 0 && dev->factory_loadm_idx > 0)
    {
        dev->factory_con_ap = meter_get_com_ap(dev->factory_conm_model, dev->factory_conm_idx);
        // prepare meter data
        dev->factory_conm_com_ap = dev->factory_con_ap;
        dev->factory_conm_com_ae = meter_get_com_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_pos_ae = meter_get_pos_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_neg_ae = meter_get_neg_ae(dev->factory_conm_model, dev->factory_conm_idx);

        dev->factory_load_ap = meter_get_com_ap(dev->factory_loadm_model, dev->factory_loadm_idx);
        // prepare meter data
        dev->factory_loadm_com_ap = dev->factory_load_ap;
        dev->factory_loadm_com_ae = meter_get_com_ae(dev->factory_loadm_model, dev->factory_loadm_idx);
        dev->factory_loadm_pos_ae = meter_get_pos_ae(dev->factory_loadm_model, dev->factory_loadm_idx);
        dev->factory_loadm_neg_ae = meter_get_neg_ae(dev->factory_loadm_model, dev->factory_loadm_idx);
    }
    else if (dev->factory_conm_idx == 0 && dev->factory_loadm_idx > 0)
    {
        dev->factory_con_ap = meter_get_com_ap(dev->factory_conm_model, dev->factory_conm_idx);
        // prepare meter data
        dev->factory_conm_com_ap = dev->factory_con_ap;
        dev->factory_conm_com_ae = meter_get_com_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_pos_ae = meter_get_pos_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_neg_ae = meter_get_neg_ae(dev->factory_conm_model, dev->factory_conm_idx);

        dev->factory_load_ap = ems_get_factory_con_com_ap() - ess_get_ap();
        // prepare meter data
        dev->factory_loadm_com_ap = dev->factory_load_ap;
        if (ts - dev->factory_ts_last_m_integ > 5000)
        { // 5s
            dev->factory_ts_last_m_integ = ts;
            if (dev->factory_loadm_com_ap > 0)
            {
                dev->factory_loadm_pos_ae += dev->factory_loadm_com_ap * (double)5.0 / (double)3600.0;
            }
            else if (dev->factory_loadm_com_ap < 0)
            {
                dev->factory_loadm_neg_ae += (0 - dev->factory_loadm_com_ap) * (double)5.0 / (double)3600.0;
            }
            dev->factory_loadm_com_ae = dev->factory_loadm_pos_ae + dev->factory_loadm_neg_ae;
        }
    }
    else if (dev->factory_conm_idx > 0 && dev->factory_loadm_idx == 0)
    {
        dev->factory_con_ap = meter_get_com_ap(dev->factory_conm_model, dev->factory_conm_idx);
        // prepare meter data
        dev->factory_conm_com_ap = dev->factory_con_ap;
        dev->factory_conm_com_ae = meter_get_com_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_pos_ae = meter_get_pos_ae(dev->factory_conm_model, dev->factory_conm_idx);
        dev->factory_conm_neg_ae = meter_get_neg_ae(dev->factory_conm_model, dev->factory_conm_idx);

        dev->factory_load_ap = ems_get_factory_con_com_ap() + ess_get_ap();
        // prepare meter data
        dev->factory_loadm_com_ap = dev->factory_load_ap;
        if (ts - dev->factory_ts_last_m_integ > 5000)
        { // 5s
            dev->factory_ts_last_m_integ = ts;
            if (dev->factory_loadm_com_ap > 0)
            {
                dev->factory_loadm_pos_ae += dev->factory_loadm_com_ap * (double)5.0 / (double)3600.0;
            }
            else if (dev->factory_loadm_com_ap < 0)
            {
                dev->factory_loadm_neg_ae += (0 - dev->factory_loadm_com_ap) * (double)5.0 / (double)3600.0;
            }
            dev->factory_loadm_com_ae = dev->factory_loadm_pos_ae + dev->factory_loadm_neg_ae;
        }
    }
    else
    {
    }
}

bool appRun = 1;

void ems_exit()
{
    appRun = 0;
}

void ems_run()
{
    static int iCounter = 0;
    syslog(LOG_INFO, "%s, ++", __func__);

    // running
    while (appRun)
    {
        ems_sm();
        ems_update();
        // 1 times per second
        if (iCounter++ > 100)
        {
            ems_fire_warning();
            iCounter = 0;
        }

        usleep(10000); // 10ms
    }
    syslog(LOG_INFO, "%s, --", __func__);
}
int ems_fire_warning_level = 0;
void ems_fire_warning()
{
    return;
    int warning_level = 0;
    for (int i = 1; i <= fa[1].model_nbr; i++)
    {
        warning_level = max(warning_level, fa_get_warning_level(i));
    }
    if (ems_fire_warning_level != warning_level)
    {
        if (warning_level > 1) // 1级以上，排风
        {
            dido_fan_switch(1, 1);
            if (warning_level > 2) // 2级以上，报警，停机,准备灭火
            {
                ess_send_sm_cmd(CMD_SM_STDBY);
                dido_sys_alarm(1, 1);
                dido_fire_confirm(1, 1);
                if (warning_level > 3) // 三级以上，灭火
                {
                    for (int j = 1; j <= fa[1].model_nbr; j++)
                    {
                        if (fa_get_warning_level(j) > 3)
                        {
                            fe_set_start(j);
                        }
                    }
                }
            }
            else
            {
                dido_sys_alarm(1, 0);
                dido_fire_confirm(1, 0);
            }
        }
        else
        {
            dido_fan_switch(1, 0);
        }
    }
    // env_get_co_density(DEVM_CD1F3300,1);
    // env_get_co_threshold(DEVM_CD1F3300,1);
}

int ems_edit_pcurv(int starthh, int startnn, int endhh, int endnn, int aps)
{
    int ret = 0;
    struct pcurv_t *pc = &ems.pcurv;
    int curr_hh;
    int curr_nn;

    log_dbg("%s, starthh:%d startnn:%d endhh:%d endnn:%d aps:%d",
            __func__, starthh, startnn, endhh, endnn, aps);

    if (starthh < 0 || starthh > 24 || endhh < 0 || endhh > 24 || startnn < 0 || startnn >= 60 || endnn < 0 || endnn >= 60)
    {
        ret = -1;
        goto leave;
    }

    if ((starthh == 24 && startnn != 0) || (endhh == 24 && endnn != 0))
    {
        ret = -2;
        goto leave;
    }

    curr_hh = starthh;
    curr_nn = startnn;
    while (curr_hh < endhh || curr_nn < endnn)
    {
        pc->aps[curr_hh][curr_nn] = aps;
        curr_nn += 60 / PCURV_PTS_PERHOUR;
        if (curr_nn >= 60)
        {
            curr_hh += 1;
            curr_nn = 0;
        }
    }

leave:
    log_dbg("%s, ret:%d", __func__, ret);
    return ret;
}

int ems_load_params()
{
    int ret = 0;
    int rc;
    char *errmsg = NULL;
    sqlite3 *db = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    struct ems_t *dev = &ems;

    plt_lock_projdb();
    db = plt_get_projdb();
    sprintf(sql, "select * from ems");
    cbparam.nrow = 0;
    rc = sqlite3_exec(db, sql, ems_dbcb_0, (void *)&cbparam, &errmsg);
    plt_unlock_projdb();
    if (rc != SQLITE_OK)
    {
        log_dbg("%s, result != SQLITE_OK", __func__);
        ret = -1;
    }
    else if (cbparam.ret != 0)
    {
        log_dbg("%s, cbparam.ret != 0", __func__);
        ret = -1;
    }
    else
    {
        if (cbparam.nrow != 1)
        {
            log_dbg("%s, cbparam.nrow(%d) != 1", __func__, cbparam.nrow);
            ret = -1;
        }
        else
        {
            dev->pow_reg.timer = 0;
            // ems.last_pcurv_aps = 999999999;
            ems_set_mode(EMSMOD_NONE);
            ems_set_pcurv(dev->pcurv_idx);
        }
    }

    log_dbg("%s, ret:%d", __func__, ret);
    return ret;
}

int ems_init()
{
    struct ems_t *e = &ems;
    syslog(LOG_INFO, "%s, ++", __func__);
    memset(&STA, 0, sizeof(struct station_t)); // !! NOTE !!

    e->transf_conm_com_ae = 0.0;
    e->transf_conm_pos_ae = 0.0;
    e->transf_conm_neg_ae = 0.0;
    e->transf_loadm_com_ae = 0.0;
    e->transf_loadm_pos_ae = 0.0;
    e->transf_loadm_neg_ae = 0.0;

    e->factory_conm_com_ae = 0.0;
    e->factory_conm_pos_ae = 0.0;
    e->factory_conm_neg_ae = 0.0;
    e->factory_loadm_com_ae = 0.0;
    e->factory_loadm_pos_ae = 0.0;
    e->factory_loadm_neg_ae = 0.0;
    e->debug_mode = 0;
    ems_sm_init();
    syslog(LOG_INFO, "%s, --", __func__);
    /*
    int ret = 0;
    int rc;
    char *errmsg = NULL;
    sqlite3* db = STA.cfg_db;
    char sql[1024];
    struct dbcbparam_t cbparam;
    struct ems_t* ems = &ems;

    sprintf(sql,"select * from ems");
    cbparam.nrow = 0;
    rc = sqlite3_exec(db,sql, ems_dbcb_0,(void*)&cbparam,&errmsg);
    if( rc != SQLITE_OK ){
        log_dbg("%s, result != SQLITE_OK", __func__ );
        ret = -1;
     }else if( cbparam.ret != 0){
         log_dbg("%s, cbparam.ret != 0", __func__ );
        ret = -1;
     }else{
        if( cbparam.nrow != 1 ){
            log_dbg("%s, cbparam.nrow(%d) != 1", __func__, cbparam.nrow );
            ret = -1;
        }else{
            ems.pow_reg.timer = 0;
            ems.last_pcurv_aps = 999999999;
            ems_set_mode(EMSMOD_NONE);
            ems_set_pdmode(PDMOD_AVG);
            ems_set_pcurv(ems->pcurv_idx );
        }
     }

    log_dbg("%s, ret:%d", __func__, ret);
    return ret;
    */
}

static void * ems_aux_task()
{
    while (1)
    {
        mac_exe();
        cloud_exe();
        tb_exe();
        // snap_exe();
        ev_exe();
        estats_exe();
        power_detection_exe();
        task_exe();
        usleep(950000); // 950ms
    }
    return NULL;
}

int  ems_get_debug_mode()
{
    struct ems_t *e = &ems;
    return e->debug_mode;
}
int  ems_set_debug_mode(int mode)
{
    struct ems_t *e = &ems;
    e->debug_mode = mode;
}
int ems_start_aux()
{
    int ret = 0;
    pthread_t xthrd;
    if (pthread_create(&xthrd, NULL, ems_aux_task, NULL) != 0)
    {
        ret = -1;
        log_dbg("%s, create ems_aux_task fail", __func__);
    }
    return ret;
}

int ems_regulate_aps(int newaps)
{
    int aps = ess_get_aps();
    int ess_ap = ess_get_ap();
    int norm_p = ess_get_norm_pow();
    // int lastaps = ess_get_last_aps();
    int con_ap;
    int reg_lo = ems_get_reglo();
    int reg_hi = ems_get_reghi();
    int tgtaps = 0;
    int *maxaps = &ems.pow_reg.aps_max;
    int *minaps = &ems.pow_reg.aps_min;
    int regaps = 0;

    if (ems_get_regulate_en() == 0)
    {
        return newaps;
    }

    if (aps > 0)
    { // dhg
        if (ems_get_factory_conm_idx() > 0)
        {
            con_ap = ems_get_factory_con_com_ap();
        }
        else
        {
            con_ap = ems_get_transf_con_com_ap();
        }
        log_info("%s, con_ap:%d aps:%d ess ap:%d reg_lo:%d norm_pow:%d", __func__, con_ap, aps, ess_ap, reg_lo, norm_p);
        if (newaps <= 0)
        {
            regaps = 0;
        }
        else
        {
            *maxaps = min(con_ap + ess_ap - reg_lo, norm_p); // max dhg power the ess can run
            if (*maxaps < 0)
            {
                *maxaps = 0;
            }
            if (con_ap < reg_lo)
            {
                tgtaps = ess_ap + (con_ap - reg_lo);
                if (tgtaps < 0)
                {
                    tgtaps = 0;
                }
                regaps = min(min(*maxaps, tgtaps), newaps);
            }
            else
            {
                regaps = min(*maxaps, newaps);
            }
        }
        log_info("%s, con_ap:%d aps:%d ess ap:%d newaps:%d,reg_hi:%d norm_pow:%d,regaps:%d", __func__, con_ap, aps, ess_ap, newaps, reg_hi, norm_p, regaps);
    }
    else if (aps < 0)
    { // chg
        con_ap = ems_get_transf_con_com_ap();
        log_info("%s, con_ap:%d aps:%d ess ap:%d reg_hi:%d norm_pow:%d", __func__, con_ap, aps, ess_ap, reg_hi, norm_p);
        if (newaps >= 0)
        {
            regaps = 0;
        }
        else
        {
            *minaps = max(0 - reg_hi + (con_ap + ess_ap), 0 - norm_p); // max chg power the ess can run
            if (*minaps > 0)
            {
                *minaps = 0;
            }
            con_ap = ems_get_transf_con_com_ap();
            if (con_ap > reg_hi)
            {
                tgtaps = ess_ap + (con_ap - reg_hi);
                if (tgtaps > 0)
                {
                    tgtaps = 0;
                }
                regaps = max(*minaps, tgtaps);
            }
            else
            {
                regaps = max(*minaps, newaps);
            }
        }
        log_info("%s, con_ap:%d aps:%d ess ap:%d newaps:%d,reg_hi:%d norm_pow:%d,regaps:%d", __func__, con_ap, aps, ess_ap, newaps, reg_hi, norm_p, regaps);
    }
    else
    { // ready
        if (newaps > 0)
        {
            if (ems_get_factory_conm_idx() > 0)
            {
                con_ap = ems_get_factory_con_com_ap();
            }
            else
            {
                con_ap = ems_get_transf_con_com_ap();
            }
            *maxaps = min(con_ap + ess_ap - reg_lo, norm_p); // max dhg power the ess can run
            if (*maxaps < 0)
            {
                *maxaps = 0;
            }
            regaps = min(*maxaps, newaps);
        }
        else if (newaps < 0)
        {
            con_ap = ems_get_transf_con_com_ap();

            *minaps = max(0 - reg_hi + (con_ap + ess_ap), 0 - norm_p); // max chg power the ess can run
            if (*minaps > 0)
            {
                *minaps = 0;
            }
            regaps = max(*minaps, newaps);
        }
        else
        {
            regaps = 0;
        }
        log_info("%s, con_ap:%d aps:%d ess ap:%d newaps:%d,reg_hi:%d norm_pow:%d,regaps:%d", __func__, con_ap, aps, ess_ap, newaps, reg_hi, norm_p, regaps);
    }

    return regaps;
}

/*
    distribute sta active_p_set to each ctn
    0 : success
*/
int ems_sta_aps_dis(void)
{
    struct station_t *dev = &STA;
    double sum;
    int aps[CESS2000_NBR_MAX + 1];
    // int total_aps = dev->pow.active_p_set;
    int idx;
    int ret = 0;
#if 0
    if( dev->ems.pdmode == PDMOD_SOC ){ /* bugs , do not use !! */
        if( total_aps > 0 ){ // dhg
            sum = 0.0;
            for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
                sum += ctn_get_soc(idx);
            }
            for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
                aps[idx] = ctn_get_soc(idx)/sum*total_aps;
            }
        }else if( total_aps < 0 ){ // chg
            sum = 0.0;
            for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
                sum += 1 - ctn_get_soc(idx);
            }
            for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
                aps[idx] = (1 - ctn_get_soc(idx))/sum*total_aps;
            }
        }else{
            ret = -1;
        }
    }else if( dev->ems.pdmode == PDMOD_AVG ){
        for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
            aps[idx] = total_aps/(double)ctn_get_nbr();
        }
        if(aps[1] < ctn_get_min_pow(1) && aps[1] > -ctn_get_min_pow(1)){
            ret = -1;
        }
    }else{
        ret = -1;
    }

    if( ret == 0 ){
        for( idx = 1; idx <= ctn_get_nbr(); idx++ ){
            //dev->ctn[idx].pow.active_p_set = aps[idx];
            ctn_set_aps( idx, aps[idx] );
        }
    }
#endif
    return ret;
}

int ems_set_pcurv(int idx)
{
    pcurv_load(idx);
    ems.pcurv = pcurv_get(idx);
    ems.pcurv_idx = idx;
    return 0;
}

int ems_save_pcurv()
{
    return pcurv_save(ems.pcurv_idx, ems.pcurv);
}

int ems_reset_pcurv()
{
    int ret = 0;
    int pidx = ems.pcurv_idx;

    pcurv_reset(pidx);
    ems_set_pcurv(pidx);
    return 0;
}

int ems_set_powreg_highlow(int hi, int lo)
{
    ems.pow_reg.high = hi;
    ems.pow_reg.low = lo;

    return 0;
}

int ems_get_pcurv_pts()
{
    int ret = -1;
    struct ems_t *dev = &ems;
    int pidx = dev->pcurv_idx;
    struct pcurv_t *pc = &dev->pcurv;
    time_t timep;
    struct tm *tsp;
    int hh, nn;

    if (pidx >= 1 && pidx <= PCURV_NBR_MAX && pc->status == PCURVST_VALID)
    {
        time(&timep);
        tsp = localtime(&timep);
        hh = tsp->tm_hour;
        nn = tsp->tm_min / (int)5 * (int)5;
        dev->pcurv_aps = pc->aps[hh][nn];
        ret = 0;
    }

    return ret;
}

int ems_get_pcurv_aps()
{
    struct ems_t *dev = &ems;
    return dev->pcurv_aps;
}

int ems_get_regulate_en()
{
    return ems.pow_reg.enable;
}

int ems_set_reg_en(int val)
{
    ems.pow_reg.enable = val;
    return 0;
}

int ems_set_reg_intv(int val)
{
    ems.pow_reg.intv = val;
    return 0;
}

int ems_get_cmd()
{
    return ems.cmd;
}

void ems_reset_cmd()
{
    ems.cmd = CMD_SM_DONE;
}

int ems_send_sm_cmd(int val)
{
    ems.cmd = val;
    return 0;
}

int ems_get_mode(void)
{
    return ems.mode;
}

char *ems_get_state_str(void)
{
    return ems.sm.szState;
}

char *ems_get_modestr(void)
{
    return ems.szmode;
}

int ems_set_mode(int mod)
{
    int ret = 0;

    switch (mod)
    {
    case EMSMOD_NONE:
        strcpy(ems.szmode, "none");
        break;

    case EMSMOD_PCURV:
        ems.last_pcurv_aps = 999999;
        strcpy(ems.szmode, "pcurv");
        break;

    case EMSMOD_PDEM:
        strcpy(ems.szmode, "pdem");
        break;

    default:
        strcpy(ems.szmode, "unknown");
        ret = -1;
        break;
    }

    ems.mode = mod;

    log_dbg("%s, mode:%d|%s", __func__, ems.mode, ems.szmode);
    return ret;
}

void ems_exe_pcurv()
{
    struct ems_t *dev = &ems;

    if (++dev->pow_reg.timer >= dev->pow_reg.intv)
    {
        dev->pow_reg.timer = 0;
        if (ems_get_pcurv_pts() == 0)
        { // valid pts
            ess_set_aps(ems_regulate_aps(dev->pcurv_aps));
        }
    }
}

void ems_exe_pdem()
{
    struct ems_t *dev = &ems;
}

int ems_get_reglo()
{
    return ems.pow_reg.low;
}

int ems_get_reghi()
{
    return ems.pow_reg.high;
}

int ems_set_timeseg(int idx)
{
    int ret = 0;
    int rc;
    if (timeseg_load(idx) != 0)
    {
        ret = -1;
    }
    else
    {
        ems.timeseg = timeseg_get(idx);
        ems.timeseg_idx = idx;
        ems_update_cur_timeseg_type();
    }

    return ret;
}

int ems_save_timeseg()
{
    return timeseg_save(ems.timeseg_idx, ems.timeseg);
}

int ems_reset_timeseg()
{
    int ret = 0;
    int idx = ems.timeseg_idx;

    timeseg_reset(idx);
    ems_set_timeseg(idx);
    return 0;
}

int ems_get_cur_timeseg_type()
{
    struct ems_t *dev = &ems;
    return dev->cur_timeseg_type;
}

int ems_get_tick()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm->tick;
}

int ems_get_tick_ave()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm->timing_ave;
}

int ems_get_tick_cur()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm->timing_cur;
}

int ems_get_tick_max()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm->timing_max;
}

int ems_get_step()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm_get_step(sm);
}

char *ems_get_err_str()
{
    struct ems_t *dev = &ems;
    struct statemachine_t *sm = &dev->sm;
    return sm->szerr;
}

int ems_get_pow_reg_timer()
{
    return ems.pow_reg.timer;
}

int ems_get_pow_reg_intv()
{
    return ems.pow_reg.intv;
}

int ems_get_pow_reg_aps_min()
{
    return ems.pow_reg.aps_min;
}

int ems_get_pow_reg_aps_max()
{
    return ems.pow_reg.aps_max;
}

int ems_get_timeseg_idx()
{
    return ems.timeseg_idx;
}

char *ems_get_timeseg_status_str()
{
    return ems.timeseg.szstatus;
}

char *ems_get_timeseg_type_str()
{
    return timeseg_segtype2string(ems.cur_timeseg_type);
}

int ems_get_estats_step()
{
    return ems.estats.step;
}

double ems_get_day_sharp_pos_ae()
{
    return ems.estats.day_sharp_pos_ae;
}

double ems_get_day_sharp_neg_ae()
{
    return ems.estats.day_sharp_neg_ae;
}

double ems_get_day_peak_pos_ae()
{
    return ems.estats.day_peak_pos_ae;
}

double ems_get_day_peak_neg_ae()
{
    return ems.estats.day_peak_neg_ae;
}

double ems_get_day_flat_pos_ae()
{
    return ems.estats.day_flat_pos_ae;
}

double ems_get_day_flat_neg_ae()
{
    return ems.estats.day_flat_neg_ae;
}

double ems_get_day_valley_pos_ae()
{
    return ems.estats.day_valley_pos_ae;
}

double ems_get_day_valley_neg_ae()
{
    return ems.estats.day_valley_neg_ae;
}

int ems_get_pcurv_idx()
{
    return ems.pcurv_idx;
}

char *ems_get_pcurv_info_str()
{
    return ems.pcurv.szinfo;
}

char *ems_get_pcurv_status_str()
{
    return ems.pcurv.szstatus;
}

struct pcurv_t *ems_get_pcurv_t()
{
    return &ems.pcurv;
}

int ems_get_tool_data(char *buf)
{
    char buf_temp[2 << 16];
    struct statemachine_t *sm = &ems.sm;
    struct estats_t *es = &ems.estats;
    if (buf == NULL)
        return -1;

    sprintf(buf, "%s ", "" REVERSE " EMS " NONE " \n");

    sm_get_summary(sm, buf_temp, sizeof(buf_temp));
    strcat(buf, buf_temp);
    strcat(buf, "\n");

    sprintf(buf_temp, "ems_debug:%d pow_reg_en:%d lo:%d hi:%d timer:%03d intv:%03d aps_min:%d max:%d ",
            ems.debug_mode, ems.pow_reg.enable, ems.pow_reg.low, ems.pow_reg.high, ems.pow_reg.timer, ems.pow_reg.intv, ems.pow_reg.aps_min, ems.pow_reg.aps_max);
    strcat(buf, buf_temp);

    if (ems.factory_conm_idx > 0)
    {
        sprintf(buf_temp, "\n factory conm_model:%s conm_idx:%d conm_com_ap:" L_GREEN "%d" NONE " conm_com_ae:%.1f con_pos_ae:%.1f con_neg_ae:%.1f\
 load_com_ap:%d load_com_ae:%.1f load_pos_ae:%.1f load_neg_ae:%.1f\n",
                ems.szfactory_conm_model, ems.factory_conm_idx, ems.factory_con_ap, ems.factory_conm_com_ae, ems.factory_conm_pos_ae, ems.factory_conm_neg_ae,
                ems.factory_loadm_com_ap, ems.factory_loadm_com_ae, ems.factory_loadm_pos_ae, ems.factory_loadm_neg_ae);
        strcat(buf, buf_temp);
    }

    if (ems.transf_conm_idx > 0)
    {
        sprintf(buf_temp, " transf conm_model:%s conm_idx:%d conm_com_ap:" L_GREEN "%d" NONE " conm_com_ae:%.1f con_pos_ae:%.1f con_neg_ae:%.1f\
 load_com_ap:%d load_com_ae:%.1f load_pos_ae:%.1f load_neg_ae:%.1f\n",
                ems.sztransf_conm_model, ems.transf_conm_idx, ems.transf_con_ap, ems.transf_conm_com_ae, ems.transf_conm_pos_ae, ems.transf_conm_neg_ae,
                ems.transf_loadm_com_ap, ems.transf_loadm_com_ae, ems.transf_loadm_pos_ae, ems.transf_loadm_neg_ae);
        strcat(buf, buf_temp);
    }
    else if (ems.transf_loadm_idx > 0)
    {
        sprintf(buf_temp, " transf loadm_model:%s loadm_idx:%d load_com_ap:%d load_com_ae:%.1f load_pos_ae:%.1f load_neg_ae:%.1f\
 conm_com_ap:" L_GREEN "%d" NONE " conm_com_ae:%.1f con_pos_ae:%.1f con_neg_ae:%.1f\n",
                ems.sztransf_loadm_model, ems.transf_loadm_idx, ems.transf_loadm_com_ap, ems.transf_loadm_com_ae, ems.transf_loadm_pos_ae, ems.transf_loadm_neg_ae,
                ems.transf_con_ap, ems.transf_conm_com_ae, ems.transf_conm_pos_ae, ems.transf_conm_neg_ae);
        strcat(buf, buf_temp);
    }
    // strcat(buf,buf_temp);

    sprintf(buf_temp, " mod:" L_GREEN "%s" NONE " pcurv_idx:%d stat:%s aps:%d timeseg_idx:%d status:%s segtype:%d-%s\n",
            ems.szmode, ems.pcurv_idx, ems.pcurv.szstatus, ems.pcurv_aps, ems.timeseg_idx, ems.timeseg.szstatus, ems.cur_timeseg_type, timeseg_segtype2string(ems.cur_timeseg_type));
    strcat(buf, buf_temp);

    sprintf(buf_temp, " estats step:%d day_sharp_pos_ae:%.1f neg:%.1f peak_pos_ae:%.1f neg:%.1f flat_pos_ae:%.1f neg:%.1f valley_pos_ae:%.1f neg:%.1f\n",
            es->step,
            es->day_sharp_pos_ae, es->day_sharp_neg_ae,
            es->day_peak_pos_ae, es->day_peak_neg_ae,
            es->day_flat_pos_ae, es->day_flat_neg_ae,
            es->day_valley_pos_ae, es->day_valley_neg_ae);
    strcat(buf, buf_temp);

    return 0;
}

int ems_get_tool_pcurv_data(char *buf)
{
    int i;
    int j;
    struct pcurv_t *pc = &ems.pcurv;
    int hh;
    int nn;
    int rows = 12;
    int cols = PCURV_PTS_NBR / rows;
    char temp_buf[128];
    char temp_buf2[128];
    char sztime[32];

    misc_gen_datetimestr(sztime, sizeof(sztime));
    sprintf(buf, "" REVERSE " PCURV " NONE "  idx:%d stat:%s %s\n", ems.pcurv_idx, ems.pcurv.szstatus, sztime);

    for (i = 0; i < 24; i++)
    { /* 24 rows in total, 1 hour 1 row */
        hh = i;
        for (j = 0; j < PCURV_PTS_PERHOUR; j++)
        {
            nn = j * (60 / PCURV_PTS_PERHOUR);
            sprintf(temp_buf, "%02d:%02d " L_GREEN "%5d" NONE "  ", hh, nn, pc->aps[hh][nn]);
            sprintf(temp_buf2, "%-12s", temp_buf);
            strcat(buf, temp_buf2);
        }
        strcat(buf, "\n");
    }
    return 0;
}

int ems_get_tool_timeseg_data(char *buf)
{
    int i;
    int j;
    struct timeseg_t *ts = &ems.timeseg;
    int hh;
    int nn;
    int rows = 12;
    int cols = TIMESEG_PTS_NBR / rows;
    char temp_buf[128];
    char temp_buf2[128];
    char sztime[32];

    misc_gen_datetimestr(sztime, sizeof(sztime));
    sprintf(buf, "" REVERSE " TIMESEG " NONE "  idx:%d stat:%s %s\n", ems.timeseg_idx, ems.timeseg.szstatus, sztime);

    for (i = 0; i < 24; i++)
    { /* 24 rows in total, 1 hour 1 row */
        hh = i;
        for (j = 0; j < TIMESEG_PTS_PERHOUR; j++)
        {
            nn = j * (60 / TIMESEG_PTS_PERHOUR);
            sprintf(temp_buf, "%02d:%02d " L_GREEN "%5s" NONE "  ", hh, nn, timeseg_segtype2string(ts->seg_type[hh][nn]));
            sprintf(temp_buf2, "%-12s", temp_buf);
            strcat(buf, temp_buf2);
        }
        strcat(buf, "\n");
    }
}

char *ems_get_transf_conm_model_str()
{
    return ems.sztransf_conm_model;
}

int ems_get_transf_conm_idx()
{
    return ems.transf_conm_idx;
}

int ems_get_transf_con_ap()
{
    struct ems_t *dev = &ems;
    return dev->transf_con_ap;
}

double ems_get_transf_con_com_ae()
{
    struct ems_t *e = &ems;
    return e->transf_conm_com_ae;
}

double ems_get_transf_con_pos_ae()
{
    struct ems_t *e = &ems;
    return e->transf_conm_pos_ae;
}

double ems_get_transf_con_neg_ae()
{
    struct ems_t *e = &ems;
    return e->transf_conm_neg_ae;
}

int ems_get_transf_con_com_ap()
{
    return ems.transf_conm_com_ap;
}

char *ems_get_transf_load_model_str()
{
    return ems.sztransf_loadm_model;
}

int ems_get_transf_loadm_idx()
{
    return ems.transf_loadm_idx;
}

int ems_get_transf_load_ap()
{
    struct ems_t *dev = &ems;
    return dev->transf_load_ap;
}

double ems_get_transf_load_com_ae()
{
    struct ems_t *e = &ems;
    return e->transf_loadm_com_ae;
}

double ems_get_transf_load_pos_ae()
{
    struct ems_t *e = &ems;
    return e->transf_loadm_pos_ae;
}

double ems_get_transf_load_neg_ae()
{
    struct ems_t *e = &ems;
    return e->transf_loadm_neg_ae;
}

int ems_get_transf_load_com_ap()
{
    struct ems_t *e = &ems;
    return e->transf_loadm_com_ap;
}

char *ems_get_factory_conm_model_str()
{
    return ems.szfactory_conm_model;
}

int ems_get_factory_conm_idx()
{
    return ems.factory_conm_idx;
}

int ems_get_factory_con_ap()
{
    struct ems_t *dev = &ems;
    return dev->factory_con_ap;
}

double ems_get_factory_con_com_ae()
{
    struct ems_t *e = &ems;
    return e->factory_conm_com_ae;
}

double ems_get_factory_con_pos_ae()
{
    struct ems_t *e = &ems;
    return e->factory_conm_pos_ae;
}

double ems_get_factory_con_neg_ae()
{
    struct ems_t *e = &ems;
    return e->factory_conm_neg_ae;
}

int ems_get_factory_con_com_ap()
{
    return ems.factory_conm_com_ap;
}

char *ems_get_factory_load_model_str()
{
    return ems.szfactory_loadm_model;
}

int ems_get_factory_loadm_idx()
{
    return ems.factory_loadm_idx;
}

int ems_get_factory_load_ap()
{
    struct ems_t *dev = &ems;
    return dev->factory_load_ap;
}

double ems_get_factory_load_com_ae()
{
    struct ems_t *e = &ems;
    return e->factory_loadm_com_ae;
}

double ems_get_factory_load_pos_ae()
{
    struct ems_t *e = &ems;
    return e->factory_loadm_pos_ae;
}

double ems_get_factory_load_neg_ae()
{
    struct ems_t *e = &ems;
    return e->factory_loadm_neg_ae;
}

int ems_get_factory_load_com_ap()
{
    struct ems_t *e = &ems;
    return e->factory_loadm_com_ap;
}