SmartPDCode/f407/applications/power.c

#include "mb.h"
#include "cfg.h"
#include "lock.h"
#include "list.h"
#include "paras.h"
#include "power.h"
#include "thread.h"
#include "datadef.h"

typedef struct {
    int8_t  type;
    uint8_t chs;
}ch_info_t;
typedef struct {
    void*           mb;
    
    power_total_t   ttl;
    board_all_t     all;
    
    lock_t          lck;
}power_handle_t;
static power_handle_t pwrHandle={0};

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 int read_reg(power_handle_t *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    return mb_read(h->mb, addr, reg, data, cnt, 100);
}
static int write_reg(power_handle_t *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    return mb_write(h->mb, addr, reg, data, cnt);
}
////////////////////////////////////////////////////////////////////
static int get_info(power_handle_t *h, int addr, ch_info_t *info)
{
    int i,r=-1;
    uint16_t tmp=0;
    
    r = read_reg(h->mb, addr, POWER_AC_GET_INFO, &tmp, 1);
    if(r==0) {
        info->type = (tmp>>8)&0xFF;
        info->chs = tmp&0xFF;
        return 0;
    }

    r = read_reg(h->mb, addr, POWER_DC_GET_INFO, &tmp, 1);
    if(r==0) {
        info->type = (tmp>>8)&0xFF;
        info->chs = tmp&0xFF;
    }
    
    return r;
}
static int get_ch(power_handle_t *h, int ch, power_ch_t *pch)
{
    if(!pch || !h->all.pch || !h->all.chs || !h->all.pch[ch]) {
        lock_d_release(h->lck);
        return -1;
    }
    *pch = *h->all.pch[ch];
    
    return 0;
}
////////////////////////////////////////////////////////////////


static int set_open_delay(power_handle_t *h, int type, int addr, uint16_t delay)
{
    switch(type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
}
static int set_close_delay(power_handle_t *h, int type, int addr, uint16_t delay)
{
    switch(type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
}
static int set_kb_value(power_handle_t *h, int type, int addr, kb_val_t *kv)
{
    switch(type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
}
static int reset_consump(power_handle_t *h, int type, int addr)
{
    
    switch(type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
}
static int get_switch(power_handle_t *h, power_ch_t *pch)
{
    int r=-1;
    
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        {
            
        }
        break;
        
        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
    
    return r;
}
static int set_switch(power_handle_t *h, power_ch_t *pch)
{
    int r=-1;
    uint16_t offset,tmp[2]={0},st=pch->power[0].status;
    
    if (pch->thr.v_upper.en == 1)
        st |= ENABLE_AC3_V_UP;
    if (pch->thr.v_lower.en == 1)
        st |= ENABLE_AC3_V_DOWN;
    if (pch->thr.c_upper.en == 1)
        st |= ENABLE_AC3_C_UP;
    if (pch->thr.p_upper.en == 1)
        st |= ENABLE_AC3_P_UP;
    if (pch->thr.w_upper.en == 1)
        st |= ENABLE_AC3_W_UP;
            
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            offset = POWER_AC_CH_STAT_L+pch->info.ch;
            r = write_reg(h, pch->info.addr, offset, &st, 1);
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        {
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t mask;
            offset = POWER_DC_GET_STAT_INFO+pch->info.ch;
            
            mask = ~(1 << pch->info.ch);
            tmp[0] &= mask;
            tmp[0] |= (st << pch->info.ch);
            write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t reg;
            uint8_t pwr_type=paras_get()->prod.pwr_type;
            if(pwr_type==PDU_AC_I3O3 || pwr_type==PDU_AC_I3O1) {
                reg = POWER_AC3_OUT_ENABLE;
            }
            else {
                reg = POWER_AC3_CH_OUT_ENABLE;
            }
            
            tmp[0] = st;
            offset = reg + +pch->info.ch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        default:
        return -1;
    }
    
    return r;
}
static int get_thr(power_handle_t *h, power_ch_t *pch)
{
    int r=-1;
    
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        default:
        return -1;
    }
    
    return r;
}
static int set_thr(power_handle_t *h, power_ch_t *pch)
{
    int r=-1;
    
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            
        }
        break;

        case DCPDU_TYPE:
        {
            
        }
        break;
        
        case TREE_AC_TYPE:
        {
            
        }
        break;
        
        default:
        return -1;
    }
    
    return r;
}


//////////////////////////////////////////////////////////////////
static int get_board(power_handle_t *h, uint8_t addr, board_data_t *pbrd)
{
    int r,i,j;
    uint16_t offset,tmp[144];
    
    switch(pbrd->type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            uint32_t val;
            
            r = read_reg(h, pbrd->addr, POWER_AC_CUR_INFO_L, tmp, pbrd->chs);
            if(r==0 && pbrd->pch) {
                for (i=0; i<pbrd->chs; i++) {
                    int idx = i * 12;
                    // 解电压数据
                    val = (tmp[1 + idx] << 16) | tmp[0 + idx];
                    pbrd->pch[i].power[0].voltage = val / 1000.0;
                    // 解电流数据
                    val = (tmp[3 + idx] << 16) | tmp[2 + idx];
                    pbrd->pch[i].power[0].current = val / 1000.0;
                    // 解功率数据
                    val = (tmp[5 + idx] << 16) | tmp[4 + idx];
                    pbrd->pch[i].power[0].power = val / 1000.0;
                    // 解频率数据
                    val = (tmp[7 + idx] << 16) | tmp[6 + idx];
                    pbrd->pch[i].power[0].freq = val / 1000.0;
                    // 解耗电量数据
                    val = (tmp[9 + idx] << 16) | tmp[8 + idx];
                    pbrd->pch[i].power[0].consump = val / 1000.0;
                    // 解功率因素数据
                    val = (tmp[11 + idx] << 16) | tmp[10 + idx];
                    pbrd->pch[i].power[0].factor = val / 1000.0;
                }
            }
            
            r = read_reg(h, pbrd->addr, POWER_AC_STAT_INFO_L, tmp, pbrd->chs);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            if(pbrd->pch) {
                for (i=0; i<pbrd->chs; i++) {
                    pbrd->pch[i].power[0].status = tmp[i] & (0x01);
                    pbrd->pch[i].alarm.v_upper   = tmp[i] & ALARM_V_UPPER;
                    pbrd->pch[i].alarm.v_lower   = tmp[i] & ALARM_V_LOWER;
                    pbrd->pch[i].alarm.c_upper   = tmp[i] & ALARM_C_UPPER;
                    pbrd->pch[i].alarm.p_upper   = tmp[i] & ALARM_P_UPPER;
                    pbrd->pch[i].alarm.w_upper   = tmp[i] & ALARM_W_UPPER;
                                                 
                    pbrd->pch[i].alarm.ph_loss  = 0;
                }
            }
        }
        break;

        case DCPDU_TYPE:
        {
            uint32_t flag;
            offset = POWER_DC_GET_OUT_INFO + 16;
            uint16_t *ptmp = tmp + 32;
            r = read_reg(h, pbrd->addr, offset, ptmp, 32);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }

            for (i = 0; i < pbrd->chs; i++) {
                int Index = i * 8;
                // 解电压数据
                float value = (tmp[1 + Index] << 16) + tmp[0 + Index];
                pbrd->pch[i].power[0].voltage = value / 1000.0;
                // 解电流数据
                value = (tmp[3 + Index] << 16) + tmp[2 + Index];
                pbrd->pch[i].power[0].current = value / 1000.0;
                // 解功率数据
                value = (tmp[5 + Index] << 16) + tmp[4 + Index];
                pbrd->pch[i].power[0].power = value / 1000.0;

                value = (tmp[7 + Index] << 16) + tmp[6 + Index];
                pbrd->pch[i].power[0].consump = value / 1000.0;

                pbrd->pch[i].power[0].freq = 0;
                pbrd->pch[i].power[0].factor = 1;
            }

            offset = POWER_DC_GET_STAT_INFO;
            
            r = read_reg(h, pbrd->addr, offset, tmp, 2);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            for (i = 0; i < pbrd->chs; i++) {
                flag = (tmp[1] << 16) + tmp[0];
                pbrd->pch[i].power[0].status = (flag >> i) & 0x1;
            }
            // 获取报警状态
            offset = POWER_DC_GET_WARNING;
            r = read_reg(h, pbrd->addr, offset, tmp, 16);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            for (i = 0; i < pbrd->chs; i++) {
                int Index = i * 2;
                pbrd->pch[i].alarm.v_upper = tmp[0+Index] & (1<<0);
                pbrd->pch[i].alarm.v_lower = tmp[0+Index] & (1<<1);
                pbrd->pch[i].alarm.c_upper = tmp[0+Index] & (1<<2);
                pbrd->pch[i].alarm.p_upper = tmp[0+Index] & (1<<3);
                pbrd->pch[i].alarm.w_upper = tmp[0+Index] & (1<<4);
            }
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint8_t v=0;
           
            offset = POWER_AC3_OUT_INFO;
            r = read_reg(h, pbrd->addr, offset, tmp, 80);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            offset = POWER_AC3_OUT_INFO+40;
            uint16_t* ptmp=tmp+80;
            r = read_reg(h, pbrd->addr, offset, ptmp, 64);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            for (i=0; i<pbrd->chs; i++) {
                int Index = i * 16;
                // 解电压数据
                float value = (tmp[1+Index] << 16) + tmp[0+Index];
                pbrd->pch[i].power[0].voltage = value / 1000.0f;
                // 解电流数据
                value = (tmp[3+Index] << 16) + tmp[2+Index];
                pbrd->pch[i].power[0].current = value / 1000.0f;
                // 解功率数据
                value = (tmp[5+Index] << 16) + tmp[4+Index];
                pbrd->pch[i].power[0].power = value / 1000.0f;
                // 无功
                value = (tmp[7+Index] << 16) + tmp[6+Index];
                // 视在功率
                value = (tmp[9+Index] << 16) + tmp[8+Index];
                // 解频率数据
                value = (tmp[11+Index] << 16) + tmp[10+Index];
                pbrd->pch[i].power[0].freq = value / 1000.0f;
                // 解耗电量数据
                value = (tmp[13+Index] << 16) + tmp[12+Index];
                pbrd->pch[i].power[0].consump = value / 1000.0f;
                // 解功率因素数据
                value = (tmp[15+Index] << 16) + tmp[14+Index];
                pbrd->pch[i].power[0].factor = value / 1023.0f;
            }
            
            //获取通道开关状态及零线状态 
            offset = POWER_AC3_OUT_ENABLE;
            r = read_reg(h, pbrd->addr, offset, tmp, 20);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            for (i=0; i<pbrd->chs; i++) {
                int Index = i * 2;
                pbrd->pch[i].power[0].status = tmp[0+Index] & 0x01;
                pbrd->pch[i].power[0].nwire  = tmp[18] & 0x01;
            }
            
            //获取故障状态
            offset = POWER_AC3_OUT_ERROR;
            r = read_reg(h, pbrd->addr, offset, tmp, 18);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            for (i=0; i<pbrd->chs; i++) {
                int Index = i * 2;
                pbrd->pch[i].alarm.v_upper = tmp[0+Index] & (1<<0);
                pbrd->pch[i].alarm.v_lower = tmp[0+Index] & (1<<1);
                pbrd->pch[i].alarm.c_upper = tmp[0+Index] & (1<<2);
                pbrd->pch[i].alarm.p_upper = tmp[0+Index] & (1<<3);
                pbrd->pch[i].alarm.w_upper = tmp[0+Index] & (1<<4);
            }
            
            offset = POWER_AC3_ALARM_MISSING_PH;
            r = read_reg(h, pbrd->addr, offset, tmp, pbrd->chs);
            if (r < 0) {
                LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                return r;
            }
            
            v = 0;
            for(i = 0; i < 3; i++) {
                if(tmp[i * 2]>0) {
                    v |= 1<<i;
                }
            }
            pbrd->ph_loss = v;
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
    
    return 0;
}


static void *power_thread(void *arg)
{
    thread_handle_t *th=(thread_handle_t*)arg;
    power_handle_t *h=(power_handle_t*)th->arg;;
    
    while(th->quit==0) {
        
        //power_get();
        //
        
    }
    pthread_exit(NULL);
}




int power_init(void)
{
    power_handle_t *h=&pwrHandle;
    mb_para_t para={
        .mode = MB_MODE_MASTER,
        .type = MB_TYPE_RTU,
        
        .para = {
            .rtu = {
                .dev = POWER_PORT,          //设备名
                .baudrate = 115200,         //波特率
                .parity = 0,                //校验位
                .pin = 1,                   //收发控制引脚, <0 表示不使用
                .lvl = 0,                   //发送控制电平
            }
        }
    };
    
    memset(h, 0, sizeof(power_handle_t));
    h->lck = lock_d_init();
    h->mb = mb_init(&para);
    if(!h->mb) {
        return -1;
    }
    thread_start(THREAD_ID_POWER, power_thread, h);
    
    return 0;
}


int power_deinit(void)
{
    power_handle_t *h=&pwrHandle;
    
    lock_d_deinit(h->lck);
    mb_deinit(h->mb);
    
    return 0;
}


int power_get_ch(int ch, power_ch_t *pch)
{
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    if(!pch || !h->all.pch || !h->all.chs || !h->all.pch[ch]) {
        lock_d_release(h->lck);
        return -1;
    }
    *pch = *h->all.pch[ch];
    lock_d_release(h->lck);
    
    return 0;
}


int power_get_board(int addr, board_data_t *pb)
{
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    if(!pb || !h->all.pch || !h->all.cnt || !h->all.pbrd[addr]) {
        lock_d_release(h->lck);
        return -1;
    }
    *pb = *h->all.pbrd[addr];
    lock_d_release(h->lck);
    
    return 0;
}


int power_set(int ch, power_ch_t *pch)
{
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    if(!pch || !h->all.pch || !h->all.chs || !h->all.pch[ch]) {
        lock_d_release(h->lck);
        return -1;
    }
    *h->all.pch[ch] = *pch;
    lock_d_release(h->lck);
    
    return 0;
}


int power_scan(int max_addr)
{
    int r,i,j,idx=0,chs=0;
    ch_info_t info;
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    for(i=1; i<=max_addr; i++) {
        r = get_info(h, i, &info);
        if(r==0) {
            h->all.pbrd[i] = (board_data_t*)calloc(1, sizeof(board_data_t));
            if(h->all.pbrd[i]) {
                h->all.pbrd[i]->type = info.type;
                h->all.pbrd[i]->chs  = info.chs;
                h->all.pbrd[i]->addr = i;
                h->all.pbrd[i]->pch = (power_ch_t*)calloc(1, sizeof(power_ch_t)*info.chs);
                if(h->all.pbrd[i]->pch) {
                    for(j=0; j<info.chs; j++) {
                        h->all.pbrd[i]->pch[j].info.addr = i;
                        h->all.pbrd[i]->pch[j].info.ch  = idx;      //序号程序从0开始
                        h->all.pbrd[i]->pch[j].info.sch = j;        //序号从0开始
                        h->all.pbrd[i]->pch[j].info.pid = i;
                        h->all.pbrd[i]->pch[j].info.addr = i;
                        
                        idx++;
                    }
                }
            }
            chs += info.chs;
        }
    }
    
    if(chs>0) {
        idx = 0;
        h->all.chs = 0;
        h->all.pch = (power_ch_t**)calloc(1, sizeof(power_ch_t*)*chs);
        if(h->all.pch) {
            h->all.chs = chs;
            for(i=1; i<=max_addr; i++) {
                board_data_t *pbrd=h->all.pbrd[i];
                for(j=0; j<pbrd->chs; j++) {
                    h->all.pch[idx++] = &h->all.pbrd[i]->pch[j];
                }
            } 
        }
    }
    
    lock_d_release(h->lck);
    
    return 0;
}


int power_clear(void)
{
    int i,j;
    power_handle_t *h=&pwrHandle;
  
    lock_d_hold(h->lck);
    for(i=0; i<BRD_MAX; i++) {
        if(h->all.pbrd[i]) {
            for(j=0; j<h->all.pbrd[i]->chs; j++) {
                if(h->all.pbrd[i]->pch) {
                    free(h->all.pbrd[i]->pch);
                    h->all.pbrd[i]->pch = NULL;
                }
                h->all.pbrd[i]->chs = 0;
            }
            free(h->all.pbrd[i]);
            h->all.pbrd[i] = NULL;
        }
        h->all.cnt = 0;
    }
    lock_d_release(h->lck);
    
    return 0;
}


int power_reset(int addr)
{
    int i,r=-1;
    uint16_t offset = 0;
    power_handle_t *h=&pwrHandle;
    board_data_t *pb=NULL;
    
    if(addr>BRD_MAX) {
        return -1;
    }
    pb = h->all.pbrd[addr];
    if(!pb) {
        return -1;
    }
    
    switch(pb->type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            uint16_t tmp[8];
            offset = POWER_AC_CH_STAT_L;
            for(i=0; i<pb->chs; i++) {
                tmp[i] = pb->pch[i].power[0].status;
            }
            r = write_reg(h, pb->addr, offset, tmp, pb->chs);
        }
        break;
        
        case DCPDU_TYPE:
        {
            offset = POWER_DC_SET_ALARM_CTRL_TOTAL;
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t data_temp[20];
            
            offset = POWER_AC3_RESET_CONSUMP;
            data_temp[0] = data_temp[1] = data_temp[2] = 1;
            r = write_reg(h, pb->addr, offset, data_temp, 3);
            if (r<0) {
                return r;        
            }
            
            //初始化报警阈值
            uint32_t value = 0;
            memset(data_temp, 0, sizeof(data_temp));
            offset = POWER_AC3_THRESHOLD_VOL_MAX;
            r = write_reg(h, pb->addr, offset, data_temp, 18);
            if (r<0) {
                return r;        
            }
            offset = POWER_AC3_THRESHOLD_VOL_MIN;
            r = write_reg(h, pb->addr, offset, data_temp, 18);
            if (r<0) {
                return r;        
            }
            
            offset = POWER_AC3_THRESHOLD_CUR_MAX;
            r = write_reg(h, pb->addr, offset, data_temp, 18);
            if (r<0) {
                return r;
            }
            offset = POWER_AC3_THRESHOLD_PWR_MAX;
            r = write_reg(h, pb->addr, offset, data_temp, 18);
            if (r<0) {
                return r;        
            }
            offset = POWER_AC3_THRESHOLD_PWRCON_MAX;
            r = write_reg(h, pb->addr, offset, data_temp, 18);
            if (r<0) {
                return r;
            }
            
            for (i = 0; i < pb->chs; i++) {
                memset(data_temp, 0, sizeof(data_temp));
                offset = POWER_AC3_OUT_ENABLE + i;
                data_temp[0] = pb->pch[i].power[0].status;
                r = write_reg(h, pb->addr, offset, data_temp, 2);
                if (r<0) {
                    return r;        
                }
            }
        }
        break;
        
        default:
        return -1;
    }
    
    
    return 0;
}


int power_set_sw(int ch, int on)
{
    int r;
    power_ch_t pc;
    uint16_t offset=0,data_temp[2];
    power_handle_t *h=&pwrHandle;
    
    r = get_ch(h, ch, &pc);
    if(r) {
        return -1;
    }
    
    switch(pc.info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            offset = POWER_AC_CH_STAT_L + ch;
            data_temp[0] = on; data_temp[1] = 0;
        }
        break;
        
        case DCPDU_TYPE:
        {
            offset = POWER_DC_SET_STAT + ch;
            data_temp[0] = on; data_temp[1] = 0;
        }
        break;
        
        case TREE_AC_TYPE:
        {
            if(ch<0) {//##################################
                //offset = POWER_AC3_OUT_INFO + ch;
                //data_temp[0] = on; data_temp[1] = 0;
            }
            
        }
        break;
        
        default:
        return -1;
    }
    data_temp[0] = on; data_temp[1] = 0;
    r = write_reg(h, pc.info.addr, offset, data_temp, 2);
    
    return r;
}

int power_set_alarm(int ch, alarm_t *alarm)
{
    int r=-1;
    power_ch_t pc;
    uint16_t offset = 0;
    uint16_t nStatus = 0;
    power_handle_t *h=&pwrHandle;
    
    r = get_ch(h, ch, &pc);
    if(r) {
        return -1;
    }
    
    switch(pc.info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            if (ch == -1) {
                offset = POWER_AC_ALARM_CTRL_TOTAL;
            }
            else {
                offset = POWER_AC_ALARM_CTRL + ch;
            }
        }
        break;
        
        case DCPDU_TYPE:
        {
            if (ch == -1) {
                offset = POWER_DC_SET_ALARM_CTRL_TOTAL;
            }
            else {
                offset = POWER_DC_SET_ALARM_CTRL + ch;
            }
        }
        break;
        
        case TREE_AC_TYPE:
        {
            if (ch == -1) {
                offset = POWER_AC3_ALARM_CTRL_TOTAL;
            }
            else {
                offset = POWER_AC3_ALARM_CTRL + ch;
            }
        }
        break;
        
        default:
        return -1;
    }
    
    if(pc.thr.v_upper.act==1) nStatus |= BIT(1);
    if(pc.thr.v_lower.act==1) nStatus |= BIT(2);
    if(pc.thr.c_upper.act==1) nStatus |= BIT(0);
    if(pc.thr.p_upper.act==1) nStatus |= BIT(3);
    if(pc.thr.w_upper.act==1) nStatus |= BIT(4);
    r = write_reg(h, pc.info.addr, offset, &nStatus, 1);
    
    return r;
}


int power_set_thr(int ch, thr_t *thr)
{
    int r=-1;
    power_ch_t pc;
    uint16_t offset;
    power_handle_t *h=&pwrHandle;
    
    r = get_ch(h, ch, &pc);
    if(r) {
        return -1;
    }
    
    switch(pc.info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            uint16_t offset = 0;
            uint32_t data_temp = 0 ;
            uint16_t data_buf[16] = {0};

            //电压上限
            data_temp =  (thr->v_upper.val*1000);
            data_buf[0] = data_temp;
            data_buf[1] = data_temp>>16;
            //电压下限
            data_temp =  (thr->v_upper.val*1000);
            data_buf[2] = data_temp;
            data_buf[3] = data_temp>>16;
            //电流上限
            data_temp =  (thr->v_upper.val*1000);
            data_buf[4] = data_temp;
            data_buf[5] = data_temp>>16;
            //电流下限
            data_temp =  (0);
            data_buf[6] = data_temp;
            data_buf[7] = data_temp>>16;

            //功率上限
            data_temp =  (thr->v_upper.val*1000);
            data_buf[8] = data_temp;
            data_buf[9] = data_temp>>16;
            //功率下限
            data_temp =  0;
            data_buf[10] = data_temp;
            data_buf[11] = data_temp>>16;

            //电能上限
            data_temp =  (thr->v_upper.val*1000);
            data_buf[12] = data_temp;
            data_buf[13] = data_temp>>16;
            //电能下限
            data_temp =  0;
            data_buf[14] = data_temp;
            data_buf[15] = data_temp>>16;

            if(ch<0) {
                offset = POWER_AC_TOTAL_THRESHOLD;
            }
            else  {
                offset = POWER_AC_THRESHOLD_L+ch*16;
            }

            r = write_reg(h, pc.info.addr, offset, data_buf, 16);
            //power_set_alarm();
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t data_temp[4];
            uint32_t value;
            
            offset = (ch<0)?POWER_DC_SET_THRESHOLD_TOTAL_VOL_MAX:POWER_DC_SET_THRESHOLD_VOL_MAX;
            value = thr->v_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            
            offset = (ch<0)?POWER_DC_SET_THRESHOLD_TOTAL_VOL_MIN:POWER_DC_SET_THRESHOLD_VOL_MIN;
            value = thr->v_lower.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            
            offset = (ch<0)?POWER_DC_SET_THRESHOLD_TOTAL_CUR_MAX:POWER_DC_SET_THRESHOLD_CUR_MAX;
            value = thr->c_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            
            offset = (ch<0)?POWER_DC_SET_THRESHOLD_TOTAL_PWR_MAX:POWER_DC_SET_THRESHOLD_POWER_MAX;
            value = thr->p_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            
            offset = (ch<0)?POWER_DC_SET_THRESHOLD_TOTAL_PWRCON_MAX:POWER_DC_SET_THRESHOLD_POWERCON_MAX;
            value = thr->w_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            
            //power_set_alarm();
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t data_temp[4];
            uint32_t value;
            
            if(ch<0) {
                offset = POWER_AC3_THRESHOLD_IN;
                value = thr->v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
                
                value = thr->v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset+1, data_temp, 2);
                
                value = thr->c_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset+2, data_temp, 2);
                
                value = thr->p_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset+3, data_temp, 2);
                
                value = thr->w_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset+4, data_temp, 2);
            }
            else {
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                value = thr->v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_VOL_MIN;
                value = thr->v_lower.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_CUR_MAX;
                value = thr->c_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_PWR_MAX;
                value = thr->p_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                value = thr->w_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pc.info.addr, offset, data_temp, 2);
            }
        }
        break;
    }
    
    return r;
}