SmartPDCode/f427/applications/power.c

#include "mb.h"
#include "cfg.h"
#include "web.h"

#include "list.h"
#include "paras.h"
#include "power.h"
#include "thread.h"
#include "datadef.h"
#include "wanning.h"
#include "beep.h"
#include "time.h"
#include "snmp.h"

#define  SECOND_MIL   20

enum 
{
	STR_POWER_ID_OVER,
	STR_POWER_ID_LOW,
	STR_POWER_ID_MAXS,
	STR_POWER_ID_MIN,
	STR_POWER_ID_VOL,
	STR_POWER_ID_CUR,
	STR_POWER_ID_POWER,
	STR_POWER_ID_CONSUMER,
	STR_POWER_ID_MAX
};
enum{

	CTRL_3_3 = 8,
	CTRL_3_2,

};




const char *lang_power_str[2][STR_POWER_ID_MAX]={
	{
		"超过",
		"低于",
		"最大",
		"最小",
		"电压",
		"电流",
		"功率",
		"耗电量",
	},
	{
		"over",
		"below",
		"max",
		"min",
		"voltage",
		"current",
		"power",
		"consumer",
	},
};

enum 
{
	STR_LOSE_ID,
	STR_LOSE_MAX,
};


const char *lang_lose_string[2][STR_LOSE_MAX]={
	{
		"缺相",
	},
	{
		"phase lose"
	},
};



extern AlarmTrapinfo data;

#define LIMIT_HOF(x)  (x*1.1f)
#define LIMIT_LOF(x)  (x*0.9f)

static power_handle_t pwrHandle={0};
static int write_reg(power_handle_t *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt);

power_handle_t * get_power_handle(void)
{
	return &pwrHandle;
}

static int get_power(power_ch_t *pch)
{
    return power_get_ch(pch->info.ch, pch);
}
static int get_alarm(power_ch_t *pch)
{
    power_ch_t pc;
    int r = power_get_ch(pch->info.ch, &pc);
    if(r==0) {
        pch->alarm = pc.alarm;
    }
    return r;
}
static int set_ch(power_ch_t *pch)
{
    return power_set_ch_sw(pch->info.ch, pch->status);
}
static int set_open_delay(power_ch_t *pch)
{
    return power_set_open_delay(pch);
}
static int set_close_delay(power_ch_t *pch)
{
    return power_set_close_delay(pch);
}
static int set_kb_value(power_ch_t *pch)
{
    return 0;//power_set_kb_val(pch);
}
static int set_threshold(power_ch_t *pch)
{
    return power_set_threshold(pch);
}
static int reset_consump(power_ch_t *pch)
{
    return power_reset();
}
static int do_detect(uint8_t addr)
{
    return 0;
}
static int get_info(uint8_t addr, board_info_t *info)
{
    return 0;
}
static int get_board(board_data_t *pbrd)
{
    return 0;
}
static int set_board(uint8_t addr, uint8_t on)
{
    return power_set_board_sw(addr, on);
}
static int set_all(uint16_t on,board_data_t *data)
{
		
    //return power_set_all_sw(on);
}


int board_ac_all_status(uint16_t on_off,board_data_t *board)
{
	//power_handle_t *h=&pwrHandle;
	power_handle_t *h=&pwrHandle;
	uint16_t switch_ctrl[8] = {0};
	lock_on(h->lck);
  for (size_t i = 0; i < 8; i++)
  {
    switch_ctrl[i] = on_off;
		if(on_off==1)
		{
			switch_ctrl[i] |= (1<<11);
		}else
		{
			switch_ctrl[i] |= (1<<12);
		}
  }
	write_reg(h, board->addr, POWER_AC_CH_STAT_L, &switch_ctrl[0], board->chs);
	lock_off(h->lck);
	return 0;
}

int board_dc_all_status(uint16_t on_off,board_data_t *board)
{
	//POWER_DC_ALL_OPEN_INFO
	power_handle_t *h=&pwrHandle;
	uint32_t val = on_off;
	lock_on(h->lck);
	if(on_off==1)
	{
		write_reg(h, board->addr, POWER_DC_ALL_OPEN_INFO, (uint16_t*)&val,2);
	}else
	{
		val = 0;
	 int r = write_reg(h, board->addr, POWER_DC_ALL_CLOSE_INFO, (uint16_t*)&val,2);
	}
	lock_off(h->lck);
	return 0;
}
int board_ac3_all_status(uint16_t on_off,board_data_t *board)
{
	power_handle_t *h=&pwrHandle;
	uint32_t val = on_off;
	lock_on(h->lck);
	if(on_off==1)
	{
		write_reg(h, board->addr, POWER_AC3_ALL_OPEN_INFO, (uint16_t*)&val,2);
	}else
	{
		val = 0;
		write_reg(h, board->addr, POWER_AC3_ALL_CLOSE_INFO, (uint16_t*)&val,2);
	}
	lock_off(h->lck);	
}

static board_fn_t board_fn_ac={
//    .get_power = get_power,
//    .get_alarm = get_alarm,
//    .set_ch = set_ch,
//    .set_open_delay = set_open_delay,
//    .set_close_delay = set_close_delay,
//    .set_kb_value = set_kb_value,
//    .set_threshold = set_threshold,
//    .reset_consump = reset_consump,

//    .detect = do_detect,
//    .get_info = get_info,
//    //.get_board = get_board,
//    .set_board = set_board,
    .set_all = board_ac_all_status,
};
static board_fn_t board_fn_dc={
    .set_all = board_dc_all_status,
};
static board_fn_t board_fn_ac3={
    .set_all = board_ac3_all_status,
};

static int get_flag(power_handle_t *h, uint8_t ch, uint8_t thr)
{
    return (h->flag[ch]&(1<<thr))?1:0;
}
static void set_flag(power_handle_t *h, uint8_t ch, uint8_t thr, int flag)
{
    if(flag) {
        h->flag[ch] |= 1<<thr;
    }
    else {
        h->flag[ch] &= ~(1<<thr);
    }
}

static int alarm_evt_handle(power_handle_t *h, power_ch_t *pch)
{
    alarm_data_t ad;
    
    ad.ch = pch->info.ch;
    ad.alarm = pch->alarm;
   // ad.time = pch->time;
    web_post(PKT_TYPE_ALARM, &ad, sizeof(ad));
    
    return 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)
{
    int i,r=0;
    for(i=0; i<POWER_RETRY_TIMES; i++) {
        r = mb_read(MB_ID_POWER, addr, reg, data, cnt, POWER_BOARD_TIMEOUT);
        if(r==cnt) {
            break;
        }
    }
    return (r==cnt)?0:-1;
}
static int write_reg(power_handle_t *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    int i,r=0;
    for(i=0; i<POWER_RETRY_TIMES; i++) {
        r = mb_write(MB_ID_POWER, addr, reg, data, cnt);
        if(r==cnt) break;
    }
    return (r==cnt)?0:-1;
}
////////////////////////////////////////////////////////////////////
static int get_key(power_handle_t *h, uint8_t addr, board_key_t *key)
{
    int i,r;
    uint16_t tmp[2];
    
    if(h->prod->type==PDU_AC_I1O1 || h->prod->type==PDU_AC_I3O1_H) {
        r = read_reg(h, addr, POWER_AC_GET_INFO, tmp, 1);
        if(r==0) {
            key->type = (tmp[0]>>8)&0xFF;
            key->chs = tmp[0]&0xFF;
        }
				
    }
    else {
        r = read_reg(h, addr, POWER_DC_INFO, tmp, 2);
        if(r==0) {
            key->type = (tmp[0]>>8)&0xFF;
            key->chs = tmp[0]&0xFF;
					if(h->prod->type == PDU_AC_I3O3)			
					{
						key->chs /= 3;
					}
					if(h->prod->type == PDU_AC_I3O2)
					{
						key->chs /= 2;
					}
          return 0;
        }
    }
    
    return r;
}
////////////////////////////////////////////////////////////////
int power_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 uint8_t get_ch_idx(board_data_t *pbrd, uint8_t sch)
{
    uint8_t ch=0;
    uint8_t pwr_type=paras_get()->prod.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(power_handle_t *h, board_data_t *pbrd)
{
    int i,j,r=-1,times=1;
    power_ch_t *pch=NULL;
    
    for (i=0; i<pbrd->chs; i++) {
        pch = &pbrd->pch[i];
        if(h->prod->type==PDU_AC_I3O3) {
            times = 3;
            
            //设置为输出三相且三相有缺失则报警
            if(pch->info.ph_val && pbrd->ph_loss  && get_flag(h, pch->info.ch, ALARM_PH_LOSS)==0) {
                set_flag(h, pch->info.ch, ALARM_PH_LOSS, 1);
                alarm_evt_handle(h, pch);
            }
            else {
                set_flag(h, pch->info.ch, ALARM_PH_LOSS, 0);
            }
        }
        
        for(j=0; j<times; j++) {
            if(pch->thr.en.v_upper_en) {
                if(pch->power[j].voltage>pch->thr.v_upper) {
                    if(pch->alarm.l1_v_upper && get_flag(h, pch->info.ch, ALARM_V_UPPER)==0) {
                        set_flag(h, pch->info.ch, ALARM_V_UPPER, 1);
                        alarm_evt_handle(h, pch);
                    }
                }
                else if(pch->power[j].voltage<pch->thr.v_lower) {
                    if(pch->alarm.l1_v_lower && get_flag(h, pch->info.ch, ALARM_V_LOWER)==0) {
                        set_flag(h, pch->info.ch, ALARM_V_LOWER, 1);
                        alarm_evt_handle(h, pch);
                    }
                }
                else {
                    set_flag(h, pch->info.ch, ALARM_V_UPPER, 0);
                    set_flag(h, pch->info.ch, ALARM_V_LOWER, 0);
                }
            }
            
            if(pch->thr.en.c_upper_en) {
                if(pch->power[j].current>pch->thr.c_upper) {
                    if(pch->alarm.l1_c_upper && get_flag(h, pch->info.ch, ALARM_C_UPPER)==0) {
                        set_flag(h, pch->info.ch, ALARM_C_UPPER, 1);
                        alarm_evt_handle(h, pch);
                    }
                    else {
                        set_flag(h, pch->info.ch, ALARM_C_UPPER, 0);
                    }
                }
            }
            
            if(pch->thr.en.p_upper_en) {
                if(pch->power[j].power>pch->thr.p_upper) {
                    if(pch->alarm.l1_p_upper && get_flag(h, pch->info.ch, ALARM_P_UPPER)==0) {
                        set_flag(h, pch->info.ch, ALARM_P_UPPER, 0);
                        alarm_evt_handle(h, pch);
                    }
                }
                else {
                    set_flag(h, pch->info.ch, ALARM_P_UPPER, 0);
                }
            }
            
            if(pch->thr.en.w_upper_en) {
                if(pch->power[j].current>pch->thr.w_upper) {
                    if(pch->alarm.l1_w_upper==1 && get_flag(h, pch->info.ch, ALARM_W_UPPER)==0) {
                        set_flag(h, pch->info.ch, ALARM_W_UPPER, 1);
                        alarm_evt_handle(h, pch);
                    }
                }
                else {
                    set_flag(h, pch->info.ch, ALARM_C_UPPER, 0);
                }
            }
        }
    }
    
    return 0;
}
static int total_proc(power_handle_t *h)
{
    total_t tmp[3]={0};
    int i,j,k,r=-1,times=1;
    power_ch_t *pch=NULL;
    board_data_t *pbrd=NULL;
    
    lock_on(h->lck);
    if(h->prod->type==PDU_AC_I3O3) times = 3;
		


		for(int i = 1 ;i < h->chs;i++)
		{
			float chn_total_p = 0.0;
			for(k=0; k<times; k++) {
				chn_total_p = (  h->pch[i]->power[k].factor == 0 ? 0 : ( h->pch[i]->power[k].power/100.0 /  h->pch[i]->power[k].factor * 100.0));
				tmp[k].consump += (h->pch[i]->power[k].consump/100.0);
				tmp[k].voltage = (tmp[k].voltage > h->pch[i]->power[k].voltage/100.0 ) ? tmp[k].voltage : h->pch[i]->power[k].voltage/100.0;
				tmp[k].current += ( h->pch[i]->power[k].current/100.0);
				tmp[k].power   += h->pch[i]->power[k].power/100.0; 
				tmp[k].reactive += chn_total_p;
				tmp[k].active +=(chn_total_p-(h->pch[i]->power[k].power/100.0));
			}
		}
		

//    for(i=0; i<h->brd_max; i++) {
//        if(h->pbrd[i]) {
//            for (j=0; i<h->pbrd[i]->chs; i++) {
//                pch = &h->pbrd[i]->pch[j];
//								float chn_total_p = 0.0; 
//                for(k=0; k<times; k++) {
//                    chn_total_p = ( pch->power[j].factor == 0 ? 0 : (pch->power[j].power/1000.0 / pch->power[j].factor * 100.0));
//										tmp[k].voltage = pch->power[j].voltage/10.0;
//                    tmp[k].current += (pch->power[j].current/10.0);
//										
//										tmp[k].power   += chn_total_p;
//                    tmp[k].freq    = (pch->power[j].freq/10.0);
//                    tmp[k].consump += (pch->power[j].consump/1000.0);
//#if 1
//                    tmp[k].active  += pch->power[j].power/1000.0;
//                    tmp[k].reactive += (chn_total_p-(pch->power[j].power/1000.0));
//#endif
//                }
//            }
//        }
//    }
    
    h->ttl.type = h->prod->type;
    for(k=0; k<times; k++) {
        h->ttl.total[k].voltage = tmp[k].voltage;
        h->ttl.total[k].current = tmp[k].current;
        h->ttl.total[k].power = tmp[k].power;
        h->ttl.total[k].freq = tmp[k].freq;
        h->ttl.total[k].consump = tmp[k].consump;
				h->ttl.total[k].factor = ((tmp[k].reactive == 0) ? 0 : tmp[k].power/tmp[k].reactive);
        h->ttl.total[k].active  = tmp[k].active;
        h->ttl.total[k].reactive = tmp[k].reactive;
    }
    lock_off(h->lck);
    
    return 0;
}

typedef struct 
{	
	uint8_t id;
	uint8_t wanning_type;
	uint8_t power_type;
	uint8_t ph_info;
	uint8_t over;
	uint8_t max_min;
	uint8_t ele_info;
}op_wanning_info;



static void wanning_operation(op_wanning_info  *info,char *name)
{
	
	
	waning_info_t w_info= {0};
	uint8_t lang = paras_get()->sys.lang;
	
	time_t t=time(NULL);
	struct tm *tm=localtime(&t);
	
	w_info.type = info->wanning_type;
	sprintf(w_info.date, "%04d%/%02d/%02d %2d:%2d:%2d", (tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday,tm->tm_hour, tm->tm_min, tm->tm_sec);
	if(info->power_type == PDU_AC_I1O1 || info->power_type == PDU_DC_I1O1)
	{
		sprintf(w_info.waning_context,"%s %s %s %s!",name,lang_power_str[lang][info->over],lang_power_str[lang][info->max_min],lang_power_str[lang][info->ele_info]);
	}else
	{
		char buff[20] = {0};
		sprintf(buff,"L%d",info->ph_info);
		sprintf(w_info.waning_context,"%s %s %s %s %s!",name,buff,lang_power_str[lang][info->over],lang_power_str[lang][info->max_min],lang_power_str[lang][info->ele_info]);
	}
	wanning_insert(w_info);
	
	if(paras_get()->snmp.trapmode == 1)
	{
			data.ID = info->id;
			data.Alarmid = ALARM_TYPE_POWER;
			memcpy(data.AlarmDate,w_info.date,32);
			memcpy(data.AlarmContext,w_info.waning_context,64);
			snmp_power_alarm_trap(&data);
	}
	beep_set(1);
}





static void lose_operation(char *name,int id,uint8_t ph)
{
	waning_info_t w_info= {0};
	uint8_t lang = paras_get()->sys.lang;
	
	time_t t=time(NULL);
	struct tm *tm=localtime(&t);
	sprintf(w_info.date, "%04d%/%02d/%02d %2d:%2d:%2d", (tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday,tm->tm_hour, tm->tm_min, tm->tm_sec);
	sprintf(w_info.waning_context,"%s L%d %s!",name,ph,lang_lose_string[lang][STR_LOSE_ID]);
	wanning_insert(w_info);
	
	if(paras_get()->snmp.trapmode == 1)
	{
			data.ID = id;
			data.Alarmid = ALARM_TYPE_POWER;
			memcpy(data.AlarmDate,w_info.date,32);
			memcpy(data.AlarmContext,w_info.waning_context,64);
			snmp_power_alarm_trap(&data);
	}
	beep_set(1);	
	
}




static int board_read(power_handle_t *h, board_data_t *pbrd,uint8_t flag)
{
    int i,j,r=-1;
    power_t *pwr,power;
    uint16_t offset,tmp[144];
    power_ch_t *pch=NULL;
		uint8_t lang = paras_get()->sys.lang;

		uint8_t old_l1_v_upper = 0;
		uint8_t old_l1_v_lower = 0;
		uint8_t old_l1_c_upper = 0;
		uint8_t old_l1_p_upper = 0;
		uint8_t old_l1_w_upper = 0;

		uint8_t old_l2_v_upper = 0;
		uint8_t old_l2_v_lower = 0;
		uint8_t old_l2_c_upper = 0;
		uint8_t old_l2_p_upper = 0;
		uint8_t old_l2_w_upper = 0;

		uint8_t old_l3_v_upper = 0;
		uint8_t old_l3_v_lower = 0;
		uint8_t old_l3_c_upper = 0;
		uint8_t old_l3_p_upper = 0;
		uint8_t old_l3_w_upper = 0;	
		
		uint8_t  old_l1_ph_lost = 0;
		uint8_t  old_l2_ph_lost = 0;
		uint8_t  old_l3_ph_lost = 0;
		
		
    lock_on(h->lck);


    if(pbrd) {
       // time_t tm = mktime(localtime(NULL));
        switch(pbrd->type) {
            case AC_SINGLE_S_TYPE:
            case AC_SINGLE_B_TYPE:
            {

								uint32_t val;
											
                offset = POWER_AC_CUR_INFO_L;
                r = read_reg(h, pbrd->addr, offset, tmp, pbrd->chs*12);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs*12);
                    break;
                }

								
								
                for (i=0; i<pbrd->chs; i++) {
                    int idx = i * 12;
                    pwr = &pbrd->pch[i].power[0];
                    
                    val = (tmp[1 + idx] << 16) | tmp[0 + idx];
                    pwr->voltage = val / 10;
                    
                    val = (tmp[3 + idx] << 16) | tmp[2 + idx];
                    pwr->current = val / 10;
                    
                    val = (tmp[5 + idx] << 16) | tmp[4 + idx];
                    pwr->power = val / 10;
                    
                    val = (tmp[7 + idx] << 16) | tmp[6 + idx];
                    pwr->freq = val / 10;
                    
                    val = (tmp[9 + idx] << 16) | tmp[8 + idx];
                    pwr->consump = val / 10;
                    
                    val = (tmp[11 + idx] << 16) | tmp[10 + idx];
                    pwr->factor = val / 10;
                    
                  //  pbrd->pch[i].time = tm;
                }

                offset = POWER_AC_STAT_INFO_L;
								memset(tmp,0,sizeof(tmp));
                r = read_reg(h, pbrd->addr, offset, tmp, pbrd->chs);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
                    break;
                }
								op_wanning_info info={0};
                for (i=0; i<pbrd->chs; i++) {
                    pch = &pbrd->pch[i];
                    //pch->power[0].status = tmp[i] & (0x01);
										pch->status = tmp[i] & (0x01);
										old_l1_v_upper = pch->alarm.l1_v_upper;
										old_l1_v_lower = pch->alarm.l1_v_lower;
										old_l1_c_upper = pch->alarm.l1_c_upper;
										old_l1_p_upper = pch->alarm.l1_p_upper;
										old_l1_w_upper = pch->alarm.l1_w_upper;
									
                    pch->alarm.l1_v_upper   = (tmp[i] & BIT(2))?1:0;
                    pch->alarm.l1_v_lower   = (tmp[i] & BIT(4))?1:0;
                    pch->alarm.l1_c_upper   = (tmp[i] & BIT(6))?1:0;
                    pch->alarm.l1_p_upper   = (tmp[i] & BIT(8))?1:0;
                    pch->alarm.l1_w_upper   = (tmp[i] & BIT(10))?1:0;
									
										info.id = i;
										info.wanning_type = ALARM_TYPE_POWER;
									  info.power_type = h->prod->type;
										if(h->prod->type == PDU_AC_I3O1 || h->prod->type == PDU_AC_I3O1_H)
										{
											info.ph_info = pch->info.ph_id;
										}
										if(!old_l1_v_upper && pch->alarm.l1_v_upper)
										{	
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l1_v_lower && pch->alarm.l1_v_lower)
										{
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l1_c_upper && pch->alarm.l1_c_upper)
										{
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l1_p_upper && pch->alarm.l1_p_upper)
										{
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l1_w_upper && pch->alarm.l1_w_upper)
										{
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}														

                }

								if(flag)
								{
									offset = POWER_AC_BREAKER_INFO;
									r = read_reg(h, pch->info.addr, offset, tmp, 1);
									if (r < 0) {
											LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
											break;
									}

									pbrd->brk[0].samp.sw = (tmp[0]&BIT(0))?1:0;
									pbrd->brk[1].samp.sw = (tmp[0]&BIT(1))?1:0;

									if(pbrd->chs < 8)
									{
										offset = POWER_AC_THRESHOLD_L;
										r = read_reg(h, pch->info.addr, offset, tmp, pbrd->chs * 16);
										if(r) break;
										for (i=0; i<pbrd->chs; i++) {
											pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[1]<<16)|tmp[0])/10;
											pch->thr.v_lower = ((tmp[3]<<16)|tmp[2])/10;
											pch->thr.c_upper = ((tmp[5]<<16)|tmp[4])/10;
											pch->thr.p_upper = ((tmp[9]<<16)|tmp[8])/10;
											pch->thr.w_upper = ((tmp[13]<<16)|tmp[12]/10);
										}
									}else
									{
										offset = POWER_AC_THRESHOLD_L;
										r = read_reg(h, pch->info.addr, offset, tmp, 7 * 16);
										if(r) break;
										for (i=0; i< 7; i++) {
											pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[1]<<16)|tmp[0])/10;
											pch->thr.v_lower = ((tmp[3]<<16)|tmp[2])/10;
											pch->thr.c_upper = ((tmp[5]<<16)|tmp[4])/10;
											pch->thr.p_upper = ((tmp[9]<<16)|tmp[8])/10;
											pch->thr.w_upper = ((tmp[13]<<16)|tmp[12]/10);										
										}
										offset = POWER_AC_THRESHOLD_L + (16*7);
										
										r = read_reg(h, pch->info.addr, offset, tmp, (pbrd->chs-7) * 16);
										for (i=0; i< (pbrd->chs-7); i++) {
											pch = &pbrd->pch[i+7];
											pch->thr.v_upper = ((tmp[1]<<16)|tmp[0])/10;
											pch->thr.v_lower = ((tmp[3]<<16)|tmp[2])/10;
											pch->thr.c_upper = ((tmp[5]<<16)|tmp[4])/10;
											pch->thr.p_upper = ((tmp[9]<<16)|tmp[8])/10;
											pch->thr.w_upper = ((tmp[13]<<16)|tmp[12])/10;										
										}
										
									}

									offset = POWER_AC_OPEN_DELAY_TIME_L;
									r =read_reg(h, pch->info.addr, offset, tmp, pbrd->chs);
									for(int i = 0; i < pbrd->chs;i++)
									{
										pch = &pbrd->pch[i];
										pch->info.open_delay = tmp[i] / 1000;
									}
									offset = POWER_AC_CLOSE_DELAY_TIME_L;
									r =read_reg(h, pch->info.addr, offset, tmp, pbrd->chs);

									
									for(int i = 0; i < pbrd->chs;i++)
									{
										pch = &pbrd->pch[i];
										pch->info.close_delay = tmp[i] / 1000;
									}		
								}
			
            }
            break;

            case DCPDU_TYPE:
            {
                uint32_t status_flag;
                //uint16_t *ptmp = tmp + 32;
                
                offset = POWER_DC_OUT_INFO;
                r = read_reg(h, pbrd->addr, offset, tmp, 32);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 32);
                    break;
                }
								 offset = POWER_DC_OUT_INFO + 16;
								uint16_t *ptmp = tmp + 32;
								
                r = read_reg(h, pbrd->addr, offset, ptmp, 32);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 32);
                    break;
                }               
                for (i = 0; i < pbrd->chs; i++) {
                    int Index = i * 8;
                    pwr = &pbrd->pch[i].power[0];
                    
                    float value = (tmp[1 + Index] << 16) + tmp[0 + Index];
                    pwr->voltage = value / 10;
                    
                    value = (tmp[3 + Index] << 16) + tmp[2 + Index];
                    pwr->current = value / 10;
                    
                    value = (tmp[5 + Index] << 16) + tmp[4 + Index];
                    pwr->power = value / 10;

                    value = (tmp[7 + Index] << 16) + tmp[6 + Index];
                    pwr->consump = value /10;

                    pwr->freq = 0;
                    pwr->factor = 1;
                    //pbrd->pch[i].time = tm;
                }

                offset = POWER_DC_STAT_INFO;
                r = read_reg(h, pbrd->addr, offset, tmp, 2);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 2);
                    break;
                }
                
                for (i = 0; i < pbrd->chs; i++) {
                    status_flag = (tmp[1] << 16) + tmp[0];
                    pbrd->pch[i].status = (status_flag >> i) & 0x1;
                }
                
                // 获取报警状态
                offset = POWER_DC_WARNING;
                r = read_reg(h, pbrd->addr, offset, tmp, 16);
                if (r<0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 16);
                    break;
                }
                op_wanning_info info={0};
                for (i = 0; i < pbrd->chs; i++) {
                    int Index = i * 2;
                    pch = &pbrd->pch[i];
										
										old_l1_v_upper = pch->alarm.l1_v_upper;
										old_l1_v_lower = pch->alarm.l1_v_lower;
										old_l1_c_upper = pch->alarm.l1_c_upper;
										old_l1_p_upper = pch->alarm.l1_p_upper;
										old_l1_w_upper = pch->alarm.l1_w_upper;
									
                    pch->alarm.l1_v_upper = (tmp[0+Index] & BIT(0))?1:0;
                    pch->alarm.l1_v_lower = (tmp[0+Index] & BIT(1))?1:0;
                    pch->alarm.l1_c_upper = (tmp[0+Index] & BIT(2))?1:0;
                    pch->alarm.l1_p_upper = (tmp[0+Index] & BIT(3))?1:0;
                    pch->alarm.l1_w_upper = (tmp[0+Index] & BIT(4))?1:0;
									
									
										info.id = i;
										info.wanning_type = ALARM_TYPE_POWER;
									  info.power_type = h->prod->type;
										if(h->prod->type == PDU_AC_I3O1 || h->prod->type == PDU_AC_I3O1_H)
										{
											info.ph_info = pch->info.ph_id;
										}
										if(!old_l1_v_upper && pch->alarm.l1_v_upper)
										{	
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l1_v_lower && pch->alarm.l1_v_lower)
										{
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l1_c_upper && pch->alarm.l1_c_upper)
										{
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l1_p_upper && pch->alarm.l1_p_upper)
										{
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l1_w_upper && pch->alarm.l1_w_upper)
										{
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}											
                }
								if(flag)
								{
										offset = POWER_DC_THRESHOLD_VOL_MAX;			//直接全部读出来
										r = read_reg(h, pbrd->addr, offset, tmp, 80);
										int j = 0;
										//电压max
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[1+Index+j] << 16)+tmp[0+Index+j])/10;
										}
										//电压min
										j+=16;
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.v_lower = ((tmp[1+Index+j] << 16)+tmp[0+Index+j])/10;
										}
										//电流max
										j+=16;
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.c_upper = ((tmp[1+Index+j] << 16)+tmp[0+Index+j])/10;
										}											
										//功率max
										j+=16;
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.p_upper = ((tmp[1+Index+j] << 16)+tmp[0+Index+j])/10;
										}		
										//耗电量max
										j+=16;
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.w_upper = ((tmp[1+Index+j] << 16)+tmp[0+Index+j])/10;
										}	
										//获取延时信息
										offset = POWER_DC_OPEN_DELAY;
										j = 0;
										r = read_reg(h, pbrd->addr, offset, tmp, 32);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->info.open_delay = ((tmp[1+Index+j] << 16)+tmp[0+Index+j]);
										}		
										j += 16;
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->info.close_delay = ((tmp[1+Index+j] << 16)+tmp[0+Index+j]);
										}											
									/*
										r = read_reg(h, pbrd->addr, offset, tmp, 16);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[1+Index] << 16)+tmp[0+Index])/100;
										}			
										
										offset = POWER_DC_THRESHOLD_VOL_MIN;
										r = read_reg(h, pbrd->addr, offset, tmp, 16);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.v_lower = ((tmp[1+Index] << 16)+tmp[0+Index])/100;
										}
										
										offset = POWER_DC_THRESHOLD_CUR_MAX;
										r = read_reg(h, pbrd->addr, offset, tmp, 16);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.c_upper = ((tmp[1+Index] << 16)+tmp[0+Index])/100;
										}											
										
										offset = POWER_DC_THRESHOLD_POWER_MAX;
										r = read_reg(h, pbrd->addr, offset, tmp, 16);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.p_upper = ((tmp[1+Index] << 16)+tmp[0+Index]);
										}		

										offset = POWER_DC_THRESHOLD_POWERCON_MAX;
										r = read_reg(h, pbrd->addr, offset, tmp, 16);
										for (i = 0; i < pbrd->chs; i++) {
												int Index = i * 2;
												pch = &pbrd->pch[i];
											pch->thr.w_upper = ((tmp[1+Index] << 16)+tmp[0+Index]);
										}		
										*/
									}
            }
            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("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 80);
                    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("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 64);
                    break;
                }
                
                for (i=0; i<pbrd->chs; i++) {

                  // if(h->prod->type==PDU_AC_I3O3) {
										 int index_2 = 0;
										 for(int j = 0; j < 3;j++)
										 {
											 pwr = &pbrd->pch[i].power[j];
											 index_2 = (j*16) + (48*i);
											 pwr->voltage = ((tmp[1+index_2] << 16) + tmp[0+index_2])/10;
											 pwr->current = ((tmp[3+index_2] << 16) + tmp[2+index_2])/10;
											 pwr->power 	= ((tmp[5+index_2] << 16) + tmp[4+index_2])/10;
											 pwr->freq 		= ((tmp[11+index_2] << 16) + tmp[10+index_2])/10;
											 pwr->consump = ((tmp[13+index_2] << 16) + tmp[12+index_2])/10;
											 pwr->factor 	= ((tmp[15+index_2] << 16) + tmp[14+index_2])/10;
										 }
									/* }else{
										int Index = i * 16;
                    pwr = &pbrd->pch[i].power[0];
                    float value = (tmp[1+Index] << 16) + tmp[0+Index];

                    pwr->voltage = value / 10;
                    
                    value = (tmp[3+Index] << 16) + tmp[2+Index];
                    pwr->current = value / 10;
                    
                    value = (tmp[5+Index] << 16) + tmp[4+Index];
                    pwr->power = value / 10;
                    
                    value = (tmp[7+Index] << 16) + tmp[6+Index];
                    
                    value = (tmp[9+Index] << 16) + tmp[8+Index];
                    
                    value = (tmp[11+Index] << 16) + tmp[10+Index];
                    pwr->freq = value / 10;
                    
                    value = (tmp[13+Index] << 16) + tmp[12+Index];
                    pwr->consump = value / 10;
                    
                    value = (tmp[15+Index] << 16) + tmp[14+Index];
                    pwr->factor = value / 10;
                    
                    //pbrd->pch[i].time = tm;										
									} */
                }
                
                //获取通道开关状态及零线状态 
                offset = POWER_AC3_OUT_ENABLE;
                r = read_reg(h, pbrd->addr, offset, tmp, 20);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 20);
                    break;
                }
                for (i=0; i<pbrd->chs; i++) {
//									if(h->prod->type==PDU_AC_I3O3) {
									for(int j = 0; j < 3;j++)
										pbrd->pch[i].status = tmp[0+(j*2)+ (i*6)] & 0x01;
									pbrd->pch[i].nwire  = tmp[18] & 0x01;
//									}else {
//                    int Index = i * 2;
//                    pbrd->pch[i].status = tmp[0+Index] & 0x01;
//                    pbrd->pch[i].nwire  = tmp[18] & 0x01;
//									}
                }
                
                //获取故障状态
                offset = POWER_AC3_OUT_ERROR;
                r = read_reg(h, pbrd->addr, offset, tmp, 18);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 18);
                    break;
                }
								op_wanning_info info={0};
                for (i=0; i<pbrd->chs; i++) {
                    int Index = i * 2 * 3;
                    pch = &pbrd->pch[i];
										old_l1_v_upper = pch->alarm.l1_v_upper;
										old_l1_v_lower = pch->alarm.l1_v_lower;
										old_l1_c_upper = pch->alarm.l1_c_upper;
										old_l1_p_upper = pch->alarm.l1_p_upper;
										old_l1_w_upper = pch->alarm.l1_w_upper;
									
										old_l2_v_upper = pch->alarm.l2_v_upper;
										old_l2_v_lower = pch->alarm.l2_v_lower;
										old_l2_c_upper = pch->alarm.l2_c_upper;
										old_l2_p_upper = pch->alarm.l2_p_upper;
										old_l2_w_upper = pch->alarm.l2_w_upper;

										old_l3_v_upper = pch->alarm.l3_v_upper;
										old_l3_v_lower = pch->alarm.l3_v_lower;
										old_l3_c_upper = pch->alarm.l3_c_upper;
										old_l3_p_upper = pch->alarm.l3_p_upper;
										old_l3_w_upper = pch->alarm.l3_w_upper;									
									
                    pch->alarm.l1_v_upper = (tmp[0+Index] & BIT(0))?1:0;
                    pch->alarm.l1_v_lower = (tmp[0+Index] & BIT(1))?1:0;
                    pch->alarm.l1_c_upper = (tmp[0+Index] & BIT(2))?1:0;
                    pch->alarm.l1_p_upper = (tmp[0+Index] & BIT(3))?1:0;
                    pch->alarm.l1_w_upper = (tmp[0+Index] & BIT(4))?1:0;

                    pch->alarm.l2_v_upper = (tmp[2+Index] & BIT(0))?1:0;
                    pch->alarm.l2_v_lower = (tmp[2+Index] & BIT(1))?1:0;
                    pch->alarm.l2_c_upper = (tmp[2+Index] & BIT(2))?1:0;
                    pch->alarm.l2_p_upper = (tmp[2+Index] & BIT(3))?1:0;
                    pch->alarm.l2_w_upper = (tmp[2+Index] & BIT(4))?1:0;					

                    pch->alarm.l3_v_upper = (tmp[4+Index] & BIT(0))?1:0;
                    pch->alarm.l3_v_lower = (tmp[4+Index] & BIT(1))?1:0;
                    pch->alarm.l3_c_upper = (tmp[4+Index] & BIT(2))?1:0;
                    pch->alarm.l3_p_upper = (tmp[4+Index] & BIT(3))?1:0;
                    pch->alarm.l3_w_upper = (tmp[4+Index] & BIT(4))?1:0;					

										info.id = i;
										info.wanning_type = ALARM_TYPE_POWER;
									  info.power_type = h->prod->type;
										if(!old_l1_v_upper && pch->alarm.l1_v_upper)
										{	
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l1_v_lower && pch->alarm.l1_v_lower)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l1_c_upper && pch->alarm.l1_c_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l1_p_upper && pch->alarm.l1_p_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l1_w_upper && pch->alarm.l1_w_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}	

										
										if(!old_l2_v_upper && pch->alarm.l2_v_upper)
										{	
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l2_v_lower && pch->alarm.l2_v_lower)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l2_c_upper && pch->alarm.l2_c_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l2_p_upper && pch->alarm.l2_p_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l2_w_upper && pch->alarm.l2_w_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l3_v_upper && pch->alarm.l3_v_upper)
										{	
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l3_v_lower && pch->alarm.l3_v_lower)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l3_c_upper && pch->alarm.l3_c_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l3_p_upper && pch->alarm.l3_p_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l3_w_upper && pch->alarm.l3_w_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				
									
                }
                
                offset = POWER_AC3_ALARM_MISSING_PH;
                r = read_reg(h, pbrd->addr, offset, tmp, 6);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
                    break;
                }
                
                v = 0;
                for(i = 0; i < 3; i++) {
                    if(tmp[i * 2]>0) {
                        v |= 1<<i;
                    }
                }
                pbrd->ph_loss = v;
								
								pch = &pbrd->pch[0];
								uint8_t old_lose_l1 = pch->alarm.ph_1_lose;
								uint8_t old_lose_l2 = pch->alarm.ph_2_lose;
								uint8_t old_lose_l3 = pch->alarm.ph_3_lose;
								
								pch->alarm.ph_1_lose = (pbrd->ph_loss & 1) ? 1: 0;
								pch->alarm.ph_2_lose = (pbrd->ph_loss & 2) ? 1: 0;
								pch->alarm.ph_3_lose = (pbrd->ph_loss & 4) ? 1: 0;
								
								if(!old_lose_l1 && pch->alarm.ph_1_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,1);
								}
								if(!old_lose_l2 && pch->alarm.ph_2_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,2);
								}
								if(!old_lose_l3 && pch->alarm.ph_3_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,3);
								}								
								
								if(flag)
								{
									offset = POWER_AC3_BREAKER_INFO;
									r = read_reg(h, pch->info.addr, offset, tmp, 1);
									if (r < 0) {
											LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
											break;
									}
									pbrd->brk[0].samp.sw = (tmp[0]&BIT(0))?1:0;
									//pbrd->brk[0].samp.time = tm;
									
									// read v max   //all read 80 register
									offset = POWER_AC3_THRESHOLD_VOL_MAX;
									
									
									
									r = read_reg(h, pch->info.addr, offset, tmp, 80);
									int j = 0;
									for (i=0; i<pbrd->chs; i++)
									{
											int index = i*3*2;
											pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*3*2;
											pch = &pbrd->pch[i];
											pch->thr.v_lower = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*3*2;
											pch = &pbrd->pch[i];
											pch->thr.c_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*3*2;
											pch = &pbrd->pch[i];
											pch->thr.p_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		

									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*3*2;
											pch = &pbrd->pch[i];
											pch->thr.w_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									//get delay
									offset = POWER_AC3_OPEN_DELAY_TIME;
									r = read_reg(h, pch->info.addr, offset, tmp, 32);
									j=0;
									for (i=0; i<pbrd->chs; i++)
									{
										int index = i*3*2;
										pch = &pbrd->pch[i];
										pch->info.open_delay = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) ;
									}
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										int index = i*3*2;
										pch = &pbrd->pch[i];
										pch->info.close_delay = ((tmp[j+1+index] << 16) + (tmp[j+0+index]));
									}									
					
								}								
            }
            break;
            
            case AC_MULTI_S_TYPE:
            case AC_MULTI_B_TYPE:
            case DC_OUT_TYPE:
            case DC_IN_TYPE:
							break;
						case TREE_AC_DUBL:
						{
								offset = POWER_AC3_OUT_INFO;
                r = read_reg(h, pbrd->addr, offset, tmp, 80);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 80);
                    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("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 64);
                    break;
                }
								for (i=0; i<pbrd->chs; i++) 
								{
									int index_2 = 0;
									uint8_t left = pbrd->pch[i].info.ph_id;						//双火线左端
									uint8_t right = pbrd->pch[i].info.ph_val;					//双火线右端
									pwr = &pbrd->pch[i].power[left];
									index_2 = i*16;
									pwr->voltage = ((tmp[1+index_2] << 16) + tmp[0+index_2])/10;
									pwr->current = ((tmp[3+index_2] << 16) + tmp[2+index_2])/10;
									pwr->power 	= ((tmp[5+index_2] << 16) + tmp[4+index_2])/10;
									pwr->freq 		= ((tmp[11+index_2] << 16) + tmp[10+index_2])/10;
									pwr->consump = ((tmp[13+index_2] << 16) + tmp[12+index_2])/10;
									pwr->factor 	= ((tmp[15+index_2] << 16) + tmp[14+index_2])/10;
									
									pwr = &pbrd->pch[i].power[right];
									index_2 = i*16 + 16 * pbrd->chs;
									
									pwr->voltage = ((tmp[1+index_2] << 16) + tmp[0+index_2])/10;
									pwr->current = ((tmp[3+index_2] << 16) + tmp[2+index_2])/10;
									pwr->power 	= ((tmp[5+index_2] << 16) + tmp[4+index_2])/10;
									pwr->freq 		= ((tmp[11+index_2] << 16) + tmp[10+index_2])/10;
									pwr->consump = ((tmp[13+index_2] << 16) + tmp[12+index_2])/10;
									pwr->factor 	= ((tmp[15+index_2] << 16) + tmp[14+index_2])/10;											
                 }
								
								//获取相错误告警
								offset = POWER_AC3_OUT_ERROR;
                r = read_reg(h, pbrd->addr, offset, tmp, 18);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, 18);
                    break;
                }
								op_wanning_info info={0};
								for (i=0; i<pbrd->chs; i++) 
								{
									uint8_t left = pbrd->pch[i].info.ph_id;
									uint8_t right = pbrd->pch[i].info.ph_val;	
									int Index = i*2;
									switch(left)
									{
										case 1:
										{
											old_l1_v_upper = pch->alarm.l1_v_upper;
											old_l1_v_lower = pch->alarm.l1_v_lower;
											old_l1_c_upper = pch->alarm.l1_c_upper;
											old_l1_p_upper = pch->alarm.l1_p_upper;
											old_l1_w_upper = pch->alarm.l1_w_upper;
											pch->alarm.l1_v_upper = (tmp[Index] & BIT(0))?1:0;
											pch->alarm.l1_v_lower = (tmp[Index] & BIT(1))?1:0;
											pch->alarm.l1_c_upper = (tmp[Index] & BIT(2))?1:0;
											pch->alarm.l1_p_upper = (tmp[Index] & BIT(3))?1:0;
											pch->alarm.l1_w_upper = (tmp[Index] & BIT(4))?1:0;
											Index += (2 * pbrd->chs);
											switch(right)
											{
												case 2:
												{
													
													old_l2_v_upper = pch->alarm.l2_v_upper;
													old_l2_v_lower = pch->alarm.l2_v_lower;
													old_l2_c_upper = pch->alarm.l2_c_upper;
													old_l2_p_upper = pch->alarm.l2_p_upper;
													old_l2_w_upper = pch->alarm.l2_w_upper;
													pch->alarm.l2_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l2_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l2_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l2_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l2_w_upper = (tmp[Index] & BIT(4))?1:0;				
												}
													break;
												case 3:
												{
													old_l3_v_upper = pch->alarm.l3_v_upper;
													old_l3_v_lower = pch->alarm.l3_v_lower;
													old_l3_c_upper = pch->alarm.l3_c_upper;
													old_l3_p_upper = pch->alarm.l3_p_upper;
													old_l3_w_upper = pch->alarm.l3_w_upper;
													pch->alarm.l3_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l3_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l3_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l3_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l3_w_upper = (tmp[Index] & BIT(4))?1:0;														
												}
													break;
												default:
													break;
											}
										}
											break;
										case 2:
										{
											old_l2_v_upper = pch->alarm.l2_v_upper;
											old_l2_v_lower = pch->alarm.l2_v_lower;
											old_l2_c_upper = pch->alarm.l2_c_upper;
											old_l2_p_upper = pch->alarm.l2_p_upper;
											old_l2_w_upper = pch->alarm.l2_w_upper;
											pch->alarm.l2_v_upper = (tmp[Index] & BIT(0))?1:0;
											pch->alarm.l2_v_lower = (tmp[Index] & BIT(1))?1:0;
											pch->alarm.l2_c_upper = (tmp[Index] & BIT(2))?1:0;
											pch->alarm.l2_p_upper = (tmp[Index] & BIT(3))?1:0;
											pch->alarm.l2_w_upper = (tmp[Index] & BIT(4))?1:0;
											Index += (2 * pbrd->chs);
											switch(right)
											{
												case 1:
												{
													old_l1_v_upper = pch->alarm.l1_v_upper;
													old_l1_v_lower = pch->alarm.l1_v_lower;
													old_l1_c_upper = pch->alarm.l1_c_upper;
													old_l1_p_upper = pch->alarm.l1_p_upper;
													old_l1_w_upper = pch->alarm.l1_w_upper;
													pch->alarm.l1_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l1_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l1_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l1_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l1_w_upper = (tmp[Index] & BIT(4))?1:0;													
												}
													break;
												case 3:
												{
													old_l3_v_upper = pch->alarm.l3_v_upper;
													old_l3_v_lower = pch->alarm.l3_v_lower;
													old_l3_c_upper = pch->alarm.l3_c_upper;
													old_l3_p_upper = pch->alarm.l3_p_upper;
													old_l3_w_upper = pch->alarm.l3_w_upper;
													pch->alarm.l3_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l3_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l3_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l3_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l3_w_upper = (tmp[Index] & BIT(4))?1:0;
													
												}
													break;
												default:
													break;
											}
										}
											break;
										case 3:
										{
											old_l3_v_upper = pch->alarm.l3_v_upper;
											old_l3_v_lower = pch->alarm.l3_v_lower;
											old_l3_c_upper = pch->alarm.l3_c_upper;
											old_l3_p_upper = pch->alarm.l3_p_upper;
											old_l3_w_upper = pch->alarm.l3_w_upper;
											pch->alarm.l3_v_upper = (tmp[Index] & BIT(0))?1:0;
											pch->alarm.l3_v_lower = (tmp[Index] & BIT(1))?1:0;
											pch->alarm.l3_c_upper = (tmp[Index] & BIT(2))?1:0;
											pch->alarm.l3_p_upper = (tmp[Index] & BIT(3))?1:0;
											pch->alarm.l3_w_upper = (tmp[Index] & BIT(4))?1:0;
											Index += (2 * pbrd->chs);		
											switch(right)
											{
								  			case 1:
												{
													old_l1_v_upper = pch->alarm.l1_v_upper;
													old_l1_v_lower = pch->alarm.l1_v_lower;
													old_l1_c_upper = pch->alarm.l1_c_upper;
													old_l1_p_upper = pch->alarm.l1_p_upper;
													old_l1_w_upper = pch->alarm.l1_w_upper;
													pch->alarm.l1_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l1_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l1_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l1_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l1_w_upper = (tmp[Index] & BIT(4))?1:0;			
												}
												break;
												case 2:
												{
													old_l2_v_upper = pch->alarm.l2_v_upper;
													old_l2_v_lower = pch->alarm.l2_v_lower;
													old_l2_c_upper = pch->alarm.l2_c_upper;
													old_l2_p_upper = pch->alarm.l2_p_upper;
													old_l2_w_upper = pch->alarm.l2_w_upper;
													pch->alarm.l2_v_upper = (tmp[Index] & BIT(0))?1:0;
													pch->alarm.l2_v_lower = (tmp[Index] & BIT(1))?1:0;
													pch->alarm.l2_c_upper = (tmp[Index] & BIT(2))?1:0;
													pch->alarm.l2_p_upper = (tmp[Index] & BIT(3))?1:0;
													pch->alarm.l2_w_upper = (tmp[Index] & BIT(4))?1:0;															
												}
												break;	
												default: 
													break;
										   }
											 break;
										default:
											break;
									  }
								   }
										info.id = i;
										info.wanning_type = ALARM_TYPE_POWER;
									  info.power_type = h->prod->type;
										if(!old_l1_v_upper && pch->alarm.l1_v_upper)
										{	
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l1_v_lower && pch->alarm.l1_v_lower)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l1_c_upper && pch->alarm.l1_c_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l1_p_upper && pch->alarm.l1_p_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l1_w_upper && pch->alarm.l1_w_upper)
										{
											info.ph_info = 1;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}	

										
										if(!old_l2_v_upper && pch->alarm.l2_v_upper)
										{	
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l2_v_lower && pch->alarm.l2_v_lower)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l2_c_upper && pch->alarm.l2_c_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l2_p_upper && pch->alarm.l2_p_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l2_w_upper && pch->alarm.l2_w_upper)
										{
											info.ph_info = 2;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l3_v_upper && pch->alarm.l3_v_upper)
										{	
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}
									
										if(!old_l3_v_lower && pch->alarm.l3_v_lower)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_VOL;
											info.max_min  = STR_POWER_ID_MIN;
											info.over = STR_POWER_ID_LOW;
											wanning_operation(&info,pch->info.name);
										}									
									
										if(!old_l3_c_upper && pch->alarm.l3_c_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_CUR;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}										

										if(!old_l3_p_upper && pch->alarm.l3_p_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_POWER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}				

										if(!old_l3_w_upper && pch->alarm.l3_w_upper)
										{
											info.ph_info = 3;
											info.ele_info = STR_POWER_ID_CONSUMER;
											info.max_min  = STR_POWER_ID_MAXS;
											info.over     = STR_POWER_ID_OVER;
											wanning_operation(&info,pch->info.name);
										}												
									}
								
									
							///
                offset = POWER_AC3_ALARM_MISSING_PH;
                r = read_reg(h, pbrd->addr, offset, tmp, 6);
                if (r < 0) {
                    LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
                    break;
                }
                uint8_t v;
                v = 0;
                for(i = 0; i < 3; i++) {
                    if(tmp[i * 2]>0) {
                        v |= 1<<i;
                    }
                }
                pbrd->ph_loss = v;
								
								pch = &pbrd->pch[i];
								uint8_t old_lose_l1 = pch->alarm.ph_1_lose;
								uint8_t old_lose_l2 = pch->alarm.ph_2_lose;
								uint8_t old_lose_l3 = pch->alarm.ph_3_lose;
								
								pch->alarm.ph_1_lose = (pbrd->ph_loss & 1) ? 1: 0;
								pch->alarm.ph_2_lose = (pbrd->ph_loss & 2) ? 1: 0;
								pch->alarm.ph_3_lose = (pbrd->ph_loss & 4) ? 1: 0;
								
								if(!old_lose_l1 && pch->alarm.ph_1_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,1);
								}
								if(!old_lose_l2 && pch->alarm.ph_2_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,2);
								}
								if(!old_lose_l3 && pch->alarm.ph_3_lose)
								{
									lose_operation( pch->info.name,pch->info.ch,3);
								}		
								if(flag)
								{
									offset = POWER_AC3_BREAKER_INFO;
									r = read_reg(h, pch->info.addr, offset, tmp, 1);
									if (r < 0) {
											LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", pbrd->addr, offset, offset, pbrd->chs);
											break;
									}
									pbrd->brk[0].samp.sw = (tmp[0]&BIT(0))?1:0;
									pbrd->brk[1].samp.sw = (tmp[0]&BIT(1))?1:0;
									//pbrd->brk[0].samp.time = tm;
									
									// read v max   //all read 80 register
									offset = POWER_AC3_THRESHOLD_VOL_MAX;
									
									
									
									r = read_reg(h, pch->info.addr, offset, tmp, 80);
									int j = 0;
									for (i=0; i<pbrd->chs; i++)
									{
											int index = i*2;
											pch = &pbrd->pch[i];
											pch->thr.v_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*2;
											pch = &pbrd->pch[i];
											pch->thr.v_lower = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*2;
											pch = &pbrd->pch[i];
											pch->thr.c_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*2;
											pch = &pbrd->pch[i];
											pch->thr.p_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		

									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										  int index = i*2;
											pch = &pbrd->pch[i];
											pch->thr.w_upper = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) / 10;
									}		
									//get delay
									offset = POWER_AC3_OPEN_DELAY_TIME;
									r = read_reg(h, pch->info.addr, offset, tmp, 32);
									j=0;
									for (i=0; i<pbrd->chs; i++)
									{
										int index = i*2;
										pch = &pbrd->pch[i];
										pch->info.open_delay = ((tmp[j+1+index] << 16) + (tmp[j+0+index])) ;
									}
									j+=16;
									for (i=0; i<pbrd->chs; i++)
									{
										int index = i*2;
										pch = &pbrd->pch[i];
										pch->info.close_delay = ((tmp[j+1+index] << 16) + (tmp[j+0+index]));
									}			
								}									
						}
						break;
            default:
							r = -1;
            break;
        }
        
//        if(r==0) {
//            threshold_proc(h, pbrd);
//        }
    }
    lock_off(h->lck);
    
    return r;
}
static int power_copy(power_handle_t *h)
{
    int i,r=-1;
    power_all_t *pd=&h->all;
    
    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);
						LOGD("channels back up ch_mem=%d\n",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]);
            }
        }
    }
    pd->ttl = h->ttl;
    
    return 0;
}


static uint32_t count = 0;

static int board_query(power_handle_t *h)
{
    int i,r;
		count++;
		uint8_t flag = 0;
		if(count == SECOND_MIL)
		{
			flag =1;
			count = 0;
		}
    for(i=1; i<(h->cnt+1); i++) {
        r = board_read(h, h->pbrd[i],flag);
    }
    total_proc(h);
    power_copy(h);
		usleep(10000);

    return r;
}

//rt_tick_t start_tick = 0;

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->attr->arg;;
	 
    
    while(th->quit==0) {
        board_query(h);			
    }
}


int power_init(void)
{
    power_handle_t *h=&pwrHandle;
    paras_data_t *p=paras_get();
    
    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_init();
    h->cur_addr = 0;
    h->brd_max = POWER_BOARD_MAX;
    h->prod = &p->prod;
    
    power_scan();
    thread_start(THREAD_ID_POWER, power_thread, h);
    return 0;
}


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

static power_ch_t* get_ch(power_handle_t *h, uint8_t ch)
{
    if(!h->chs || !h->pch[ch]) {
        return NULL;
    }
    return h->pch[ch];
}
int power_get_ch(uint8_t ch, power_ch_t *pch)
{
    int r=-1;
    power_ch_t *p=NULL;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    p = get_ch(h, ch);
    if(p && pch) {
        *pch = *p;
        r = 0;
    }
    lock_off(h->lck);
    
    return r;
}


int power_get_board(board_data_t *pbrd)
{
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    if(!pbrd || !h->cnt || !h->pbrd[pbrd->addr]) {
        lock_off(h->lck);
        return -1;
    }
    *pbrd = *h->pbrd[pbrd->addr];
    lock_off(h->lck);
    
    return 0;
}


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

static int power_map(power_handle_t *h, int chs)
{
    int i,j,r,idx=1;
    board_data_t *pbrd=NULL;
    uint8_t pwr_type=paras_get()->prod.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;
            h->pch[0] = &h->ch0;
            strcpy(h->pch[0]->info.name, "ALL");
            
            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];
                        h->pch[idx]->pbrd = h->pbrd[i];
                        sprintf(h->pch[idx]->info.name, "CH%d", idx);
                        idx++;
                    }
                }
            } 
      //  }
    }
    
    return 0;
}

static int power_clear(power_handle_t *h)
{
    int i,j;
    
    memset(&h->ch0, 0, sizeof(h->ch0));
    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;
    h->cur_addr = 0;
    
    return 0;
}
int power_scan(void)
{
    int r,i,j,total_chs=1;
    int ch_idx=1,brd_idx=0;
    power_ch_t *pch=NULL;
    board_key_t *pkey=NULL;
    board_data_t *pbrd=NULL;
    power_handle_t *h=&pwrHandle;
    uint16_t times,nGroups=h->prod->ch_delay;
		uint16_t flag_full = 0;
    paras_data_t *p=paras_get();
    lock_on(h->lck);
    power_clear(h);
    
    pch = &h->ch0;
    pch->info.addr = 0;
    pch->info.ch = 0;
    int ch_count = 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);
            h->cnt++;
        }
        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) {
            pbrd = (board_data_t*)calloc(1, sizeof(board_data_t));
            if(!pbrd) {
                LOGE("___ power_scan, calloc pbrd %d failed\n", i);
                return -1;
            }
            
            //pbrd->fn = board_fn;
            pbrd->type = pkey->type;
						if(pkey->type == 1 || pkey->type == 2)
						{
							pbrd->fn = board_fn_ac;
						}else if(pkey->type == CTRL_3_3 || CTRL_3_2 == pkey->type)
						{
							pbrd->fn = board_fn_ac3;
						}else 
						{
							pbrd->fn = board_fn_dc;
						}
            pbrd->chs  = pkey->chs;
            pbrd->addr = i;
            pbrd->ch0 = ch_idx;
						if((ch_count+ pkey->chs) >= 32)
						{
							pkey->chs = 31 - ch_count;
							flag_full = 1; 
						}
            pch = (power_ch_t*)calloc(1, sizeof(power_ch_t)*pkey->chs);
						ch_count += (pkey->chs);
            if(!pch) {
                LOGE("___ power_scan, calloc pch failed\n");
                return -1;
            }
            LOGD("__ power init board %d, b_mem=%d ch_mem=%d sizeof(power_ch_t)=%d\n",i,sizeof(board_data_t),sizeof(power_ch_t)*pkey->chs,sizeof(power_ch_t));
            for(j=0; j<pkey->chs; j++) {
                pch[j].info.addr = i;
                pch[j].info.sch  = j;                    //序号从0开始
                pch[j].info.type = pkey->type;
                
                if(h->prod->type==PDU_AC_I3O3) {
                    pch[j].info.ch  = ch_idx;       //序号从1开始, 发给控制板需从0开始
									pch[j].info.ph_id = j+1;				  //可以不使用
                }else if(h->prod->type == PDU_AC_I3O2)
								{
									pch[j].info.ch  = ch_idx+j;
									pch[j].info.ph_id = p->phase_seq_2.phase_left[ch_idx-1] -'0';
									pch[j].info.ph_val = p->phase_seq_2.phase_right[ch_idx-1] -'0';						//作为双火线的右边相
								}
                else {
                    pch[j].info.ch  = ch_idx+j;         //序号从1开始, 发给控制板需从0开始
                    if(h->prod->type==PDU_AC_I3O1 || h->prod->type == PDU_AC_I3O1_H)
										{
											pch[j].info.ph_id = p->phase_seq.phase_seq[ch_idx-1] -'0';
										}	else
											pch[j].info.ph_id = 0;
                }
                
                times = (pch[j].info.ch%nGroups)?pch[j].info.ch:nGroups;
                pch[j].info.open_delay =  times;
                pch[j].info.close_delay  = times;
            }
            
            if(pbrd->type==AC_SINGLE_S_TYPE || pbrd->type==AC_SINGLE_B_TYPE) {
                pbrd->brk[0].info.addr = pbrd->brk[1].info.addr = pbrd->addr;
            }
            else if(pbrd->type==TREE_AC_TYPE) {
                pbrd->brk[0].info.addr = pbrd->addr;
            }
            
//            if(h->prod->type==PDU_AC_I3O3) {
//                ch_idx += pkey->chs/3;
//            }
//            else {
                ch_idx += pkey->chs;
 //           }
						
            brd_idx++;
            
            pbrd->pch = pch;
            h->pbrd[i] = pbrd;
            total_chs += pkey->chs;
						if(flag_full)
							break;
        }
    }
    power_map(h, total_chs);
    lock_off(h->lck);
    
    return 0;
}


int power_reset(void)
{
    int i,r=-1;
    uint16_t offset = 0;
    power_handle_t *h=&pwrHandle;
    board_data_t *pbrd=NULL;
    
    lock_on(h->lck);
    for(i=0; i<=h->brd_max; i++) {
        pbrd = h->pbrd[i];
        if(pbrd) {
            switch(pbrd->type) {
                case AC_SINGLE_S_TYPE:
                case AC_SINGLE_B_TYPE:
                {
                    uint16_t tmp[8];
                    offset = POWER_AC_CH_STAT_L;
                    for(i=1; i<=pbrd->chs; i++) {
                        tmp[i] = pbrd->pch[i].status;
                    }
                    r = write_reg(h, pbrd->addr, offset, tmp+1, pbrd->chs-1);
                }
                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, pbrd->addr, offset, data_temp, 3);
                    if (r<0) {
                        break;
                    }
                    
                    //初始化报警阈值
                    uint32_t value = 0;
                    memset(data_temp, 0, sizeof(data_temp));
                    offset = POWER_AC3_THRESHOLD_VOL_MAX;
                    r = write_reg(h, pbrd->addr, offset, data_temp, 18);
                    if (r<0) {
                        break;
                    }
                    offset = POWER_AC3_THRESHOLD_VOL_MIN;
                    r = write_reg(h, pbrd->addr, offset, data_temp, 18);
                    if (r<0) {
                        break;
                    }
                    
                    offset = POWER_AC3_THRESHOLD_CUR_MAX;
                    r = write_reg(h, pbrd->addr, offset, data_temp, 18);
                    if (r<0) {
                        break;
                    }
                    offset = POWER_AC3_THRESHOLD_PWR_MAX;
                    r = write_reg(h, pbrd->addr, offset, data_temp, 18);
                    if (r<0) {
                        break;
                    }
                    offset = POWER_AC3_THRESHOLD_PWRCON_MAX;
                    r = write_reg(h, pbrd->addr, offset, data_temp, 18);
                    if (r<0) {
                        break;
                    }
                    
                    for (i=1; i<=pbrd->chs; i++) {
                        memset(data_temp, 0, sizeof(data_temp));
                        offset = POWER_AC3_OUT_ENABLE + i;
                        data_temp[0] = pbrd->pch[i].status;
                        r = write_reg(h, pbrd->addr, offset, data_temp, 2);
                    }
                }
                break;
            }
        }
    }
    lock_off(h->lck);
    
    return r;
}

int power_set_ch_sw_n(power_ch_t *pch)
{
		int r;
		uint16_t	st= pch->status,offset,tmp[2]={0};
		power_handle_t *h=&pwrHandle;
    lock_on(h->lck);		
    if (pch->thr.en.v_upper_en == 1)
        st |= ENABLE_AC3_V_UP;
    if (pch->thr.en.v_lower_en == 1)
        st |= ENABLE_AC3_V_DOWN;
    if (pch->thr.en.c_upper_en == 1)
        st |= ENABLE_AC3_C_UP;
    if (pch->thr.en.p_upper_en == 1)
        st |= ENABLE_AC3_P_UP;
    if (pch->thr.en.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.sch;
            tmp[0] = st;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;			
			  case DCPDU_TYPE:
        {
            uint16_t mask;
            offset = POWER_DC_STAT_INFO;
						//获取状态。
						r = read_reg(h, pch->info.addr, offset, tmp, 2);
            
            mask = ~(1 << (pch->info.sch));
            tmp[0] &= mask;
            tmp[0] |= (st << (pch->info.sch));
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t reg;
            uint8_t type=paras_get()->prod.type;
            if(type==PDU_AC_I3O3 || type==PDU_AC_I3O1) {
                reg = POWER_AC3_CH_OUT_ENABLE;
            }
            else {
                reg = POWER_AC3_OUT_ENABLE;
            }
            
            tmp[0] = st;
            offset = reg+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
				case TREE_AC_DUBL:
				{
					uint16_t reg;
					reg = POWER_AC3_CH_OUT_ENABLE;
					tmp[0] = st;
          offset = reg+pch->info.sch;
					r = write_reg(h, pch->info.addr, offset, tmp, 2);
				}
				break;
		}
		lock_off(h->lck);
}



int power_set_ch_sw(uint8_t ch, uint8_t on)
{
    int r;
    power_ch_t *pch;
    power_handle_t *h=&pwrHandle;
    uint16_t offset,tmp[2]={0},st=on;
    
    lock_on(h->lck);
    pch = get_ch(h, ch);
    if(!pch) {
        lock_off(h->lck);
        return -1;
    }
    
    if (pch->thr.en.v_upper_en == 1)
        st |= ENABLE_AC3_V_UP;
    if (pch->thr.en.v_lower_en == 1)
        st |= ENABLE_AC3_V_DOWN;
    if (pch->thr.en.c_upper_en == 1)
        st |= ENABLE_AC3_C_UP;
    if (pch->thr.en.p_upper_en == 1)
        st |= ENABLE_AC3_P_UP;
    if (pch->thr.en.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.sch;
            tmp[0] = st;;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t mask;
            offset = POWER_DC_STAT_INFO+pch->info.sch;
            
            mask = ~(1 << (pch->info.ch-1));
            tmp[0] &= mask;
            tmp[0] |= (st << (pch->info.ch-1));
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t reg;
            uint8_t type=paras_get()->prod.type;
            if(type==PDU_AC_I3O3 || type==PDU_AC_I3O1) {
                reg = POWER_AC3_CH_OUT_ENABLE;
            }
            else {
                reg = POWER_AC3_OUT_ENABLE;
            }
            
            tmp[0] = st;
            offset = reg+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
				case TREE_AC_DUBL:
				{
					uint16_t reg;
					reg = POWER_AC3_CH_OUT_ENABLE+pch->info.sch;
					tmp[0] = st;
					r = write_reg(h, pch->info.addr, offset, tmp, 2);
				}
				break;
    }
    lock_off(h->lck);
    
    return r;
}


int power_set_board_sw(uint8_t addr, uint8_t on)
{
    int i,r;
    power_ch_t *pch;
    board_data_t *pbrd;
    power_handle_t *h=&pwrHandle;
    
    pbrd = h->pbrd[addr];
    if(!pbrd) {
        return -1;
    }
    
    for(i=0; i<pbrd->chs; i++) {
        power_set_ch_sw(pbrd->pch[i].info.ch, on);
    }
    
    return 0;
}


int power_set_all_sw(uint8_t on)
{
    int i,r;
    power_handle_t *handle=&pwrHandle;
	
		if(handle->cnt > 0)
		{
			for(int i = 1 ; i <= handle->cnt;i++)
			{
				if(handle->pbrd[i])
				{
					handle->pbrd[i]->fn.set_all(on,handle->pbrd[i]);
				}
			}
		}
    

    
    return 0;
}


int power_set_alarm(power_ch_t *pch)
{
    int r=0;
    uint16_t offset = 0;
    uint16_t nStatus = 0;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    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-1;
            }
        }
        break;
        
        case DCPDU_TYPE:
        {
            if (pch->info.ch==0) {
                offset = POWER_DC_ALARM_CTRL_TOTAL;
            }
            else {
                offset = POWER_DC_ALARM_CTRL + pch->info.ch-1;
            }
        }
        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-1;
            }
        }
        break;
        
        default:
        r = -1;
    }
    
//    if(r==0) {
//        if(pch->thr.v_upper.act==ALARM_ACT_CLOSE_CH) nStatus |= BIT(1);
//        if(pch->thr.v_lower.act==ALARM_ACT_CLOSE_CH) nStatus |= BIT(2);
//        if(pch->thr.c_upper.act==ALARM_ACT_CLOSE_CH) nStatus |= BIT(0);
//        if(pch->thr.p_upper.act==ALARM_ACT_CLOSE_CH) nStatus |= BIT(3);
//        if(pch->thr.w_upper.act==ALARM_ACT_CLOSE_CH) nStatus |= BIT(4);
//        r = write_reg(h, pch->info.addr, offset, &nStatus, 1);
//    }
    lock_off(h->lck);
    
    return r;
}


int power_get_threshold(power_ch_t *pch)
{
    int i,r=0;
    uint16_t offset;
    power_ch_t *pch2=NULL;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    pch2 = get_ch(h, pch->info.ch);
    pch2->thr = pch->thr;
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            uint16_t offset = 0;
            uint32_t temp = 0 ;
            uint16_t buffer[16] = {0};

            if(pch->info.ch==0) {
                offset = POWER_AC_TOTAL_THRESHOLD;
            }
            else  {
                offset = POWER_AC_THRESHOLD_L+(pch->info.ch-1)*16;
            }
            r = read_reg(h, pch->info.addr, offset, buffer, 16);
            if(r) break;
            
            pch->thr.v_upper = ((buffer[1]<<16)|buffer[0])/100;
            pch->thr.v_lower = ((buffer[3]<<16)|buffer[2])/100;
            pch->thr.c_upper = ((buffer[5]<<16)|buffer[4])/100;
            pch->thr.p_upper = ((buffer[9]<<16)|buffer[8])/100;
            pch->thr.w_upper = ((buffer[13]<<16)|buffer[12])/100;
            
        }
        break;
        
        case DCPDU_TYPE:
        {
            uint16_t temp[4];
            uint32_t value;
            
            offset = (pch->info.ch==0)?POWER_DC_THRESHOLD_TOTAL_VOL_MAX:POWER_DC_THRESHOLD_VOL_MAX;
            r = read_reg(h, pch->info.addr, offset, temp, 2);
            if(r) break;
            pch->thr.v_upper = ((temp[1]<<16)|temp[0])/100;
            
            offset = (pch->info.ch==0)?POWER_DC_THRESHOLD_TOTAL_VOL_MIN:POWER_DC_THRESHOLD_VOL_MIN;
            r = read_reg(h, pch->info.addr, offset, temp, 2);
            if(r) break;
            pch->thr.v_lower = ((temp[1]<<16)|temp[0])/100;
            
            offset = (pch->info.ch==0)?POWER_DC_THRESHOLD_TOTAL_CUR_MAX:POWER_DC_THRESHOLD_CUR_MAX;
            r = read_reg(h, pch->info.addr, offset, temp, 2);
            if(r) break;
            pch->thr.c_upper = ((temp[1]<<16)|temp[0])/100;
            
            offset = (pch->info.ch==0)?POWER_DC_THRESHOLD_TOTAL_PWR_MAX:POWER_DC_THRESHOLD_POWER_MAX;
            r = read_reg(h, pch->info.addr, offset, temp, 2);
            if(r) break;
            pch->thr.p_upper = ((temp[1]<<16)|temp[0])/100;
            
            offset = (pch->info.ch==0)?POWER_DC_THRESHOLD_TOTAL_PWRCON_MAX:POWER_DC_THRESHOLD_POWERCON_MAX;
            r = read_reg(h, pch->info.addr, offset, temp, 2);
            if(r) break;
            pch->thr.w_upper = ((temp[1]<<16)|temp[0])/100;
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t temp[4];
            uint32_t value;
            
            if(pch->info.ch==0) {
                offset = POWER_AC3_THRESHOLD_IN;
                
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.v_upper = ((temp[1]<<16)|temp[0])/100;
                
                r = read_reg(h, pch->info.addr, offset+1, temp, 2);
                if(r) break;
                pch->thr.v_lower = ((temp[1]<<16)|temp[0])/100;
                
                r = read_reg(h, pch->info.addr, offset+2, temp, 2);
                if(r) break;
                pch->thr.c_upper = ((temp[1]<<16)|temp[0])/100;
                
                r = read_reg(h, pch->info.addr, offset+3, temp, 2);
                if(r) break;
                pch->thr.p_upper = ((temp[1]<<16)|temp[0])/100;
                
                r = read_reg(h, pch->info.addr, offset+4, temp, 2);
                pch->thr.w_upper = ((temp[1]<<16)|temp[0])/100;
            }
            else {
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.v_upper = ((temp[1]<<16)|temp[0])/100;
                
                offset = POWER_AC3_THRESHOLD_VOL_MIN;
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.v_lower = ((temp[1]<<16)|temp[0])/100;
                
                offset = POWER_AC3_THRESHOLD_CUR_MAX;
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.c_upper = ((temp[1]<<16)|temp[0])/100;
                
                offset = POWER_AC3_THRESHOLD_PWR_MAX;
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.p_upper = ((temp[1]<<16)|temp[0]);
                
                offset = POWER_AC3_THRESHOLD_VOL_MAX;
                r = read_reg(h, pch->info.addr, offset, temp, 2);
                if(r) break;
                pch->thr.p_upper = ((temp[1]<<16)|temp[0]);
            }
        }
        break;
        
        default:
        r = -1;
        break;
    }
    lock_off(h->lck);
    
    return r;
}


int power_set_threshold(power_ch_t *pch)
{
    int r=0;
    uint16_t offset;
    power_ch_t *pch2=NULL;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    pch2 = get_ch(h, pch->info.ch);
    pch2->thr = pch->thr;
    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*10);
            data_buf[0] = data_temp;
            data_buf[1] = data_temp>>16;
            //电压下限
            data_temp =  (pch->thr.v_lower*10);
            data_buf[2] = data_temp;
            data_buf[3] = data_temp>>16;
            //电流上限
            data_temp =  (pch->thr.c_upper*10);
            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.p_upper)*10;
            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.w_upper)*10;
            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.sch)*16;
            }

            r = write_reg(h, pch->info.addr, offset, data_buf, 16);
            if(r==0) {
                r = power_set_alarm(pch);
            }
        }
        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;
						if(pch->info.ch!=0)
						{
							offset += pch->info.sch;
						}
            value = pch->thr.v_upper * 10;
            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;
						if(pch->info.ch!=0)
						{
							offset += pch->info.sch;
						}
            value = pch->thr.v_lower * 10;
            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;
						if(pch->info.ch!=0)
						{
							offset += pch->info.sch;
						}
            value = pch->thr.c_upper * 10;
            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;
						if(pch->info.ch!=0)
						{
							offset += pch->info.sch;
						}
            value = pch->thr.p_upper * 10;
            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;
						if(pch->info.ch!=0)
						{
							offset += pch->info.sch;
						}
            value = pch->thr.w_upper * 10;
            data_temp[0] = value & 0XFFFF;
            data_temp[1] = (value >> 16) & 0xFFFF;
            r = write_reg(h, pch->info.addr, offset, data_temp, 2);
            if(r==0) {
                r = power_set_alarm(pch);
            }
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint16_t data_temp[4];
            uint32_t value;
            
           offset = POWER_AC3_THRESHOLD_VOL_MAX;
           value = pch->thr.v_upper * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);

           offset = POWER_AC3_THRESHOLD_VOL_MIN;
           value = pch->thr.v_lower * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
					
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
              
           offset = POWER_AC3_THRESHOLD_CUR_MAX;
           value = pch->thr.c_upper * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
								                  
           offset = POWER_AC3_THRESHOLD_PWR_MAX;
           value = pch->thr.p_upper*10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
           offset = POWER_AC3_THRESHOLD_PWRCON_MAX;
           value = pch->thr.w_upper*10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);	
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset +=1;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);  
        }
        break;
				case TREE_AC_DUBL:
				{
           uint16_t data_temp[4];
           uint32_t value;
					 uint8_t chs = h->pbrd[pch->info.addr]->chs;
            
           offset = POWER_AC3_THRESHOLD_VOL_MAX+pch->info.sch;
           value = pch->thr.v_upper * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset+=chs;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);

           offset = POWER_AC3_THRESHOLD_VOL_MIN+pch->info.sch;
           value = pch->thr.v_lower * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
					
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset+=chs;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
              
           offset = POWER_AC3_THRESHOLD_CUR_MAX+pch->info.sch;
           value = pch->thr.c_upper * 10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset+=chs;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
								                  
           offset = POWER_AC3_THRESHOLD_PWR_MAX+pch->info.sch;
           value = pch->thr.p_upper*10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);
					 offset+=chs;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);
                
           offset = POWER_AC3_THRESHOLD_PWRCON_MAX+pch->info.sch;
           value = pch->thr.w_upper*10;
           data_temp[0] = value & 0XFFFF;
           data_temp[1] = (value >> 16) & 0xFFFF;
           r = write_reg(h, pch->info.addr, offset, data_temp, 2);	
					 offset+=chs;
					 r = write_reg(h, pch->info.addr, offset, data_temp, 2);  
				}
				break;
        
        default:
        r = -1;
        break;
    }
    lock_off(h->lck);
    
    return r;
}


int power_set_open_delay(power_ch_t *pch)
{
    int r=-1;
    uint16_t tmp[2],reg,offset;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            tmp[0] = pch->info.open_delay*1000;
            offset = POWER_AC_OPEN_DELAY_TIME_L+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;

        case DCPDU_TYPE:
        {
            uint32_t time=pch->info.open_delay;
						
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
            offset = POWER_DC_OPEN_DELAY+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint32_t time=pch->info.open_delay;
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
 
            offset = POWER_AC3_OPEN_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;
        }
        break;
				case TREE_AC_DUBL:
				{
          uint32_t time=pch->info.open_delay;
					uint8_t chs = h->pbrd[pch->info.addr]->chs;
					
					
          tmp[0] = time & 0xffff;
          tmp[1] = (time >> 16) & 0xffff;
					offset = POWER_AC3_OPEN_DELAY_TIME+pch->info.sch;
					r = write_reg(h, pch->info.addr, offset+0, tmp, 2);
					if(r) break;
					
					offset+= chs;
					r = write_reg(h, pch->info.addr, offset, tmp, 2);
					if(r) break;
				}
				break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        r = -1;
    }
    lock_off(h->lck);
    
    return r;
}
int power_set_ph_cfg(power_ch_t *pch)
{
	int r=-1;
  uint16_t tmp[2],reg,offset;
  power_handle_t *h=&pwrHandle;  
	paras_data_t *p=paras_get();
  lock_on(h->lck);
	switch(h->prod->type)
	{
		case PDU_AC_I3O1:
		{
			h->pbrd[pch->info.addr]->pch[pch->info.sch].info.ph_id = pch->info.ph_id;					//ph
			p->phase_seq.phase_seq[pch->info.ch-1] = pch->info.ph_id+'0';
			paras_save();
		}
		break;
		case PDU_AC_I3O2:
		{
			h->pbrd[pch->info.addr]->pch[pch->info.sch].info.ph_id = pch->info.ph_id;						//left ph
			h->pbrd[pch->info.addr]->pch[pch->info.sch].info.ph_val = pch->info.ph_val;					//right ph
			p->phase_seq_2.phase_left[pch->info.ch-1] = pch->info.ph_id+'0';
			p->phase_seq_2.phase_right[pch->info.ch-1] = pch->info.ph_val+'0';
			paras_save();
		}
		break;
		default:
			break;
	}
	lock_off(h->lck);	
}






int power_set_clear_consumer(power_ch_t *pch)
{
	
	int r=-1;
  uint16_t tmp[2],reg,offset;
  power_handle_t *h=&pwrHandle;  
  lock_on(h->lck);
	switch(pch->info.type) {
	  case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
		{
			uint16_t val = 1;
			offset = POWER_AC_RESET_CONSUMP + pch->info.sch;
			r = write_reg(h, pch->info.addr, offset, &val, 1);
		}		
		break;
		case DCPDU_TYPE:
		{
			uint32_t val = 1;
			offset = POWER_DC_CONSUMP_CLEAR + pch->info.sch;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
		}
		break;
		case TREE_AC_TYPE:
		{
			uint32_t val = 1;
			offset = POWER_AC3_RESET_CONSUMP;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
			offset+=1;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
			offset+=1;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);			
		}
		break;
		case TREE_AC_DUBL:
		{
			uint32_t val = 1;
			offset = POWER_AC3_RESET_CONSUMP;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
			uint8_t chs = h->pbrd[pch->info.addr]->chs;
			offset += chs;
			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
		}
		break;
		default:
			break;
	}
	lock_off(h->lck);
	
	return 0;
}


int power_set_close_delay(power_ch_t *pch)
{
    int r=-1;
    uint16_t tmp[2],reg,offset;
    power_handle_t *h=&pwrHandle;
    
    lock_on(h->lck);
    switch(pch->info.type) {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            tmp[0] = pch->info.close_delay*1000;
            offset = POWER_AC_CLOSE_DELAY_TIME_L+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 1);
        }
        break;

        case DCPDU_TYPE:
        {
            uint32_t time=pch->info.open_delay;
            tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
            offset = POWER_DC_CLOSE_DELAY+pch->info.sch;
            r = write_reg(h, pch->info.addr, offset, tmp, 2);
        }
        break;
        
        case TREE_AC_TYPE:
        {
            uint32_t time=pch->info.close_delay;
						tmp[0] = time & 0xffff;
            tmp[1] = (time >> 16) & 0xffff;
 
            offset = POWER_AC3_CLOSE_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;

        }
        break;
        
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_OUT_TYPE:
        case DC_IN_TYPE:
        default:
        r = -1;
        break;
    }
    lock_off(h->lck);
    
    return r;
}


int power_data_get(power_all_t *all)
{
    power_handle_t *h=&pwrHandle;
    
    if(!all) {
        return -1;
    }
    
    *all = h->all;
    return 0;
}


power_all_t * power_get_all(void)
{
	power_handle_t *h=&pwrHandle;
	return &h->all;
}


int power_breaker_get(breaker_all_t *all)
{
    int i,j,idx=0;
    power_handle_t *h=&pwrHandle;
    
    if(!all) {
        return -1;
    }
    
    lock_on(h->lck);
    all->cnt = 0;
    for(i=1; i<=h->cnt; i++) {
        if(h->pbrd[i]) {
            all->cnt += h->pbrd[i]->chs;
        }
    }
    if(all->cnt>0) {
        all->data = (breaker_data_t*)malloc(sizeof(breaker_data_t)*all->cnt);
        if(all->data) {
            for(i=1; i<=h->cnt; i++) {
                if(h->pbrd[i]) {
                    for(j=0; j<2; j++) {
                        if(h->pbrd[i]->brk[j].info.addr>0) {
                            all->data[idx++] = h->pbrd[i]->brk[j];
                        }
                    }
                }
            }
        }
        else {
            all->cnt = 0;
        }
    }
    lock_off(h->lck);
    
    return 0;
}