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"
#include "led.h"
#include "math.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_new_t pwr_Handle ={0};
static int write_reg(void *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt);

static int read_reg(void *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
		(void)(h);
    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(void *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
		(void)(h);
    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 total_proc(power_handle_new_t *h)
{
    power_t tmp[3]={0};
		power_t tmp_all = {0};
    lock_on(h->lck);
		 if(h->product->type==PDU_AC_I3O1 || h->product->type==PDU_AC_I3O1_H)
		 {
			 for(int i = 0; i < h->chs;i++)
			 {
				 int k = h->pch[i].info.pse.ph - 1;
				 tmp[k].consump += h->pch[i].power[k].consump;
				 tmp[k].voltage = (tmp[k].voltage > h->pch[i].power[k].voltage ) ? tmp[k].voltage : h->pch[i].power[k].voltage;
				 tmp[k].current += ( h->pch[i].power[k].current);
				 tmp[k].power   += h->pch[i].power[k].power; 
				 tmp[k].reactive_power +=  h->pch[i].power[k].reactive_power;
				 tmp[k].app_power += h->pch[i].power[k].app_power;
			 }
			 for(int i = 0 ; i < 3;++i)
			 { 
				 tmp[i].factor = tmp[i].app_power > 0 ?(tmp[i].power /tmp[i].app_power) : 0.0;
				 h->total.all_l[i] = tmp[i];
				 tmp_all.consump += tmp[i].consump;
				 tmp_all.voltage = tmp_all.voltage > tmp[i].voltage ? tmp_all.voltage: tmp[i].voltage;
				 tmp_all.current += tmp[i].current;
				 tmp_all.power += tmp[i].power;
				 tmp_all.reactive_power += tmp[i].reactive_power;
				 tmp_all.app_power += tmp[i].app_power;
			 }
			 tmp_all.current /= 3;
			 tmp_all.current *=1.732;
			 tmp_all.voltage *= 1.732;
			 tmp_all.factor = tmp_all.app_power > 0 ? (tmp_all.power / tmp_all.app_power) : 0.0;	 
		 }else if(h->product->type==PDU_AC_I3O3)
		 {
				for(int i = 0 ;i < h->chs;i++)
				{
					float chn_total_p = 0.0;
					for(int k=0; k<3; k++) {
					tmp[k].consump += h->pch[i].power[k].consump;
					tmp[k].voltage = (tmp[k].voltage > h->pch[i].power[k].voltage ) ? tmp[k].voltage : h->pch[i].power[k].voltage;
					tmp[k].current += ( h->pch[i].power[k].current);
					tmp[k].power   += h->pch[i].power[k].power; 
					tmp[k].reactive_power +=  h->pch[i].power[k].reactive_power;
					tmp[k].app_power += h->pch[i].power[k].app_power;
					}
				}		
			 for(int i = 0 ; i < 3;++i)
			 { 
				 tmp[i].factor = tmp[i].app_power > 0 ?(tmp[i].power /tmp[i].app_power) : 0;
				 h->total.all_l[i] = tmp[i];
				 tmp_all.consump += tmp[i].consump;
				 tmp_all.voltage = tmp_all.voltage > tmp[i].voltage ? tmp_all.voltage: tmp[i].voltage;
				 tmp_all.current += tmp[i].current;
				 tmp_all.power += tmp[i].power;
				 tmp_all.reactive_power += tmp[i].reactive_power;
				 tmp_all.app_power += tmp[i].app_power;
			 }
			 tmp_all.voltage *= 1.732;
			 tmp_all.factor = tmp_all.app_power > 0 ? (tmp_all.power / tmp_all.app_power) : 0.0; 
	   }else if(h->product->type==PDU_AC_I3O2)
		 {

			 for(int i = 0 ;i < h->chs;i++)
			 {
				 int left = h->pch[i].info.pse.ph2.ph_l-1;
			   int right = h->pch[i].info.pse.ph2.ph_l -1;
				 tmp[left].consump += (h->pch[i].power[left].consump);
				 tmp[left].voltage = (tmp[left].voltage > h->pch[i].power[left].voltage) ? tmp[left].voltage : h->pch[i].power[left].voltage;
				 tmp[left].current += ( h->pch[i].power[left].current);
				 tmp[left].power   += h->pch[i].power[left].power; 
				 tmp[left].reactive_power += h->pch[i].power[left].reactive_power;
				 tmp[left].app_power +=h->pch[i].power[left].app_power;		
				
				 tmp[right].consump += (h->pch[i].power[right].consump);
				 tmp[right].voltage = (tmp[right].voltage > h->pch[i].power[right].voltage) ? tmp[right].voltage : h->pch[i].power[right].voltage;
				 tmp[right].current += ( h->pch[i].power[right].current);
				 tmp[right].power   += h->pch[i].power[right].power; 
				 tmp[right].reactive_power += h->pch[i].power[right].reactive_power;
				 tmp[right].app_power +=h->pch[i].power[right].app_power;		
			 }				 
			 for(int i = 0 ; i < 3;++i)
			 { 
				 tmp[i].factor = tmp[i].app_power > 0 ?(tmp[i].power /tmp[i].app_power) : 0;
				 h->total.all_l[i] = tmp[i];
				 tmp_all.consump += tmp[i].consump;
				 tmp_all.voltage = tmp_all.voltage > tmp[i].voltage ? tmp_all.voltage: tmp[i].voltage;
				 tmp_all.current += tmp[i].current;
				 tmp_all.power += tmp[i].power;
				 tmp_all.reactive_power += tmp[i].reactive_power;
				 tmp_all.app_power += tmp[i].app_power;
			 }
			 tmp_all.voltage *= 1.732;
			 tmp_all.factor = tmp_all.app_power > 0 ? (tmp_all.power / tmp_all.app_power) : 0.0; 
		 }else if(PDU_AC_I1O1 == h->product->type)
		 {
			 float chn_total_p = 0.0;
			 for(int i = 0; i < h->chs;i++)
			 {
				 tmp_all.consump += h->pch[i].power[0].consump;
				 tmp_all.voltage = (tmp_all.voltage > h->pch[i].power[0].voltage) ? tmp_all.voltage : h->pch[i].power[0].voltage;
				 tmp_all.current += ( h->pch[i].power[0].current);
				 tmp_all.reactive_power += h->pch[i].power[0].reactive_power;
				 tmp_all.power   += h->pch[i].power[0].power; 
				 tmp_all.app_power +=(h->pch[i].power[0].app_power);
			 }		 
			 tmp_all.factor = tmp_all.app_power > 0 ? (tmp_all.power / tmp_all.app_power) > 1 ? 0.999: (tmp_all.power / tmp_all.app_power) : 0;
		 }else if(PDU_DC_I1O1 == h->product->type)
		 {
			 for(int i = 0; i < h->chs;i++)
			 {
				 tmp_all.consump += h->pch[i].power[0].consump;
				 tmp_all.voltage = (tmp_all.voltage > h->pch[i].power[0].voltage) ? tmp_all.voltage : h->pch[i].power[0].voltage;
				 tmp_all.current += ( h->pch[i].power[0].current);
				 tmp_all.power   += h->pch[i].power[0].power; 
				 tmp_all.app_power +=(h->pch[i].power[0].app_power);
			 }
				tmp_all.factor = 1;			 
		 }
		h->total.all = tmp_all;
		
    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)
	{
		if(lang == 0)
			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
			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);
		if(lang == 0)
			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]);
		else
			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_alarm_trap(&data,0);
	}
	beep_set(BEEP_MODE_WARN1);
	led_set(LED_MODE_WARN1);
}





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);
	if(lang == 0)
		sprintf(w_info.waning_context,"%sL%d%s!",name,ph,lang_lose_string[lang][STR_LOSE_ID]);
	else
		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_alarm_trap(&data,0);
	}
	beep_set(BEEP_MODE_WARN1);	
	led_set(LED_MODE_WARN1);
}




static void power_thread(void *arg)
{
    int r;
    thread_handle_t *th=(thread_handle_t*)arg;
    power_handle_new_t *h=(power_handle_new_t*)th->attr->arg;
	  
    while(th->quit==0) {
			for(int i = 1;i < h->brd_max;i++)
			{
				if(h->board[i].flag)
				{
					h->get_board_power_info(h->board[i].board_new.addr);
					rt_thread_mdelay(40);	
				}
			}		
			total_proc(h);
			//usleep(10000);			
    }
}



static void b_ac_power_get(uint8_t addr)
{
		power_handle_new_t *h = &pwr_Handle;
	  power_t *pwr=NULL,power={0};
    uint16_t offset,tmp[144]={0};
    power_ch_new_t *pch=NULL;
		alarm_all_t alarm_stat = {0};
		int r = 0;
		
    lock_on(h->lck);
		uint32_t val;									
    offset = POWER_AC_CUR_INFO_L;
    r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*12);
    if (r== 0) {
       for (int i=0; i<h->board[addr].board_new.cnt; i++) {
				 if(h->product->type == PDU_AC_I3O1 || h->product->type == PDU_AC_I3O1_H)
				 {
					 // _id = 0 ,1 , 2
					 uint8_t _id =h->board[addr].board_new.p_ch[i].info.pse.ph - 1;
					 pwr = &h->board[addr].board_new.p_ch[i].power[_id];
				 }else
					 pwr = &h->board[addr].board_new.p_ch[i].power[0];
         int idx = i * 12;
				 val = (tmp[1 + idx] << 16) | tmp[0 + idx];
         pwr->voltage = val / 1000.0;
                    
         val = (tmp[3 + idx] << 16) | tmp[2 + idx];
         pwr->current = val / 1000.0;
                    
         val = (tmp[5 + idx] << 16) | tmp[4 + idx];
         pwr->power = val / 1000.0;

         val = (tmp[7 + idx] << 16) | tmp[6 + idx];
         pwr->freq = val / 1000.0;
                    
         val = (tmp[9 + idx] << 16) | tmp[8 + idx];
         pwr->consump = val / 1000.0;
                    
         val = (tmp[11 + idx] << 16) | tmp[10 + idx];
         pwr->factor = val / 1000.0;
				 if(pwr->factor >0.01)
				 {
					 pwr->app_power =  pwr->power / pwr->factor;
				 }else
				 {
					 pwr->app_power = pwr->power;
				 }

				 if(pwr->factor >0.01)
				 {
					 float app_power2 = pwr->app_power * pwr->app_power;
					 float power2 = pwr->power * pwr->power;
					 
					 double f = (double)(app_power2) - power2;
					 if(f < 0.0)
							pwr->reactive_power = 0;
					 else
							pwr->reactive_power = (float)sqrt(f);
				 }else
				 {
					 pwr->reactive_power = 0;
				 }
				pwr->power /= 1000.0;
				pwr->app_power /= 1000.0;
				pwr->reactive_power /= 1000.0;
			 }
    }else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}

    offset = POWER_AC_STAT_INFO_L;
		memset(tmp,0,sizeof(tmp));
    r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt);
    if (r==0)
		{
      for (int i=0; i< h->board[addr].board_new.cnt; i++) 
			{
         pch = &h->board[addr].board_new.p_ch[i];
				 alarm_stat = pch->info.alarm;
				 pch->info.status = tmp[i] & (0x01);			
				 op_wanning_info info={0};
				 if(h->product->type == PDU_AC_I3O1 || h->product->type == PDU_AC_I3O1_H)
				 {
					 uint8_t _id = pch->info.pse.ph -1;
					 switch(_id)
					 {
						 case 0:
						 {
							pch->info.alarm.l1_v_upper   = (tmp[i] & BIT(2))?1:0;
							pch->info.alarm.l1_v_lower   = (tmp[i] & BIT(4))?1:0;
							pch->info.alarm.l1_c_upper   = (tmp[i] & BIT(6))?1:0;
							pch->info.alarm.l1_p_upper   = (tmp[i] & BIT(8))?1:0;
							pch->info.alarm.l1_w_upper   = (tmp[i] & BIT(10))?1:0;							
						}
						break;
						case 1:
					  {
							pch->info.alarm.l2_v_upper   = (tmp[i] & BIT(2))?1:0;
							pch->info.alarm.l2_v_lower   = (tmp[i] & BIT(4))?1:0;
							pch->info.alarm.l2_c_upper   = (tmp[i] & BIT(6))?1:0;
							pch->info.alarm.l2_p_upper   = (tmp[i] & BIT(8))?1:0;
							pch->info.alarm.l2_w_upper   = (tmp[i] & BIT(10))?1:0;
							
					  }
					  break;
						case 2:
						{
							pch->info.alarm.l3_v_upper   = (tmp[i] & BIT(2))?1:0;
							pch->info.alarm.l3_v_lower   = (tmp[i] & BIT(4))?1:0;
							pch->info.alarm.l3_c_upper   = (tmp[i] & BIT(6))?1:0;
							pch->info.alarm.l3_p_upper   = (tmp[i] & BIT(8))?1:0;
							pch->info.alarm.l3_w_upper   = (tmp[i] & BIT(10))?1:0;																
						}
						break;
						default:
							break;
						}
					}else
					{
						pch->info.alarm.l1_v_upper   = (tmp[i] & BIT(2))?1:0;
						pch->info.alarm.l1_v_lower   = (tmp[i] & BIT(4))?1:0;
						pch->info.alarm.l1_c_upper   = (tmp[i] & BIT(6))?1:0;
						pch->info.alarm.l1_p_upper   = (tmp[i] & BIT(8))?1:0;
						pch->info.alarm.l1_w_upper   = (tmp[i] & BIT(10))?1:0;		
					}
					info.id = i;
					info.wanning_type = ALARM_TYPE_POWER;
					info.power_type = h->product->type;
					if(h->product->type == PDU_AC_I3O1 || h->product->type == PDU_AC_I3O1_H)
					{
						info.ph_info = pch->info.pse.ph;
						uint8_t _id =  pch->info.pse.ph-1;
						switch(_id)
						{
							case 0:
							{
								if(!alarm_stat.l1_v_upper && pch->info.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(!alarm_stat.l1_v_lower && pch->info.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(!alarm_stat.l1_c_upper && pch->info.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(!alarm_stat.l1_p_upper && pch->info.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(!alarm_stat.l1_w_upper && pch->info.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);
								}														
							}
							break;
							case 1:
							{
								if(!alarm_stat.l2_v_upper && pch->info.alarm.l2_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(!alarm_stat.l2_v_lower && pch->info.alarm.l2_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(!alarm_stat.l2_c_upper && pch->info.alarm.l2_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(!alarm_stat.l2_p_upper && pch->info.alarm.l2_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(!alarm_stat.l2_w_upper && pch->info.alarm.l2_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);
								}	
							}
							break;
							case 2:
							{
								if(!alarm_stat.l3_v_upper && pch->info.alarm.l3_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(!alarm_stat.l3_v_lower && pch->info.alarm.l3_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(!alarm_stat.l3_c_upper && pch->info.alarm.l3_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(!alarm_stat.l3_p_upper && pch->info.alarm.l3_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(!alarm_stat.l3_w_upper && pch->info.alarm.l3_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);
								}	
							}
								break;
							default:
								break;
						}
						
					}else
					{
						if(!alarm_stat.l1_v_upper && pch->info.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(!alarm_stat.l1_v_lower && pch->info.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(!alarm_stat.l1_c_upper && pch->info.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(!alarm_stat.l1_p_upper && pch->info.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(!alarm_stat.l1_w_upper && pch->info.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);
						}														
					}
				}
		}
		else{
       LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset, h->board[addr].board_new.cnt);
     }							
		lock_off(h->lck);
}

static void b_ac_delay_get(uint8_t addr)
{
	power_handle_new_t *h = &pwr_Handle;
	power_t *pwr=NULL,power={0};
  uint16_t offset,tmp[144]={0};
  power_ch_new_t *pch=NULL;
	int r = 0;	
	offset = POWER_AC_OPEN_DELAY_TIME_L;
	r =read_reg(NULL,addr, offset, tmp, h->board[addr].board_new.cnt);
	if(r == 0)
	{
		for(int i = 0; i < h->board[addr].board_new.cnt;i++)
		{
			pch = &h->board[addr].board_new.p_ch[i];
			pch->info.open_delay = tmp[i] / 1000;
		}
	}
	offset = POWER_AC_CLOSE_DELAY_TIME_L;
	r =read_reg(NULL,addr, offset, tmp, h->board[addr].board_new.cnt);
	if(r == 0)
	{	
		for(int i = 0; i < h->board[addr].board_new.cnt;i++)
		{
			pch = &h->board[addr].board_new.p_ch[i];
			pch->info.close_delay = tmp[i] / 1000;
		}		
	}
}

static void b_ac_thr_get(uint8_t addr)
{
	power_handle_new_t *h = &pwr_Handle;
	power_t *pwr=NULL;
  uint16_t offset,tmp[144]={0};
  power_ch_new_t *pch=NULL;

	int r = 0;	
	if(h->board[addr].board_new.cnt < 8)
	{
		offset = POWER_AC_THRESHOLD_L;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt * 16);
		if(r == 0)
		{
			for (int i=0; i<h->board[addr].board_new.cnt; i++) {
				pch = &h->board[addr].board_new.p_ch[i];
				int index = i*16;
				pch->thr.v_upper = ((tmp[1+index]<<16)|tmp[0+index])/1000.0;
				pch->thr.v_lower = ((tmp[3+index]<<16)|tmp[2+index])/1000.0;
				pch->thr.c_upper = ((tmp[5+index]<<16)|tmp[4+index])/1000.0;
				pch->thr.p_upper = ((tmp[9+index]<<16)|tmp[8+index])/1000.0;
				pch->thr.w_upper = ((tmp[13+index]<<16)|tmp[12+index])/1000.0;
			}
		}
	}else
	{
		offset = POWER_AC_THRESHOLD_L;
		r = read_reg(NULL, addr, offset, tmp, 7 * 16);
		if(r == 0)
		{
			for (int i=0; i < 7; i++) {
				pch = &h->board[addr].board_new.p_ch[i];
				int index = i*16;
				pch->thr.v_upper = ((tmp[1+index]<<16)|tmp[0+index])/1000.0;
				pch->thr.v_lower = ((tmp[3+index]<<16)|tmp[2+index])/1000.0;
				pch->thr.c_upper = ((tmp[5+index]<<16)|tmp[4+index])/1000.0;
				pch->thr.p_upper = ((tmp[9+index]<<16)|tmp[8+index])/1000.0;
				pch->thr.w_upper = ((tmp[13+index]<<16)|tmp[12+index])/1000.0;										
			}
		}
		offset = POWER_AC_THRESHOLD_L + (16*7);
										
		r = read_reg(NULL,addr, offset, tmp, (h->board[addr].board_new.cnt-7) * 16);
		if(r == 0)
		{
			for (int i=0; i< (h->board[addr].board_new.cnt-7); i++) {
				pch = &h->board[addr].board_new.p_ch[i+7];
				int index = i*16;
				pch->thr.v_upper = ((tmp[1+index]<<16)|tmp[0+index]) / 1000.0;
				pch->thr.v_lower = ((tmp[3+index]<<16)|tmp[2+index]) / 1000.0;
				pch->thr.c_upper = ((tmp[5+index]<<16)|tmp[4+index]) / 1000.0;
				pch->thr.p_upper = ((tmp[9+index]<<16)|tmp[8+index]) / 1000.0;
				pch->thr.w_upper = ((tmp[13+index]<<16)|tmp[12+index]) / 1000.0;										
			}
		}
	}
}

static void b_ac_set_delay(uint8_t addr,uint8_t b_addr,uint16_t delay_open, uint16_t delay_close)
{
	power_handle_new_t *h = &pwr_Handle;
  uint16_t tmp[2]={0};
  power_ch_new_t *pch=NULL;
	int r = 0;
	pch = &h->board[addr].board_new.p_ch[b_addr];
  
	tmp[0] = delay_open*1000;
  uint16_t offset = POWER_AC_OPEN_DELAY_TIME_L+b_addr;
	r = write_reg(NULL, addr, offset, tmp, 1);
	if(r != 0)
	{
		r = write_reg(NULL, addr, offset, tmp, 1);
	}
	if(r == 0)
	{
		pch->info.open_delay = delay_open;
	}
	
	offset = POWER_AC_CLOSE_DELAY_TIME_L + b_addr;
	tmp[0] = delay_close*1000;
  r = write_reg(NULL, addr, offset, tmp, 1);	
	if(r != 0)
	{
		r = write_reg(NULL, addr, offset, tmp, 1);
	}	
	if(r == 0)
	{
		pch->info.close_delay = delay_close;
	}	
}

static void b_ac_set_thr(uint8_t addr,uint8_t b_addr,thr_t *thr)
{
	power_handle_new_t *h = &pwr_Handle;
  power_ch_new_t *pch=NULL;
	
	int r = 0;	
  uint16_t offset = 0;
  uint32_t data_temp = 0 ;
	uint16_t data_buf[16] = {0};

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

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

	//电能上限
	data_temp =  (thr->w_upper)*1000;
	data_buf[12] = data_temp;
	data_buf[13] = data_temp>>16;
	//电能下限
	data_temp =  0;
	data_buf[14] = data_temp;
	data_buf[15] = data_temp>>16;
	
	offset = POWER_AC_THRESHOLD_L + (b_addr*16);
	r = write_reg(NULL,addr, offset, data_buf, 16);
	if(r < 0)
	{
		r = write_reg(NULL,addr, offset, data_buf, 16);
	}
	if(r == 0)
	{
		pch = &h->board[addr].board_new.p_ch[b_addr];
		pch->thr = *thr;
	}else
	{
		LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,b_addr);
	}
}
static void b_ac_set_batch_thr(uint8_t addr,thr_t *thr)
{
	power_handle_new_t *h = &pwr_Handle;
  power_ch_new_t *pch=NULL;
	int r = 0;	
  uint16_t offset = 0;
  uint32_t data_temp = 0 ;
	
	int count = h->board[addr].board_new.cnt;
	for(int i = 0;i < count;i++)
	{
		uint16_t data_buf[16] = {0};
		offset = POWER_AC_THRESHOLD_L + (i * 16);
		//电压上限
		data_temp =  (thr->v_upper*1000);
		data_buf[0] = data_temp;
		data_buf[1] = data_temp>>16;
		//电压下限
		data_temp =  (thr->v_lower*1000);
		data_buf[2] = data_temp;
		data_buf[3] = data_temp>>16;
		//电流上限
		data_temp =  (thr->c_upper*1000);
		data_buf[4] = data_temp;
		data_buf[5] = data_temp>>16;
		//电流下限
		data_temp =  (0);
		data_buf[6] = data_temp;
		data_buf[7] = data_temp>>16;

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

		//电能上限
		data_temp =  (thr->w_upper)*1000;
		data_buf[12] = data_temp;
		data_buf[13] = data_temp>>16;
		//电能下限
		data_temp =  0;
		data_buf[14] = data_temp;
		data_buf[15] = data_temp>>16;
		r = write_reg(NULL,addr, offset, data_buf, 16);
		if(r < 0)
		{
			r = write_reg(NULL,addr, offset, data_buf, 16);
		}
		if(r == 0)
		{
			pch = &h->board[addr].board_new.p_ch[i];
			pch->thr = *thr;
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,count);
		}		
	}

}




static void b_ac_set_status(uint8_t addr,uint8_t b_addr,uint8_t status)
{
	int r;
	uint16_t st= status,offset,tmp[2]={0};
	
  offset = POWER_AC_CH_STAT_L + b_addr;
  tmp[0] = st;
  r = write_reg(NULL, addr, offset, tmp, 1);
	if(r != 0)
	{
		r = write_reg(NULL, addr, offset, tmp, 1);
	}
	if(r != 0)
	{
		LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,b_addr);
	}
}
static void b_ac_set_consumer_clear(uint8_t addr,uint8_t b_addr)
{
	int r =0;
	uint16_t val = 1;
	uint16_t offset = POWER_AC_RESET_CONSUMP + b_addr;
	r = write_reg(NULL, addr, offset, &val, 1);
	if(r != 0)
	{
		r = write_reg(NULL, addr, offset, &val, 1);
	}
	if(r != 0)
	{
		LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,b_addr);
	}
}
static void b_ac_set_all_status(uint8_t status)
{
	int r = 0;
	power_handle_new_t *h = &pwr_Handle;
	for(int j = 1; j < 33;j++)
	{
		if(h->board[j].flag)
		{
			uint16_t switch_ctrl[8] = {0};
			for (size_t i = 0; i < h->board[j].board_new.cnt; i++)
			{
				switch_ctrl[i] = status;
				if(status==1)
				{
					switch_ctrl[i] |= (1<<11);
				}else
				{
					switch_ctrl[i] |= (1<<12);
				}
			}
			r = write_reg(NULL,j, POWER_AC_CH_STAT_L, &switch_ctrl[0], h->board[j].board_new.cnt);
			if(r != 0)
			{
				r = write_reg(NULL,j, POWER_AC_CH_STAT_L, &switch_ctrl[0], h->board[j].board_new.cnt);
			}
			if(r != 0)
			{
				LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", j, POWER_AC_CH_STAT_L, POWER_AC_CH_STAT_L,h->board[j].board_new.cnt);
			}
		}
	}
}
static void b_ac_set_all_consumer_clear(uint8_t addr)
{
	//todo
}




static void b_dc_power_get(uint8_t addr)
{
	
}
static void b_dc_delay_get(uint8_t addr)
{
	//todo
}

static void b_dc_thr_get(uint8_t addr)
{
	//todo
}

static void b_dc_set_delay(uint8_t addr,uint8_t b_addr,uint16_t delay_open, uint16_t delay_close)
{
	//todo
}
static void b_dc_set_thr(uint8_t addr,uint8_t b_addr,thr_t *th)
{
		//todo
}
static void b_dc_set_status(uint8_t addr,uint8_t b_addr,uint8_t status)
{
		//todo
}
static void b_dc_set_consumer_clear(uint8_t addr,uint8_t b_addr)
{
		//todo
}
static void b_dc_set_all_status(uint8_t status)
{
}
static void b_dc_set_all_consumer_clear(uint8_t addr)
{
}






static void b_3_3_ac_power_get(uint8_t addr)
{
		power_handle_new_t *h = &pwr_Handle;
	  power_t *pwr=NULL,power={0};
    uint16_t offset,tmp[144]={0};
    power_ch_new_t *pch=NULL;
		alarm_all_t alarm_stat = {0};
		int r = 0;
		offset = POWER_AC3_OUT_INFO;
		uint32_t val = 0;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*3*16);
		if (r== 0) {
			for(int k = 0; k < h->board[addr].board_new.cnt;k++)
			{
       for (int i=0; i < 3; i++) {
				 
				 int idx = i*16;
				 pwr = &h->board[addr].board_new.p_ch[k].power[i];
				 
				 val = (tmp[1 + idx] << 16) | tmp[0 + idx];
         pwr->voltage = val / 1000.0;
                    
         val = (tmp[3 + idx] << 16) | tmp[2 + idx];
         pwr->current = val / 1000.0;
                    
         val = (tmp[5 + idx] << 16) | tmp[4 + idx];
         pwr->power = val / 1000.0;

         val = (tmp[11 + idx] << 16) | tmp[10 + idx];
         pwr->freq = val / 1000.0;
                    
         val = (tmp[13 + idx] << 16) | tmp[13 + idx];
         pwr->consump = val / 1000.0;
                    
         val = (tmp[15 + idx] << 16) | tmp[14 + idx];
         pwr->factor = val / 1000.0;
				 if(pwr->factor >0.01)
				 {
					 pwr->app_power =  pwr->power / pwr->factor;
				 }else
				 {
					 pwr->app_power = pwr->power;
				 }

				 if(pwr->factor >0.01)
				 {
					 float app_power2 = pwr->app_power * pwr->app_power;
					 float power2 = pwr->power * pwr->power;
					 
					 double f = (double)(app_power2) - power2;
					 if(f < 0.0)
							pwr->reactive_power = 0;
					 else
							pwr->reactive_power = (float)sqrt(f);
				 }else
				 {
					 pwr->reactive_power = 0;
				 }
				pwr->power /= 1000.0;
				pwr->app_power /= 1000.0;
				pwr->reactive_power /= 1000.0;
			 }
		 }
    }else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		offset = POWER_AC3_OUT_ENABLE;
		memset(tmp,0,sizeof(tmp));
    r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if (r== 0) {
			for(int k = 0;k <  h->board[addr].board_new.cnt;k++)
			{
				pch = &h->board[addr].board_new.p_ch[k];
				for (int i=0; i < 3; i++) {
					int index = i * 2;
					pch->info.status = (tmp[0+index] & BIT(0)) ? 1 : 0;
				}
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		
		offset = POWER_AC3_OUT_ERROR;
		memset(tmp,0,sizeof(tmp));
    r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		p_alar_t alarm = {0};
		p_alar_t alarm_old = {0};
		if (r== 0) {
			for(int k = 0;k <  h->board[addr].board_new.cnt;k++)
			{
				alarm_old.ala_all = h->board[addr].board_new.p_ch[k].info.alarm;
				for (int i=0; i < 3; i++) {
					int index = i * 2;
					alarm.ala[i].l_v_upper = (tmp[0+index] & BIT(0))?1:0;
					alarm.ala[i].l_v_lower = (tmp[0+index] & BIT(1))?1:0;
					alarm.ala[i].l_c_upper = (tmp[0+index] & BIT(2))?1:0;
					alarm.ala[i].l_p_upper = (tmp[0+index] & BIT(3))?1:0;
					alarm.ala[i].l_w_upper = (tmp[0+index] & BIT(4))?1:0;
					op_wanning_info info={0};
					info.ph_info = (i+1);
					if(!alarm_old.ala[i].l_v_upper && alarm.ala[i].l_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(!alarm_old.ala[i].l_v_lower && alarm.ala[i].l_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(!alarm_old.ala[i].l_c_upper &&  alarm.ala[i].l_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(!alarm_old.ala[i].l_p_upper &&  alarm.ala[i].l_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(!alarm_old.ala[i].l_w_upper &&  alarm.ala[i].l_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);
						}							
				}
				h->board[addr].board_new.p_ch[k].info.alarm =  alarm.ala_all;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}		
		
		offset = POWER_AC3_ALARM_MISSING_PH;
		memset(tmp,0,sizeof(tmp));
    r = read_reg(NULL, addr, offset, tmp, 6);
		
		if(r == 0)
		{  
			for(int k = 0;k <  h->board[addr].board_new.cnt;k++)
			{
				int value[3] = {0};
				for(int i = 0; i < 3; i++)
				{
					 if(tmp[i * 2]>0)
					 {
							value[i]=1;
					 }
				}
				alarm.ala[3].l_v_upper = value[0];				//lost 1 phase
				alarm.ala[3].l_v_lower = value[1];				//lost 2 phase
				alarm.ala[3].l_c_upper = value[2];				//lost 3 phase
				op_wanning_info info={0};

				if(!alarm_old.ala[3].l_v_upper && alarm.ala[3].l_v_upper)
				{	
					lose_operation(pch->info.name,1,1);
				}
											
				if(!alarm_old.ala[3].l_v_lower && alarm.ala[3].l_v_lower)
				{
					lose_operation(pch->info.name,2,2);
				}									
											
				if(!alarm_old.ala[3].l_c_upper &&  alarm.ala[3].l_c_upper)
				{
						lose_operation(pch->info.name,3,3);
				}		
				h->board[addr].board_new.p_ch[k].info.alarm =  alarm.ala_all;	
			}				
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
}


static void b_3_3_ac_delay_get(uint8_t addr)
{
	power_handle_new_t *h = &pwr_Handle;
	power_t *pwr=NULL,power={0};
  uint16_t offset,tmp[20]={0};
  power_ch_new_t *pch=NULL;
	int r = 0;	
	offset = POWER_AC3_OPEN_DELAY_TIME;
	uint32_t val = 0;
	r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
	if(r == 0)
	{
		for(int i = 0; i <  h->board[addr].board_new.cnt;i++)
		{
			pch =  &h->board[addr].board_new.p_ch[i];
			int index = i * 2 * 3;
			val = (tmp[1+index] << 16) | tmp[0+index];
			pch->info.open_delay = val / 1000.0;
		}
	}else
	{
		LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
	}
	offset = POWER_AC3_CLOSE_DELAY_TIME;
	r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
	if(r == 0)
	{
		for(int i = 0; i <  h->board[addr].board_new.cnt;i++)
		{
			pch =  &h->board[addr].board_new.p_ch[i];
			int index = i * 2 * 3;
			val = (tmp[1+index] << 16) | tmp[0+index];
			pch->info.close_delay = val / 1000.0;
		}
	}else
	{
		LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
	}
}

static void b_3_3_ac_thr_get(uint8_t addr)
{
		power_handle_new_t *h = &pwr_Handle;
	  power_t *pwr=NULL,power={0};
    uint16_t offset,tmp[144]={0};
    power_ch_new_t *pch=NULL;
		int r = 0;
		offset = POWER_AC3_THRESHOLD_VOL_MAX;
		uint32_t val = 0;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if(r == 0)
		{
			for( int i = 0; i < h->board[addr].board_new.cnt;i++)
			{
				int index = i*2*3;
				pch = &h->board[addr].board_new.p_ch[i];
				val = tmp[1+ index] << 16 | tmp[0+index] ;
				pch->thr.v_upper = val / 1000.0;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		offset = POWER_AC3_THRESHOLD_VOL_MIN;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if(r == 0)
		{
			for( int i = 0; i < h->board[addr].board_new.cnt;i++)
			{
				int index = i*2*3;
				pch = &h->board[addr].board_new.p_ch[i];
				val = tmp[1+ index] << 16 | tmp[0+index];
				pch->thr.v_lower = val / 1000.0;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		offset = POWER_AC3_THRESHOLD_CUR_MAX;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if(r == 0)
		{
			for( int i = 0; i < h->board[addr].board_new.cnt;i++)
			{
				int index = i*2*3;
				pch = &h->board[addr].board_new.p_ch[i];
				val = tmp[1+ index] << 16 | tmp[0+index];
				pch->thr.c_upper = val / 1000.0;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		
		offset = POWER_AC3_THRESHOLD_PWR_MAX;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if(r == 0)
		{
			for( int i = 0; i < h->board[addr].board_new.cnt;i++)
			{
				int index = i*2*3;
				pch = &h->board[addr].board_new.p_ch[i];
				val = tmp[1+ index] << 16 | tmp[0+index];
				pch->thr.p_upper = val / 1000.0;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}
		
		offset = POWER_AC3_THRESHOLD_PWRCON_MAX;
		r = read_reg(NULL, addr, offset, tmp, h->board[addr].board_new.cnt*2*3);
		if(r == 0)
		{
			for( int i = 0; i < h->board[addr].board_new.cnt;i++)
			{
				int index = i*2*3;
				pch = &h->board[addr].board_new.p_ch[i];
				val = tmp[1+ index] << 16 | tmp[0+index];
				pch->thr.w_upper = val / 1000.0;
			}
		}else
		{
			LOGE("read_reg failed, addr:%d reg:0x%04x/%d cnt:%d\n", addr, offset, offset,  h->board[addr].board_new.cnt);
		}		
		
			
}

static void b_3_3_ac_set_delay(uint8_t addr,uint8_t b_addr,uint16_t delay_open, uint16_t delay_close)
{
		power_handle_new_t *h = &pwr_Handle;
	  power_t *pwr=NULL,power={0};
    uint16_t offset,tmp[6]={0};
    power_ch_new_t *pch=NULL;
		int r = 0;
		offset = POWER_AC3_OPEN_DELAY_TIME;
		pch = &h->board[addr].board_new.p_ch[b_addr];
		uint32_t delay = delay_open * 1000;
		
		tmp[0] = delay & 0xFFFF;
		tmp[1] = (delay >> 16) & 0xFFFF;
		
		tmp[2] = delay & 0xFFFF;
		tmp[3] = (delay >> 16) & 0xFFFF;
		
		tmp[4] = delay & 0xFFFF;
		tmp[5] = (delay >> 16) & 0xFFFF;
		
		r = write_reg(NULL, addr, offset, tmp, 6);
		
		offset = POWER_AC3_CLOSE_DELAY_TIME;
		delay = delay_close * 1000;
		
		tmp[0] = delay & 0xFFFF;
		tmp[1] = (delay >> 16) & 0xFFFF;
		
		tmp[2] = delay & 0xFFFF;
		tmp[3] = (delay >> 16) & 0xFFFF;
		
		tmp[4] = delay & 0xFFFF;
		tmp[5] = (delay >> 16) & 0xFFFF;
		
		r = write_reg(NULL, addr, offset, tmp, 6);		
		
		pch->info.open_delay = delay_open;
		pch->info.close_delay = delay_close;
		
}
static void b_3_3_ac_set_thr(uint8_t addr,uint8_t b_addr,thr_t *th)
{
	power_handle_new_t *h = &pwr_Handle;
	power_t *pwr=NULL,power={0};
  uint16_t offset,tmp[6]={0};
  power_ch_new_t *pch=NULL;
	int r = 0;	
	offset = POWER_AC3_THRESHOLD_VOL_MAX+(b_addr * 3);
	pch = &h->board[addr].board_new.p_ch[b_addr];
	uint32_t value = th->v_upper * 1000;
	tmp[0] = value & 0xffff;
	tmp[1] = (value >> 16) & 0xffff;
	
	tmp[2] = value & 0xffff;
	tmp[3] = (value >> 16) & 0xffff;
	
	tmp[4] = value & 0xffff;
	tmp[5] = (value >> 16) & 0xffff;
	
	r = write_reg(NULL, addr, offset, tmp, 6);	
	
	offset = POWER_AC3_THRESHOLD_VOL_MIN+(b_addr * 3);
	value = th->v_lower * 1000;
	tmp[0] = value & 0xffff;
	tmp[1] = (value >> 16) & 0xffff;
	
	tmp[2] = value & 0xffff;
	tmp[3] = (value >> 16) & 0xffff;
	
	tmp[4] = value & 0xffff;
	tmp[5] = (value >> 16) & 0xffff;
	
	r = write_reg(NULL, addr, offset, tmp, 6);	
	
	
	offset = POWER_AC3_THRESHOLD_CUR_MAX+(b_addr * 3);
	value = th->c_upper * 1000;
	tmp[0] = value & 0xffff;
	tmp[1] = (value >> 16) & 0xffff;
	
	tmp[2] = value & 0xffff;
	tmp[3] = (value >> 16) & 0xffff;
	
	tmp[4] = value & 0xffff;
	tmp[5] = (value >> 16) & 0xffff;
	
	r = write_reg(NULL, addr, offset, tmp, 6);	

	offset = POWER_AC3_THRESHOLD_PWR_MAX+(b_addr * 3);
	value = th->p_upper * 1000;
	tmp[0] = value & 0xffff;
	tmp[1] = (value >> 16) & 0xffff;
	
	tmp[2] = value & 0xffff;
	tmp[3] = (value >> 16) & 0xffff;
	
	tmp[4] = value & 0xffff;
	tmp[5] = (value >> 16) & 0xffff;
	
	r = write_reg(NULL, addr, offset, tmp, 6);		
	
	offset = POWER_AC3_THRESHOLD_PWRCON_MAX+(b_addr * 3);
	value = th->w_upper * 1000;
	tmp[0] = value & 0xffff;
	tmp[1] = (value >> 16) & 0xffff;
	
	tmp[2] = value & 0xffff;
	tmp[3] = (value >> 16) & 0xffff;
	
	tmp[4] = value & 0xffff;
	tmp[5] = (value >> 16) & 0xffff;
	
	r = write_reg(NULL, addr, offset, tmp, 6);		
	
	pch->thr = *th;
}
static void b_3_3_ac_set_status(uint8_t addr,uint8_t b_addr,uint8_t status)
{
  uint16_t offset,tmp[6]={0};
	int r = 0;	
	tmp[0] = status;
	tmp[1] = status;
	tmp[2] = status;
	offset = POWER_AC3_CH_OUT_ENABLE + (b_addr*3);
	r = write_reg(NULL, addr, offset, tmp, 3);
}
static void b_3_3_ac_set_consumer_clear(uint8_t addr,uint8_t b_addr)
{
		uint16_t offset,tmp[6]={0};
		int r = 0;	
		offset = POWER_AC3_RESET_CONSUMP + (b_addr*3);
		tmp[0] = 1;
		tmp[1] = 1;
		tmp[2] = 1;
		r = write_reg(NULL, addr, offset, tmp, 3);
}
static void b_3_3_ac_set_all_status(uint8_t status)
{
		power_handle_new_t *h = &pwr_Handle;
		power_t *pwr=NULL,power={0};
		uint16_t offset,tmp[6]={0};
		power_ch_new_t *pch=NULL;
		int r = 0;	
		tmp[0] = 1;
		if(status)
			offset = POWER_AC3_ALL_OPEN_INFO;
		else
			offset = POWER_AC3_ALL_CLOSE_INFO;
		r = write_reg(NULL, 0, offset, tmp, 1);
		r = write_reg(NULL, 0, offset, tmp, 1);
}
static void b_3_3_ac_set_all_consumer_clear(uint8_t addr)
{
		uint16_t offset,tmp[6]={0};
		int r = 0;	
		tmp[0] = 1;
		offset = POWER_AC3_RESET_CONSUMP_ALL;
		r = write_reg(NULL, 0, offset, tmp, 1);
		r = write_reg(NULL, 0, offset, tmp, 1);
}

static void b_3_2_ac_power_get(uint8_t addr)
{
	
}

static void b_3_2_ac_delay_get(uint8_t addr)
{
	
}

static void b_3_2_ac_thr_get(uint8_t addr)
{
	
}

static void b_3_2_ac_set_delay(uint8_t addr,uint8_t b_addr,uint16_t delay_open, uint16_t delay_close)
{
}
static void b_3_2_ac_set_thr(uint8_t addr,uint8_t b_addr,thr_t *th)
{
}
static void b_3_2_ac_set_status(uint8_t addr,uint8_t b_addr,uint8_t status)
{
}
static void b_3_2_ac_set_consumer_clear(uint8_t addr,uint8_t b_addr)
{
}
static void b_3_2_ac_set_all_status(uint8_t status)
{
}
static void b_3_2_ac_set_all_consumer_clear(uint8_t addr)
{
}



static int board_scan()
{
	int cnts = 0;
	power_handle_new_t *h = &pwr_Handle;
	paras_data_t* para=paras_get();
	uint16_t tmp[2] = {0};
	int r =0;
	uint8_t board_count = 0;
	h->power_type = h->product->type;
	for(int i =1; i <h->brd_max;i++)
	{
		uint8_t cnt =0;
		//board_count ++;
    if(h->product->type==PDU_AC_I1O1 || h->product->type==PDU_AC_I3O1_H || h->product->type==PDU_AC_I3O1) {
        r = read_reg(NULL, i, POWER_AC_GET_INFO, tmp, 1);
        if(r==0) {
					board_count++;
					cnt =tmp[0]&0xFF;
					h->board[i].flag =1;
					h->board[i].board_new.addr = i;
					LOGD("___ board scan addr %d ok, type: %d, chs: %d\n", i, h->product->type, cnt);
					
					if((cnts + cnt) > h->ch_max)
					{
						cnts = h->ch_max;
						h->board[i].board_new.cnt = h->ch_max - cnts;
						break;
					}else
					{
						cnts += cnt;
						h->board[i].board_new.cnt = cnt;
					}
        }else
				{
					LOGD("___ board scan addr %d failed\n", i);
				}
    }
    else {
        r = read_reg(NULL, i, POWER_DC_INFO, tmp, 2);
        if(r==0) 
				{
					board_count++;
					cnt = tmp[0]&0xFF;
					h->board[i].flag =1;
					h->board[i].board_new.addr = i;
					if(h->product->type == PDU_AC_I3O3)	cnt /= 3;
					if(h->product->type == PDU_AC_I3O2) cnt /= 2;
					LOGD("___ board scan addr %d ok, type: %d, chs: %d\n", i, h->product->type, cnt);
					if((cnts + cnt) > h->ch_max)
					{
						cnts = h->ch_max;
						h->board[i].board_new.cnt = h->ch_max - cnts;
						break;
					}else
					{
						cnts += cnt;
						h->board[i].board_new.cnt = cnt;
					}				
        }
    }
	}
	h->chs = cnts;
	h->brd_cnt = board_count;
	//  
	h->pch =  calloc(1, sizeof(power_ch_new_t) * h->chs);
	
	LOGD("__ power init ch_mem=%d sizeof(power_ch_new_t)=%d\n",sizeof(power_ch_new_t) * h->chs,sizeof(power_ch_new_t));
	memset(h->pch,0,sizeof(power_ch_new_t)*h->chs);
	
	power_ch_new_t * p_start = h->pch;
	char temp[16] = {0};
	int index = 1;
	for(int i =1; i <h->brd_max;i++)
	{
		if(h->board[i].flag)
		{
			for(int j = 0;j<h->board[i].board_new.cnt;j++)
			{
				p_start[j].info.sch = j;
				p_start[j].info.addr = i;
				sprintf(temp,"CH-%d",index++);
				strcpy(p_start[j].info.name,temp);
			}
			h->board[i].board_new.p_ch = p_start;
			p_start += h->board[i].board_new.cnt;
		}
	}
	if(h->product->type==PDU_AC_I3O1 || h->product->type==PDU_AC_I3O1_H)
	{
		for(int i = 0; i < h->chs;i++)
		{
			h->pch[i].info.pse.ph = para->phase_seq.phase_seq[i] -'0';
		}
	}
	
	if(h->product->type==PDU_AC_I1O1 || h->product->type==PDU_AC_I3O1_H || h->product->type==PDU_AC_I3O1) {
		h->get_board_power_info = b_ac_power_get;
		h->get_board_delay_info = b_ac_delay_get;
		h->get_board_thr_info = b_ac_thr_get;
		h->set_all_consumer_clear = b_ac_set_all_consumer_clear;
		h->set_all_status = b_ac_set_all_status;
		h->set_consumer_clear = b_ac_set_consumer_clear;
		h->set_delay = b_ac_set_delay;
		h->set_status = b_ac_set_status;
		h->set_thr = b_ac_set_thr;
		h->set_batch_thr = b_ac_set_batch_thr;
	}else if(h->product->type==PDU_DC_I1O1) {
		h->get_board_power_info = b_dc_power_get;
		h->get_board_delay_info = b_dc_delay_get;
		h->get_board_thr_info = b_dc_thr_get;
		h->set_all_consumer_clear = b_dc_set_all_consumer_clear;
		h->set_all_status = b_dc_set_all_status;
		h->set_consumer_clear = b_dc_set_consumer_clear;
		h->set_delay = b_dc_set_delay;
		h->set_status = b_dc_set_status;
		h->set_thr = b_dc_set_thr;			
	}else if(h->product->type==PDU_AC_I3O3) {
		h->get_board_power_info = b_3_3_ac_power_get;
		h->get_board_delay_info = b_3_3_ac_delay_get;
		h->get_board_thr_info = b_3_3_ac_thr_get;
		h->set_all_consumer_clear = b_3_3_ac_set_all_consumer_clear;
		h->set_all_status = b_3_3_ac_set_all_status;
		h->set_consumer_clear = b_3_3_ac_set_consumer_clear;
		h->set_delay = b_3_3_ac_set_delay;
		h->set_status = b_3_3_ac_set_status;
		h->set_thr = b_3_3_ac_set_thr;				
	}else if(h->product->type==PDU_AC_I3O2) {
		h->get_board_power_info = b_3_2_ac_power_get;
		h->get_board_delay_info = b_3_2_ac_delay_get;
		h->get_board_thr_info = b_3_2_ac_thr_get;
		h->set_all_consumer_clear = b_3_2_ac_set_all_consumer_clear;
		h->set_all_status = b_3_2_ac_set_all_status;
		h->set_consumer_clear = b_3_2_ac_set_consumer_clear;
		h->set_delay = b_3_2_ac_set_delay;
		h->set_status = b_3_2_ac_set_status;
		h->set_thr = b_3_2_ac_set_thr;			
	}
	
	return 0;
}
	



int power_init(void)
{
	  power_handle_new_t *h = &pwr_Handle;
    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_new_t));
    h->lck = lock_init();
		h->brd_max = POWER_BOARD_MAX;
		h->ch_max = POWER_BOARD_MAX;
    h->product = &p->prod;
		
		
    board_scan();
		
		for(int i = 1;i < h->brd_max;i++)
		{
			if(h->board[i].flag)
			{
				h->get_board_delay_info(h->board[i].board_new.addr);
				h->get_board_thr_info(h->board[i].board_new.addr);
			}
		}
    thread_start(THREAD_ID_POWER, power_thread, h);
    return 0;
}


int power_data_get(power_handle_new_t *all)
{
    return 0;
}

int power_data_get_board_cnt()
{
	return pwr_Handle.brd_cnt;
}


power_handle_new_t * power_get_all(void)
{
	return &pwr_Handle;
}


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;
}