SmartPDCode/pro/src/cascade.c

#include "cascade.h"
#include "common.h"
#include "elog.h"
#include "cfg.h"
#include "thread.h"
#include "switch_ctrl.h"
#include "modbus_handle.h"
#include "sqlite_handle.h"
#include "paras.h"

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

#define MB_MAX_LEN      250


//#define MB_PARA_SIM
//#define SLAVE_DATA_SIM


#ifdef MB_PARA_SIM
    #define MB_MASTER       0
#endif

typedef struct {
    
    int                 inited;
    pthread_mutex_t     mutex;          //used for list lock  
    pthread_mutex_t     lock;
    
    Modbus_Manger       m;
    int                 addr;
    slave_t             slaves[CASCADE_MAX+1];

    ModbusInfo_t        mInfo;
    modbus_mapping_t    *map;
    modbus_mapping_t    *map2;

    cmd_data_t          cmd;
    int                 scanAddr;

    slave_info_t        sInfo;      //current slave infomation

    handle_t            list;
}cascade_handle_t;

int cur_dev_addr=0;
static cascade_handle_t casHandle={.inited=0};
static void* cmd_thread(void *arg);

//////////////////////////////////////////////////
static inline GlobalDeviceManager* get_dm(void)
{
    return &__globalDeviceManage;
}
static inline GlobalDeviceManager* get_dm2(void)
{
    return &__globalDeviceManage2;
}
static inline ModbusInfo_t *get_mb(void)
{
#ifdef MB_PARA_SIM
    static ModbusInfo_t mbinfo={
    #if (MB_MASTER==1)
        .product_modbus_type=0,
    #else
        .product_modbus_type=1,
    #endif
        .product_modbus_addr=1,
        .product_modbus_baud=115200,
    };

    return &mbinfo;
#else
    return &get_dm()->_global_device_info->_gmodbus_info;
#endif
}
static int slave_init(cascade_handle_t *cas)
{
    int i;
    for(i=0; i<=CASCADE_MAX; i++) {
        cas->slaves[i].addr = -1;
        cas->slaves[i].err  = 0;
    }

    return 0;
}
static int slave_add(cascade_handle_t *cas, int addr)
{
    if(addr<0 || addr>CASCADE_MAX) {
        return -1;
    }

    cas->slaves[addr].addr = addr;
    cas->slaves[addr].err  = 0;
    return 0;
}
static int slave_rm(cascade_handle_t *cas, int addr)
{
    if(addr<0 || addr>CASCADE_MAX) {
        return -1;
    }

    cas->slaves[addr].addr = -1;
    cas->slaves[addr].err  = 0;
    return 0;
}

static int slave_cnt(cascade_handle_t *cas)
{
    int i,cnt=0;
    for(i=0; i<=CASCADE_MAX; i++) {
        if(cas->slaves[i].addr>0) {
            cnt++;
        }
    }
    return cnt;
}
static slave_t* slave_get(cascade_handle_t *cas, int addr)
{
    return &cas->slaves[addr];
}
static int slave_find(cascade_handle_t *cas, int addr)
{
    if(cas->slaves[addr].addr>0) {
        return 1;
    }
    return 0;
}
static int slave_get_info(cascade_handle_t *cas)
{
    int cnt=0,cnt2;
    GlobalDeviceManager *dm=get_dm();
    GlobalPowerManger *tmp=NULL;
    GlobalTreeACManager* tmp3=NULL;
    slave_info_t *info=&cas->sInfo;

    info->cnt=0;
    info->prod.product_type = dm->_global_device_info->product_type;
    info->prod.product_pwr_type = dm->_global_device_info->product_pwr_type;
    info->prod.product_id = dm->_global_device_info->product_id;

    list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
    {
        if(tmp->product_saddr==0) {
            continue;
        }

        info->ch[cnt].product_saddr = tmp->product_saddr;
        info->ch[cnt].product_ch_type = tmp->product_ch_type;
        info->ch[cnt].product_ch_addr = tmp->product_ch_addr;
        info->ch[cnt].product_ch_id = tmp->product_ch_id;
        info->ch[cnt].product_ch_status = tmp->product_ch_status;
        info->ch[cnt].start_delay = tmp->product_ch_start_delay;
        info->ch[cnt].stop_delay  = tmp->product_ch_stop_delay;
        if (tmp->product_ch_type==TREE_AC_TYPE) {
            cnt2 = 0;
            list_for_each_entry(tmp3, &tmp->list_Tree_AC, list_Tree_AC)
            {
                info->ch[cnt].pinfo[cnt2].power = tmp3->_PowerInfo;
                info->ch[cnt].pinfo[cnt2].phase.product_ph_id = tmp3->product_ph_id;
                info->ch[cnt].pinfo[cnt2].phase.product_ph_type = tmp3->product_ph_type;
                info->ch[cnt].pinfo[cnt2].phase.product_ph_outputType = tmp3->product_ph_outputType;
                info->ch[cnt].pinfo[cnt2].phase.product_ph_outputStatus = tmp3->product_ph_outputStatus;
                cnt2++;
            }
        }
        else {
            info->ch[cnt].pinfo[0].power = tmp->_PowerInfo;
        }
        cnt++;
    }
    info->cnt = cnt;
    LOGD("___ slave_get_info, cnt: %d\n", info->cnt);

    return 0;
}

static int get_pwr_info(int chId, GlobalPowerManger *power)
{
    int i;
    GlobalPowerManger *tmp=NULL;
    GlobalDeviceManager *dm=get_dm();

    list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
    {
        if(tmp->product_ch_id==chId) {
            power->product_id = dm->_global_device_info->product_id;
            power->product_ch_id = tmp->product_ch_id;
            strcpy(power->product_ch_name, tmp->product_ch_name);
            power->product_ch_type = tmp->product_ch_type;
            power->product_ch_status = tmp->product_ch_status;
            power->product_ch_start_delay = tmp->product_ch_start_delay;
            power->product_ch_stop_delay = tmp->product_ch_stop_delay;

            return 0;
        }
    }

    return -1;
}
static int slave_save(cascade_handle_t *cas)
{
    int r;
    GlobalPowerManger power;
    GlobalDeviceManager *dm=get_dm();

    if(cas->cmd.obj!=OBJ_CHANNEL) {
        return -1;
    }
    
    r = get_pwr_info(cas->cmd.chId, &power);
    if(r) {
        LOGE("____ get_pwr_info failed\n");
        return -1;
    }
    r = dev_update_power_manage_genera_info(dm->db, dm->_global_device_info->product_id, cas->cmd.chId, &power);

    return r;
}
/////////////////////////////////////////////////////////////////////////////////////////

static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32_t baud)
{
    int r;
    r = g_modbus_init(&cas->m, path, baud, type, addr, type?"master":"slave", 0);
    if(r==0 && type>0) {
        if(type>0) {
            LOGD("___ set slave addr: %d\n", addr);

            cas->addr = addr;
            g_modbus_set_slave(&cas->m, addr);
            cascade_slave_init();
        }
        else {
            cas->addr = 0;
        }
        cas->inited = 1;
    }
    else {
        LOGE("___ mb init failed, %s\n", modbus_strerror(errno));
    }

    return 0;
}
static int mb_deinit(cascade_handle_t *cas)
{
    g_modbus_deinit(&cas->m);
    return 0;
}
static int _mb_scan(cascade_handle_t *cas, int addr)
{
    int r;
    uint16_t tmp;

    //g_modbus_set_timeout(&cas->m, 100);
    r = g_modbus_read_x_reg(&cas->m, addr, CASCADE_REG_SCAN, 1, &tmp);
    //g_modbus_set_timeout(&cas->m, 1500);

    return r;
}
static int _mb_read(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
{
    int r;
    r = g_modbus_read_x_reg(&cas->m, addr, reg, cnt, data);
    if(r<0) {
        cas->slaves[addr].err++;
        if(cas->slaves[addr].err>ERR_MAX) {
            slave_rm(cas, addr);
        }
    }
    else {
        cas->slaves[addr].err = 0;
    }
    return r;
}
static int _mb_write(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
{
    int r;
    r = g_modbus_write_x_reg(&cas->m, addr, reg, cnt, data);
    if(r<0) {
        cas->slaves[addr].err++;
        if(cas->slaves[addr].err>ERR_MAX) {
            slave_rm(cas, addr);
        }
    }
    else {
        cas->slaves[addr].err = 0;
    }
    return r;
}
static int _mb_recv(cascade_handle_t *cas, uint8_t *buf)
{
    return g_modbus_receive(&cas->m, buf);
}
static int _mb_reply(cascade_handle_t *cas, uint8_t *buff, int reqlen, modbus_mapping_t *map)
{
    return g_modbus_reply(&cas->m, buff, reqlen, map);
}
////////////////////////////////////////////////////////////
static void print_data(uint8_t *data, int len)
{
    int i;
    for(i=0; i<len; i++) {
        LOGD("0x%02x, ", data[i]);
    }
    LOGD("\n");
}
static void print_cmd(char *s, cmd_data_t *cmd)
{
    int i;

    LOGD("__%s__ cmd.obj: %d\n",    s, cmd->obj);
    LOGD("__%s__ cmd.cmd: %d\n",    s, cmd->cmd);
    LOGD("__%s__ cmd.chId: %d\n",   s, cmd->chId);
    //LOGD("__%s__ cmd.time_s: %s\n", s, cmd->time_s);
    //LOGD("__%s__ cmd.time_e: %s\n", s, cmd->time_e);

    LOGD("\n");
}

static void memswap(uint8_t *buf, int len)
{
    int i;
    uint8_t tmp;

    for(i=0; i<len; i+=2) {
        tmp = buf[i];
        buf[i] = buf[i+1];
        buf[i+1] = tmp;
    }
}
static void memcpy_swap(uint8_t *dst, uint8_t *src, int len)
{
    int i;

    for(i=0; i<len; i+=2) {
        dst[i] = src[i+1];
        dst[i+1] = src[i];
    }
}
static int print_hdr(char *s, mb_hdr_t *h)
{
    LOGD("____%s___ h.addr: %d\n", s, h->addr);
    LOGD("____%s___ h.func: %d\n", s, h->func);
    LOGD("____%s___ h.reg: %d\n",  s, h->reg);
    LOGD("____%s___ h.regcnt: %d\n", s, h->regcnt);
    LOGD("____%s___ h.dlen: %d\n", s, h->dlen);
    LOGD("____%s___ h.data: %d\n", s, (int)h->data);
    LOGD("\n");

    return 0;
}
static int mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
{
    h->addr = data[0];
    h->func = data[1];
    h->reg  = data[2]<<8 | data[3];
    h->regcnt = data[4]<<8 | data[5];

    h->dlen = 0;
    h->data = NULL;
    if(datalen>8) {
        h->dlen = data[6];
        h->data = data+7;

        memswap(h->data, h->dlen+h->dlen%2);
    }
    //print_hdr("sss", h);

    return 0;
}
static int mb_read(cascade_handle_t *cas, int addr, data_t *d)
{
    int r=0,finish=0;
    int xlen,rlen=0,oncelen=MB_MAX_LEN;
    uint16_t buff[MODBUS_RTU_MAX_ADU_LENGTH];

    if(d->dlen<=0) {
        //LOGE("___ mb_read dlen %d is wrong!\n", d->dlen);
        return -1;
    }
    //LOGD("___ mb_read dlen: %d\n", d->dlen);

    while(1) {
        if(rlen+oncelen>d->dlen) {
            xlen = d->dlen-rlen;
        }
        else {
            xlen = oncelen;
        }
        xlen += xlen%2;

        r = _mb_read(cas, addr, CASCADE_REG_READ, buff, xlen/2);
        if(r<0) {
            LOGE("___ _mb_read failed, %s, rlen: %d\n", modbus_strerror(errno), rlen);
            return -1;
        }
        if(rlen+r*2>=d->dlen) {
            xlen = d->dlen-rlen;
            finish = 1;
        }
        else {
            xlen = r*2;
        }

        memcpy((char*)d->data+rlen, buff, xlen);
        rlen += xlen;

        if(finish) {
            break;
        }
    }
    
    return 0;
}
static int mb_write(cascade_handle_t *cas, int addr, data_t *d)
{
    int r=0;
    int xlen,wlen=0,oncelen=MB_MAX_LEN;
    uint16_t buff[MODBUS_RTU_MAX_ADU_LENGTH];

    if(d->dlen<=0) {
        //LOGE("___ mb_write dlen %d is wrong!\n", d->dlen);
        return -1;
    }
    //LOGD("___ mb_write dlen: %d\n", d->dlen);

    while(1) {
        if(wlen+oncelen>d->dlen) {
            xlen = d->dlen-wlen;
        }
        else {
            xlen = oncelen;
        }
        xlen += xlen%2;

        memcpy(buff, d->data+wlen, xlen);
        r = _mb_write(cas, addr, CASCADE_REG_WRITE, buff, xlen/2);
        if(r<0) {
            LOGE("___ _mb_write, addr: %d, reg: %d, cnt: %d, %s\n", addr, CASCADE_REG_WRITE, xlen/2, modbus_strerror(errno));
            return -1;
        }
        if(wlen+r*2>=d->dlen) {
            break;
        }
        else {
            xlen = r*2;
        }
        wlen += xlen;
    }
    
    return 0;
}
static int mb_write_read(cascade_handle_t *cas, int addr, data_t *wd, data_t *rd)
{
    int r=0;
    
    r = mb_write(cas, addr, wd);
    if(r==0) {
        r = mb_read(cas, addr, rd);
    }

    return r;
}
static int mb_receive(cascade_handle_t *cas)
{
    int r=-1,rc,rlen=0;
    mb_hdr_t h;
    uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
    static int sendlen=0;
    cmd_data_t *cmd=NULL;
    
    rc = _mb_recv(cas, buff);
    if(rc<0) {
        return -1;
    }
    mb_hdr(buff, rc, &h);

#if 1
    //do not know why slave can receive all address data
    if(h.addr>0 && h.addr!=cas->addr) {
        return -1;
    }
#endif

    switch(h.reg) {
        case CASCADE_REG_SCAN:
        {
            r = _mb_reply(cas, buff, rc, cas->map2);
        }
        break;

        case CASCADE_REG_WRITE:
        {
            if(h.data) {
                cmd = (cmd_data_t*)h.data;
                if(cmd->cmd>=CASCADE_CMD_GET_INFO) {
                    cas->cmd = *cmd;
                }
                sendlen = 0;
            }
            else {
                return -1;
            }

            switch(cmd->cmd) {
                case CASCADE_CMD_OPEN:
                case CASCADE_CMD_CLOSE:
                {
                    cmd_data_t *pcmd=malloc(sizeof(cmd_data_t));
                    if(pcmd) {
                        *pcmd = *cmd;
                        thread_start_simp(cmd_thread, pcmd, 4*MB);
                    }
                }
                break;

                case CASCADE_CMD_SAVE:
                case CASCADE_CMD_SAVE3:
                {
                    slave_save(cas);
                }
                break;
            }

            r = _mb_reply(cas, buff, rc, cas->map2);
        }
        break;

        case CASCADE_REG_READ:
        {
            cmd = &cas->cmd;

            //LOGD("____ CASCADE_REG_READ %d\n", cmd->cmd);
            switch(cmd->cmd) {

                case CASCADE_CMD_GET_INFO:
                {
                    LOGD("_____ slave CASCADE_CMD_GET_INFO\n");
                    slave_get_info(cas);
                    memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), (char*)&cas->sInfo+sendlen, h.regcnt*2);
                }
                break;

                case CASCADE_CMD_QUERY_CH:
                {
                    LOGD("___ slave CASCADE_CMD_QUERY_CH\n");

                    slave_get_info(cas);
                    memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->sInfo)+sendlen, h.regcnt*2);
                }
                break;

                case CASCADE_CMD_QUERY_VOL:break;
                case CASCADE_CMD_QUERY_CUR:break;
                case CASCADE_CMD_QUERY_PWR:break;
                case CASCADE_CMD_QUERY_PWRQ:break;
                case CASCADE_CMD_QUERY_HIS:break;
                case CASCADE_CMD_QUERY_TOTAL:break;
                case CASCADE_CMD_QUERY_TOTAL_PWR:break;
            }

            r = _mb_reply(cas, buff, rc, cas->map2);
            if(r>0) {
                sendlen += h.regcnt*2;
                //LOGD("____  slave sendlen: %d, h.dlen: %d, r: %d\n", sendlen, h.dlen, r);
            }
        }
        break;

        default:
        {
            Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;

            LOGD("___ slave XXXXXXXXXXX\n");

            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
                cascade_slave_read(h.reg, h.regcnt);
            }
            else if(h.func==MODBUS_FC_WRITE_SINGLE_REGISTER) {
                cascade_slave_write(h.reg, h.regcnt);
            }

            r = _mb_reply(cas, buff, rc, cas->map);
        }
    }

    return r;
}
/////////////////////////////////////////////////////////////////////////
static int master_scan(cascade_handle_t *cas)
{
    int i,r=0 ;
    uint16_t tmp[10];

    if(cas->scanAddr>CASCADE_MAX) {
        cas->scanAddr = 1;
    }

    if(!slave_find(cas, cas->scanAddr)) {
         r = _mb_scan(cas, cas->scanAddr);
        if(r>0) {
            LOGD("____ find a slave, addr: %d\n", cas->scanAddr);
            slave_add(cas, cas->scanAddr);
        }
        else {
            LOGW("____ scan %d fail, %s\n", cas->scanAddr, modbus_strerror(errno));
        }
    }
    cas->scanAddr++;
    //print_slave(cas);
      
    return 0;
}
///////////////////////////////////////////////////////////////////////////////////////
static int power_init(void)
{
    int nGroups=18,chn=1;
    GlobalDeviceManager *dm=get_dm();
    GlobalDeviceManager *dm2=get_dm2();

    dm2->_global_device_info = (GlobalDeviceInfo*)malloc(sizeof(GlobalDeviceInfo));
    if(dm2->_global_device_info==NULL) {
        LOGE("____ power_init, malloc failed\n");
        return -1;
    }

    dm2->_global_device_info->product_pwr_type = dm->_global_device_info->product_pwr_type;
    dm2->_global_device_info->product_id = dm->_global_device_info->product_id;
    strcpy(dm2->_global_device_info->product_name, dm->_global_device_info->product_name);
    strcpy(dm2->_global_device_info->product_number, dm->_global_device_info->product_number);
    strcpy(dm2->_global_device_info->product_status, dm->_global_device_info->product_status);
    
    INIT_LIST_HEAD(&dm2->_globalPowerManger.list);
    return 0;
}
static int power_clear(cascade_handle_t *cas)
{
    GlobalPowerManger *pos,*tmp;
    GlobalTreeACManager *pos3,*tmp3;
    GlobalDeviceManager *dm2=get_dm2();

    if(list_empty(&dm2->_globalPowerManger.list)) {
        return -1;
    }

    list_for_each_entry_safe(tmp,pos,&dm2->_globalPowerManger.list,list)
    {
        if(tmp && tmp->product_ch_type==TREE_AC_TYPE) {
            if(list_empty(&tmp->list_Tree_AC)) {
                continue;
            }
                
            list_for_each_entry_safe(tmp3,pos3,&tmp->list_Tree_AC,list_Tree_AC)
            {
                list_del(&tmp3->list_Tree_AC);
                free(tmp3);
            }
        }

        list_del(&tmp->list);
        free(tmp);
    }

    return 0;
}
static int power_add(cascade_handle_t *cas)
{
    int i,j;
    GlobalDeviceManager *dm2=get_dm2();
    GlobalPowerManger *tmp=NULL;
    GlobalTreeACManager *tmp3=NULL;
    slave_info_t *info=&cas->sInfo;

    LOGD("____ master add channel to the list, cnt: %d\n", info->cnt);
    cascade_lock();
    dm2->_global_device_info->product_id=cur_dev_addr;
    power_clear(cas);

    for(i=0; i<info->cnt; i++) {
        tmp = (GlobalPowerManger*)calloc(1, sizeof(GlobalPowerManger));
        if(!tmp) {
            return -1;
        }
        
        tmp->product_id = info->prod.product_id;
        tmp->product_saddr = info->ch[i].product_saddr;
        tmp->product_ch_id = info->ch[i].product_ch_id;
        tmp->product_ch_addr = info->ch[i].product_ch_addr;
        sprintf(tmp->product_ch_name, "CH%d", tmp->product_ch_id);
        tmp->product_ch_type = info->ch[i].product_ch_type;
        tmp->product_ch_status = info->ch[i].product_ch_status;
        tmp->product_ch_start_delay = info->ch[i].start_delay;
        tmp->product_ch_stop_delay = info->ch[i].stop_delay;

        if(info->ch[i].product_ch_type==TREE_AC_TYPE) {
            INIT_LIST_HEAD(&tmp->list_Tree_AC);
            for (j=0; j<3; j++) {
                tmp3 = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                if (tmp3 == NULL) {
                    LOGE("tm malloc error.\n");
                    return -1;
                }
                memset(tmp3, 0, sizeof(GlobalTreeACManager));

                tmp3->product_id = info->prod.product_id;
                tmp3->product_saddr = info->ch[i].product_saddr;
                tmp3->product_ch_id = tmp->product_ch_id;
                tmp3->product_ch_addr = info->ch[i].product_ch_addr;
                tmp3->product_ph_id = info->ch[i].pinfo[j].phase.product_ph_id;
                tmp3->product_ph_type = info->ch[i].pinfo[j].phase.product_ph_type;
                tmp3->product_ph_outputType = info->ch[i].pinfo[j].phase.product_ph_outputType;
                tmp3->product_ph_outputStatus = info->ch[i].pinfo[j].phase.product_ph_outputStatus;
                tmp3->_PowerInfo = info->ch[i].pinfo[j].power;

                list_add_tail(&tmp3->list_Tree_AC, &tmp->list_Tree_AC);
            }
        }
        else {
            tmp->_PowerInfo = info->ch[i].pinfo[0].power;
        }

        list_add_tail(&tmp->list,&dm2->_globalPowerManger.list);
    }
    cascade_unlock();

    return 0;
}
static int power_update(cascade_handle_t *cas)
{
    int cnt=0;
    GlobalPowerManger *tmp=NULL;
    GlobalTreeACManager *tmp3=NULL;
    GlobalDeviceManager *dm2=get_dm2();
    slave_info_t *info=&cas->sInfo;

    LOGD("______ power_update, %d\n", info->cnt);
    if(info->cnt==0 || list_empty(&dm2->_globalPowerManger.list)) {
        LOGE("___ sInfo.cnt is 0\n");
        return -1;
    }

    list_for_each_entry(tmp, &dm2->_globalPowerManger.list, list)
    {
        if(tmp->product_ch_type==TREE_AC_TYPE) {
            if(list_empty(&tmp->list_Tree_AC)) {
                continue;
            }

            int cnt2=0;
            list_for_each_entry(tmp3,&tmp->list_Tree_AC,list_Tree_AC)
            {
                tmp3->_PowerInfo = info->ch[cnt].pinfo[cnt2++].power;
            }
        }
        else {
            tmp->_PowerInfo = info->ch[cnt].pinfo[0].power;
        }
        cnt++;
    }
    
    return 0;
}


static void print_sensor(char *s, sensor_data_t *ss)
{
    LOGD("__%s__ ss.type: %d\n", s, ss->type);
    LOGD("__%s__ ss.addr: %d\n", s, ss->addr);

    LOGD("__%s__ ss.voltage: %f\n", s, ss->pwr.voltage);
    LOGD("__%s__ ss.current: %f\n", s, ss->pwr.current);
    LOGD("__%s__ ss.power: %f\n", s, ss->pwr.power);
    LOGD("__%s__ ss.consumption: %f\n", s, ss->pwr.consumption);
    LOGD("__%s__ ss.freq: %f\n", s, ss->pwr.freq);
    LOGD("__%s__ ss.factor: %f\n", s, ss->pwr.factor);
    LOGD("__%s__ ss.status: %d\n", s, ss->pwr.status);

    LOGD("__%s__ ss.temprature: %f\n", s, ss->temprature);
    LOGD("__%s__ ss.humidity: %f\n", s, ss->humidity);
    LOGD("__%s__ ss.warning: %d\n", s, ss->warning);
    LOGD("__%s__ ss.power_status: %d\n", s, ss->power_status);
    LOGD("__%s__ ss.sensor_status: %d\n", s, ss->sensor_status);
    LOGD("\n");

}
#define VALUE_OF(m,a,b)   ((m[a]<<16)+m[b])
static int sensor_get(cascade_handle_t *cas, int addr, sensor_data_t *ss)
{
    uint32_t offset = 6000;
    uint32_t value = 0 ;
    uint16_t temp[100];
    int r,cnt = sizeof(sensor_ori_t)/2;
    
    r = _mb_read(cas, addr, offset, temp, cnt);
    if(r!=cnt) {
        LOGE("___mbus_read slave %d failed, %s\n", addr, modbus_strerror(errno));
        return -1;
    }
    
    ss->type = temp[0];
    ss->addr = temp[1];
    
    ss->pwr.voltage = VALUE_OF(temp,3,2)/1000.0;
    ss->pwr.current = VALUE_OF(temp,5,4)/1000.0;
    ss->pwr.power   = VALUE_OF(temp,7,6)/1000.0;
    ss->pwr.consumption = VALUE_OF(temp,9,8)/1000.0;
    ss->pwr.freq   = VALUE_OF(temp,11,10)/1000.0;
    ss->pwr.factor = VALUE_OF(temp,13,12)/1000.0;
    ss->pwr.status = temp[20];

    ss->temprature = VALUE_OF(temp,15,14)/1000.0;
    ss->humidity   = VALUE_OF(temp,17,16)/1000.0;
    ss->warning    = VALUE_OF(temp,19,18)/1000.0;
    ss->sensor_status = temp[21];

    //print_sensor("11", ss);

    return 0;
}

#define REGS(x)    (((x)+(x)%2)/2)
static int master_cmd(cascade_handle_t *cas, cmd_data_t *cmd)
{
    int i,r;
    GlobalPowerManger *tmp=NULL;
    GlobalDeviceManager *dm=get_dm();
    GlobalDeviceManager *dm2=get_dm2();
    GlobalDeviceInfo    *dev=dm2->_global_device_info;
    data_t rdata,wdata;

    if(cur_dev_addr==0) {
        return -1;
    }

    switch(cmd->cmd) {
        case CASCADE_CMD_OPEN:
        case CASCADE_CMD_CLOSE:
        case CASCADE_CMD_SAVE:
        case CASCADE_CMD_SAVE3:
        {
            LOGD("____ master CMD: %d\n", cmd->cmd);

            wdata.dlen = sizeof(cmd_data_t);
            wdata.data = (uint8_t*)cmd;
            r = mb_write(cas, cur_dev_addr, &wdata);
        }
        break;

        case CASCADE_CMD_GET_INFO:
        {
            wdata.dlen = sizeof(cmd_data_t);
            wdata.data = (uint8_t*)cmd;

            rdata.dlen = 1;
            rdata.data = (uint8_t*)&cas->sInfo.cnt;

            LOGD("_____ master send CASCADE_CMD_GET_INFO\n");
            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
            if(r==0) {
                LOGD("______cas->info.cnt: %d\n", cas->sInfo.cnt);
                rdata.dlen = sizeof(slave_info_t)-sizeof(channel_info_t)*(CH_MAX-cas->sInfo.cnt);
                rdata.data = (uint8_t*)&cas->sInfo;
                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
                if(r==0) {
                    power_add(cas);
                }
            }
            else {
                LOGE("_____ master CASCADE_CMD_GET_INFO failed\n");
            }
        }
        break;

        default:
        cas->cmd = *cmd;
        r = 0;
    }

    return r;
}
static int master_query(cascade_handle_t *cas)
{
    int i,r;
    GlobalPowerManger *tmp=NULL;
    GlobalDeviceManager *dm2=get_dm2();
    GlobalDeviceInfo    *dev=dm2->_global_device_info;
    cmd_data_t *cmd=&cas->cmd;
    data_t rdata,wdata;

    if(cur_dev_addr==0) {
        return -1;
    }

    wdata.dlen = sizeof(*cmd);
    wdata.data = (uint8_t*)cmd;
    
    switch(cmd->cmd) {

        case CASCADE_CMD_QUERY_CH:
        {
            //LOGD("____ master query CASCADE_CMD_QUERY_CH, cnt: %d\n", cas->info.cnt);
            if(cas->sInfo.cnt==0) {
                return -1;
            }

            rdata.dlen = sizeof(slave_info_t)-sizeof(channel_info_t)*(CH_MAX-cas->sInfo.cnt);
            rdata.data = (uint8_t*)&cas->sInfo;
            
            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
            if(r==0) {
                power_update(cas);
            }
            else {
                LOGE("____ master query CASCADE_CMD_QUERY_CH failed\n");
            }
        }
        break;

        case CASCADE_CMD_QUERY_VOL:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_CUR:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_PWR:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_PWRQ:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_HIS:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_TOTAL:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        case CASCADE_CMD_QUERY_TOTAL_PWR:
        {
            if(cmd->obj==OBJ_CHANNEL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else if(cmd->obj==OBJ_OVERALL) {
                //rdata.dlen = sizeof(chInfo);
                //rdata.data = (uint8_t*)&chInfo;
            }
            else {
                return -1;
            }
        }
        break;

        default:
        //LOGD("____ master query cmd: %d\n", cmd->cmd);
        return -1;
    }

    return r;
}


static int slave_receive(cascade_handle_t *cas)
{
    return mb_receive(cas);
}

static void* cascade_thread(void *arg)
{
    int r;
    thread_handle_t *h=(thread_handle_t*)arg;
    cascade_handle_t *cas=(cascade_handle_t*)h->arg;
    ModbusInfo_t *info=&cas->mInfo;
    
    LOGD("__ cascade %s\n", info->product_modbus_type?"slave":"master");
    while(h->quit==0) {
        if(info->product_modbus_type==0) {      //主模
            r = master_query(cas);
            sleep(1);
        }
        else {                                  //从模式，等待主设备发起数据请�?
            r = slave_receive(cas);
        }  
    }
    
    pthread_exit(NULL);
}
static void* scan_thread(void *arg)
{
    int r;
    thread_handle_t *h=(thread_handle_t*)arg;
    cascade_handle_t *cas=(cascade_handle_t*)h->arg;
    ModbusInfo_t *info=&cas->mInfo;
    
    while(h->quit==0) {
        if(info->product_modbus_type==0) {  //master
            r = master_scan(cas);
        }
        sleep(1);
    }

    pthread_exit(NULL);
}
static void* cmd_thread(void *arg)
{
    int i,t=0;
    char temp[100];
    cascade_handle_t *cas=&casHandle;
    slave_info_t *info=&cas->sInfo;
    GlobalDeviceManager *dm=get_dm();
    cmd_data_t *pcmd=(cmd_data_t*)arg;

    if(pcmd->cmd==CASCADE_CMD_OPEN) {
        LOGD("____ slave CASCADE_CMD_OPEN\n");
    }
    else {
        LOGD("____ slave CASCADE_CMD_CLOSE\n");
    }

    int flag=(pcmd->cmd==CASCADE_CMD_OPEN)?1:0;
    if(pcmd->chId == 0xff) {
        int sendAddr = 0;
        for(i=0; i<info->cnt; i++) {
            if(info->ch[i].product_ch_addr>0) {
                if(info->ch[i].product_ch_addr==sendAddr) {
                    continue;
                }
                else {
                    sendAddr = info->ch[i].product_ch_addr;
                }

                t = g_switch_set_all_ctrl(&dm->_globalRelaySampManger, info->ch[i].product_ch_type, info->ch[i].product_ch_addr, flag);
                if(t<0) {
                    LOGE("___ %d %s failed\n", info->ch[i].product_ch_addr, (pcmd->cmd==CASCADE_CMD_OPEN)?"open":"close");
                }
            }
        }
    }
    else {
        GlobalPowerManger *tmp=NULL;
        list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
        {
            if(tmp->product_ch_id==pcmd->chId) {
                t = g_switch_set_all_chn_ctrl(&dm->_globalRelaySampManger, tmp, tmp->product_saddr, tmp->product_ch_addr, flag, false);
                break;
            }
        }
    }

    if(pcmd->cmd==CASCADE_CMD_OPEN) {
        sprintf(temp,"$开启$|$所有$|$通道$");
    }
    else {
        sprintf(temp,"$关闭$|$所有$|$通道$");
    }
    dev_insert_alarm_ctrl(dm->db, dm->_global_device_info->product_id,3,temp);
    free(pcmd);

    pthread_exit(NULL);
}
static int set_modbus(cascade_handle_t *cas, ModbusInfo_t *info)
{
    int r;

    if(cas->inited) {
        mb_deinit(cas);
    }
    cas->inited = 0;
    cas->mInfo = *info;
    //LOGD("master init modbus:  port: %s, type: %d, baud: %d\n", CASCADE_MODBUS_PORT, info->product_modbus_type, info->product_modbus_baud);

    r = mb_init(cas, CASCADE_MODBUS_PORT, info->product_modbus_type,
                  info->product_modbus_addr, info->product_modbus_baud);
    if(r!=0) {
        LOGE("cascade modbus init error.\n");
        return -1;
    }
    cas->inited = 1;

    return 0;
}

int cascade_init(void)
{
    int r=0;
    list_cfg_t lc;
    cascade_handle_t *cas=&casHandle;
    
    memset(cas, 0, sizeof(casHandle));

    power_init();
    slave_init(cas);
    pthread_mutex_init(&cas->mutex, NULL);
    pthread_mutex_init(&cas->lock, NULL);
    
    cas->scanAddr = 1;
    cas->map2 = modbus_mapping_new_start_address(0,0,0,0,
                                                 CASCADE_REG_READ,  MAX_READ_REGS2,
                                                 CASCADE_REG_WRITE, MAX_WRITE_REGS2);

    set_modbus(cas, get_mb());
    slave_add(cas, 0);

    thread_start(THREAD_ID_CASCADE, cascade_thread, cas, 4*MB, 0);
    thread_start(THREAD_ID_SCAN, scan_thread, cas, 4*MB, 0);
        
    return 0;
}


int cascade_set_modbus(ModbusInfo_t *info)
{
    cascade_handle_t *cas=&casHandle;
    if(!info || info->product_modbus_addr>CASCADE_MAX) {
        return -1;
    }

    return set_modbus(cas, info);
}


int cascade_get_dlist(dev_list_t *dl)
{
    int i,cnt=0;
    slave_t *sl=NULL;
    cascade_handle_t *cas=&casHandle;

    if(!dl) {
        return -1;
    }

    sl = (slave_t*)malloc(sizeof(slave_t)*(CASCADE_MAX+1));
    if(!sl) {
        return -1;
    }

    for(i=0; i<=CASCADE_MAX; i++) {
        if(cas->slaves[i].addr>=0) {
            sl[cnt++] = cas->slaves[i];
        }
    }
    dl->slave = sl;
    dl->cnt = cnt;
    LOGD("____dev cnt: %d\n", cnt);

    return 0;
}
int cascade_free_dlist(dev_list_t *dl)
{
    if(!dl) {
        return -1;
    }

    free(dl->slave);
    return 0;
}
 
int cascade_request(cmd_data_t *cmd)
{
    int r=0;
    cascade_handle_t *cas=&casHandle;

    if(!cmd) {
        return -1;
    }

    pthread_mutex_lock(&cas->lock);
    r = master_cmd(cas, cmd);
    pthread_mutex_unlock(&cas->lock);

    return r;
}


int cascade_get_all(_OverAllPwrAckInfo *all)
{

    return 0;
}


int cascade_get_ch(_OverChnPwrAckInfo *ch)
{
    GlobalPowerManger *tmp=NULL;
    GlobalTreeACManager *tmp3=NULL;
    _OverChnPwrAckInfo *pch=NULL;
    GlobalDeviceManager* dm2=get_dm2();

    list_for_each_entry(tmp, &dm2->_globalPowerManger.list, list)
    {
        if (tmp->product_ch_type==TREE_AC_TYPE){
            int nStatus=-1;//-1则状态不变，0、1则是子状态
            //判断是否三相单输出情况下
            if(tmp->product_ch_type==TREE_AC_TYPE) {
                list_for_each_entry(tmp3, &tmp->list_Tree_AC, list_Tree_AC) {
                    if (2 == tmp3->product_ph_outputType &&1==tmp3->product_ph_outputStatus)
                    {//单项并且状态为输出
                        nStatus = tmp3->_PowerInfo.status;
                    }
                }
            }

            list_for_each_entry(tmp3, &tmp->list_Tree_AC, list_Tree_AC)
            {
                pch = (_OverChnPwrAckInfo *)malloc(sizeof(_OverChnPwrAckInfo));
                if (pch == NULL) {
                    LOGE("pch malloc err.\n");
                    return -1;
                }
                pch->product_name = dm2->_global_device_info->product_name;
                pch->product_number = dm2->_global_device_info->product_number;
                pch->product_id = dm2->_global_device_info->product_id;
                pch->productChName = tmp->product_ch_name;
                pch->productChId = tmp->product_ch_id;
                pch->status = tmp->_PowerInfo.status;
                pch->voltage = tmp->_PowerInfo.voltage;
                pch->current = tmp->_PowerInfo.current;
                pch->power = tmp->_PowerInfo.power;
                pch->freq = tmp->_PowerInfo.freq;
                pch->consumption = tmp->_PowerInfo.consumption;
                pch->factor = tmp->_PowerInfo.factor;
                pch->product_ch_start_delay = tmp->product_ch_start_delay;
                pch->product_ch_stop_delay = tmp->product_ch_stop_delay;
                pch->product_type=tmp->product_ch_type;
                pch->product_phType = tmp3->product_ph_type;
                pch->ph_voltage = tmp3->_PowerInfo.voltage;
                pch->ph_current = tmp3->_PowerInfo.current;
                pch->ph_power = tmp3->_PowerInfo.power;
                pch->ph_consumption = tmp3->_PowerInfo.consumption;
                pch->ph_outputType   = tmp3->product_ph_outputType;
                pch->ph_outputStatus = tmp3->product_ph_outputStatus;
                if (dm2->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_One && 
                    tmp3->product_ph_outputType == 2 && tmp3->product_ph_outputStatus == 2) // 如果是单项输出并且则非输出通道数据为0
                { 
                    // 3-1模式 单项状态，不输出则数据为空
                    pch->ph_voltage = 0.0;
                    pch->ph_current = 0.0;
                    pch->ph_power = 0.0;
                    pch->ph_consumption = 0.0;
                }
                if (nStatus>=0)
                {
                    pch->status = nStatus;
                }else {
                    pch->status = tmp->_PowerInfo.status;
                }

                
                list_add_tail(&pch->list, &ch->list);
            }
        }
        else {
            pch = (_OverChnPwrAckInfo *)malloc(sizeof(_OverChnPwrAckInfo));
            if (pch == NULL) {
                log_e("_overChnPwrBackInfoTemp malloc err.");
                return -1;
            }
            // 填数据
            pch->product_name = dm2->_global_device_info->product_name;
            pch->product_number = dm2->_global_device_info->product_number;
            pch->product_id = dm2->_global_device_info->product_id;
            pch->productChName = tmp->product_ch_name;
            pch->productChId = tmp->product_ch_id;
            pch->status = tmp->_PowerInfo.status;
            pch->voltage = tmp->_PowerInfo.voltage;
            pch->current = tmp->_PowerInfo.current;
            pch->power = tmp->_PowerInfo.power;
            pch->freq = tmp->_PowerInfo.freq;
            pch->consumption = tmp->_PowerInfo.consumption;
            pch->factor = tmp->_PowerInfo.factor;
            pch->product_ch_start_delay = tmp->product_ch_start_delay;
            pch->product_ch_stop_delay = tmp->product_ch_stop_delay;
            
            
            list_add_tail(&pch->list, &ch->list);
        }
    }

    return 0;
}


int cascade_lock(void)
{
    cascade_handle_t *cas=&casHandle;

    return pthread_mutex_lock(&cas->mutex);
}


int cascade_unlock(void)
{
    cascade_handle_t *cas=&casHandle;

    return pthread_mutex_unlock(&cas->mutex);
}