SmartPDCode/pro/src/paras.c

#include <stdlib.h>
#include <stdio.h>
#include "sys.h"
#include "file.h"
#include "lock.h"
#include "paras.h"
#include "cascade.h"
#include "dictionary.h"
#include "iniparser.h"


#if 1
    #define LOGD            log_d
    #define LOGE            log_e
    #define LOGW            log_w
#else
    #define LOGD            printf
    #define LOGE            printf
    #define LOGW            printf
#endif

enum {
    INI_READ=0,
    INI_WRITE,
};

extern GlobalDeviceInfo DFLT_PARAS;

typedef struct {
    dictionary          *dic;
    GlobalDeviceInfo    *info;
    char                path[200];
}paras_handle_t;
static paras_handle_t  paraHandle={0};


#if 1


static int ini_rw_dev(dictionary *dic, int rw, GlobalDeviceInfo *info)
{
    int r=-1,ok=1;
    char *p=NULL;
    char temp[100];
    char *token=NULL;

    if(info->product.language>=4) {
        LOGE("___ product.language %d is wrong\n", info->product.language);
        ok = 0;
    }
    if(info->product.type>=2) {
        LOGE("___ product.type %d is wrong\n", info->product.type);
        ok = 0;
    }
    if(info->product.pwr_type>SmartPDU_Tree_AC_One_B) {
        LOGE("___ product.pwr_type %d is wrong\n", info->product.pwr_type);
        ok = 0;
    }
    if(!ok) {
        return -1;
    }

    token = "product:id";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product.id = r;
    }
    else {
        sprintf(temp, "%d", info->product.id);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:number";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product.number, p);
    }
    else {
        r = iniparser_set(dic, token, info->product.number);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
    
    token = "product:name";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product.name, p);
    }
    else {
        r = iniparser_set(dic, token, info->product.name);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
    
    token = "product:type";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product.type = r;
    }
    else {
        sprintf(temp, "%d", info->product.type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:pwrtype";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product.pwr_type = r;
    }
    else {
        sprintf(temp, "%d", info->product.pwr_type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

#if 0
    token = "product:version";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product.version, p);
    }
    else {
        r = iniparser_set(dic, token, info->product.version);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
#endif

    token = "product:language";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product.language = r;
    }
    else {
        sprintf(temp, "%d", info->product.language);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:samptime";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product.samp_time = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product.samp_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:savetime";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product.save_time = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product.save_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:ph_group";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product.ph_group = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product.ph_group);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:ch_delay";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product.ch_delay = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product.ch_delay);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    if(rw==INI_READ) {
        info->product.count = 0;
        info->product.status[0] = 0;
    }
    
    return 0;
}
static int ini_rw_modbus(dictionary *dic, int rw, GlobalDeviceInfo *info)
{
    int r=-1;
    char temp[100];
    char *token=NULL;
    ModbusInfo_t *mb=&info->cascade;

    if(rw==INI_WRITE) {
        if(mb->mode!=0 && mb->mode!=1) {
            LOGE("___ set modbus, mode %d is invalid\n", mb->mode);
            return -1; 
        }

        if(mb->mode==1 && (mb->addr==0 || mb->addr>CASCADE_MAX)) {    //slave
            LOGE("___ set modbus, slave addr %d is invalid\n", mb->addr);
        }
    }

    token = "modbus:mode";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->mode = r;
    }
    else {
        sprintf(temp, "%d", mb->mode);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:address";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->addr = r;
    }
    else {
        sprintf(temp, "%d", mb->addr);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:baudrate";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->baudrate = r;
    }
    else {
        sprintf(temp, "%d", mb->baudrate);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    return 0;
}

static int ini_rw_ptotal(dictionary *dic, int rw, PowerTotal_t *ptotal)
{
    int r=-1;
    char temp[100];
    char *token=NULL;

    if(rw==INI_WRITE) {
        if(ptotal->voltage<=0 || ptotal->current<=0 || ptotal->power<=0 || ptotal->brdMax<=0) {
            LOGE("___ set ptotal, paras is invalid\n");
            return -1; 
        }
    }

    token = "ptotal:voltage";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        ptotal->voltage = r;
    }
    else {
        sprintf(temp, "%d", ptotal->voltage);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "ptotal:current";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        ptotal->current = r;
    }
    else {
        sprintf(temp, "%d", ptotal->current);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "ptotal:power";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        ptotal->power = r;
    }
    else {
        sprintf(temp, "%d", ptotal->power);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "ptotal:brd_max";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        ptotal->brdMax = r;
    }
    else {
        sprintf(temp, "%d", ptotal->brdMax);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    return 0;
}



static dictionary* ini_load(char *path, GlobalDeviceInfo *info)
{
    int r=-1;
    char temp[200];
    
    dictionary *dic=iniparser_load(path);
    if(dic == NULL){
        return NULL;
    }
    
    r = ini_rw_dev(dic, INI_READ, info);
    if(r) {
        LOGE("___ini_r_dev failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    r = ini_rw_modbus(dic, INI_READ, info);
    if(r) {
        LOGE("___ini_r_modbus failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    r = ini_rw_ptotal(dic, INI_READ, &info->ptotal);
    if(r) {
        LOGE("___ini_r_modbus failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    return dic;
}
static int ini_check(char *path)
{
    GlobalDeviceInfo info=DFLT_PARAS;
    dictionary *dic=ini_load(path, &info);

    if(!dic) {
        return -1;
    }
    iniparser_freedict(dic);

    return 0;
}
static int ini_reset(paras_handle_t *h)
{
    int r;
    FILE *fp=NULL;
    char tmp[200];
    GlobalDeviceInfo *info=&DFLT_PARAS;

    fp = fopen(h->path, "w");
    if (fp==NULL) {
        LOGE("ini_reset, fopen %s failed\n", h->path);
        return -1;
    }

    fprintf(fp, "[product]\n");
    fprintf(fp, "id          = \"%d\"\n", info->product.id);
    fprintf(fp, "number      = \"%s\"\n", info->product.number);
    fprintf(fp, "name        = \"%s\"\n", info->product.name);
    fprintf(fp, "type        = \"%d\"\n", info->product.type);
    fprintf(fp, "pwrtype     = \"%d\"\n", info->product.pwr_type);
    //fprintf(fp, "version     = %s\\"n", info->product.version);
    fprintf(fp, "language    = \"%d\"\n", info->product.language);
    fprintf(fp, "samptime    = \"%d\"\n", info->product.samp_time);
    fprintf(fp, "savetime    = \"%d\"\n", info->product.save_time);
    fprintf(fp, "ph_group    = \"%d\"\n", info->product.ph_group);
    fprintf(fp, "ch_delay    = \"%d\"\n", info->product.ch_delay);
    fprintf(fp, "\n");

    fprintf(fp, "[modbus]\n");
    fprintf(fp, "mode        = \"%d\"\n", info->cascade.mode);
    fprintf(fp, "address     = \"%d\"\n", info->cascade.addr);
    fprintf(fp, "baudrate    = \"%d\"\n", info->cascade.baudrate);
    fprintf(fp, "\n");

    fprintf(fp, "[ptotal]\n");
    fprintf(fp, "voltage     = \"%d\"\n", info->ptotal.voltage);
    fprintf(fp, "current     = \"%d\"\n", info->ptotal.current);
    fprintf(fp, "power       = \"%d\"\n", info->ptotal.power);
    fprintf(fp, "brd_max     = \"%d\"\n", info->ptotal.brdMax);
    fprintf(fp, "\n");

    fclose(fp);

    sys_get_path(tmp, INI_FILE_BAK_NAME);
    file_copy(tmp, h->path);

    if(h->dic) {
        iniparser_freedict(h->dic);
    }
    h->dic = ini_load(h->path, h->info);

    return 0;
}
static int ini_free(paras_handle_t *h)
{
    iniparser_freedict(h->dic);
    return 0;
}
static int ini_save(paras_handle_t *h)
{
    int r=-1;
    
    r = ini_rw_dev(h->dic, INI_WRITE, h->info);
    if(r) {
        LOGE("___ini_w_dev failed\n");
        return -1;
    }

    r = ini_rw_modbus(h->dic, INI_WRITE, h->info);
    if(r) {
        LOGE("___ini_w_modbus failed\n");
        return -1;
    }

    FILE *fp=fopen(h->path, "w");
    if(!fp) {
        LOGE("___%s open failed\n", h->path);
        return -1;
    }
    iniparser_dump_ini(h->dic, fp);
    fclose(fp);

    return 0;
}
#endif

static GlobalDeviceInfo *get_info(void)
{
    return &__globalDeviceManage._globalDevInfo;
}
////////////////////////////////////////////////////////////


int paras_init(void)
{
    int r=0;
    paras_handle_t  *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    memset(&paraHandle, 0, sizeof(paraHandle));
    h->info = get_info();
    sys_get_path(h->path, INI_FILE_NAME);
    h->dic = ini_load(h->path, h->info);
    if(h->dic==NULL) {
        r = ini_reset(h);
    }
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_deinit(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_free(h);
    lock_s_release(LOCK_ID_PARAS);
    
    return 0;
}


int paras_check(char *path)
{
    int r=0;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_check(path);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_load(char *path)
{
    int r=-1;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_free(h);
    h->dic = ini_load(path, h->info);
    if(h->dic) r = 0;
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_reset(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_reset(h);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_copy(char *dst, char *src)
{
    int r=-1;

    lock_s_hold(LOCK_ID_PARAS);
    r = file_copy(dst, src);
    lock_s_release(LOCK_ID_PARAS);

    return r;
}


int paras_save(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_save(h);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}