ctnd/platform/device/ac/mc90hdnc1a/mc90hdnc1a.c

#include "plt.h"


int mc90hdnc1a_nbr;
struct mc90hdnc1a_t mc90hdnc1a[MC90HDNC1A_NBR_MAX + 1];

int mc90hdnc1a_send_sm_cmd( int idx, int cmd )
{
    int ret = 0;
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    dev->cmd = cmd;
    log_dbg("%s, idx:%d, cmd:%d, ret:%d", __func__, idx, cmd, ret);
    return ret;
}

int mc90hdnc1a_send_sm_cmd_all( int cmd )
{
    int ret = 0;
    int idx;
    struct mc90hdnc1a_t* dev = NULL;
    for( idx = 1; idx <= mc90hdnc1a_nbr; idx++ ){
        mc90hdnc1a_send_sm_cmd( idx, cmd );
    }
    return ret;
}

int mc90hdnc1a_chk_state_all( int stat)
{
    int idx;
    for( idx = 1; idx <= mc90hdnc1a_nbr; idx++){
        if( mc90hdnc1a_get_state(idx) != stat){
            return -1;
        }
    }
    return 0;
}

int mc90hdnc1a_get_cmd( int idx )
{
    return mc90hdnc1a[idx].cmd;
}

void mc90hdnc1a_reset_cmd(int idx)
{
    mc90hdnc1a[idx].cmd = CMD_SM_DONE;
}

int mc90hdnc1a_get_state( int idx )
{
    return mc90hdnc1a[idx].sm.state;
}

static void* mc90hdnc1a_thrd_main(void* param)
{
    struct mc90hdnc1a_t* dev = NULL;
    int idx;

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

    for( idx = 1; idx <= mc90hdnc1a_nbr; idx++ ){
        mc90hdnc1a_sm_init(idx);
        mc90hdnc1a_comm_init(idx);
    }

	while(1){
        for( idx = 1; idx <= mc90hdnc1a_nbr; idx++ ){
            mc90hdnc1a_comm_dac(idx);
            mc90hdnc1a_sm(idx);
            usleep(100000); /* 100ms */
        }
	}

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

static int mc90hdnc1a_dbcb(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct mc90hdnc1a_t* pdev;
    int idx = 0;

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

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

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

int mc90hdnc1a_set_workstat(int idx, int stat)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    dev->dev_work_stat = stat;
    if( stat == 1 ){
        strcpy(dev->szdev_work_stat, "idle");
    }else if( stat == 2 ){
        strcpy(dev->szdev_work_stat, "run");
    }else if( stat == 3 ){
        strcpy(dev->szdev_work_stat, "err");
    }    

    return 0;
}

int mc90hdnc1a_get_workstat(int idx)
{
    return mc90hdnc1a[idx].dev_work_stat;
}

char* mc90hdnc1a_get_workstat_str(int idx)
{
    return mc90hdnc1a[idx].szdev_work_stat;
}

int mc90hdnc1a_set_infan_stat(int idx, int stat)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    dev->in_fan_stat = stat;
    if( stat == 1 ){
        strcpy(dev->szinfan_stat, "idle");
    }else if( stat == 2 ){
        strcpy(dev->szinfan_stat, "run");
    }else if( stat == 3 ){
        strcpy(dev->szinfan_stat, "err");
    }    

    return 0;
}

int mc90hdnc1a_get_infan_stat(int idx)
{
    return mc90hdnc1a[idx].in_fan_stat;
}

char* mc90hdnc1a_get_infan_stat_str(int idx)
{
    return mc90hdnc1a[idx].szinfan_stat;
}

int mc90hdnc1a_set_outfan_stat(int idx, int stat)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    dev->out_fan_stat = stat;
    if( stat == 1 ){
        strcpy(dev->szoutfan_stat, "idle");
    }else if( stat == 2 ){
        strcpy(dev->szoutfan_stat, "run");
    }else if( stat == 3 ){
        strcpy(dev->szoutfan_stat, "err");
    }    

    return 0;
}

int mc90hdnc1a_get_outfan_stat(int idx)
{
    return mc90hdnc1a[idx].out_fan_stat;
}

char* mc90hdnc1a_get_outfan_stat_str(int idx)
{
    return mc90hdnc1a[idx].szoutfan_stat;
}

int mc90hdnc1a_set_compstat(int idx, int stat)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    dev->comp_stat = stat;
    if( stat == 1 ){
        strcpy(dev->szcomp_stat, "idle");
    }else if( stat == 2 ){
        strcpy(dev->szcomp_stat, "run");
    }else if( stat == 3 ){
        strcpy(dev->szcomp_stat, "err");
    }    

    return 0;
}

int mc90hdnc1a_get_cmp_stat(int idx)
{
    return mc90hdnc1a[idx].comp_stat;
}

char* mc90hdnc1a_get_cmp_stat_str(int idx)
{
    return mc90hdnc1a[idx].szcomp_stat;
}

int mc90hdnc1a_set_rtnwind_temp(int idx, int val)
{
    mc90hdnc1a[idx].rtnwind_temp = val;
    return 0;
}

int mc90hdnc1a_get_rtnwind_temp(int idx)
{
    return mc90hdnc1a[idx].rtnwind_temp;
}

int mc90hdnc1a_set_cond_temp(int idx, int val)
{
    mc90hdnc1a[idx].cond_temp = val;
    return 0;
}

int mc90hdnc1a_set_eva_temp(int idx, int val)
{
    mc90hdnc1a[idx].eva_temp = val;
    return 0;
}

int mc90hdnc1a_get_cond_temp(int idx)
{
    return mc90hdnc1a[idx].cond_temp;
}

int mc90hdnc1a_get_eva_temp(int idx)
{
    return mc90hdnc1a[idx].eva_temp;
}

int mc90hdnc1a_set_infan_spd(int idx, int val)
{
    mc90hdnc1a[idx].infan_spd = val;
    return 0;
}

int mc90hdnc1a_get_infan_spd(int idx)
{
    return mc90hdnc1a[idx].infan_spd;
}

int mc90hdnc1a_set_outfan_spd(int idx, int val)
{
    mc90hdnc1a[idx].outfan_spd = val;
    return 0;
}

int mc90hdnc1a_get_outfan_spd(int idx)
{
    return mc90hdnc1a[idx].outfan_spd;
}

int mc90hdnc1a_set_comp_start_temp(int idx, int val)
{
    mc90hdnc1a[idx].comp_start_temp = val;
    return 0;
}

int mc90hdnc1a_set_comp_gap_temp(int idx, int val)
{
    mc90hdnc1a[idx].comp_gap_temp = val;
    return 0;
}

int mc90hdnc1a_set_heat_start_temp(int idx, int val)
{
    mc90hdnc1a[idx].heat_start_temp = val;
    return 0;
}

int mc90hdnc1a_set_heat_gap_temp(int idx, int val)
{
    mc90hdnc1a[idx].heat_gap_temp = val;
    return 0;
}

int mc90hdnc1a_init( void )
{
    pthread_t thrd;
    int result = 0;
    int ret = 0;
    int idx = 0;
    struct mc90hdnc1a_t* dev = NULL ;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3* db = STA.cfg_db;

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

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

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

int mc90hdnc1a_get_addr( int idx )
{
    return mc90hdnc1a[idx].comm.adr;
}

int mc90hdnc1a_get_comm_st(int idx)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_state(comm);
}

int mc90hdnc1a_get_chan_idx(int idx)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_chan_idx(comm);
}

char* mc90hdnc1a_get_comm_st_str(int idx)
{
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_state_str(comm);
}

int mc90hdnc1a_get_tick(int idx)
{
    return mc90hdnc1a[idx].sm.tick;
}

int mc90hdnc1a_get_nbr()
{
    return mc90hdnc1a_nbr;
}

int mc90hdnc1a_get_tool_data(int idx,char* buf)
{
    if(idx < 1 || idx > mc90hdnc1a_nbr || buf == NULL)
        return -1;
    struct mc90hdnc1a_t* dev = &mc90hdnc1a[idx];
    struct statemachine_t* sm = &dev->sm;
    struct comm_t* comm = &dev->comm; 
    char buf_temp [1024];
    
    sm_get_summary(sm, buf_temp, sizeof(buf_temp));
    sprintf(buf," [%d] %s ", idx, buf_temp);

    comm_get_summary(comm, buf_temp, sizeof(buf_temp));
    strcat(buf, buf_temp); 

    sprintf(buf_temp,"work_stat:"L_GREEN"%s"NONE" comp_start_temp:%d gap:%d heat_start_temp:%d gap:%d ", 
                    dev->szdev_work_stat,
                    dev->comp_start_temp, dev->comp_gap_temp, dev->heat_start_temp, dev->heat_gap_temp);
    strcat(buf, buf_temp); 

    sprintf(buf_temp,"infan:%s outfan:%s comp:%s rtnwindtemp:"L_GREEN"%d"NONE" condtemp:%d evatemp:%d infanspd:%d outfanspd:%d\n",
            dev->szinfan_stat, dev->szoutfan_stat, dev->szcomp_stat, dev->rtnwind_temp, dev->cond_temp, dev->eva_temp, dev->infan_spd, dev->outfan_spd);  
    strcat(buf, buf_temp); 
    return 0;  
}

int mc90hdnc1a_get_tbmqtt_data(int idx,char* buf)
{
    sprintf(buf, "'ac%d_state':'%s', 'ac%d_if_state':'%s','ac%d_of_state':'%s', 'ac%d_cmp_state':'%s',\
'ac%d_rtn_t':%d, 'ac%d_cond_t':%d,'ac%d_eva_t':%d, 'ac%d_if_spd':%d,'ac%d_of_spd':%d", 
        idx, mc90hdnc1a_get_workstat_str(idx), 
        idx, mc90hdnc1a_get_infan_stat_str(idx),
        idx, mc90hdnc1a_get_outfan_stat_str(idx), 
        idx, mc90hdnc1a_get_cmp_stat_str(idx),
        idx, mc90hdnc1a_get_rtnwind_temp(idx),
        idx, mc90hdnc1a_get_cond_temp(idx),
        idx, mc90hdnc1a_get_eva_temp(idx),
        idx, mc90hdnc1a_get_infan_spd(idx),
        idx, mc90hdnc1a_get_outfan_spd(idx));    
}

int mc90hdnc1a_get_cloud_data(int ctn_idx,int idx,char* buf)
{
    sprintf(buf, "'device_id':'ac_%d', 'work_state':%d, 'if_state':%d,'of_state':%d, 'cmp_state':%d,\
'rtn_t':%d, 'cond_t':%d,'eva_t':%d, 'if_spd':%d,'of_spd':%d,'state':%d", 
        idx, mc90hdnc1a_get_workstat( idx ), 
        mc90hdnc1a_get_infan_stat( idx ),
        mc90hdnc1a_get_outfan_stat( idx ), 
        mc90hdnc1a_get_cmp_stat( idx ),
        mc90hdnc1a_get_rtnwind_temp( idx ),
        mc90hdnc1a_get_cond_temp( idx ),
        mc90hdnc1a_get_eva_temp( idx ),
        mc90hdnc1a_get_infan_spd( idx ),
        mc90hdnc1a_get_outfan_spd( idx ),
        mc90hdnc1a_get_state( idx ));

    return 0;
}

int mc90hdnc1a_get_bkds_data(int idx,char *buf)
{
    sprintf(buf,"\
\"info\":\"%d#\",\"model\":\"%s\",\"chan_idx\":%d,\"adr\":%d,\"state\":\"%s\",\
\"tick\":%d,\"if_state\":\"%s\",\"of_state\":\"%s\", \"cmp_state\":\"%s\",\"rtn_t\":%d,\
\"cond_t\":%d,\"eva_t\":%d, \"if_spd\":%d,\"of_spd\":%d\
",
        idx,"mc90hdnc1a",mc90hdnc1a_get_chan_idx( idx ),mc90hdnc1a_get_addr( idx ),mc90hdnc1a_get_workstat_str( idx ),
        mc90hdnc1a_get_tick( idx ),mc90hdnc1a_get_infan_stat_str( idx ),mc90hdnc1a_get_outfan_stat_str( idx ),mc90hdnc1a_get_cmp_stat_str( idx ),mc90hdnc1a_get_rtnwind_temp( idx ),
        mc90hdnc1a_get_cond_temp( idx ),mc90hdnc1a_get_eva_temp( idx ),mc90hdnc1a_get_infan_spd( idx ),mc90hdnc1a_get_outfan_spd( idx ));
}


int mc90hdnc1a_get_modbus_data(int idx,unsigned short* data)
{    
    struct mc90hdnc1a_t *dev = &mc90hdnc1a[idx];
    data[0] = (unsigned short)DEVM_MC90HDNC1A;
    data[1] = (unsigned short)1;
    data[2] = (unsigned short)dev->sm.state;
    data[3] = (unsigned short)dev->sm.step;
    data[4] = (unsigned short)dev->sm.err;
    data[5] = (unsigned short)dev->comm.adr;
    data[6] = (unsigned short)dev->comm.state;
    // data[7] = (unsigned short)dev->runmod;
    // data[8] = (unsigned short)dev->ctlMode;
    // data[9] = (unsigned short)dev->cool_temp;
    // data[10] = (unsigned short)dev->heat_temp;
    // data[11] = (unsigned short)dev->cool_gap_temp;
    // data[12] = (unsigned short)dev->heat_gap_temp;
    // data[13] = (unsigned short)dev->pump_gear;
    // data[14] = (unsigned short)dev->comp_gear;
    // data[15] = (unsigned short)dev->out_water_temp;
    // data[16] = (unsigned short)dev->in_water_temp;
    // data[17] = (unsigned short)dev->out_water_press;
    // data[18] = (unsigned short)dev->in_water_press;
    // data[19] = (unsigned short)dev->pump_speed;
    return 0;
}