ctnd/platform/device/pcs/itech/it6000.c

#include "plt.h"

struct it6000_t it6000[IT6000_NBR_MAX + 1];

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

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

int it6000_set_bsytik(int idx)
{
    it6000[idx].bsytik.from_host++;
    return 0;
}

int it6000_get_bsytikchk_from_host(int idx)
{
    it6000[idx].bsytik.from_host++;
    return 0;
}

int it6000_get_bsytikchk_en(int idx)
{
   return it6000[idx].bsytik.chken;
}

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

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

static int it6000_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct it6000_t* dev = &it6000[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]);
        }else if( strcmp("Vh",columnname[i]) == 0){
            dev->Vh_set = atof(columnvalue[i]);
        }else if( strcmp("Vl",columnname[i]) == 0){
            dev->Vl_set = atof(columnvalue[i]);
        }else if( strcmp("ovp",columnname[i]) == 0){
            dev->ovp_set = atof(columnvalue[i]);
        }else if( strcmp("uvp",columnname[i]) == 0){
            dev->uvp_set = atof(columnvalue[i]);
        }else if( strcmp("ocp",columnname[i]) == 0){
            dev->ocp_set = atof(columnvalue[i]);
        }
    }

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

int it6000_get_cmd( int idx )
{
    return it6000[idx].cmd;
}

int it6000_get_comm_st(int idx)
{
    struct it6000_t* dev = &it6000[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_state(comm);
}

void it6000_reset_cmd(int idx)
{
    it6000[idx].cmd = CMD_SM_DONE;
}

int it6000_get_state( int idx )
{
    return it6000[idx].sm.state;
}

char* it6000_get_state_str( int idx )
{
    return it6000[idx].sm.szState;
}

int it6000_get_step( int idx )
{
    return it6000[idx].sm.step;
}

int it6000_get_tick( int idx )
{
    return it6000[idx].sm.tick;
}

double it6000_get_tick_ave( int idx )
{
    return it6000[idx].sm.timing_ave;
}

double it6000_get_tick_cur( int idx )
{
    return it6000[idx].sm.timing_cur;
}

double it6000_get_tick_max( int idx )
{
    return it6000[idx].sm.timing_max;
}

char* it6000_get_err_str( int idx )
{
    return it6000[idx].sm.szerr;
}

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

int it6000_get_sysstatus( int idx ) 
{
	return it6000[idx].sysStatus;
}

int it6000_get_dc_mode( int idx ) 
{
	return it6000[idx].dc_mode;
}

float it6000_get_dc_volt( int idx ) 
{
	return it6000[idx].dc_volt;
}

float it6000_get_dc_volt_rise( int idx ) 
{
	return it6000[idx].dc_volt_rise;
}

float it6000_get_dc_volt_fall( int idx ) 
{
	return it6000[idx].dc_volt_fall;
}

float it6000_get_dc_current( int idx ) 
{
	return it6000[idx].dc_current;
}

float it6000_get_dc_current_rise( int idx ) 
{
	return it6000[idx].dc_current_rise;
}

float it6000_get_dc_current_fall( int idx ) 
{
	return it6000[idx].dc_current_fall;
}

float it6000_get_dc_v_high( int idx ) 
{
	return it6000[idx].dc_v_high;
}

float it6000_get_dc_v_low( int idx ) 
{
	return it6000[idx].dc_v_low;
}

float it6000_get_dc_i_high( int idx ) 
{
	return it6000[idx].dc_i_high;
}

float it6000_get_dc_i_low( int idx ) 
{
	return it6000[idx].dc_i_low;
}

int it6000_get_cc_speed_state( int idx ) 
{
	return it6000[idx].cc_speed_state;
}

int it6000_get_cv_speed_state( int idx ) 
{
	return it6000[idx].cv_speed_state;
}

float it6000_get_power_high( int idx ) 
{
	return it6000[idx].power_high;
}

float it6000_get_power_low( int idx ) 
{
	return it6000[idx].power_low;
}

float it6000_get_meter_v_rms( int idx ) 
{
	return it6000[idx].meter_v_rms;
}

float it6000_get_meter_i_rms( int idx ) 
{
	return it6000[idx].meter_i_rms;
}

float it6000_get_meter_p_rms( int idx ) 
{
	return it6000[idx].meter_p_rms;
}

int it6000_get_meter_op_reg( int idx ) 
{
	return it6000[idx].meter_op_reg;
}

int it6000_get_meter_state_reg( int idx ) 
{
	return it6000[idx].meter_state_reg;
}

int it6000_get_meter_ques_reg( int idx ) 
{
	return it6000[idx].meter_ques_reg;
}

int it6000_get_dc_ovp_enable( int idx ) 
{
	return it6000[idx].dc_ovp_enable;
}

float it6000_get_dc_ovp( int idx ) 
{
	return it6000[idx].dc_ovp;
}

float it6000_get_dc_ovp_delay( int idx ) 
{
	return it6000[idx].dc_ovp_delay;
}

int it6000_get_dc_ocp_enable( int idx ) 
{
	return it6000[idx].dc_ocp_enable;
}

float it6000_get_dc_ocp( int idx ) 
{
	return it6000[idx].dc_ocp;
}

float it6000_get_dc_ocp_delay( int idx ) 
{
	return it6000[idx].dc_ocp_delay;
}

int it6000_get_dc_opp_enable( int idx ) 
{
	return it6000[idx].dc_opp_enable;
}

float it6000_get_dc_opp( int idx ) 
{
	return it6000[idx].dc_opp;
}

float it6000_get_dc_opp_delay( int idx ) 
{
	return it6000[idx].dc_opp_delay;
}

int it6000_get_dc_ucp_enable( int idx ) 
{
	return it6000[idx].dc_ucp_enable;
}

float it6000_get_dc_ucp( int idx ) 
{
	return it6000[idx].dc_ucp;
}

float it6000_get_dc_ucp_delay( int idx ) 
{
	return it6000[idx].dc_ucp_delay;
}

float it6000_get_dc_ucp_warmup( int idx ) 
{
	return it6000[idx].dc_ucp_warmup;
}

int it6000_get_dc_uvp_enable( int idx ) 
{
	return it6000[idx].dc_uvp_enable;
}

float it6000_get_dc_uvp( int idx ) 
{
	return it6000[idx].dc_uvp;
}

float it6000_get_dc_uvp_delay( int idx ) 
{
	return it6000[idx].dc_uvp_delay;
}

float it6000_get_dc_uvp_warmup( int idx ) 
{
	return it6000[idx].dc_uvp_warmup;
}

int it6000_get_sw_prot( int idx ) 
{
	return it6000[idx].sw_prot;
}

int it6000_get_hw_prot( int idx ) 
{
	return it6000[idx].hw_prot;
}

static void it6000_update(int idx)
{
    struct it6000_t* dev = &it6000[idx];

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

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

    it6000_set_bsytikchk_en(idx, 1);
    it6000_sm_init(1);
    it6000_comm_init(1);
    while(1){
        it6000_comm_dac(1);
        it6000_sm(1);
        it6000_update(1);
        usleep(10000); /* 10ms */
    }
    log_dbg("%s, --",__func__);
}

static void* it6000_thrd_aux(void* param)
{
    int idx = 1;
    struct it6000_t* dev = &it6000[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 it6000_init()
{
    pthread_t thrd;
    int ret = 0;
    int result;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3* db = NULL;
    struct it6000_t* dev = &it6000[1];

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

    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"select * from it6000");
    cbparam.nrow = 0;
	result = sqlite3_exec(db,sql, it6000_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, it6000_thrd_main, NULL) != 0){
            log_dbg( "%s, create it6000 thrd main fail", __func__);
            ret = -1;
        }else if(pthread_create(&thrd, NULL, it6000_thrd_aux, NULL) != 0){
            log_dbg( "%s, create it6000 thrd aux fail", __func__);
            ret = -1;
        }       
	 }

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

int it6000_send_sm_cmd( int idx, int val )
{
    int ret = 0;
    struct it6000_t* dev = &it6000[idx];

    dev->cmd = val;

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

int it6000_set_aps(int idx, int aps)
{
    struct it6000_t* dev = &it6000[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 it6000_reset_aps(int idx)
{
    struct it6000_t* dev = &it6000[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 it6000_get_aps(int idx)
{
    return it6000[idx].pow.aps;
}

int it6000_get_last_aps(int idx)
{
    return it6000[idx].pow.last_aps;
}

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

int it6000_get_chan_idx(int idx)
{
    return it6000[idx].comm.chanidx;
}

int it6000_get_adr(int idx)
{
    return it6000[idx].comm.adr;
}

char* it6000_get_comm_state_str(int idx)
{
    return  it6000[idx].comm.szState;
}

double it6000_get_dac_ave(int idx)
{
    return  it6000[idx].comm.dac.timing_ave;
}

double it6000_get_dac_cur(int idx)
{
    return  it6000[idx].comm.dac.timing_cur;
}

double it6000_get_dac_max(int idx)
{
    return  it6000[idx].comm.dac.timing_max;
}

int it6000_get_dac_param_en(int idx)
{
    return it6000[idx].comm.dac.param_en;
}

char* it6000_get_info_str(int idx)
{
    return it6000[idx].szinfo;
}

struct it6000_t* it6000_get_all_data_ptr()
{
    return it6000;
}

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

    struct it6000_t* dev = &it6000[idx];
    struct statemachine_t* sm = &dev->sm;
    struct comm_t* comm = &dev->comm;
    char temp_buf[1000];
    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); 

    sprintf(temp_buf,"param vh_set:%.3f,vl_set:%.3f,aps:%d,aps_last:%d ",dev->Vh_set,dev->Vl_set,dev->pow.aps,dev->pow.last_aps);
    strcat(buf, temp_buf); 
    
    sprintf(temp_buf,"SysStatus:%s,dc_mode:%s,Iset:%.3f,v_high:%.3f,v_low:%.3f\n",
        dev->szSysStatus,dev->szDc_mode,it6000_get_dc_current(idx),it6000_get_dc_v_high(idx),it6000_get_dc_v_low(idx));
    strcat(buf, temp_buf); 

    sprintf(temp_buf,"ovp_e:%d,ovp:%.3f,uvp_e:%d,uvp:%.3f,ocp_e:%d,ocp:%.3f\n",
        it6000_get_dc_ovp_enable(idx),it6000_get_dc_ovp(idx),
        it6000_get_dc_uvp_enable(idx),it6000_get_dc_uvp(idx),
        it6000_get_dc_ocp_enable(idx),it6000_get_dc_ocp(idx));
    strcat(buf, temp_buf); 

    sprintf(temp_buf,"v_rms:%.3f,i_rms:%.3f,p_rms:%.3f\n",it6000_get_meter_v_rms(idx),it6000_get_meter_i_rms(idx),it6000_get_meter_p_rms(idx));
    strcat(buf, temp_buf);      
}

int it6000_get_ap( int idx )
{
    return it6000[idx].pow.ap;
}

int it6000_get_tbmqtt_main_data(int idx,char* buf)
{

    sprintf(buf,"'pcs_state':'%s','pcs_dc_v':%.3f,'pcs_dc_i':%.3f,'pcs_dc_p':%.3f",
        it6000_get_state_str(idx),it6000_get_meter_v_rms(idx),it6000_get_meter_i_rms(idx),it6000_get_meter_p_rms(idx));
}


int it6000_get_tbmqtt_secondy_data(int idx,char* buf)
{

    sprintf(buf, "'Vh':%.1f, 'Vl':%.1f, 'Iset':%.1f,'ovp':%.1f,'uvp':%.1f, 'ocp':%.1f", 
                it6000_get_dc_v_high(idx),it6000_get_dc_v_low(idx),it6000_get_dc_current(idx),
                it6000_get_dc_ovp(idx),it6000_get_dc_uvp(idx),it6000_get_dc_ocp(idx));
}


int it6000_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, it6000_get_state( idx ), 
//                 cnt_idx, it6000_get_runstat( idx ), 
//                 cnt_idx, it6000_get_dcv( idx ), 
//                 cnt_idx, it6000_get_dcc( idx ),
//                 cnt_idx, it6000_get_ac_brk( idx ),
//                 cnt_idx, it6000_get_dc_brk( idx ),
//                 cnt_idx, it6000_get_emg_btn( idx ),
//                 cnt_idx, it6000_get_errstat( idx ),
//                 cnt_idx, it6000_get_grid_freq( idx ),
//                 cnt_idx, it6000_get_ap( idx ));
}

int it6000_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, it6000_get_ua( idx ), 
//                 cnt_idx, it6000_get_ub( idx ), 
//                 cnt_idx, it6000_get_uc( idx ),
//                 cnt_idx, it6000_get_ia( idx ),
//                 cnt_idx, it6000_get_ib( idx ),
//                 cnt_idx, it6000_get_ic( idx ),
//                 cnt_idx, it6000_get_grid_freq( idx ),
//                 cnt_idx, it6000_get_temp_igbt_a( idx ),
//                 cnt_idx, it6000_get_temp_igbt_b( idx ),
//                 cnt_idx, it6000_get_temp_igbt_c( idx ),
//                 cnt_idx, it6000_get_temp_reactor( idx ),
//                 cnt_idx, it6000_get_temp_env( idx ));
}