ctnd/appl/snap/snap.c

#include "plt.h"
#include "snap.h"
#include "snap_abb.h"
struct snap_t snap;
static int snap_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct snap_t* s = &snap;

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

    for( i = 0; i < ncolumn; i++){
        if( strcmp("en",columnname[i]) == 0){
            s->enable = atoi(columnvalue[i]);
        }else if( strcmp("intv",columnname[i]) == 0){
            s->intv = atoi(columnvalue[i]);
        }else if( strcmp("keep_day",columnname[i]) == 0){
            s->keep_day = atoi(columnvalue[i]);
        }else if( strcmp("info",columnname[i]) == 0){
            strcpy(s->szinfo,columnvalue[i]);
        }
    }

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

int snap_day_diff(int year_start, int month_start, int day_start, int year_end, int month_end, int day_end)
{
	int y2, m2, d2;
	int y1, m1, d1;
	
	m1 = (month_start + 9) % 12;
	y1 = year_start - m1/10;
	d1 = 365*y1 + y1/4 - y1/100 + y1/400 + (m1*306 + 5)/10 + (day_start - 1);
 
	m2 = (month_end + 9) % 12;
	y2 = year_end - m2/10;
	d2 = 365*y2 + y2/4 - y2/100 + y2/400 + (m2*306 + 5)/10 + (day_end - 1);
	
	return (d2 - d1);
}

int snap_get_datetime(int* y, int* m, int* d, int* h, int* min, int* s)
{
    time_t timep;
    struct tm *tsp;
	int ret = 0;

    time(&timep);
    //tsp = gmtime(&timep);
    tsp = localtime(&timep);

    *y = 1900+tsp->tm_year;
    *m = 1+tsp->tm_mon;
    *d = tsp->tm_mday;
    *h = tsp->tm_hour;
    *min = tsp->tm_min;
    *s = tsp->tm_sec;

	return ret;
}

int snap_del_outofdate_file(char *basePath, int curryy, int currmm, int currdd, int keep_day)
{
    DIR *dir;
    struct dirent *ptr;
    char base[1000];
    char* p = NULL;
    char szyy[8];
    char szmm[8];
    char szdd[8];
    int yy, mm, dd;
    int day_diff;
    char szfile_todel[128];
    int diff_day;

    if( (dir=opendir(basePath)) == NULL ){
        //printf("opendir :%s, fail\n", basePath);
        return -1;
    }
    //printf("opendir :%s, ok\n", basePath);

    while ((ptr=readdir(dir)) != NULL){
        if(strcmp(ptr->d_name,".")==0 || strcmp(ptr->d_name,"..")==0){    ///current dir OR parrent dir
            continue;
        }else if(ptr->d_type == 8){    ///file
            //printf("get file:%s\n", ptr->d_name);
            p = ptr->d_name;
            if( strlen(ptr->d_name)==23 && p[4]=='-' && p[7]=='-' && p[13]=='-' && p[16]=='-'){
                strncpy(szyy, p, 4);
                strncpy(szmm, p+5, 2);
                strncpy(szdd, p+8, 2);
                yy = atoi(szyy);
                mm = atoi(szmm);
                dd = atoi(szdd);
                diff_day = snap_day_diff(yy, mm, dd, curryy, currmm, currdd);
                //printf("diff_day:%d\n", diff_day);
                if( diff_day > keep_day ){
                    sprintf(szfile_todel,"%s/%s",basePath, ptr->d_name);
                    remove(szfile_todel);
                    //printf("remove %s\n",szfile_todel);
                }
            }else{
                //printf("file format not match\n");
            }
        }else if(ptr->d_type == 10){    ///link file
            //printf("d_name:%s/%s\n",basePath,ptr->d_name);
        }else if(ptr->d_type == 4){    ///dir
            memset(base,'\0',sizeof(base));
            strcpy(base,basePath);
            strcat(base,"/");
            strcat(base,ptr->d_name);
            snap_del_outofdate_file(base, curryy, currmm, currdd, keep_day);
        }
    }
    closedir(dir);
    return 0;
}

int snap_deltest()
{
    snap_del_outofdate_file("../snap/", 2021, 12, 13, 3);
}

FILE* _fp_snap = NULL;
int snap_start()
{
    struct snap_t* s = &snap;
    int ret = 0;
    int y,m,d,h,min,ss;
    char szfn[128];

    snap_get_datetime( &y, &m, &d, &h, &min, &ss);
    // sprintf(s->szcurr_date, "%d-%02d-%02d", y,m,d);

    sprintf(szfn,"../snap/%d-%02d-%02d %02d-%02d-%02d.dat",y,m,d,h,min,ss);
    _fp_snap = fopen(szfn, "w+");
    if( _fp_snap == NULL){
        ret = -1;
    }else{
        fprintf(_fp_snap,"%s,%s,%s,%s,", "time","cpu_occupy","mem_occupy","disk_occupy"); /* 1 2 3 4 */    
        fprintf(_fp_snap,"%s,%s,%s,%s,%s,%s,", "state","err","ap","con_ap","load_ap","soc"); /* 5 6 7 8 */   
        fprintf(_fp_snap,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,", 
                         "pcs_runstat","pcs_ap", "pcs_errstat",
                         "pcs_dcv", "pcs_dcc",
                         "pcs_gridv", "pcs_ua", "pcs_ub", "pcs_uc","pcs_ia", "pcs_ib", "pcs_ic");
        fprintf(_fp_snap,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,", 
                "bms_hvstat",
                "bms_v",
                "bms_c",
                "bms_ap",
                "bms_sysstat",
                "bms_soc",
                "bms_nsub",
                "bms_cellvmax",
                "bms_cellvmin",
                "bms_cellvave",
                "bms_celltmax",
                "bms_celltmin",
                "bms_celltave",
                "bms_max_dhg_c",
                "bms_max_chg_c"); /* bms */ 
        fprintf(_fp_snap,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,", 
                "ac1_workstat",
                "ac1_comp",
                "ac1_rtntemp",
                "ac1_condtemp",
                "ac1_evatemp",
                "ac2_workstat",
                "ac2_comp",
                "ac2_rtntemp",
                "ac2_condtemp",
                "ac2_evatemp"); /* ac */      
        fprintf(_fp_snap,"%s,%s,%s,%s,%s,\
%s,%s,%s,%s,%s,", 
                "m1_state","m1_com_ap", "m1_com_ae","m1_pos_ae","m1_neg_ae",
                "m2_state","m2_com_ap", "m2_com_ae","m2_pos_ae","m2_neg_ae"); /* meter */       
        fprintf(_fp_snap,"%s,%s,%s,%s,", 
                "env1_temp",
                "env1_humi",                
                "env2_temp",
                "env2_humi"); /* env */     
        fprintf(_fp_snap,"%s\n", 
                "plc_transtemp"); /* plc */                                                            
        s->started = 0;  
    }    

    return ret ;
}

int snap_stop()
{
    if(_fp_snap != NULL){
        fclose(_fp_snap);
    }

    return 0;
}

int snap_run()
{
    int ret = 0;
    int y, m, d, h, min, s;
    #if 1

    snap_get_datetime( &y, &m, &d, &h, &min, &s);
    /* time and mac */
    fprintf(_fp_snap, "%02d:%02d:%02d,%.1f,%.1f,%.1f,", 
            h,min,s, mac_get_cpu_occupy_info(),mac_get_mem_occupy_info(),mac_get_disk_occupy_info());  
    /* sys */        
    fprintf(_fp_snap,"%s,%s,%d,%d,%d,%.1f,",
            cess2000_get_state_str(1),cess2000_get_err_str(1),cess2000_get_ap(1),
            ems_get_transf_con_ap(),ems_get_transf_load_ap(),
            cess2000_get_soc(1));
          
    /* pcs */     
    fprintf(_fp_snap, "%s,%d,%d,\
%d,%d,\
%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,",
                    pcs_get_runstat_str(), pcs_get_ap(), pcs_get_errstat(),
                    pcs_get_dcv(), pcs_get_dcc(),
                    pcs_get_gridv(), pcs_get_ua(),pcs_get_ub(),pcs_get_uc(),pcs_get_ia(),pcs_get_ib(),pcs_get_ic());   
    /* bms */
    fprintf(_fp_snap, "%s,%d,%d,%d,%s,%.1f,%d,%.3f,%.3f,%.3f,%d,%d,%d,%d,%d,",
            pack_get_hvstat(),
            pack_get_v(),
            pack_get_c(),
            pack_get_ap(),
            pack_get_sysstat_str(),
            pack_get_soc(),
            pack_get_nsub(),
            pack_get_cellvmax(),
            pack_get_cellvmin(),
            pack_get_cellvave(),
            pack_get_celltmax(),
            pack_get_celltmin(),
            pack_get_celltave(),
            pack_get_max_dhgc(),
            pack_get_max_chgc()); 

    /* ac */     
     fprintf(_fp_snap, "%s,%s,%d,%d,%d,%s,%s,%d,%d,%d,",
             ac_get_work_stat_str(1), ac_get_cmp_stat_str(1), ac_get_rtnwind_temp(1), ac_get_cond_temp(1), ac_get_eva_temp(1),
             ac_get_work_stat_str(2), ac_get_cmp_stat_str(2), ac_get_rtnwind_temp(2), ac_get_cond_temp(2), ac_get_eva_temp(2));    

    /* meter */     
    fprintf(_fp_snap, "%s,%d,%.1f,%.1f,%.1f,",
                meter_get_state_string(DEVM_DTSD1352, 1),
                meter_get_com_ap(DEVM_DTSD1352, 1), 
                meter_get_com_ae(DEVM_DTSD1352 ,1),
                meter_get_pos_ae(DEVM_DTSD1352 ,1),
                meter_get_neg_ae(DEVM_DTSD1352 ,1));   
    fprintf(_fp_snap, "%s,%d,%.1f,%.1f,%.1f,",
                meter_get_state_string(DEVM_DTSD1352, 2),
                meter_get_com_ap(DEVM_DTSD1352, 2), 
                meter_get_com_ae(DEVM_DTSD1352 ,2),
                meter_get_pos_ae(DEVM_DTSD1352 ,2),
                meter_get_neg_ae(DEVM_DTSD1352 ,2));                   
    /* env */     
    fprintf(_fp_snap, "%d,%d,%d,%d,",env_get_temp(DEVM_RS_WS_N,1), env_get_humi(DEVM_RS_WS_N,1),env_get_temp(DEVM_RS_WS_N,2), env_get_humi(DEVM_RS_WS_N,2));
    /* plc */     
    fprintf(_fp_snap, "%d",plc_get_transf_temp());                  
    fprintf(_fp_snap,"\n");   /* end of row */                     
    fflush(_fp_snap);
    #endif
    return 0;
}

int snap_init()
{
    int ret = 0;
    int rc;
    char *errmsg = NULL;
    sqlite3* db = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;        
    struct snap_t* s = &snap;

    plt_lock_cfgdb();
    db = plt_get_cfgdb();
    sprintf(sql,"select * from snap");
    cbparam.nrow = 0;
	rc = sqlite3_exec(db,sql, snap_dbcb_0,(void*)&cbparam,&errmsg);
    plt_unlock_cfgdb();
	if( rc != SQLITE_OK ){
        log_dbg("%s, result != SQLITE_OK", __func__ );
        ret = -1;
	 }else if( cbparam.ret != 0){
         log_dbg("%s, cbparam.ret != 0", __func__ );
        ret = -1;
	 }else{
        if( cbparam.nrow != 1 ){
            log_dbg("%s, cbparam.nrow(%d) != 1", __func__, cbparam.nrow );
            ret = -1;
        }else{
            s->timer = s->intv;
            s->started = 0;  
            s->datechk_timer = 0;
        }
	 }

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

void snap_exe()
{
    struct snap_t* s = &snap;
    char buf[16];
    int y,m,d,h,min,ss;
    if( s->enable == 0 ){
        return;
    }

    if( s->started == 0 ){
        snap_get_datetime( &y, &m, &d, &h, &min, &ss);
        sprintf(s->szcurr_date, "%d-%02d-%02d", y,m,d);

        if(strcmp(s->szinfo,"abb") == 0){
            if(snap_start_abb(&_fp_snap) == 0){
                s->started = 1;
            }else{
                s->enable = 0;
                s->started = 0;
                return;
            }
        }else{
            if( snap_start() == 0){
                s->started = 1;
            }else{
                s->enable = 0;
                return;
            }
        }  
    }else{
        if( s->datechk_timer++ >= 10 ){ /* chk every 10 seconds */
            s->datechk_timer = 0;
            snap_get_datetime( &y, &m, &d, &h, &min, &ss);
            sprintf(buf, "%d-%02d-%02d", y,m,d);
            if( strcmp(buf, s->szcurr_date) != 0 ){ /* new date */
                snap_stop();
                snap_del_outofdate_file("../snap/", y, m, d, s->keep_day);
                s->started = 0; /* start again at next second */
                return;
            }
        }
        if( s->timer++ >= s->intv ){
            s->timer = 0;
            if(strcmp(s->szinfo,"abb") == 0){
                snap_run_abb(_fp_snap);
            }else{
                snap_run();
            } 
        }        
    }
}

int snap_get_en()
{
    struct snap_t* s = &snap;
    return s->enable;
}

int snap_get_started()
{
    struct snap_t* s = &snap;
    return s->started;
}