ctnd/platform/device/ctn/cess2000.c

#include "plt.h"

struct cess2000_t cess2000[CESS2000_NBR_MAX + 1];

int cess2000_enable_pcs_bsytiksnd(int idx)
{
    cess2000[idx].pcstik.en = 1;
    return 0;
}

int cess2000_disable_pcs_bsytiksnd(int idx) 
{
    cess2000[idx].pcstik.en = 0;
    return 0;
}

int cess2000_get_pcs_bsytiksnd_en(int idx)
{
    return cess2000[idx].pcstik.en;
}

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

int cess2000_enable_bsytikchk(int idx)
{
    cess2000[idx].bsytik.en = 1;
    return 0;
}

int cess2000_disable_bsytikchk(int idx)
{
    cess2000[idx].bsytik.en = 0;
    return 0;
}

int cess2000_get_bsytikchk_en(int idx)
{
    return cess2000[idx].bsytik.en;
}

int cess2000_get_bsytikchk_from_host(int idx)
{
    return cess2000[idx].bsytik.from_host;
}

int cess2000_get_bsytikchk_timeout(int idx)
{
    return cess2000[idx].bsytik.timeout;
}

static double cess2000_get_timeofday()
{
    struct  timeval    tv;
    struct  timezone   tz;
    gettimeofday(&tv,&tz);
    return (double)tv.tv_sec * 1000 + (double)tv.tv_usec/1000;  
}

static int cess2000_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct cess2000_t* dev = &cess2000[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("chan_idx",columnname[i]) == 0){
            dev->chan_idx = atoi(columnvalue[i]);
        }else if( strcmp("norm_cap",columnname[i]) == 0){
            dev->pow.norm_cap = atoi(columnvalue[i]);
        }else if( strcmp("norm_pow",columnname[i]) == 0){
            dev->pow.norm_pow = atoi(columnvalue[i]);
        }else if( strcmp("min_pow",columnname[i]) == 0){
            dev->pow.min_pow = atoi(columnvalue[i]);
        }else if( strcmp("socc",columnname[i]) == 0){
            dev->socc = atof(columnvalue[i]);
        }else if( strcmp("socd",columnname[i]) == 0){
            dev->socd = atof(columnvalue[i]);
        }else if( strcmp("cell_otp",columnname[i]) == 0){
            dev->cell_otp = atoi(columnvalue[i]);
        }else if( strcmp("cell_utp",columnname[i]) == 0){
            dev->cell_utp = atoi(columnvalue[i]);
        }else if( strcmp("modbus_tcp_slave_port",columnname[i]) == 0){
            dev->modbus_tcp_slave_port = atoi(columnvalue[i]);
        }else if( strcmp("modbus_tcp_slave_port_EMA",columnname[i]) == 0){
            dev->modbus_tcp_slave_port_EMA = atoi(columnvalue[i]);
        }
    }

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

void cess2000_set_state(int idx, int state, int err)
{
    sm_set_state(&cess2000[idx].sm, state, err);
}

int cess2000_get_state( int idx )
{
    return cess2000[idx].sm.state;
}

int cess2000_get_step( int idx )
{
    return cess2000[idx].sm.step;
}

int cess2000_get_tick( int idx )
{
    return cess2000[idx].sm.tick;
}

double cess2000_get_tick_ave( int idx )
{
    return cess2000[idx].sm.timing_ave;
}

double cess2000_get_tick_cur( int idx )
{
    return cess2000[idx].sm.timing_cur;
}

double cess2000_get_tick_max( int idx )
{
    return cess2000[idx].sm.timing_max;
}


char* cess2000_get_state_str( int idx )
{
    return cess2000[idx].sm.szState;
}

char* cess2000_get_err_str( int idx )
{
    return cess2000[idx].sm.szerr;
}

int cess2000_get_err( int idx )
{
    return cess2000[idx].sm.err;
}

int cess2000_set_aps(int idx, int aps)
{
    struct cess2000_t* dev = &cess2000[idx];
    int ret = 0;

    dev->pow.last_aps = dev->pow.aps;
    dev->pow.aps = aps;

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

int cess2000_reset_aps(int idx)
{
    struct cess2000_t* dev = &cess2000[idx];
    int ret = 0;

    dev->pow.last_aps = 0;
    dev->pow.aps = 0;

    return ret;
}

int cess2000_get_ap(int idx)
{
    return cess2000[idx].pow.ap;
}

int cess2000_get_dhgable(int idx)
{
    return cess2000[idx].pow.bdhgable;
}

void cess2000_set_dhgable(int idx, int val)
{
    cess2000[idx].pow.bdhgable = val;
}

int cess2000_get_chgable(int idx)
{
    return cess2000[idx].pow.bchgable;
}

void cess2000_set_chgable(int idx, int val)
{
    cess2000[idx].pow.bchgable = val;
}

int cess2000_get_aps(int idx)
{
    return cess2000[idx].pow.aps;
}

int cess2000_get_last_aps(int idx)
{
    return cess2000[idx].pow.last_aps;
}

double cess2000_get_soc(int idx)
{
    return cess2000[idx].pow.soc;
}

int cess2000_get_norm_cap(int idx)
{
    return cess2000[idx].pow.norm_cap;
}

int cess2000_get_norm_pow(int idx)
{
    return cess2000[idx].pow.norm_pow;
}

int cess2000_get_min_pow(int idx)
{
    return cess2000[idx].pow.min_pow;
}

int cess2000_send_cmd( int idx, int cmd )
{
    int ret = 0;

    cess2000[idx].cmd = cmd;

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

/*************************************
static void cess2000_usleep(unsigned int nusecs)
{
    struct timeval    tval;
 
    tval.tv_sec = nusecs / 1000000;
    tval.tv_usec = nusecs % 1000000;
    select(0, NULL, NULL, NULL, &tval);
}
*************************************/

static void cess2000_update(int idx)
{
    struct cess2000_t* dev = &cess2000[idx];
    struct statemachine_t* sm = &dev->sm;

    dev->pow.ap = pcs_get_ap();
    dev->pow.soc = pack_get_soc();    
}

static void cess2000_aux(int idx)
{
    struct cess2000_t* dev = &cess2000[idx];
    struct statemachine_t* sm = &dev->sm;


        if( dev->bsytik.timer++ >= 100 ){ 
            dev->bsytik.timer = 0;
            if( dev->bsytik.last_from_host != dev->bsytik.from_host ){
                dev->bsytik.last_from_host = dev->bsytik.from_host;
                dev->bsytik.chkcnt = 0;
            }else{
                if( dev->bsytik.chkcnt++ >= 5){
                    dev->bsytik.timeout = 1;
                }
            }
        }
    
    
    if( cess2000_get_pcs_bsytiksnd_en(idx) ){
        if( dev->pcstik.timer++ >= 100 ){ // 1s
            dev->pcstik.timer = 0;
            pcs_set_bsytik();
        }
    }

}

static void* cess2000_thrd_main( void* param )
{
    struct cess2000_t* dev = &cess2000[1];

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

    cess2000_set_dhgable(1, 1);
    cess2000_set_chgable(1, 1);
    cess2000_enable_bsytikchk(1);
    cess2000_disable_pcs_bsytiksnd(1);

    cess2000_sm_init(1);
    while( 1 ){
        cess2000_sm(1);
        cess2000_update(1);
        cess2000_aux(1);
        usleep(10000); /* 10ms */
    }

    log_dbg("%s, --",__func__);
    return NULL;
}

//static void cess2000_task(int signo){
//    cess2000_sm( 1 );
//}

//static void cess2000_init_sigaction(){
//    struct sigaction act;
//    act.sa_handler = cess2000_task;
//    act.sa_flags = 0;
//    sigemptyset(&act.sa_mask); 
//    sigaction(SIGPROF,&act,NULL); //设置信号 SIGPROF 的处理函数为 print_info
//}

//static void cess2000_init_timer() 
//{ 
//    struct itimerval value; 
//    value.it_value.tv_sec = 0; 
//    value.it_value.tv_usec = 10000; 
//    value.it_interval=value.it_value; 
//    setitimer(ITIMER_PROF,&value,NULL); 
//}

/********************************************
static int cess2000_init_timer2()
{
    struct sigevent evp;
    struct itimerspec ts;
    timer_t timer;
    int ret;
    memset(&evp, 0, sizeof(evp));
    evp.sigev_value.sival_ptr = &timer;
    evp.sigev_notify = SIGEV_THREAD;
    evp.sigev_notify_function = cess2000_task;
    evp.sigev_value.sival_int = 3;   //作为handle()的参数
    ret = timer_create(CLOCK_REALTIME, &evp, &timer);
    if( ret){
        perror("timer_create");
    }
   
    ts.it_interval.tv_sec = 0;
    ts.it_interval.tv_nsec = 10000000;
    ts.it_value.tv_sec = 0;
    ts.it_value.tv_nsec = 10000000;
    ret = timer_settime(timer, TIMER_ABSTIME, &ts, NULL);
    if( ret )
    {
        perror("timer_settime");
    }
}
*************************************************/

int cess2000_get_cmd( int idx )
{
    return cess2000[idx].cmd;
}

void cess2000_reset_cmd(int idx)
{
    cess2000[idx].cmd = CMD_SM_DONE;
}

int cess2000_init( void )
{
    pthread_t thrd;
    char buf[32];
    int result;
    char *errmsg = NULL;
    sqlite3* db = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    int ret = 0;
    struct cess2000_t* dev = &cess2000[1];

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

    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"select * from cess2000");
    cbparam.nrow = 0;
	result = sqlite3_exec(db,sql, cess2000_dbcb_0,(void*)&cbparam,&errmsg);
    plt_unlock_ctndb();
	if( result != SQLITE_OK ){
        log_dbg("%s, result != SQLITE_OK : %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{
        //chan_set_mbs(dev->chan_idx, DEVM_CESS2000, 1);
        //chan_set_en(dev->chan_idx, 1);
        if(pthread_create(&thrd,NULL, cess2000_thrd_main, NULL)!=0){
            log_dbg("%s, create cess2000 thrd main fail", __func__);
            ret = -1;
        }
	 }

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

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

int cess2000_set_socd(int idx, double val)
{
    cess2000[idx].socd = val;
    return 0;
}

int cess2000_set_socc(int idx, double val)
{
    cess2000[idx].socc = val;
    return 0;
}

double cess2000_get_socd(int idx)
{
    return cess2000[idx].socd;
}

double cess2000_get_socc(int idx)
{
    return cess2000[idx].socc;
}

int cess2000_get_cell_otp(int idx)
{
    return cess2000[idx].cell_otp;
}

int cess2000_get_cell_utp(int idx)
{
    return cess2000[idx].cell_utp;
}


int cess2000_cfg_save_socc(int idx)
{
    sqlite3* db = NULL;
    char sql[1024];
    int result = 0;
    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"update cess2000 set socc=%d where idx=1",(int)cess2000_get_socc(idx));
	result = sqlite3_exec(db,sql, NULL,NULL,NULL);
    plt_unlock_ctndb();
    if(result == SQLITE_OK){
        return 0;
    }else{
        return -1;
    }
}

int cess2000_cfg_save_socd(int idx)
{
    sqlite3* db = NULL;
    char sql[1024];
    int result = 0;
    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"update cess2000 set socd=%d where idx=1",(int)cess2000_get_socd(idx));
	result = sqlite3_exec(db,sql, NULL,NULL,NULL);
    plt_unlock_ctndb();
    if(result == SQLITE_OK){
        return 0;
    }else{
        return -1;
    }
}

int cess2000_get_tool_data(int idx,char* buf)
{
    struct cess2000_t* dev = &cess2000[idx];
    struct statemachine_t* sm = &dev->sm;
    char buf_temp[1024];
    if(idx < 1 || idx > CESS2000_NBR_MAX )
        return -1;

    sprintf(buf, " norm_cap:%d norm_pow:%d min_pow:%d\n", dev->pow.norm_cap, dev->pow.norm_pow, dev->pow.min_pow);
    sm_get_summary(sm, buf_temp, sizeof(buf_temp));
    strcat(buf,buf_temp);

    sprintf(buf_temp," ap:"L_GREEN"%d"NONE" aps:%d soc:"L_GREEN"%.1f"NONE" dhgable:%d chgable:%d socd:%.1f socc:%.1f cell_otp:%d utp:%d",
                    dev->pow.ap, dev->pow.aps, dev->pow.soc,
                    dev->pow.bdhgable,dev->pow.bchgable, dev->socd, dev->socc, dev->cell_otp, dev->cell_utp);    
    strcat(buf,buf_temp);

    sprintf(buf_temp," bsytik_en:%d from_host:%03d tiemout:%d pcs_bsytik_en:%d\n", 
        dev->bsytik.en, dev->bsytik.from_host, dev->bsytik.timeout,
        dev->pcstik.en);
    strcat(buf,buf_temp); 

    return 0;
}

unsigned short cess2000_get_cmd_param1(int idx)
{
    return cess2000[idx].cmdpara[0];
}

unsigned short cess2000_get_cmd_param2(int idx)
{
    return cess2000[idx].cmdpara[1];
}

unsigned short cess2000_get_cmd_param3(int idx)
{
    return cess2000[idx].cmdpara[2];
}

unsigned short cess2000_get_cmd_param4(int idx)
{
    return cess2000[idx].cmdpara[3];
}

int cess2000_set_cmd(int idx,int cmd)
{
    cess2000[idx].cmd = cmd;
	return 0;
}

int cess2000_set_cmd_param1(int idx,unsigned short param)
{
    cess2000[idx].cmdpara[0] = param;
	return 0;
}

int cess2000_set_cmd_param2(int idx,unsigned short param)
{
    cess2000[idx].cmdpara[1] = param;
	return 0;
}

int cess2000_set_cmd_param3(int idx,unsigned short param)
{
    cess2000[idx].cmdpara[2] = param;
	return 0;
}

int cess2000_set_cmd_param4(int idx,unsigned short param)
{
    cess2000[idx].cmdpara[3] = param;
	return 0;
}

int cess2000_set_bsytikchk_from_host(int idx,unsigned char tick)
{
    cess2000[idx].bsytik.from_host = tick;
    return 0;
}