SmartPDCode/f407/applications/power.c

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

#define BRD_NUM   3 //BRD_MAX


typedef struct {
    void*           mb;
    lock_t          lck;
    uint8_t         cur_addr;
    
    uint8_t         chs;                    //所有控制板的总通道数
    power_ch_t      **pch;                  //动态指针
    
    uint8_t         cnt;                    //实际扫到的板子个数，不可大于BRD_MAX
    uint8_t         brd_max;
    board_data_t    *pbrd[BRD_MAX+1];       //通过modbus地址索引
    
    board_key_t     key[BRD_MAX+1];
    power_total_t   ttl;
    
    product_data_t *prod;
}power_handle_t;
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, 800);
}
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_key(power_handle_t *h, uint8_t addr, board_key_t *key)
{
    int i,r=-1;
    uint16_t tmp[2];
    
    r = read_reg(h, addr, POWER_DC_INFO, tmp, 2);
    if(r==0) {
        key->type = (tmp[0]>>8)&0xFF;
        key->chs = tmp[0]&0xFF;
        return 0;
    }
    
    r = read_reg(h, addr, POWER_AC_GET_INFO, tmp, 2);
    if(r==0) {
        key->type = (tmp[0]>>8)&0xFF;
        key->chs = tmp[0]&0xFF;
    }
    
    return r;
}
////////////////////////////////////////////////////////////////
static int set_kb_value(power_handle_t *h, int type, int addr, kb_val_t *kv)
{
    switch(type) {
        case AC_SINGLE_S_TYPE:
        {
            /*
            unsigned int offset = 0;
            unsigned int rval = 0 ;
            unsigned short data_temp[8] = {0};
            if(chn>=8)
                return -1;  
            offset = _SWITCH_AC_SINGLE_S_KB_VAL+chn*8;
            data_temp[0] = (unsigned short)_kb_val->voltage_k;
            data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
            data_temp[2] = (unsigned short)_kb_val->voltage_b;
            data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
            data_temp[4] = (unsigned short)_kb_val->current_k;
            data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
            data_temp[6] = (unsigned short)_kb_val->current_b;
            data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
            g_modbus_write_x_reg(manger,saddr,offset,8,data_temp);
            */
        }
        break;
        
        case AC_SINGLE_B_TYPE:
        {
            /*
            unsigned int offset = 0;
            unsigned int rval = 0 ;
            unsigned short data_temp[8] = {0};
            if(pch->info.>=4)
                return -1;  
            offset = _SWITCH_AC_SINGLE_B_KB_VAL+chn*8;
            data_temp[0] = (unsigned short)_kb_val->voltage_k;
            data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
            data_temp[2] = (unsigned short)_kb_val->voltage_b;
            data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
            data_temp[4] = (unsigned short)_kb_val->current_k;
            data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
            data_temp[6] = (unsigned short)_kb_val->current_b;
            data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
            g_modbus_write_x_reg(manger,saddr,offset,8,data_temp);
            */
        }
        break;

        case DCPDU_TYPE:
        {/*
            unsigned short offset = 0;
            unsigned short data_temp[8] = {0};
            offset = _SWITCH_DC_KB_VAL;
            data_temp[0] = (unsigned short)_kb_val->voltage_k;
            data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
            data_temp[2] = (unsigned short)_kb_val->voltage_b;
            data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
            data_temp[4] = (unsigned short)_kb_val->current_k;
            data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
            data_temp[6] = (unsigned short)_kb_val->current_b;
            data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
            g_modbus_write_x_reg(manger,saddr,offset,8, data_temp);
            */
        }
        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 board_data_t* board_next(power_handle_t *h)
{
    uint8_t addr=h->cur_addr;
    while(1) {
        h->cur_addr++;
        if(h->cur_addr>h->brd_max) {
            h->cur_addr = 1;
        }
        else if(h->cur_addr==addr) {
            break;
        }
        if(h->pbrd[h->cur_addr]) {
            return h->pbrd[h->cur_addr];
        }
    }
    return NULL;
}
static uint8_t get_ch_idx(board_data_t *pbrd, uint8_t sch)
{
    uint8_t ch=0;
    uint8_t pwr_type=paras_get()->prod.pwr_type;
    if(pbrd->type==TREE_AC_TYPE) {
        if(pwr_type == PDU_AC_I3O3) {
            ch = pbrd->ch0 + sch/3;
        }
        else {
            ch = pbrd->ch0 + sch;
        }
    }
    else {
        ch = pbrd->ch0 + sch;
    }
    
    return ch;
}
static int threshold_proc(board_data_t *pbrd)
{
    int i,j,r=-1;
    
    
    
    return 0;
}
static board_data_t* board_query(power_handle_t *h)
{
    int i,j,r=-1;
    uint16_t offset,tmp[144];
    board_data_t *pbrd=NULL;
    
    lock_d_hold(h->lck);
    pbrd = board_next(h);
    if(pbrd) {
        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) {
                    LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
                    break;
                }
                
                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);
                    break;
                }
 
                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_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);
                    break;
                }
                
                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_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);
                    break;
                }
                
                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_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);
                    break;
                }
                
                for (i = 0; i < pbrd->chs; i++) {
                    int Index = i * 2;
                    pbrd->pch[i].alarm.v_upper = tmp[0+Index] & BIT(0);
                    pbrd->pch[i].alarm.v_lower = tmp[0+Index] & BIT(1);
                    pbrd->pch[i].alarm.c_upper = tmp[0+Index] & BIT(2);
                    pbrd->pch[i].alarm.p_upper = tmp[0+Index] & BIT(3);
                    pbrd->pch[i].alarm.w_upper = tmp[0+Index] & BIT(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);
                    break;
                }
                
                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);
                    break;
                }
                
                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);
                    break;
                }
                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);
                    break;
                }
                for (i=0; i<pbrd->chs; i++) {
                    int Index = i * 2;
                    pbrd->pch[i].alarm.v_upper = tmp[0+Index] & BIT(0);
                    pbrd->pch[i].alarm.v_lower = tmp[0+Index] & BIT(1);
                    pbrd->pch[i].alarm.c_upper = tmp[0+Index] & BIT(2);
                    pbrd->pch[i].alarm.p_upper = tmp[0+Index] & BIT(3);
                    pbrd->pch[i].alarm.w_upper = tmp[0+Index] & BIT(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);
                    break;
                }
                
                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:
            break;
        }
        
        if(r==0) {
            threshold_proc(pbrd);
        }
    }
    lock_d_release(h->lck);
    
    return pbrd;
}


static void *power_thread(void *arg)
{
    int r;
    board_data_t *pbrd=NULL;
    thread_handle_t *th=(thread_handle_t*)arg;
    power_handle_t *h=(power_handle_t*)th->arg;;
    
    power_scan();
    while(th->quit==0) {
        board_query(h);
        sleep(1);
    }
    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;
    }
    h->cur_addr = 0;
    h->brd_max = BRD_NUM;
    h->prod = &paras_get()->prod;
    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->pch || !h->chs || !h->pch[ch]) {
        lock_d_release(h->lck);
        return -1;
    }
    *pch = *h->pch[ch];
    lock_d_release(h->lck);
    
    return 0;
}


int power_get_board(board_data_t *pb)
{
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    if(!pb || !h->pch || !h->cnt || !h->pbrd[pb->addr]) {
        lock_d_release(h->lck);
        return -1;
    }
    *pb = *h->pbrd[pb->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->pch || !h->chs || !h->pch[pch->info.ch]) {
        lock_d_release(h->lck);
        return -1;
    }
    *h->pch[pch->info.ch] = *pch;
    lock_d_release(h->lck);
    
    return 0;
}

static int pch_map(power_handle_t *h, int chs)
{
    int i,j,r,idx=0;
    board_data_t *pbrd=NULL;
    uint8_t pwr_type=paras_get()->prod.pwr_type;
    
    if(chs>0) {
        h->chs = 0;
        h->pch = (power_ch_t**)calloc(1, sizeof(power_ch_t*)*chs);
        if(h->pch) {
            h->chs = chs;
            for(i=1; i<=h->brd_max; i++) {
                pbrd = h->pbrd[i];
                if(pbrd) {
                    for(j=0; j<pbrd->chs; j++) {
                        h->pch[idx++] = &h->pbrd[i]->pch[j];
                    }
                }
            } 
        }
    }
    
    return 0;
}

int power_scan(void)
{
    int r,i,j,chs=0;
    int ch_idx=0,brd_idx=0;
    power_handle_t *h=&pwrHandle;
    board_key_t *pkey=NULL;
    uint16_t times,nGroups=h->prod->ch_delay;
    
    power_clear();
    
    lock_d_hold(h->lck);
    h->cur_addr = 0;
    for(i=1; i<=h->brd_max; i++) {
        r = get_key(h, i, &h->key[i]);
        if(r==0) {
            LOGD("___ power_scan addr %d ok, type: %d, chs: %d\n", i, h->key[i].type, h->key[i].chs);
        }
        else {
            LOGE("___ power_scan addr %d failed\n", i);
        }
    }
    
    for(i=1; i<h->brd_max; i++) {
        pkey = &h->key[i];
        if(pkey->chs>0) {
            h->pbrd[i] = (board_data_t*)calloc(1, sizeof(board_data_t));
            if(h->pbrd[i]) {
                h->pbrd[i]->type = pkey->type;
                h->pbrd[i]->chs  = pkey->chs;
                h->pbrd[i]->addr = i;
                h->pbrd[i]->ch0 = ch_idx;
                h->pbrd[i]->pch = (power_ch_t*)calloc(1, sizeof(power_ch_t)*pkey->chs);
                if(h->pbrd[i]->pch) {
                    times = (ch_idx+1)%nGroups?(ch_idx+1):nGroups;
                    for(j=0; j<pkey->chs; j++) {
                        h->pbrd[i]->pch[j].info.addr = i;
                        h->pbrd[i]->pch[j].info.sch = j;                    //序号从0开始
                        h->pbrd[i]->pch[j].info.type = pkey->type;
                        h->pbrd[i]->pch[j].info.start_delay = 1000*times;
                        h->pbrd[i]->pch[j].info.stop_delay  = 1000*times;
                        
                        if(h->prod->pwr_type==PDU_AC_I3O3) {
                            h->pbrd[i]->pch[j].info.ch  = ch_idx+j/3;       //序号程序从0开始
                            h->pbrd[i]->pch[j].info.pid = j%3;
                        }
                        else {
                            h->pbrd[i]->pch[j].info.ch  = ch_idx+j;         //序号程序从0开始
                            h->pbrd[i]->pch[j].info.pid = 0;
                        }
                    }
                    
                    if(h->prod->pwr_type==PDU_AC_I3O3) {
                        ch_idx += pkey->chs/3;
                    }
                    else {
                        ch_idx += pkey->chs;
                    }
                }
                brd_idx++;
            }
            chs += pkey->chs;
        }
    }
    pch_map(h, chs);
    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<=h->brd_max; i++) {
        if(h->pbrd[i]) {
            for(j=0; j<h->pbrd[i]->chs; j++) {
                if(h->pbrd[i]->pch) {
                    free(h->pbrd[i]->pch);
                    h->pbrd[i]->pch = NULL;
                }
                h->pbrd[i]->chs = 0;
            }
            free(h->pbrd[i]);
            h->pbrd[i] = NULL;
        }
    }
    memset(h->key, 0, sizeof(h->key));
    h->cnt = 0;
    lock_d_release(h->lck);
    
    return 0;
}


int power_reset_consump(uint8_t addr)
{
    int i,r=-1;
    uint16_t offset = 0;
    power_handle_t *h=&pwrHandle;
    board_data_t *pb=NULL;
    
    if(addr>h->brd_max) {
        return -1;
    }
    pb = h->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_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(power_ch_t *pch)
{
    int r;
    power_ch_t pc;
    power_handle_t *h=&pwrHandle;
    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;
            tmp[0] = pch->power[0].status; tmp[1] = 0;
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t mask;
            offset = POWER_DC_STAT_INFO+pch->info.ch;
            
            mask = ~(1 << pch->info.ch);
            tmp[0] &= mask;
            tmp[0] |= (st << pch->info.ch);
        }
        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;
        }
        break;
        
        default:
        return -1;
    }
    r = write_reg(h, pc.info.addr, offset, tmp, 2);
    
    return r;
}

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


int power_set_threshold(power_ch_t *pch)
{
    int r=-1;
    uint16_t offset;
    power_handle_t *h=&pwrHandle;
    
    switch(pch->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 =  (pch->thr.v_upper.val*1000);
            data_buf[0] = data_temp;
            data_buf[1] = data_temp>>16;
            //电压下限
            data_temp =  (pch->thr.v_upper.val*1000);
            data_buf[2] = data_temp;
            data_buf[3] = data_temp>>16;
            //电流上限
            data_temp =  (pch->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 =  (pch->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 =  (pch->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(pch->info.ch<0) {
                offset = POWER_AC_TOTAL_THRESHOLD;
            }
            else  {
                offset = POWER_AC_THRESHOLD_L+pch->info.ch*16;
            }

            r = write_reg(h, pch->info.addr, offset, data_buf, 16);
            //power_set_alarm();
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t data_temp[4];
            uint32_t value;
            
            offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_VOL_MAX:POWER_DC_THRESHOLD_VOL_MAX;
            value = pch->thr.v_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            
            offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_VOL_MIN:POWER_DC_THRESHOLD_VOL_MIN;
            value = pch->thr.v_lower.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            
            offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_CUR_MAX:POWER_DC_THRESHOLD_CUR_MAX;
            value = pch->thr.c_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            
            offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_PWR_MAX:POWER_DC_THRESHOLD_POWER_MAX;
            value = pch->thr.p_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            
            offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_PWRCON_MAX:POWER_DC_THRESHOLD_POWERCON_MAX;
            value = pch->thr.w_upper.val * 1000;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            
            //power_set_alarm();
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t data_temp[4];
            uint32_t value;
            
            if(pch->info.ch<0) {
                offset = POWER_AC3_THRESHOLD_IN;
                value = pch->thr.v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
                value = pch->thr.v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset+1, data_temp, 2);
                
                value = pch->thr.c_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset+2, data_temp, 2);
                
                value = pch->thr.p_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset+3, data_temp, 2);
                
                value = pch->thr.w_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset+4, data_temp, 2);
            }
            else {
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                value = pch->thr.v_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_VOL_MIN;
                value = pch->thr.v_lower.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_CUR_MAX;
                value = pch->thr.c_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_PWR_MAX;
                value = pch->thr.p_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                value = pch->thr.w_upper.val * 1000;
                data_temp[0] = value & 0XFFFF;
                data_temp[1] = (value >> 16) & 0xFFFF;
                r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            }
        }
        break;
    }
    
    return r;
}


int power_set_start_delay(power_ch_t *pch)
{
    int r=-1;
    uint16_t tmp[2],reg,offset;
    power_handle_t *h=&pwrHandle;
    
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            tmp[0] = pch->info.start_delay;
            offset = POWER_AC_START_DELAY_TIME_L+pch->info.ch;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;

        case DCPDU_TYPE:
        {
            uint32_t time=pch->info.start_delay/1000;
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
            offset = POWER_DC_SET_START_DELAY+pch->info.ch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint32_t time=pch->info.start_delay/1000;
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
            if(h->prod->pwr_type==PDU_AC_I3O3) {
                offset = POWER_AC3_START_DELAY_TIME+pch->info.sch*3;
                r = write_reg(h, pch->info.addr, offset+0, tmp, 2);
                if(r) break;
                r = write_reg(h, pch->info.addr, offset+1, tmp, 2);
                if(r) break;
                r = write_reg(h, pch->info.addr, offset+2, tmp, 2);
                if(r) break;
            }
            else {
                offset = POWER_AC3_START_DELAY_TIME+pch->info.sch;
                r = write_reg(h, pch->info.addr, offset, tmp, 2);
            }
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
    
    return r;
}
int power_set_stop_delay(power_ch_t *pch)
{
    int r=-1;
    uint16_t tmp[2],reg,offset;
    power_handle_t *h=&pwrHandle;
    
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            tmp[0] = pch->info.start_delay;
            offset = POWER_AC_STOP_DELAY_TIME_L+pch->info.ch;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;

        case DCPDU_TYPE:
        {
            uint32_t time=pch->info.stop_delay/1000;
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
            offset = POWER_DC_SET_STOP_DELAY+pch->info.ch;
            //r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint32_t time=pch->info.stop_delay/1000;
            if(h->prod->pwr_type==PDU_AC_I3O3) {
                offset = POWER_AC3_STOP_DELAY_TIME+pch->info.sch*3;
                r = write_reg(h, pch->info.addr, offset+0, tmp, 2);
                if(r) break;
                r = write_reg(h, pch->info.addr, offset+1, tmp, 2);
                if(r) break;
                r = write_reg(h, pch->info.addr, offset+2, tmp, 2);
                if(r) break;
            }
            else {
                offset = POWER_AC3_START_DELAY_TIME+pch->info.sch;
                r = write_reg(h, pch->info.addr, offset, tmp, 2);
            }
        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        return -1;
    }
    
    return r;
}


int power_data_clone(power_data_t *pd)
{
    int i,r=-1;
    power_handle_t *h=&pwrHandle;
    
    lock_d_hold(h->lck);
    if(h->chs>0) {
        if(!pd->pch || pd->chs!=h->chs) {
            if(pd->pch) free(pd->pch);
            pd->chs = 0;
            pd->pch = malloc(sizeof(power_ch_t)*h->chs);
        }
        
        if(pd->pch) {
            pd->chs = h->chs;
            for(i=0; i<pd->chs; i++) {
                pd->pch[i] = *h->pch[i];
            }
        }
    }
    lock_d_release(h->lck);
    
    return 0;
}