ctnd/platform/device/pcs/ies/ies1000.c

#include "plt.h"

struct ies1000_t ies1000[IES1000_NBR_MAX + 1];

int ies1000_reset_bsytikchk(int idx)
{
    ies1000[idx].bsytik.timer = 0;
    ies1000[idx].bsytik.timeout = 0;
    ies1000[idx].bsytik.chkcnt = 0;
    return 0;
}

// 0 : not timeout
// 1 : timeout
int ies1000_is_bsytikchk_timeout(int idx)
{
    struct ies1000_t* dev = &ies1000[1];
    if( dev->bsytik.chken == 1 ){
        return ies1000[idx].bsytik.timeout;
    }else{
        return 0;
    }
    
}

int ies1000_set_bsytik(int idx)
{
    ies1000[idx].bsytik.from_host++;
    return 0;
}

int ies1000_get_bsytikchk_from_host(int idx)
{
    ies1000[idx].bsytik.from_host++;
    return 0;
}

int ies1000_get_bsytikchk_en(int idx)
{
   return ies1000[idx].bsytik.chken;
}

int ies1000_set_bsytikchk_en(int idx, int val)
{
    ies1000[idx].bsytik.chken = val;
    return 0;
}

int ies1000_set_dac_param_en(int idx, int val)
{
    struct ies1000_t* dev = &ies1000[1];
    struct comm_t* comm = &dev->comm;
    comm_set_dac_param_en(comm, val);
    return 0;
}

static int ies1000_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct ies1000_t* dev = &ies1000[1];

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

    for( i = 0; i < ncolumn; i++){
        if( strcmp("info",columnname[i]) == 0){
            strcpy(dev->szinfo,columnvalue[i]);
        }else if( strcmp("adr",columnname[i]) == 0){
            dev->comm.adr = atoi(columnvalue[i]);
        }else if( strcmp("chan_idx",columnname[i]) == 0){
            dev->comm.chanidx = atoi(columnvalue[i]);
        }
    }

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

int ies1000_get_cmd( int idx )
{
    return ies1000[idx].cmd;
}

int ies1000_get_comm_st(int idx)
{
    struct ies1000_t* dev = &ies1000[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_state(comm);
}

void ies1000_reset_cmd(int idx)
{
    ies1000[idx].cmd = CMD_SM_DONE;
}

int ies1000_get_state( int idx )
{
    return ies1000[idx].sm.state;
}

char* ies1000_get_state_str( int idx )
{
    return ies1000[idx].sm.szState;
}

int ies1000_get_step( int idx )
{
    return ies1000[idx].sm.step;
}

int ies1000_get_tick( int idx )
{
    return ies1000[idx].sm.tick;
}

double ies1000_get_tick_ave( int idx )
{
    return ies1000[idx].sm.timing_ave;
}

double ies1000_get_tick_cur( int idx )
{
    return ies1000[idx].sm.timing_cur;
}

double ies1000_get_tick_max( int idx )
{
    return ies1000[idx].sm.timing_max;
}

char* ies1000_get_err_str( int idx )
{
    return ies1000[idx].sm.szerr;
}

int ies1000_chk_state( int idx, int stat )
{
    return ies1000_get_state(idx) == stat ? 0 : -1;
}

int ies1000_get_ap( int idx )
{
    return ies1000[idx].pow.ap;
}

int ies1000_get_dcp( int idx )
{
    return ies1000[idx].dc_p;
}

int ies1000_get_breaker_ac( int idx )
{
    return ies1000[idx].ac_breaker;
}

int ies1000_get_breaker_dc( int idx )
{
    return ies1000[idx].dc_breaker;
}

int ies1000_get_dcbuf_cont( int idx )
{
    return ies1000[idx].dcbuf_cont;
}

int ies1000_get_dev_aps( int idx )
{
    return ies1000[idx].active_p_set;
}

int ies1000_get_dcv( int idx )
{
    return ies1000[idx].dc_v;
}

int ies1000_get_dcc( int idx )
{
    return ies1000[idx].dc_c;
}

int ies1000_get_dc_ovp( int idx )
{
    return ies1000[idx].dc_ovp;
}

int ies1000_get_dc_uvp( int idx )
{
    return ies1000[idx].dc_uvp;
}

int ies1000_get_dc_dfp( int idx )
{
    return ies1000[idx].dc_dfp;
}

int ies1000_get_env_otp( int idx )
{
    return ies1000[idx].env_otp;
}

int ies1000_get_reactor_otp( int idx )
{
    return ies1000[idx].reactor_otp;
}

int ies1000_get_igbt_otp( int idx )
{
    return ies1000[idx].igbt_otp;
}

int ies1000_get_ac_brk( int idx )
{
    return ies1000[idx].ac_breaker;
}

int ies1000_get_dc_brk( int idx )
{
    return ies1000[idx].dc_breaker;
}

int ies1000_get_emg_btn( int idx )
{
    return ies1000[idx].emg_btn;
}

int ies1000_get_errstat( int idx )
{
    return ies1000[idx].errstatus;
}

double ies1000_get_gridv( int idx )
{
    return ies1000[idx].grid_v;
}

double ies1000_get_gridc( int idx )
{
    return ies1000[idx].ac_c;
}

double ies1000_get_grid_freq( int idx )
{
    return ies1000[idx].grid_freq;
}

double ies1000_get_ua( int idx )
{
    return ies1000[idx].ua;
}

double ies1000_get_ub( int idx )
{
    return ies1000[idx].ub;
}

double ies1000_get_uc( int idx )
{
    return ies1000[idx].uc;
}

double ies1000_get_ia( int idx )
{
    return ies1000[idx].ia;
}
double ies1000_get_ib( int idx )
{
    return ies1000[idx].ib;
}
double ies1000_get_ic( int idx )
{
    return ies1000[idx].ic;
}

int ies1000_get_temp_igbt_a( int idx )
{
    return ies1000[idx].temp_igbt_a;
}

int ies1000_get_temp_igbt_b( int idx )
{
    return ies1000[idx].temp_igbt_b;
}

int ies1000_get_temp_igbt_c( int idx )
{
    return ies1000[idx].temp_igbt_c;
}

int ies1000_get_temp_reactor( int idx )
{
    return ies1000[idx].temp_reactor;
}

int ies1000_get_temp_env( int idx )
{
    return ies1000[idx].temp_env;
}

static void ies1000_update(int idx)
{
    struct ies1000_t* dev = &ies1000[idx];

    dev->pow.ap = dev->ap;
}

static void* ies1000_thrd_main(void* param)
{
    int idx = 1;
    struct ies1000_t* dev = &ies1000[idx];    
    log_dbg("%s, idx:%d, ++",__func__, idx);

    ies1000_set_bsytikchk_en(idx, 1);
    ies1000_sm_init(1);
    ies1000_comm_init(1);
    while(1){
        ies1000_comm_dac(1);
        ies1000_sm(1);
        ies1000_update(1);
        usleep(10000); /* 10ms */
    }
    log_dbg("%s, --",__func__);
}

static void* ies1000_thrd_aux(void* param)
{
    int idx = 1;
    struct ies1000_t* dev = &ies1000[idx];
    struct statemachine_t* sm = &dev->sm;
    log_dbg("%s, ++",__func__);

    while(1){
        if( dev->bsytik.timer++ >= 10 ){ // chk every 1 second
            dev->bsytik.timer = 0;
            if( dev->bsytik.last_from_host != dev->bsytik.from_host ){ // refresh
                dev->bsytik.last_from_host = dev->bsytik.from_host;
                dev->bsytik.chkcnt = 0;
            }else{ // counting
                if( dev->bsytik.chkcnt++ >= 5){ // 5s
                    dev->bsytik.timeout = 1;
                    dev->bsytik.chkcnt = 0;
                }
            }
        } 
        usleep(100000); /* 100ms */
    }
    log_dbg("%s, --",__func__);
}

int ies1000_init()
{
    pthread_t thrd;
    int ret = 0;
    int result;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3* db = NULL;
    struct ies1000_t* dev = &ies1000[1];

    log_dbg( "%s, ++",__func__);

    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"select * from ies1000");
    cbparam.nrow = 0;
	result = sqlite3_exec(db,sql, ies1000_dbcb_0,(void*)&cbparam,&errmsg);
    plt_unlock_ctndb();
	if( result != SQLITE_OK ){
        log_dbg("%s, result != SQLITE_OK, result:%d", __func__, result);
        ret = -1;
	 }else if( cbparam.ret != 0){
        log_dbg("%s, cbparam.ret != 0, %d", __func__, cbparam.ret);
        ret = -2;
	 }else if( cbparam.nrow != 1 ){
        log_dbg("%s, cbparam.nrow != 1, %d", __func__, cbparam.nrow);
        ret = -3;
     }else{
        if(pthread_create(&thrd, NULL, ies1000_thrd_main, NULL) != 0){
            log_dbg( "%s, create ies1000 thrd main fail", __func__);
            ret = -1;
        }else if(pthread_create(&thrd, NULL, ies1000_thrd_aux, NULL) != 0){
            log_dbg( "%s, create ies1000 thrd aux fail", __func__);
            ret = -1;
        }       
	 }

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

int ies1000_send_sm_cmd( int idx, int val )
{
    int ret = 0;
    struct ies1000_t* dev = &ies1000[idx];

    dev->cmd = val;

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

int ies1000_get_runmod( int idx )
{
    return ies1000[idx].runmod;
}

int ies1000_get_runstat( int idx )
{
    return ies1000[idx].runstatus;
}

char* ies1000_get_runstat_str( int idx )
{
    return ies1000[idx].szrunstatus;
}

int ies1000_set_aps(int idx, int aps)
{
    struct ies1000_t* dev = &ies1000[idx];
    int ret = 0;
    dev->pow.last_aps = dev->pow.aps;
    dev->pow.aps = aps;
    log_dbg( "%s, idx:%d, aps:%d, last_aps:%d", __func__, idx, dev->pow.aps, dev->pow.last_aps);
    return ret;
}

int ies1000_reset_aps(int idx)
{
    struct ies1000_t* dev = &ies1000[idx];
    int ret = 0;
    dev->pow.last_aps = 0;
    dev->pow.aps = 0;
    //log_dbg( "%s, idx:%d, val:%d, ret:%d", __func__, idx, aps, ret);
    return ret;
}

int ies1000_get_aps(int idx)
{
    return ies1000[idx].pow.aps;
}

int ies1000_get_last_aps(int idx)
{
    return ies1000[idx].pow.last_aps;
}

int ies1000_is_aps_changed(int idx)
{
    return (ies1000[idx].pow.aps != ies1000[idx].pow.last_aps)?1:0;
}

int ies1000_get_chan_idx(int idx)
{
    return ies1000[idx].comm.chanidx;
}

int ies1000_get_adr(int idx)
{
    return ies1000[idx].comm.adr;
}

char* ies1000_get_comm_state_str(int idx)
{
    return  ies1000[idx].comm.szState;
}

double ies1000_get_dac_ave(int idx)
{
    return  ies1000[idx].comm.dac.timing_ave;
}

double ies1000_get_dac_cur(int idx)
{
    return  ies1000[idx].comm.dac.timing_cur;
}

double ies1000_get_dac_max(int idx)
{
    return  ies1000[idx].comm.dac.timing_max;
}

unsigned short* ies1000_get_faults(int idx)
{
    return  ies1000[idx].faults;
}

unsigned short* ies1000_get_warns(int idx)
{
    return  ies1000[idx].warns;
}

int ies1000_get_dac_param_en(int idx)
{
    return ies1000[idx].comm.dac.param_en;
}

char* ies1000_get_info_str(int idx)
{
    return ies1000[idx].szinfo;
}

double ies1000_get_chg_e_total(int idx)
{
return ies1000[idx].chg_e_total;
}

double ies1000_get_dhg_e_total(int idx)
{
return ies1000[idx].dhg_e_total;
}


struct ies1000_t* ies1000_get_all_data_ptr()
{
    return ies1000;
}

int ies1000_get_tool_data(int idx,char* buf)
{
    if(idx < 1 || idx > IES1000_NBR_MAX || buf == NULL){
        return -1;
    }

    struct ies1000_t* dev = &ies1000[idx];
    struct statemachine_t* sm = &dev->sm;
    struct comm_t* comm = &dev->comm;
    char temp_buf[8192];
    int i = 0;
    sm_get_summary(sm, temp_buf, sizeof(temp_buf));
    sprintf(buf,"%s ", temp_buf);

    comm_get_summary(comm, temp_buf, sizeof(temp_buf));
    strcat(buf, temp_buf); 
    // 0xF100 
    sprintf(temp_buf,"bsytik_from_host:%03d timeout:%d en:%d\n", 
            dev->bsytik.from_host, dev->bsytik.timeout, dev->bsytik.chken);  
    strcat(buf, temp_buf); 
    // 0xED00 
    sprintf(temp_buf,"0xED00 runstat:"L_GREEN"%s"NONE" dc_v:"L_GREEN"%d"NONE", dc_c:%d, grid_freq:%.2f, grid_v:%.1f, ac_c:%.1f,\
ua:%.1f ub:%.1f uc:%.1f ia:%.1f ib:%.1f ic:%.1f,\
ap:"L_GREEN"%d"NONE" dc_p:%d, breaker_ac:%d dc:%d dcbuf_cont:%d emgbtn:%d \
day_chg:%.1f dhg:%.1f, total_chg:%.1f dhg:%.1f, \
igbt_temp a:%d b:%d c:%d reactor_temp:%d env:%d,\
errstatus:"L_GREEN"%d"NONE"\n", 
            dev->szrunstatus, dev->dc_v,dev->dc_c,dev->grid_freq, dev->grid_v, dev->ac_c,
            dev->ua,dev->ub,dev->uc,dev->ia,dev->ib,dev->ic,
            dev->ap, dev->dc_p, dev->ac_breaker,dev->dc_breaker,  dev->dcbuf_cont, dev->emg_btn,
            dev->chg_e_day, dev->dhg_e_day,dev->chg_e_total,dev->dhg_e_total,
            dev->temp_igbt_a, dev->temp_igbt_b, dev->temp_igbt_c, dev->temp_reactor, dev->temp_env,
            dev->errstatus);
    strcat(buf, temp_buf); 

    // 0x0E14 and 0x0F14   
    strcat(buf, "0x0E14 and 0x0F14 Faults:"); 
    for( i = 1; i <= 6; i++ ){
        sprintf(temp_buf,"%d:0x%02X ", i, dev->faults[i]);
        strcat(buf, temp_buf); 
    } 
    strcat(buf, " Warns:"); 
    for( i = 1; i <= 6; i++ ){
        sprintf(temp_buf,"%d:0x%02X ", i, dev->warns[i]);
        strcat(buf, temp_buf); 
    } 
    strcat(buf,"\n"); 

    // 0xF000            
    sprintf(temp_buf,"0xF000 cmdsrc:%s runmod:"L_GREEN"%s"NONE" workmod:%s switch_init:%s offgrid_freq:%s offgrid_v_set:%d \
reactive_pow_set_mod:%s  aps:%d devaps:"L_GREEN"%d"NONE" devrps:%d PQ_cv_vset:%d PQ_cc_cset:%d pow_set_src:%s ins_det:%d\n", 
                dev->szcmdsrc,dev->szrunmod,dev->szworkmod,dev->szswitch_initmod,dev->szoffgrid_freq,dev->offgrid_vol_set,
                dev->szreactive_p_set_mod, dev->pow.aps, dev->active_p_set,dev->reactive_p_set,dev->cv_v_set,dev->cc_c_set,dev->szpow_set_src, dev->ins_det); 
    strcat(buf, temp_buf); 

    // 0xF509
    sprintf(temp_buf,"0xF509 gridfreq_autoadj:%d pow_rate_ctl:%d pow_rate_set:%d isl_det:%d\n",
                    dev->gridfreq_autoadj, dev->pow_adjrate_en, dev->pow_adjrate_set, dev->isl_det); 
    strcat(buf, temp_buf); 

    // 0xEB37                 
    sprintf(temp_buf,"0xEB37 sync_time:%d-%d-%d %d:%d:%d\n", dev->sync_year, dev->sync_month, dev->sync_day, dev->sync_hour, dev->sync_min, dev->sync_sec);
    strcat(buf, temp_buf);
}

int ies1000_get_tbmqtt_main_data(int idx,char* buf)
{

    sprintf(buf, "'pcs_runstat':'%s','pcs_ap':%d,'pcs_dcv':%d, 'pcs_dcc':%d,\
'pcs_ac_brk':%d, 'pcs_dc_brk':%d, 'pcs_emg_btn':%d, 'pcs_errstat':%d,\
'pcs_state':'%s'", 
                ies1000_get_runstat_str( idx ), ies1000_get_ap( idx ), ies1000_get_dcv( idx ), ies1000_get_dcc( idx ),
                ies1000_get_ac_brk( idx ), ies1000_get_dc_brk( idx ), ies1000_get_emg_btn( idx ), ies1000_get_errstat( idx ),
                ies1000_get_state_str( idx ));

}


int ies1000_get_tbmqtt_secondy_data(int idx,char* buf)
{

    sprintf(buf, "'pcs_ua':%.1f, 'pcs_ub':%.1f, 'pcs_uc':%.1f,\
'pcs_ia':%.1f, 'pcs_ib':%.1f, 'pcs_ic':%.1f,\
'pcs_t_a':%d, 'pcs_t_b':%d, 'pcs_t_c':%d, 'pcs_t_rct':%d,'pcs_t_env':%d", 
                ies1000_get_ua( idx ), ies1000_get_ub( idx ), ies1000_get_uc( idx ),
                ies1000_get_ia( idx ),ies1000_get_ib( idx ),ies1000_get_ic( idx ),
                ies1000_get_temp_igbt_a( idx ),ies1000_get_temp_igbt_b( idx ),ies1000_get_temp_igbt_c( idx ),
                ies1000_get_temp_reactor( idx ),
                ies1000_get_temp_env( idx ));

}


int ies1000_get_cloud_main_data(int cnt_idx,int idx,char* buf)
{
    sprintf(buf, "'ctn%d_pcs_state':%d, 'ctn%d_pcs_runstat':%d, 'ctn%d_pcs_dcv':%d, 'ctn%d_pcs_dcc':%d,\
'ctn%d_pcs_ac_brk':%d, 'ctn%d_pcs_dc_brk':%d, 'ctn%d_pcs_emg_btn':%d, 'ctn%d_pcs_errstat':%d, 'ctn%d_pcs_gf':%.1f, 'ctn%d_pcs_ap':%d", 
                cnt_idx, ies1000_get_state( idx ), 
                cnt_idx, ies1000_get_runstat( idx ), 
                cnt_idx, ies1000_get_dcv( idx ), 
                cnt_idx, ies1000_get_dcc( idx ),
                cnt_idx, ies1000_get_ac_brk( idx ),
                cnt_idx, ies1000_get_dc_brk( idx ),
                cnt_idx, ies1000_get_emg_btn( idx ),
                cnt_idx, ies1000_get_errstat( idx ),
                cnt_idx, ies1000_get_grid_freq( idx ),
                cnt_idx, ies1000_get_ap( idx ));
}

int ies1000_get_cloud_secondy_data(int cnt_idx,int idx,char* buf)
{
    sprintf(buf, "'ctn%d_pcs_ua':%.1f, 'ctn%d_pcs_ub':%.1f, 'ctn%d_pcs_uc':%.1f,\
'ctn%d_pcs_ia':%.1f, 'ctn%d_pcs_ib':%.1f, 'ctn%d_pcs_ic':%.1f,'ctn%d_pcs_gf':%.1f,\
'ctn%d_pcs_t_a':%d, 'ctn%d_pcs_t_b':%d, 'ctn%d_pcs_t_c':%d, 'ctn%d_pcs_t_rct':%d,'ctn%d_pcs_t_env':%d", 
                cnt_idx, ies1000_get_ua( idx ), 
                cnt_idx, ies1000_get_ub( idx ), 
                cnt_idx, ies1000_get_uc( idx ),
                cnt_idx, ies1000_get_ia( idx ),
                cnt_idx, ies1000_get_ib( idx ),
                cnt_idx, ies1000_get_ic( idx ),
                cnt_idx, ies1000_get_grid_freq( idx ),
                cnt_idx, ies1000_get_temp_igbt_a( idx ),
                cnt_idx, ies1000_get_temp_igbt_b( idx ),
                cnt_idx, ies1000_get_temp_igbt_c( idx ),
                cnt_idx, ies1000_get_temp_reactor( idx ),
                cnt_idx, ies1000_get_temp_env( idx ));
}

int ies1000_get_bkds_data(int idx,char* buf)
{
    unsigned short* faults = ies1000_get_faults( idx );
    unsigned short* warns = ies1000_get_warns( idx );
    sprintf(buf,"\
\"model\":\"%s\",\"info\":\"%s\",\"state\":\"%s\",\"step\":%d,\"err\":\"%s\",\
\"ap\":%d,\"aps\":%d,\"tick\":%d,\"chan_idx\":%d,\"adr\":%d,\
\"comm_state\":\"%s\",\"dac_param_en\":%d,\"bsytikchk_en\":%d,\"bsytikchk_from_host\":%d,\"bsytikchk_timeout\":%d,\
\"dc_ovp\":%d,\"dc_uvp\":%d,\"dc_dfp\":%d,\"env_otp\":%d,\"reactor_otp\":%d,\
\"igbt_otp\":%d,\"run_state\":\"%s\",\"dc_v\":%d,\"dc_c\":%d,\"grid_freq\":%.1f,\
\"grid_v\":%.1f,\"grid_c\":%.1f,\"ua\":%.1f,\"ub\":%.1f,\"uc\":%.1f,\
\"ia\":%.1f,\"ib\":%.1f,\"ic\":%.1f,\"ap\":%d,\"dc_p\":%d,\
\"breaker_ac\":%d,\"breaker_dc\":%d,\"dcbuf_cont\":%d,\"emg_btn\":%d,\"igbt_a_temp\":%d,\
\"igbt_b_temp\":%d,\"igbt_c_temp\":%d,\"reactor_temp\":%d,\"env_temp\":%d,\"err_status\":%d,\
\"fault1\":\"0x%0x\",\"fault2\":\"0x%0x\",\"fault3\":\"0x%0x\",\"fault4\":\"0x%0x\",\"fault5\":\"0x%0x\",\
\"fault6\":\"0x%0x\",\"warn1\":\"0x%0x\",\"warn2\":\"0x%0x\",\"warn3\":\"0x%0x\",\"warn4\":\"0x%0x\",\
\"warn5\":\"0x%0x\",\"warn6\":\"0x%0x\"\
","ies1000","pcs",ies1000_get_state_str( idx ),ies1000_get_step( idx ),ies1000_get_err_str( idx ),
    ies1000_get_ap( idx ),ies1000_get_aps( idx ),ies1000_get_tick( idx ),ies1000_get_chan_idx( idx ),ies1000_get_adr( idx ),
    ies1000_get_comm_state_str( idx ),ies1000_get_dac_param_en( idx ),ies1000_get_bsytikchk_en( idx ),ies1000_get_bsytikchk_from_host( idx ),ies1000_is_bsytikchk_timeout( idx ),
    ies1000_get_dc_ovp( idx ),ies1000_get_dc_uvp( idx ),ies1000_get_dc_dfp( idx ),ies1000_get_env_otp( idx ),ies1000_get_reactor_otp( idx ),
    ies1000_get_igbt_otp( idx ),ies1000_get_runstat_str( idx ),ies1000_get_dcv( idx ),ies1000_get_dcc( idx ),ies1000_get_grid_freq( idx ),
    ies1000_get_gridv( idx ),ies1000_get_gridc( idx ),ies1000_get_ua( idx ),ies1000_get_ub( idx ),ies1000_get_uc( idx ),
    ies1000_get_ia( idx ),ies1000_get_ib( idx ),ies1000_get_ic( idx ),ies1000_get_ap( idx ),ies1000_get_dcp( idx ),
    ies1000_get_breaker_ac( idx ),ies1000_get_breaker_dc( idx ),ies1000_get_dcbuf_cont( idx ),ies1000_get_emg_btn( idx ),ies1000_get_temp_igbt_a( idx ),
    ies1000_get_temp_igbt_b( idx ),ies1000_get_temp_igbt_c( idx ),ies1000_get_temp_reactor( idx ),ies1000_get_temp_env( idx ),ies1000_get_errstat( idx ),
    faults[0],faults[1],faults[2],faults[3],faults[4],
    faults[5],warns[0],warns[1],warns[2],warns[3],
    warns[4],warns[5]);
}