ctnd/appl/bkd/bkds.c

#include "plt.h"

static struct bkd_shm_t *SHM = NULL;
static int sbmu_idx = 1;

static void bkds_gen_datetimestr(char *buf, int len)
{
    time_t timep;
    struct tm *tsp;
    char tmpbuf[32];

    time(&timep);
    // tsp = gmtime(&timep);
    tsp = localtime(&timep);
    sprintf(tmpbuf, "%04d-%02d-%02d %02d:%02d:%02d", tsp->tm_year + 1900, tsp->tm_mon + 1, tsp->tm_mday,
            tsp->tm_hour, tsp->tm_min, tsp->tm_sec);
    strncpy(buf, tmpbuf, len);
}

extern int VERSION[3];

static int bkds_proc_get_ctn_data()
{
    char itm_buf[2048];
    char buf[128];
    unsigned short *faults = pcs_get_faults();
    unsigned short *warns = pcs_get_warns();
    itm_buf[0] = 0;
    int i = 0;

    char itm_buf_sys[1024];
    char itm_buf_pcs[1024 * 2];
    char itm_buf_bms[1024];
    char itm_buf_meter[1024 * 2];
    char itm_buf_ac[1024];
    char itm_buf_ems[1024];
    char itm_buf_plc[1024 * 2];
    char itm_buf_th[1024];
    char itm_buf_gas[1024];
    char itm_buf_chan[1024 * 4];
    char itm_buf_mqtt[1024];
    char itm_buf_temp[4096];
    char itm_buf_ups[1024];
    // sys
    sprintf(itm_buf_sys, "\"info\":\"%s\",\"idx_in_ess\":%d,\"sw_version\":\"%d.%d.%d\",\"bkd_head_version\":\"%s\",\"state\":\"%s\",\
\"step\":%d,\"err\":\"%s\",\"ap\":%d,\"soc\":%.1f,\"aps\":%d,\
\"chgable\":%d,\"dhgable\":%d,\"tick\":%d,\"socc\":%.1f,\"socd\":%.1f,\
\"cell_otp\":%d,\"cell_utp\":%d,\"bsytikchk_en\":%d,\"bsytikchk_from_host\":%d,\"bsytikchk_timeout\":%d,\
\"pcs_bsytiksnd_en\":%d,\"norm_e\":%d,\"norm_p\":%d",
            ctn_get_info(), ctn_get_idx_in_ess(), VERSION[0], VERSION[1], VERSION[2], BKD_HEAD_VERSION, ctn_get_state_str(),
            ctn_get_step(), ctn_get_err_str(), ctn_get_ap(), ctn_get_soc(), ctn_get_aps(),
            ctn_get_chgable(), ctn_get_dhgable(), ctn_get_tick(), ctn_get_socc(), ctn_get_socd(),
            ctn_get_cell_otp(), ctn_get_cell_utp(), ctn_get_bsytikchk_en(), ctn_get_bsytikchk_from_host(), ctn_get_bsytikchk_timeout(),
            ctn_get_pcs_bsytiksnd_en(), ctn_get_norm_cap(), ctn_get_norm_pow());

    // pcs
    pcs_get_bkds_data(itm_buf_temp);
    sprintf(itm_buf_pcs, ",%s", itm_buf_temp);
    // pack
    pack_get_bkds_mbmu_data(itm_buf_temp);
    sprintf(itm_buf_bms, ",%s", itm_buf_temp);
    // meter
    memset(itm_buf_meter, 0, sizeof(itm_buf_meter));
    meter_get_bkds_data(itm_buf_temp);
    sprintf(itm_buf_meter, ",%s", itm_buf_temp);
    // ac
    memset(itm_buf_ac, 0, sizeof(itm_buf_ac));
    // ac_get_bkds_data(itm_buf_temp);
    sprintf(itm_buf_ac, ",%s", itm_buf_temp);

    // ems
    sprintf(itm_buf_ems, ",\"ems\":\
{\
\"state\":\"%s\",\"tick\":%d,\"tick_ave\":%d,\"tick_cur\":%d,\"tick_max\":%d,\
\"con_com_ap\":%d,\"con_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\
}\
",
            ems_get_state_str(), ems_get_tick(), ems_get_tick_ave(), ems_get_tick_cur(), ems_get_transf_con_com_ap(),
            ems_get_tick_max(), ems_get_transf_con_com_ae(), ems_get_transf_con_pos_ae(), ems_get_transf_con_neg_ae(), ems_get_transf_load_com_ap(),
            ems_get_transf_load_com_ae(), ems_get_transf_load_pos_ae(), ems_get_transf_load_neg_ae());

    // plc
    plc_get_bkds_data(itm_buf_temp);
    sprintf(itm_buf_plc, ",%s", itm_buf_temp);

    // ups
    ups_get_bkds_data(itm_buf_temp);
    sprintf(itm_buf_ups, ",%s", itm_buf_temp);
    // log_info("%s,ups:%s\n",__func__,itm_buf_ups);
    // re_ws_n
    memset(itm_buf_th, 0, sizeof(itm_buf_th));
    env_get_bkds_data(DEVM_RS_WS_N, itm_buf_temp);
    sprintf(itm_buf_th, "%s", itm_buf_temp);

    // gas
    memset(itm_buf_gas, 0, sizeof(itm_buf_gas));
    env_get_bkds_data(DEVM_SGA500E, itm_buf_temp);
    sprintf(itm_buf_gas, ",%s", itm_buf_temp);
    // log_info("%s,gas:%s\n",__func__,itm_buf_gas);

    // chan
    memset(itm_buf_chan, 0, sizeof(itm_buf_chan));
    chan_get_bkds_data(itm_buf_chan);
    // log_info("%s,chan:%s\n",__func__,itm_buf_chan);

    // mqtt
    memset(itm_buf_mqtt, 0, sizeof(itm_buf_mqtt));
    sprintf(itm_buf_mqtt, ",\"mqtt\":[");

    // tbmqtt
    memset(itm_buf_temp, 0, sizeof(itm_buf_temp));
    sprintf(itm_buf_temp, "{\"info\":\"%s\",\"state\":\"%s\",\"stp\":%d,\"err\":\"%s\",\"tick\":%d,\
\"tick_max\":%.1f,\"enable\":%d,\"tz\":%d,\"servip\":\"%s\",\"servport\":%d,\
\"client_id\":\"%s\",\"txbuf_usage\":%.1f,\"access_token\":\"%s\"}",
            "tb", tb_get_state_str(), tb_get_stp(), tb_get_err_str(), tb_get_tick(),
            tb_get_timing_max(), tb_get_enable(), tbmqtt_get_tz(), tb_get_servip_str(), tb_get_servport(), tb_get_client_id(),
            tb_get_txbuf_usage(), tb_get_access_token());
    strcat(itm_buf_mqtt, itm_buf_temp);
    strcat(itm_buf_mqtt, ",");
    // cloud mqtt
    memset(itm_buf_temp, 0, sizeof(itm_buf_temp));
    sprintf(itm_buf_temp, "{\"info\":\"%s\",\"state\":\"%s\",\"stp\":%d,\"err\":\"%s\",\"tick\":%d,\
\"tick_ave\":%.1f,\"tick_cur\":%.1f,\"tick_max\":%.1f,\"enable\":%d,\"tz\":%d,\
\"servip\":\"%s\",\"servport\":%d,\"client_id\":\"%s\",\"txbuf_usage\":%.1f,\"access_token\":\"%s\"}",
            "cloud", cloud_get_state_str(), cloud_get_stp(), cloud_get_err_str(), cloud_get_tick(),
            cloud_get_timing_ave(), cloud_get_timing_cur(), cloud_get_timing_max(), cloud_get_enable(), cloud_get_tz(),
            cloud_get_servip_str(), cloud_get_servport(), cloud_get_client_id(), cloud_get_txbuf_usage(), cloud_get_access_token());

    strcat(itm_buf_mqtt, itm_buf_temp);
    strcat(itm_buf_mqtt, "]");

    // log_info("%s,mqtt:%s\n",__func__,itm_buf_mqtt);
    bkds_gen_datetimestr(buf, sizeof(buf));
    // log_info("%s,bms:%s\n",__func__,itm_buf_bms);
    sprintf(SHM->rsp.buf, "{\"dt\":\"%s\",\"values\":{%s%s%s%s%s%s%s%s\
,\"env\":{%s%s}\
,\"comm\":{%s%s}}}",
            buf,
            itm_buf_sys, itm_buf_pcs, itm_buf_bms, itm_buf_meter, itm_buf_ac, itm_buf_ems,
            itm_buf_plc, itm_buf_ups, itm_buf_th, itm_buf_gas, itm_buf_chan, itm_buf_mqtt);
    printf("%s,value:%s\n", __func__, SHM->rsp.buf);
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
}

static int bkds_proc_get_bms(int sub_idx)
{
    char itm_buf_mbmu[1024];
    char itm_buf_sbmu_sum[1024 * 3];
    char itm_buf_sbmu_summary[1024];
    char itm_buf_sbmu_mod[1024 * 5];
    char buf[128];

    char itm_buf_temp[1024];
    int i = 0;

    // mbu
    sprintf(itm_buf_mbmu, "\"mbmu\":\
{\
\"info\":\"%s\",\"model\":\"%s\",\"state\":\"%s\",\"step\":%d,\"err\":\"%s\",\
\"tick\":%d,\"chan_idx\":%d,\"adr\":%d,\"comm_state\":\"%s\",\"emshbsnd_en\":%d,\
\"bmshbchk_en\":%d,\"sbmu_idx\":%d,\"sbmu_nbr\":%d,\"mod_nbr_in_sbmu\":%d,\"cell_nbr_in_mod\":%d,\
\"temp_nbr_in_mod\":%d,\"v\":%d,\"c\":%d,\"soc\":%.1f,\"cellvave\":%.3f,\
\"cellvmax\":%.3f,\"cellvmin\":%.3f,\"celltave\":%d,\"celltmax\":%d,\"celltmin\":%d,\
\"maxdhgc\":%d,\"maxchgc\":%d\
}",
            "bms", pack_get_model_str(), pack_get_state_str(), pack_get_step(), pack_get_err_str(),
            pack_get_tick(), pack_get_chan_idx(), pack_get_adr(), pack_get_comm_state_str(), pack_is_emshb_sending_en(),
            pack_is_bmshb_check_en(), sub_idx, pack_get_sbmu_nbr(), pack_get_mod_nbr_in_sbmu(), pack_get_cell_nbr_in_mod(),
            pack_get_temp_nbr_in_mod(), pack_get_v(), pack_get_c(), pack_get_soc(), pack_get_cellvave(),
            pack_get_cellvmax(), pack_get_cellvmin(), pack_get_celltave(), pack_get_celltmax(), pack_get_celltmin(),
            pack_get_max_dhgc(), pack_get_max_chgc());

    // sbmu_summary
    sprintf(itm_buf_sbmu_sum, ",\"sbmu_summary\":[");
    for (i = 1; i <= pack_get_sbmu_nbr(); i++)
    {
        sprintf(itm_buf_temp, "{\"v\":%d,\"c\":%d,\"soc\":%.1f,\"soh\":%d}",
                pack_get_sub_v(i), pack_get_sub_c(i), pack_get_sub_soc(i), pack_get_sub_soh(i));
        strcat(itm_buf_sbmu_sum, itm_buf_temp);
        if (i != pack_get_sbmu_nbr())
        {
            strcat(itm_buf_sbmu_sum, ",");
        }
    }
    strcat(itm_buf_sbmu_sum, "]");

    // sbmu--summary
    sprintf(itm_buf_sbmu_summary, ",\"sbmu\":{\"summary\":{\
\"v\":%d,\"c\":%d,\"soc\":%.1f,\"soh\":%d\
}",
            pack_get_sub_v(sub_idx), pack_get_sub_c(sub_idx), pack_get_sub_soc(sub_idx), pack_get_sub_soh(sub_idx));

    // mode
    sprintf(itm_buf_sbmu_mod, ",\"mod\":[");
    for (i = 1; i <= pack_get_mod_nbr_in_sbmu(); i++)
    {

        sprintf(itm_buf_temp, "{\"cellv\":[");
        int j = 0;
        char temp_buf[1024];

        // cell
        double cellv_max = -1.0;
        double cellv_min = 5.0;
        double cellv_ave = 0.0;
        double v = 0.0;
        for (j = 1; j <= pack_get_cell_nbr_in_mod(); j++)
        {
            v = pack_get_sub_module_cellv(sub_idx, i, j);
            sprintf(temp_buf, "%.3f", v);
            strcat(itm_buf_temp, temp_buf);
            if (j != pack_get_cell_nbr_in_mod())
            {
                strcat(itm_buf_temp, ",");
            }
            cellv_ave += v / pack_get_cell_nbr_in_mod();
            if (cellv_max < v)
                cellv_max = v;
            if (cellv_min > v)
                cellv_min = v;
        }
        strcat(itm_buf_temp, "],\"cellt\":[");

        // tmp
        int cellt_max = -100;
        int cellt_min = 100;
        int cellt_ave = 0.0;
        int t = 0;
        for (j = 1; j <= pack_get_temp_nbr_in_mod(); j++)
        {
            t = pack_get_sub_module_cellt(sub_idx, i, j);
            sprintf(temp_buf, "%d", t);
            strcat(itm_buf_temp, temp_buf);
            if (j != pack_get_temp_nbr_in_mod())
            {
                strcat(itm_buf_temp, ",");
            }
            cellt_ave += t / pack_get_temp_nbr_in_mod();
            if (cellt_max < t)
                cellt_max = t;
            if (cellt_min > t)
                cellt_min = t;
        }
        strcat(itm_buf_temp, "],");
        // vmax....
        sprintf(temp_buf, "\"vmax\":%.3f,\"vave\":%.3f,\"vmin\":%.3f,\"tmax\":%d,\"tave\":%d,\"tmin\":%d",
                cellv_max, cellv_ave, cellv_min, cellt_max, cellt_ave, cellt_min);
        strcat(itm_buf_temp, temp_buf);
        strcat(itm_buf_temp, "}");

        strcat(itm_buf_sbmu_mod, itm_buf_temp);
        if (i != pack_get_mod_nbr_in_sbmu())
        {
            strcat(itm_buf_sbmu_mod, ",");
        }
    }
    strcat(itm_buf_sbmu_mod, "]");

    // log_info("%s,mqtt:%s\n",__func__,itm_buf_mqtt);
    bkds_gen_datetimestr(buf, sizeof(buf));
    // log_info("%s,bms:%s\n",__func__,itm_buf_bms);
    sprintf(SHM->rsp.buf, "{\"dt\":\"%s\",\"values\":{%s%s%s%s}}}", buf,
            itm_buf_mbmu, itm_buf_sbmu_sum, itm_buf_sbmu_summary, itm_buf_sbmu_mod);
    // printf("%s,value:%s\n",__func__,SHM->rsp.buf);
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
}
static int bkds_proc_get_ems()
{
    char itm_buf_ems[1024 * 4];
    char itm_buf_pcurv_info[1024];
    char itm_buf_pcurv_data[1024];
    char buf[128];

    sprintf(itm_buf_ems, "\
\"state\":\"%s\",\"step\":%d,\"err\":\"%s\",\"tick\":%d,\"tick_ave\":%d,\
\"tick_cur\":%d,\"tick_max\":%d,\"pow_reg_en\":%d,\"lo\":%d,\"hi\":%d,\
\"timer\":%d,\"intv\":%d,\"aps_min\":%d,\"aps_max\":%d,\"conm_model\":\"%s\",\
\"conm_idx\":%d,\"conm_com_ap\":%f,\"conm_com_ae\":%f,\"conm_pos_ae\":%f,\"conm_neg_ae\":%f,\
\"loadm_model\":\"%s\",\"loadm_idx\":%d,\"loadm_com_ap\":%f,\"loadm_com_ae\":%f,\"loadm_pos_ae\":%f,\
\"loadm_neg_ae\":%f,\"timeseg_idx\":%d,\"timeseg_status\":\"%s\",\"timeseg_type\":\"%s\",\"estats_step\":%d,\
\"day_sharp_pos_ae\":%f,\"day_sharp_neg_ae\":%f,\"day_peak_pos_ae\":%f,\"day_peak_neg_ae\":%f,\"day_flat_pos_ae\":%f,\
\"day_flat_neg_ae\":%f,\"day_valley_pos_ae\":%f,\"day_valley_neg_ae\":%f,\"mode\":\"%s\"\
",
            ems_get_state_str(), ems_get_step(), ems_get_err_str(), ems_get_tick(), ems_get_tick_ave(),
            ems_get_tick_cur(), ems_get_tick_max(), ems_get_regulate_en(), ems_get_reglo(), ems_get_reghi(),
            ems_get_pow_reg_timer(), ems_get_pow_reg_intv(), ems_get_pow_reg_aps_min(), ems_get_pow_reg_aps_max(), ems_get_transf_conm_model_str(),
            ems_get_transf_conm_idx(), ems_get_transf_con_com_ap(), ems_get_transf_con_com_ae(), ems_get_transf_con_pos_ae(), ems_get_transf_con_neg_ae(),
            ems_get_transf_load_model_str(), ems_get_transf_loadm_idx(), ems_get_transf_load_com_ap(), ems_get_transf_load_com_ae(), ems_get_transf_load_pos_ae(),
            ems_get_transf_load_neg_ae(), ems_get_timeseg_idx(), ems_get_timeseg_status_str(), ems_get_timeseg_type_str(), ems_get_estats_step(),
            ems_get_day_sharp_pos_ae(), ems_get_day_sharp_neg_ae(), ems_get_day_peak_pos_ae(), ems_get_day_peak_neg_ae(), ems_get_day_flat_pos_ae(),
            ems_get_day_flat_neg_ae(), ems_get_day_valley_pos_ae(), ems_get_day_valley_neg_ae(), ems_get_modestr());

    sprintf(itm_buf_pcurv_info, ",\"pcurv\":{\
\"idx\":%d,\"info\":\"%s\",\"status\":\"%s\",\"resolution\":%d,\"aps\":%d\
",
            ems_get_pcurv_idx(), ems_get_pcurv_info_str(), ems_get_pcurv_status_str(), 15, ems_get_pcurv_aps());

    sprintf(itm_buf_pcurv_data, ",\"values\":[");

    char temp_buf[100];
    int i = 0;
    int hh = 0;
    int mm = 0;
    struct pcurv_t *pc = ems_get_pcurv_t();
    for (i < 0; i < 96; i++)
    { // 5min 1 point -> 15min 1 point
        hh = i * 15 / 60;
        mm = i * 15 % 60;
        mm = mm / 5 * 5;
        sprintf(temp_buf, "%d", pc->aps[hh][mm]);
        strcat(itm_buf_pcurv_data, temp_buf);
        if (i < 96 - 1)
        {
            strcat(itm_buf_pcurv_data, ",");
        }
    }
    strcat(itm_buf_pcurv_data, "]");

    // log_info("%s,mqtt:%s\n",__func__,itm_buf_mqtt);
    bkds_gen_datetimestr(buf, sizeof(buf));
    // log_info("%s,bms:%s\n",__func__,itm_buf_bms);
    sprintf(SHM->rsp.buf, "{\"dt\":\"%s\",\"values\":{%s%s%s}}}", buf,
            itm_buf_ems, itm_buf_pcurv_info, itm_buf_pcurv_data);
    printf("%s,value:%s\n", __func__, SHM->rsp.buf);
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
}

static int bkds_proc_ctn_send_cmd()
{
    if (strcmp(SHM->cmd.buf, "stdby") == 0)
    {
        ctn_send_cmd(CMD_SM_STDBY);
    }
    else if (strcmp(SHM->cmd.buf, "stop") == 0)
    {
        ctn_send_cmd(CMD_SM_STOP);
    }
    else if (strcmp(SHM->cmd.buf, "ready") == 0)
    {
        ctn_send_cmd(CMD_SM_READY);
    }
    else if (strcmp(SHM->cmd.buf, "offgrid") == 0)
    {
        ctn_send_cmd(CMD_SM_OFFGRID);
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
}

static int bkds_proc_ctn_set_bystikchk_en()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    int bystikchk_en = atoi(SHM->cmd.buf);
    if (bystikchk_en != 1 && bystikchk_en != 0)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, bystikchk_en);
        (bystikchk_en == 1) ? ctn_enable_bsytikchk() : ctn_disable_bsytikchk();
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_ctn_set_pcs_bystikchk_en()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    int bystikchk_en = atoi(SHM->cmd.buf);
    if (bystikchk_en != 1 && bystikchk_en != 0)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, bystikchk_en);
        (bystikchk_en == 1) ? ctn_enable_pcs_bsytiksnd() : ctn_disable_pcs_bsytiksnd();
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_ctn_set_socd()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    double socd = atof(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%f", __func__, SHM->cmd.szcmd, socd);
    ctn_set_socd(socd);
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_ctn_set_socc()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    double socc = atof(SHM->cmd.buf);
    ctn_set_socc(socc);
    log_info("%s,cmd:%s,param:%f", __func__, SHM->cmd.szcmd, socc);
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_ctn_save_param()
{
    int ret = 0;
    ctn_cfg_save_socd();
    ctn_cfg_save_socc();
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_bms_set_sbmu_idx()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    int idx = atoi(SHM->cmd.buf);
    if (idx < 1 || idx > pack_get_sbmu_nbr())
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, idx);
        sbmu_idx = idx;
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_bms_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    pack_send_sm_cmd(cmd);
    return ret;
}

static int bkds_proc_bms_set_emshsnd_en()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    int en = atoi(SHM->cmd.buf);
    if (en != 1 && en != 0)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, en);
        pack_set_emshb_sending_en(en);
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_bms_set_bmsshbchk_en()
{
    int ret = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    int en = atoi(SHM->cmd.buf);
    if (en != 1 && en != 0)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, en);
        pack_set_bmshb_chk_en(en);
    }
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
    return ret;
}

static int bkds_proc_pcs_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    pcs_send_sm_cmd(cmd);
    return ret;
}

static int bkds_proc_pcs_set_dev_startcmd()
{
    int ret = 0;
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    pcs_set_dev_startcmd();
    return ret;
}

static int bkds_proc_pcs_set_dev_stopcmd()
{
    int ret = 0;
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    pcs_set_dev_stopcmd();
    return ret;
}

static int bkds_proc_pcs_set_dev_idlecmd()
{
    int ret = 0;
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    pcs_set_dev_idlecmd();
    return ret;
}

static int bkds_proc_pcs_set_dev_resetcmd()
{
    int ret = 0;
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    pcs_set_dev_resetcmd();
    return ret;
}

static int bkds_proc_pcs_set_aps()
{
    int ret = 0;
    int aps = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    aps = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, aps);
    pcs_set_aps(aps);
    return ret;
}

static int bkds_proc_pcs_set_dev_datetime()
{
    int ret = 0;
    int aps = 0;

    int y, m, d, h, min, s;
    log_info("%s,cmd:%s,param:%s", __func__, SHM->cmd.szcmd, "none");
    misc_get_datetime(&y, &m, &d, &h, &min, &s);
    pcs_set_datetime(y, m, d, h, min, s);

    return ret;
}

static int bkds_proc_pcs_set_dac_param_en()
{
    int ret = 0;
    int en = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    en = atoi(SHM->cmd.buf);
    if (en != 1 && en != 0)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, en);
        pcs_set_dac_param_en(en);
    }
    return ret;
}

static int bkds_proc_ems_save_pcurv()
{
    int ret = 0;
    int idx = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    idx = atoi(SHM->cmd.buf);
    if (idx < 1 && idx > 16)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, idx);
        ems_save_pcurv(idx);
    }
    return ret;
}

static int bkds_proc_ems_set_pcurv_idx()
{
    int ret = 0;
    int idx = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    idx = atoi(SHM->cmd.buf);
    if (idx < 1 && idx > 16)
    {
        return -1;
    }
    else
    {
        log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, idx);
        ems_set_pcurv(idx);
    }
    return ret;
}

static int bkds_proc_meter_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    meter_send_sm_cmd_all(cmd);
    return ret;
}

static int bkds_proc_ems_set_pcurv()
{
    int ret = 0;
    int idx = 0;

    int start_hh = 0;
    int start_mm = 0;
    int end_hh = 0;
    int end_mm = 0;
    int aps = 0;

    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cJSON *root = cJSON_Parse(SHM->cmd.buf);
    if (root == NULL)
    {
        return -2;
    }

    cJSON *start_Item = cJSON_GetObjectItem(root, "start");
    if (start_Item == NULL)
    {
        return -3;
    }
    cJSON *start_hh_Item = cJSON_GetObjectItem(start_Item, "hh");
    cJSON *start_nn_Item = cJSON_GetObjectItem(start_Item, "nn");
    if (start_hh_Item == NULL || start_nn_Item == NULL)
    {
        return -4;
    }
    start_hh = atoi(cJSON_GetStringValue(start_hh_Item));
    start_mm = atoi(cJSON_GetStringValue(start_nn_Item));

    cJSON *end_Item = cJSON_GetObjectItem(root, "end");
    if (start_Item == NULL)
    {
        return -5;
    }
    cJSON *end_hh_Item = cJSON_GetObjectItem(end_Item, "hh");
    cJSON *end_nn_Item = cJSON_GetObjectItem(end_Item, "nn");
    if (end_hh_Item == NULL || end_nn_Item == NULL)
    {
        return -6;
    }
    end_hh = atoi(cJSON_GetStringValue(end_hh_Item));
    end_mm = atoi(cJSON_GetStringValue(end_nn_Item));

    cJSON *aps_Item = cJSON_GetObjectItem(root, "aps");
    if (aps_Item == NULL)
    {
        return -7;
    }

    aps = atoi(cJSON_GetStringValue(aps_Item));

    log_info("%s,start:%d,%d,end:%d,%d", __func__, start_hh, start_mm, end_hh, end_mm, aps);

    ems_edit_pcurv(start_hh, start_mm, end_hh, end_mm, aps);

    cJSON_Delete(root);

    return ret;
}

static int bkds_proc_evn_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    env_send_sm_cmd_all(DEVM_RS_WS_N, cmd);
    env_send_sm_cmd_all(DEVM_SGA500E, cmd);
    return ret;
}

static int bkds_proc_plc_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    plc_send_sm_cmd(cmd);
    return ret;
}

static int bkds_proc_ups_set_sm_cmd()
{
    int ret = 0;
    int cmd = 0;
    if (SHM->cmd.buf[0] == 0)
    {
        return -1;
    }
    cmd = atoi(SHM->cmd.buf);
    log_info("%s,cmd:%s,param:%d", __func__, SHM->cmd.szcmd, cmd);
    ups_send_sm_cmd(cmd);
    return ret;
}

static int bkds_proc_cmd()
{
    if (strcmp(SHM->cmd.szcmd, "bms_set_sbmu_idx") == 0)
    {
        bkds_proc_bms_set_sbmu_idx();
    }
    else if (strcmp(SHM->cmd.szcmd, "ctn_set_bsytikchk_en") == 0)
    {
        bkds_proc_ctn_set_bystikchk_en();
    }
    else if (strcmp(SHM->cmd.szcmd, "ctn_set_pcs_bsytiksnd_en") == 0)
    {
        bkds_proc_ctn_set_pcs_bystikchk_en();
    }
    else if (strcmp(SHM->cmd.szcmd, "ctn_set_socd") == 0)
    {
        bkds_proc_ctn_set_socd();
    }
    else if (strcmp(SHM->cmd.szcmd, "ctn_set_socc") == 0)
    {
        bkds_proc_ctn_set_socc();
    }
    else if (strcmp(SHM->cmd.szcmd, "ctn_save_param") == 0)
    {
        bkds_proc_ctn_save_param();
    }
    else if (strcmp(SHM->cmd.szcmd, "bms_set_sm_cmd") == 0)
    {
        bkds_proc_bms_set_sm_cmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "bms_set_emshbsnd_en") == 0)
    {
        bkds_proc_bms_set_emshsnd_en();
    }
    else if (strcmp(SHM->cmd.szcmd, "bms_set_bmshbchk_en") == 0)
    {
        bkds_proc_bms_set_bmsshbchk_en();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_sm_cmd") == 0)
    {
        bkds_proc_bms_set_sm_cmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dev_startcmd") == 0)
    {
        bkds_proc_pcs_set_dev_startcmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dev_stopcmd") == 0)
    {
        bkds_proc_pcs_set_dev_stopcmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dev_idlecmd") == 0)
    {
        bkds_proc_pcs_set_dev_idlecmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dev_resetcmd") == 0)
    {
        bkds_proc_pcs_set_dev_resetcmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_aps") == 0)
    {
        bkds_proc_pcs_set_aps();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dev_datetime") == 0)
    {
        bkds_proc_pcs_set_dev_datetime();
    }
    else if (strcmp(SHM->cmd.szcmd, "pcs_set_dac_param_en") == 0)
    {
        bkds_proc_pcs_set_dac_param_en();
    }
    else if (strcmp(SHM->cmd.szcmd, "set_pcurv") == 0)
    {
        bkds_proc_ems_set_pcurv();
    }
    else if (strcmp(SHM->cmd.szcmd, "set_pcurv_idx") == 0)
    {
        bkds_proc_ems_set_pcurv_idx();
    }
    else if (strcmp(SHM->cmd.szcmd, "save_pcurv") == 0)
    {
        bkds_proc_ems_save_pcurv();
    }
    else if (strcmp(SHM->cmd.szcmd, "plc_set_sm_cmd") == 0)
    {
        bkds_proc_plc_set_sm_cmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "evn_set_sm_cmd") == 0)
    {
        bkds_proc_evn_set_sm_cmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "meter_set_sm_cmd") == 0)
    {
        bkds_proc_meter_set_sm_cmd();
    }
    else if (strcmp(SHM->cmd.szcmd, "ups_set_sm_cmd") == 0)
    {
        bkds_proc_ups_set_sm_cmd();
    }
    else
    {
        log_info("%s,unkown cmd:%s", __func__, SHM->cmd.szcmd);
        return -1;
    }
}

static int bkds_proc_ctn_set_aps()
{
    ctn_set_aps(atoi(SHM->cmd.buf));
    strcpy(SHM->rsp.szcmd, SHM->cmd.szcmd);
    SHM->rsp.serial = SHM->cmd.serial;
    SHM->rsp.ready = 1;
}

static thrd_bkds(void *param)
{
    syslog(LOG_INFO, "%s, ++", __func__);
    sleep(10);
    while (1)
    {
        if (SHM->cmd.ready == 1)
        {
            SHM->cmd.ready = 0;
            if (strcmp(SHM->cmd.szcmd, "set_ctn_cmd") == 0)
            {
                bkds_proc_ctn_send_cmd();
            }
            else if (strcmp(SHM->cmd.szcmd, "ctn_get_data") == 0)
            {
                bkds_proc_get_ctn_data();
            }
            else if (strcmp(SHM->cmd.szcmd, "bms_get_data") == 0)
            {
                if (sbmu_idx < 1 || sbmu_idx > 10)
                {
                    sbmu_idx = 1;
                }
                bkds_proc_get_bms(sbmu_idx);
            }
            else if (strcmp(SHM->cmd.szcmd, "set_ctn_aps") == 0)
            {
                bkds_proc_ctn_set_aps();
            }
            else if (strcmp(SHM->cmd.szcmd, "get_ems_data") == 0)
            {
                bkds_proc_get_ems();
            }
            else
            {
                bkds_proc_cmd();
            }
        }
        usleep(10000); // 10ms
    }
}

int bkds_init()
{
    pthread_t xthrd;
    int ret = 0;
    int shm_id = -1;
    void *shared_memory = NULL;

    shm_id = shmget((key_t)BKDSHMID, sizeof(struct bkd_shm_t), 0666 | IPC_CREAT);
    if (shm_id < 0)
    {
        switch (errno)
        {
        case EINVAL:
            syslog(LOG_INFO, "%s shmget fail:EINVAL\n", __func__);
            break;

        case EEXIST:
            syslog(LOG_INFO, "%s shmget fail:EEXIST\n", __func__);
            break;

        case EIDRM:
            syslog(LOG_INFO, "%s shmget fail:EIDRM\n", __func__);
            break;

        case ENOSPC:
            syslog(LOG_INFO, "%s shmget fail:ENOSPC\n", __func__);
            break;

        case ENOENT:
            syslog(LOG_INFO, "%s shmget fail:ENOENT\n", __func__);
            break;

        case EACCES:
            syslog(LOG_INFO, "%s shmget fail:EACCES\n", __func__);
            break;

        case ENOMEM:
            syslog(LOG_INFO, "%s shmget fail:ENOMEM\n", __func__);
            break;

        default:
            syslog(LOG_INFO, "%s shmget fail:unknown err\n", __func__);
            break;
        }
        ret = -1;
        goto leave;
    }

    shared_memory = shmat(shm_id, NULL, 0);
    if (shared_memory == NULL)
    {
        ret = -2;
        syslog(LOG_INFO, "%s shmat fail\n", __func__);
        goto leave;
    }
    else
    {
        SHM = (struct bkd_shm_t *)shared_memory;
        SHM->cmd.ready = 0;
        SHM->rsp.ready = 0;
        if (pthread_create(&xthrd, NULL, thrd_bkds, NULL) != 0)
        {
            ret = -3;
            syslog(LOG_INFO, "%s, create thread bkds fail\n", __func__);
        }
    }
leave:
    return ret;
}