Merge branch 'master' of https://gowone.dy.takin.cc/liyuezong/SmartPDCode

f427/applications/cfg.h

@@ -49,8 +49,8 @@
     
     #define CHANNEL_DELAY                       8
 
-    //#define PROD_TYPE                           PDU_AC_I3O3
-    #define PROD_TYPE                           PDU_AC_I1O1
+    #define PROD_TYPE                           PDU_AC_I3O3
+    //#define PROD_TYPE                           PDU_AC_I1O1
     //#define PROD_TYPE 													 PDU_DC_I1O1
     #define USE_UI
     #define ROTATE                             90

f427/applications/datadef.h

@@ -883,7 +883,8 @@ enum {
 		SUB_TYPE_PARAS_SNMP,
     SUB_TYPE_PARAS_NTP,
 		SUB_TYPE_POWER_CONSUMER_CLEAR,
-    SUB_TYPE_MAX
+		SUB_TYPE_POWER_PH_CFG,
+    SUB_TYPE_MAX,
 };
 
 #define PKT_MAGIC  0xdead

f427/applications/fifo/fifo.c

@@ -72,6 +72,29 @@ bool generic_list_append(GenericFixedList *list, const void *data, size_t data_s
     }
 }
 
+void * generic_list_get_index(GenericFixedList *list,uint8_t index)
+{
+	void *data = NULL;
+	GenericNode *p_node = list->head;
+	
+	if(index < list->current_size)
+	{
+		int i = 0;
+		for(;p_node != list->tail;p_node=p_node->next)
+		{
+			if(i>= index)
+			{
+				data = p_node->data;
+				break;
+			}
+			i++;
+		}
+		if(index == list->current_size-1)
+			data = list->tail->data;
+	}
+	return data;
+}
+
 void generic_list_get(GenericFixedList *list,void * data,uint8_t lenth)
 {
 	if(lenth >= list->current_size)

f427/applications/fifo/fifo.h

@@ -39,7 +39,7 @@ void generic_list_destroy(GenericFixedList *list);
 int generic_list_get_count(GenericFixedList *list);
 
 
-
+void * generic_list_get_index(GenericFixedList *list,uint8_t index);
 
 
 

f427/applications/power.c

@@ -29,6 +29,8 @@ enum
 enum{
 
 	CTRL_3_3 = 8,
+	CTRL_3_2,
+
 };
 
 
@@ -310,7 +312,6 @@ static int get_key(power_handle_t *h, uint8_t addr, board_key_t *key)
 					{
 						key->chs /= 2;
 					}
-					
           return 0;
         }
     }
@@ -1462,82 +1463,474 @@ static int board_read(power_handle_t *h, board_data_t *pbrd,uint8_t flag)
 										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;
 									
-									/*
-									offset = POWER_AC3_THRESHOLD_VOL_MIN;
-									r = read_reg(h, pch->info.addr, offset, tmp, 18);		
-									for (i=0; i<pbrd->chs; i++)
+									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)
 									{
-										 
-										 if(h->prod->type==PDU_AC_I3O3) {
-												int Index = i * 3;
-												int ch_idx = pbrd->ch0-1+i/3;
-												pch = &pbrd->pch[ch_idx];
-												pch->thr.v_lower = ((tmp[Index+1] << 16) + (tmp[Index+0])) / 10;
+										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;
 											}
-											else {
-												pch = &pbrd->pch[i];
-												pch->thr.v_lower = ((tmp[i+1] << 16) + (tmp[i+0])) / 10;               
+										}
+											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;
 											}
-									}								
-									offset = POWER_AC3_THRESHOLD_CUR_MAX;
-									r = read_reg(h, pch->info.addr, offset, tmp, 18);		
+										}
+											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++)
 									{
-										 
-										 if(h->prod->type==PDU_AC_I3O3) {
-												int Index = i * 3;
-												int ch_idx = pbrd->ch0-1+i/3;
-												pch = &pbrd->pch[ch_idx];
-												pch->thr.c_upper = ((tmp[Index+1] << 16) + (tmp[Index+0])) / 10;
-											}
-											else {
-												pch = &pbrd->pch[i];
-												pch->thr.c_upper = ((tmp[i+1] << 16) + (tmp[i+0])) / 10;               
-											}
+											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;
 									}		
-									offset = POWER_AC3_THRESHOLD_PWR_MAX;
-									r = read_reg(h, pch->info.addr, offset, tmp, 18);		
+									j+=16;
 									for (i=0; i<pbrd->chs; i++)
 									{
-										 
-										 if(h->prod->type==PDU_AC_I3O3) {
-												int Index = i * 3;
-												int ch_idx = pbrd->ch0-1+i/3;
-												pch = &pbrd->pch[ch_idx];
-												pch->thr.p_upper = ((tmp[Index+1] << 16) + (tmp[Index+0])) / 10;
-											}
-											else {
-												pch = &pbrd->pch[i];
-												pch->thr.p_upper = ((tmp[i+1] << 16) + (tmp[i+0])) / 10;               
-											}
+										  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])) ;
 									}
-									offset = POWER_AC3_THRESHOLD_PWRCON_MAX;
-									r = read_reg(h, pch->info.addr, offset, tmp, 18);		
+									j+=16;
 									for (i=0; i<pbrd->chs; i++)
 									{
-										 
-										 if(h->prod->type==PDU_AC_I3O3) {
-												int Index = i * 3;
-												int ch_idx = pbrd->ch0-1+i/3;
-												pch = &pbrd->pch[ch_idx];
-												pch->thr.w_upper = ((tmp[Index+1] << 16) + (tmp[Index+0])) / 10;
-											}
-											else {
-												pch = &pbrd->pch[i];
-												pch->thr.w_upper = ((tmp[i+1] << 16) + (tmp[i+0])) / 10;               
-											}
-									}	*/
-								}								
-            }
-            break;
-            
-            case AC_MULTI_S_TYPE:
-            case AC_MULTI_B_TYPE:
-            case DC_OUT_TYPE:
-            case DC_IN_TYPE:
+										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;
+							r = -1;
             break;
         }
         
@@ -1809,7 +2202,7 @@ int power_scan(void)
 						if(pkey->type == 1 || pkey->type == 2)
 						{
 							pbrd->fn = board_fn_ac;
-						}else if(pkey->type == CTRL_3_3)
+						}else if(pkey->type == CTRL_3_3 || CTRL_3_2 == pkey->type)
 						{
 							pbrd->fn = board_fn_ac3;
 						}else 
@@ -1842,14 +2235,14 @@ int power_scan(void)
                 }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] -'0';
-									pch[j].info.ph_val = p->phase_seq_2.phase_right[ch_idx] -'0';						//作为双火线的右边相
+									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] -'0';
+											pch[j].info.ph_id = p->phase_seq.phase_seq[ch_idx-1] -'0';
 										}	else
 											pch[j].info.ph_id = 0;
                 }
@@ -2009,9 +2402,9 @@ int power_set_ch_sw_n(power_ch_t *pch)
 						//获取状态。
 						r = read_reg(h, pch->info.addr, offset, tmp, 2);
             
-            mask = ~(1 << (pch->info.ch-1));
+            mask = ~(1 << (pch->info.sch));
             tmp[0] &= mask;
-            tmp[0] |= (st << (pch->info.ch-1));
+            tmp[0] |= (st << (pch->info.sch));
             r = write_reg(h, pch->info.addr, offset, tmp, 2);
         }
         break;
@@ -2028,10 +2421,19 @@ int power_set_ch_sw_n(power_ch_t *pch)
             }
             
             tmp[0] = st;
-            offset = reg+pch->info.ch-1;
+            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);
 }
@@ -2097,10 +2499,18 @@ int power_set_ch_sw(uint8_t ch, uint8_t on)
             }
             
             tmp[0] = st;
-            offset = reg + +pch->info.sch;
+            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);
     
@@ -2526,11 +2936,57 @@ int power_set_threshold(power_ch_t *pch)
 					 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);
-														
-            
+					 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;
@@ -2585,6 +3041,23 @@ int power_set_open_delay(power_ch_t *pch)
             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:
@@ -2597,6 +3070,41 @@ int power_set_open_delay(power_ch_t *pch)
     
     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)
 {
@@ -2624,10 +3132,26 @@ int power_set_clear_consumer(power_ch_t *pch)
 		case TREE_AC_TYPE:
 		{
 			uint32_t val = 1;
-			offset = POWER_AC3_RESET_CONSUMP + pch->info.sch;
+			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;		
+		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);
 	

f427/applications/power.h

@@ -101,6 +101,7 @@ enum {
     DC_IN_TYPE,
     DCPDU_TYPE,
     TREE_AC_TYPE,   //三相进三项出
+		TREE_AC_DUBL,		//双火线
 };
 enum {
     ENABLE_V_UP         = (1<<1),
@@ -197,5 +198,7 @@ int power_breaker_get(breaker_all_t *all);
 power_handle_t * get_power_handle(void);
 int power_set_clear_consumer(power_ch_t *pch);
 
+int power_set_ph_cfg(power_ch_t *pch);
+
 #endif
 

f427/applications/sensor.c

@@ -20,6 +20,74 @@
 #define CHKECK_COUNT  3
 
 
+enum 
+{
+	STR_SENSOR_ID_OVER,
+	STR_SENSOR_ID_LOW,
+	STR_SENSOR_ID_MAXS,
+	STR_SENSOR_ID_MIN,
+	STR_SENSOR_PARA,
+	STR_SENSOR_ID_VALUE,
+	STR_SENSOR_ID_MAX
+};
+
+const char *lang_sensor_str[2][STR_SENSOR_ID_MAX]={
+	{
+		"超过",
+		"低于",
+		"最大",
+		"最小",
+		"参数",
+		"值",
+	},
+	{
+		"over",
+		"below",
+		"max",
+		"min",
+		"parameter"
+		"value",
+	},
+};
+
+typedef struct 
+{	
+	uint8_t id;
+	uint8_t wanning_type;
+	uint8_t over_low;
+	uint8_t para;
+	uint8_t max_min;
+}op_sensor_w_info;
+
+AlarmTrapinfo sensor_data={0};
+
+static void sensor_wanning_operation(op_sensor_w_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);
+
+	sprintf(w_info.waning_context,"%s %s %d %s %s %s!",name,lang_sensor_str[lang][info->para],info->para,lang_sensor_str[lang][info->over_low],lang_sensor_str[lang][info->max_min],lang_sensor_str[lang][STR_SENSOR_ID_VALUE]);
+
+	wanning_insert(w_info);
+	
+	if(paras_get()->snmp.trapmode == 1)
+	{
+			sensor_data.ID = info->id;
+			sensor_data.Alarmid = ALARM_TYPE_SENSOR;
+			memcpy(sensor_data.AlarmDate,w_info.date,32);
+			memcpy(sensor_data.AlarmContext,w_info.waning_context,64);
+			snmp_sensor_alarm_trap(&sensor_data);
+	}
+	beep_set(1);
+}
 
 
 
@@ -319,6 +387,7 @@ int sensor_query(void)
 				{
 					ssHandle.all.data[i].info.status = 1;
 					ssHandle.all.data[i].info.check_count = 0;
+					op_sensor_w_info info={0};
 					if(ssHandle.all.data[i].val[0].thr.en.th_sen_max_en)
 					{
 						uint8_t  back_waning_up = ssHandle.all.data[i].val[0].s_alarm.max_up;
@@ -327,23 +396,12 @@ int sensor_query(void)
 							ssHandle.all.data[i].val[0].s_alarm.max_up = 1;
 							if(back_waning_up != ssHandle.all.data[i].val[0].s_alarm.max_up)
 							{
-									time_t t=time(NULL);
-										struct tm *tm=localtime(&t);
-									memset(&info.waning_context,0,sizeof(64)); 
-									sprintf(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(info.waning_context,"%s value 1 over max threshold!!",ssHandle.all.data[i].info.name);
-									wanning_insert(info);
-
-									if(paras_get()->snmp.trapmode == 1)
-									{
-												//AlarmTrapinfo t_info={0};
-											data.ID = i;
-											data.Alarmid = ALARM_TYPE_SENSOR;
-											memcpy(data.AlarmDate,info.date,32);
-											memcpy(data.AlarmContext,info.waning_context,64);
-											snmp_sensor_alarm_trap(&data);
-									}
-									beep_set(1);
+								info.id = i;
+								info.max_min = STR_SENSOR_ID_MAXS;
+								info.over_low = STR_SENSOR_ID_OVER;
+								info.para = 1;
+								info.wanning_type = ALARM_TYPE_SENSOR;
+								sensor_wanning_operation(&info,ssHandle.all.data[i].info.name);
 							}
 						}else
 						{
@@ -358,23 +416,12 @@ int sensor_query(void)
 							ssHandle.all.data[i].val[0].s_alarm.min_down = 1;
 							if(back_waning_down != ssHandle.all.data[i].val[0].s_alarm.min_down)
 							{
-									time_t t=time(NULL);
-										struct tm *tm=localtime(&t);
-									memset(&info.waning_context,0,sizeof(64));
-									sprintf(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(info.waning_context,"%s value 1 over min threshold!!",ssHandle.all.data[i].info.name);
-									wanning_insert(info);
-
-									if(paras_get()->snmp.trapmode == 1)
-									{
-												//AlarmTrapinfo t_info={0};
-											data.ID = i;
-											data.Alarmid = ALARM_TYPE_SENSOR;
-											memcpy(data.AlarmDate,info.date,32);
-											memcpy(data.AlarmContext,info.waning_context,64);
-											snmp_sensor_alarm_trap(&data);
-									}
-									beep_set(1);
+								info.id = i;
+								info.max_min = STR_SENSOR_ID_MIN;
+								info.over_low = STR_SENSOR_ID_LOW;
+								info.para = 1;
+								info.wanning_type = ALARM_TYPE_SENSOR;
+								sensor_wanning_operation(&info,ssHandle.all.data[i].info.name);
 							}
 						}else
 						{
@@ -391,23 +438,12 @@ int sensor_query(void)
 								ssHandle.all.data[i].val[1].s_alarm.max_up = 1;
 								if(back_waning_up != ssHandle.all.data[i].val[1].s_alarm.max_up)
 								{
-										memset(&info.waning_context,0,sizeof(64));
-										time_t t=time(NULL);
-											struct tm *tm=localtime(&t);
-										sprintf(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(info.waning_context,"%s value 2 over max threshold!!",ssHandle.all.data[i].info.name);
-										wanning_insert(info);
-
-										if(paras_get()->snmp.trapmode == 1)
-										{
-													//AlarmTrapinfo t_info={0};
-												data.ID = i;
-												data.Alarmid = ALARM_TYPE_SENSOR;
-												memcpy(data.AlarmDate,info.date,32);
-												memcpy(data.AlarmContext,info.waning_context,64);
-												snmp_sensor_alarm_trap(&data);
-										}
-										beep_set(1);
+									info.id = i;
+									info.max_min = STR_SENSOR_ID_MAXS;
+									info.over_low = STR_SENSOR_ID_OVER;
+									info.para = 2;
+									info.wanning_type = ALARM_TYPE_SENSOR;
+									sensor_wanning_operation(&info,ssHandle.all.data[i].info.name);
 								}
 								}else
 								{
@@ -422,23 +458,12 @@ int sensor_query(void)
 									ssHandle.all.data[i].val[1].s_alarm.min_down = 1;
 									if(back_waning_down != ssHandle.all.data[i].val[1].s_alarm.min_down)
 									{
-										memset(&info.waning_context,0,sizeof(64));
-										time_t t=time(NULL);
-										struct tm *tm=localtime(&t);
-										sprintf(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(info.waning_context,"%s value 2 over min threshold!!",ssHandle.all.data[i].info.name);
-										wanning_insert(info);
-
-										if(paras_get()->snmp.trapmode == 1)
-										{
-													//AlarmTrapinfo t_info={0};
-												data.ID = i;
-												data.Alarmid = ALARM_TYPE_SENSOR;
-												memcpy(data.AlarmDate,info.date,32);
-												memcpy(data.AlarmContext,info.waning_context,64);
-												snmp_sensor_alarm_trap(&data);
-										}
-										beep_set(1);
+										info.id = i;
+										info.max_min = STR_SENSOR_ID_MIN;
+										info.over_low = STR_SENSOR_ID_LOW;
+										info.para = 2;
+										info.wanning_type = ALARM_TYPE_SENSOR;
+										sensor_wanning_operation(&info,ssHandle.all.data[i].info.name);
 									}
 								}else
 								{

f427/applications/snmp.c

@@ -14,6 +14,7 @@
 #include "paras.h"
 #include "pthread.h"
 #include "rtthread.h"
+#include "wanning.h"
 
 
 
@@ -645,46 +646,52 @@ static s16_t alarm_get_value(struct snmp_node_instance *instance, void *value)
 {
     u32_t row = instance->reference.u32;
     u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
+		waning_info_t *info = {0};
+		info = waning_get_info(row-1);
+		
 		char buff[50]= {0};
 		switch (col)
 		{
 			case COLUMN_PDUALARMID:
 			{
-				*(s32_t *)value	= p_a_data[row-1].id;
+				*(s32_t *)value	= row-1;
 				return 4;
 			}
 			break;
 			case COLUMN_PDUALARMTYPE:
 			{
-				*(s32_t *)value	= p_a_data[row-1].type;
+				*(s32_t *)value	= info->type;
 				return 4;				
 			}
 			break;
 			case COLUMN_PDUALARMCONTEXT:
 			{
-				sprintf(buff,"%s",p_a_data[row-1].alarm_info);
+				sprintf(buff,"%s",info->waning_context);
 			}
 			break;
 			case COLUMN_PDUALARMACTION:
 			{
-				*(s32_t *)value	= p_a_data[row-1].alarm_action;
+				*(s32_t *)value	= 0;
 				return 4;				
 			}
 			break;
 			case COLUMN_PDUALARMACTIONPARA:
 			{
-				*(s32_t *)value	= p_a_data[row-1].alarm_action_para;
-				return 4;					
+				*(s32_t *)value	= 0;
+				return 4;
 			}
 			break;
 			case COLUMN_PDUALARMDATE:
 			{
-				sprintf(buff,"%s",p_a_data[row-1].date);
+				snprintf(buff,10,"%s",info->date);
+				//sprintf(buff,"%s",p_a_data[row-1].date);
 			}
 			break;
 			case COLUMN_PDUALARMTIME:
 			{
-				sprintf(buff,"%s",p_a_data[row-1].time);
+				char * _info = &(info->date[11]);
+				snprintf(buff,8,"%s",_info);
+			//	sprintf(buff,"%s",p_a_data[row-1].time);
 			}
 			break;
 			default:
@@ -750,13 +757,14 @@ static snmp_err_t get_sensor_next_instance(const u32_t *column, struct snmp_obj_
     return SNMP_ERR_NOSUCHINSTANCE;		
 }
 
-
+static  uint8_t ph_cont = 0;
 
 static snmp_err_t power_get_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance)
 {
     u8_t i = 0;
     struct snmp_next_oid_state state;
     u32_t next_oid = 0;
+		
 
     snmp_next_oid_init(&state, row_oid->id, row_oid->len, &next_oid, 1);
 		
@@ -770,24 +778,51 @@ static snmp_err_t power_get_next_instance(const u32_t *column, struct snmp_obj_i
 
     if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS)
     {
+#if 0
+			if(all->ttl.type == PDU_AC_I3O3)
+			{
+				if(ph_cont==3)
+				{
+					snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
+					cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
+					cell_instance->reference.u32++;	
+					ph_cont=0;					
+				}
+			}else if(all->ttl.type == PDU_AC_I3O2)
+			{
+				if(ph_cont == 2)
+				{
+					snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
+					cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
+					cell_instance->reference.u32++;			
+					ph_cont=0;					
+				}
+			}else
+#endif
+			{
         snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
         cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
 				cell_instance->reference.u32++;
-        return SNMP_ERR_NOERROR;
+			}
+      return SNMP_ERR_NOERROR;
     }
 
     return SNMP_ERR_NOSUCHINSTANCE;
 }
+
+
+
+
 static snmp_err_t get_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance)
 {
     u8_t i = 0;
     struct snmp_next_oid_state state;
     u32_t next_oid = 0;
-
+		wanning_get_count();
     snmp_next_oid_init(&state, row_oid->id, row_oid->len, &next_oid, 1);
-		power_all_t *all = power_get_all();
+		//power_all_t *all = power_get_all();
     //power_data_get(&snmp_smart.all);
-    for (i = 0; i < POWER_VALUE; i++)
+    for (i = 0; i < wanning_get_count(); i++)
     {
         u32_t test_oid = i + 1;
         snmp_next_oid_check(&state, &test_oid, 1, NULL);
@@ -917,12 +952,12 @@ static s16_t power_get_value(struct snmp_node_instance *instance, void *value)
 				break;
 			case COLUMN_PDUCHANNELVOLTAGE:
 			{
-				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].voltage)/10.0);
+				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].voltage)/100.0);
 			}
 				break;
 			case COLUMN_PDUCHANNELCURRENT:
 			{
-				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].current)/10.0);
+				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].current)/100.0);
 			}
 				break;
 			case COLUMN_PDUCHANNELFREQUENCY:
@@ -932,7 +967,7 @@ static s16_t power_get_value(struct snmp_node_instance *instance, void *value)
 				break;
 			case COLUMN_PDUCHANNELCONSUMPTION:
 			{
-				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].consump)/1000.0);
+				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].consump)/100.0);
 			}
 				break;
 			case COLUMN_PDUCHANNELPOWERFACTOR:
@@ -942,17 +977,25 @@ static s16_t power_get_value(struct snmp_node_instance *instance, void *value)
 				break;
 			case COLUMN_PDUCHANNELPACTIVEPOWER:
 			{
-				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].power)/1000.0);
+				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].power)/100.0);
 			}
 				break;
 			case COLUMN_PDUCHANNELREACTIVEPOWER:
 			{
-				sprintf(buff,"%.2f",p_data[row-1].r_p);
+				float reactive = 0.0;
+				if(all->pch[row-1].power[0].power > 0)
+				{
+					reactive =  (float)(all->pch[row-1].power[0].power) / all->pch[row-1].power[0].factor - ((float)all->pch[row-1].power[0].power/100.0);
+				}
+				sprintf(buff,"%.2f",reactive);
 			}
 				break;
 			case COLUMN_PDUCHANNELAPPARENTPOWER:
 			{
-				sprintf(buff,"%.2f",p_data[row-1].a_p);
+				float app_power = 0.0;
+				if(all->pch[row-1].power[0].power > 0)
+					app_power = (float)(all->pch[row-1].power[0].power) / all->pch[row-1].power[0].factor;
+				sprintf(buff,"%.2f",app_power);
 			}
 				break;
 			default:
@@ -997,7 +1040,7 @@ static snmp_err_t thr_set_value(struct snmp_node_instance *instance,u16_t len, v
 		{
 			case COLUMN_PDUCHANNELCURRENTLIMITUP:
 			{
-				all->pch[row].thr.c_upper = (float)atof((char *)value) * 10;
+				all->pch[row].thr.c_upper = (float)atof((char *)value) * 100;
 				//p_t_data[row-1].i_max = (float)atof((char *)value);
 				//all->pch[row-1]
 				power_set_threshold(&all->pch[row]);
@@ -1006,13 +1049,13 @@ static snmp_err_t thr_set_value(struct snmp_node_instance *instance,u16_t len, v
 			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
 			{
 				//p_t_data[row-1].v_max = (float)atof((char *)value);
-				all->pch[row].thr.v_upper = (float)atof((char *)value) * 10;
+				all->pch[row].thr.v_upper = (float)atof((char *)value) * 100;
 				power_set_threshold(&all->pch[row]);
 			}
 			break;
 			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
 			{
-				all->pch[row].thr.v_lower = (float)atof((char *)value) * 10;
+				all->pch[row].thr.v_lower = (float)atof((char *)value) * 100;
 				power_set_threshold(&all->pch[row]);
 				//p_t_data[row-1].v_min = (float)atof((char *)value);
 				//all->pch[row-1].thr.v_upper = (float)atof((char *)value) * 10;
@@ -1021,14 +1064,14 @@ static snmp_err_t thr_set_value(struct snmp_node_instance *instance,u16_t len, v
 			case COLUMN_PDUCHANNELPOWERLIMITUP:
 			{
 				//p_t_data[row-1].p_max = (float)atof((char *)value);
-				all->pch[row].thr.p_upper = (float)atof((char *)value) * 1000;
+				all->pch[row].thr.p_upper = (float)atof((char *)value) * 100;
 				power_set_threshold(&all->pch[row]);
 			}
 			break;
 			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
 			{
 				//p_t_data[row-1].c_max = (float)atof((char *)value);
-				all->pch[row].thr.w_upper = (float)atof((char *)value) * 1000;
+				all->pch[row].thr.w_upper = (float)atof((char *)value) * 100;
 				power_set_threshold(&all->pch[row]);
 			}
 			break;
@@ -1249,8 +1292,6 @@ const struct snmp_tree_node thr_s_treenode 	= SNMP_CREATE_TREE_NODE(3, thr_s_sub
 const struct snmp_tree_node sensor_treenode = SNMP_CREATE_TREE_NODE(4, sensor_subnodes);
 
 
-
-
 static const struct snmp_node *const mib2_nodes_dev[] =
 {
     &sysinfo_scalars.node.node,
@@ -1307,12 +1348,12 @@ void snmp_power_alarm_trap(AlarmTrapinfo *data)
     vb1.value_len = 4;	
 		
 	  vb2.type = SNMP_ASN1_TYPE_OCTET_STRING;
-    vb2.value = (void*)(&data->AlarmDate);
-    vb2.value_len = strlen(data->AlarmDate);	
+    vb2.value = (void*)(&data->AlarmContext);
+    vb2.value_len = strlen(data->AlarmContext);	
 		
 	  vb3.type = SNMP_ASN1_TYPE_OCTET_STRING;
-    vb3.value = (void*)(&data->AlarmContext);
-    vb3.value_len = strlen(data->AlarmContext);	
+    vb3.value = (void*)(&data->AlarmDate);
+    vb3.value_len = strlen(data->AlarmDate);	
 		
 		vb.next = &vb1;
 		vb1.next = &vb2;

f427/applications/wanning.c

@@ -12,7 +12,7 @@ typedef struct {
 
 static wanning_cache_t wan;
 
-
+waning_info_t  *next = NULL; 
 void wanning_init()
 {
 		wan.list = generic_list_create(MAX_WANIING_LENTH);
@@ -47,6 +47,16 @@ int wanning_get(waning_info_t *waning,uint8_t lenth)
 	return 0;
 }
 
+waning_info_t * waning_get_info(uint8_t index)
+{
+	waning_info_t *info = NULL;
+	pthread_mutex_lock(&wan.mutex);
+	info = (waning_info_t *)generic_list_get_index(wan.list,index);
+	pthread_mutex_unlock(&wan.mutex);
+	return info;
+}
+
+
 
 void wanning_deinit()
 {

f427/applications/wanning.h

@@ -26,6 +26,8 @@ int wanning_get_count();
 
 void wanning_deinit();
 
+waning_info_t * waning_get_info(uint8_t index);
+
 
 #endif
 

f427/applications/web.c

@@ -745,6 +745,17 @@ static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
                             
                         }											
 										}
+										break;
+										case SUB_TYPE_POWER_PH_CFG:
+										{
+											if(hdr->addr==0) {
+													power_set_ph_cfg(pch);
+											}else
+											{
+												
+											}
+										}
+										break;
                 }
             }
             else {