Revert "modbus读取温度湿度bug"

This reverts commit e83d2ee5a082cde375e68138255d0b9c265db9e9.

pro/src/cascade_slave.c

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 #include "modbus.h"
 #include "common.h"
 #include "list.h"
@@ -137,8 +138,8 @@ int cascade_slave_init(void)
     slave_handle_t *sh=&slHandle;
     GlobalDeviceManager* mgr=get_dm();
 
-    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC ||
-        mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)       // single AC
+    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC ||
+        mgr->_global_device_info->product_pwr_type == SmartPDU_DC)       // single AC
     {
         if(sh->map)
         {
@@ -191,9 +192,9 @@ int cascade_slave_init(void)
 static void slave_read(slave_handle_t *sh, uint32_t addr,int num,uint32_t reg_type,uint32_t type)
 {
     GlobalDeviceManager* mgr=get_dm();
-  
-    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC || 
-            mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC){    
+
+    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC || 
+            mgr->_global_device_info->product_pwr_type == SmartPDU_DC){    
         if(addr >= DEV_CHN_REG && addr <= ALL_SET_SWITCH_REG)
         {
             if(type == TYPE_U16)
@@ -331,9 +332,9 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
     slave_handle_t *sh=&slHandle;
     GlobalDeviceManager* mgr=get_dm();
     uint16_t buff[128] = {0};
- 
-    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC 
-            || mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)   
+
+    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC 
+            || mgr->_global_device_info->product_pwr_type == SmartPDU_DC)   
     {
         switch(addr)
         {
@@ -347,7 +348,7 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                             break;
                         if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                         {
-                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
+                            if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC){
                                 _globalPowerMangerTemp->product_ch_start_delay=val;
                                 g_switch_set_ac_single_s_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                                 _globalPowerMangerTemp->product_ch_addr,val);
@@ -378,7 +379,7 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                             break;
                         if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                         {
-                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
+                            if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC){
                                   _globalPowerMangerTemp->product_ch_stop_delay=val;
                                 g_switch_set_ac_single_s_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                                 _globalPowerMangerTemp->product_ch_addr,val);
@@ -459,9 +460,9 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                         int ret = 0;
 
                         _globalPowerMangerTemp->product_ch_start_delay = val;
-                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B
+                        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One_B
                         )
                         {
                             printf("hwllo every one stop time !!!!\n");
@@ -499,9 +500,9 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                         int ret = 0;
 
                         _globalPowerMangerTemp->product_ch_stop_delay = val;
-                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B)
+                        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One_B)
                         {
                             ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                         _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
@@ -543,9 +544,9 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                         {
                             t_ac_CtrlType=_globalTACManager->product_ph_outputType;
                         }
-                        if (t_ac_CtrlType == 2&&(__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
-                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B))
+                        if (t_ac_CtrlType == 2&&(__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One_B))
                         {
                             if(_globalPowerMangerTemp->product_ch_type == AC_SINGLE_S_TYPE || _globalPowerMangerTemp->product_ch_type == AC_SINGLE_B_TYPE)
                             {
@@ -612,7 +613,7 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
                                 sts |= ENABLE_TAC_STIME;
                                 sts |= ENABLE_TAC_ETIME;
                             }*/
-                            if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One)
+                            if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
                             {
                                 g_switch_set_t_ac_phchn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                 _globalPowerMangerTemp->product_saddr,
@@ -651,3 +652,652 @@ void cascade_slave_write(uint32_t addr, uint16_t val)
         }
     }
 }
+=======
+#include "modbus.h"
+#include "common.h"
+#include "list.h"
+#include "switch_ctrl.h"
+#include "cascade.h"
+#include "sqlite_handle.h"
+
+
+
+#define DEV_CHN_REG                 (4000)  
+#define OUT_INFO_REG                (4001)     
+#define IN_TOTAL_REG                (4385)  
+#define TEM_HUMAN_REG               (4389)       
+#define CHN_SWITCH_REG              (4390)
+#define CHN_OPEN_DLA_REG            (4454)
+#define CHN_CLOSE_DLA_REG           (4518)
+#define CHN_SET_OPEN_DLA_REG        (5000)
+#define CHN_SET_CLOSE_DLA_REG       (5064)
+#define CHN_SET_SWITCH_STA_REG      (5128)
+#define ALL_SET_SWITCH_REG          (5192)
+
+
+
+enum{
+    TYPE_U16,
+    TYPE_U32
+};
+
+
+enum {
+    DS_R_DEV_CHN = 0,
+    DS_R_OUT_INFO,
+    DS_R_IN_TOTAL,
+    DS_R_TEMP_HUM,
+    DS_R_SWITCH_STA,
+    DS_R_OPEN_DELAY,
+    DS_R_CLOSE_DELAY,
+    DS_W_OPEN_DELAY,
+    DS_W_CLOSE_DELAY,
+    DS_W_CHN_SWITCH_STA,
+    DS_W_ALL_CHN_STA
+};
+
+
+#define TREE_DEV_CHN_REG                (6000)  
+#define TREE_INPUT_A_REG                (6001)     
+#define TREE_INPUT_B_REG                (6009)  
+#define TREE_INPUT_C_REG                (6017)       
+#define TREE_CHN_TOTAL_REG              (6025)
+#define TREE_CHN_PH_REG                 (6665)
+#define TREE_TEMP_HUM_REG               (8585)
+#define TREE_CHN_SWITCH_STA_REG         (8587)
+#define TREE_CHN_OPEN_DLA_REG           (8651)
+#define TREE_CHN_CLOSE_DLA_REG          (8715)
+#define TREE_CHN_SET_OPEN_DLA_REG       (9000)
+#define TREE_CHN_SET_CLOSE_DLA_REG      (9064)
+#define TREE_CHN_SET_SWITCH_STA_REG     (9128)
+#define TREE_ALL_SET_SWITCH_REG         (9192)
+
+enum {
+    TREE_R_DEV_CHN,
+    TREE_R_INPUT_ALL_A,
+    TREE_R_INPUT_ALL_B,
+    TREE_R_INPUT_ALL_C,
+    TREE_R_CHN_TOTAL,
+    TREE_R_CHN_PH_INFO,
+    TREE_R_TEMP_HUM,
+    TREE_R_SWITCH_STA,
+    TREE_R_OPEN_DELAY,
+    TREE_R_CLOSE_DELAY,
+    TREE_W_OPEN_DELAY,
+    TREE_W_CLOSE_DELAY,
+    TREE_W_CHN_SWITCH_STA,
+    TREE_W_ALL_CHN_STA
+};
+
+
+
+
+static inline GlobalDeviceManager* get_dm(void)
+{
+    return &__globalDeviceManage;
+}
+static inline GlobalDeviceManager* get_dm2(void)
+{
+    return &__globalDeviceManage2;
+}
+
+static mmap_modbus_t modbus_single[] = {
+    [DS_R_DEV_CHN       ]{.offset = DEV_CHN_REG             },
+    [DS_R_OUT_INFO      ]{.offset = OUT_INFO_REG            },
+    [DS_R_IN_TOTAL      ]{.offset = IN_TOTAL_REG            },
+    [DS_R_TEMP_HUM      ]{.offset = TEM_HUMAN_REG           },
+    [DS_R_SWITCH_STA    ]{.offset = CHN_SWITCH_REG          },
+    [DS_R_OPEN_DELAY    ]{.offset = CHN_OPEN_DLA_REG        },
+    [DS_R_CLOSE_DELAY   ]{.offset = CHN_CLOSE_DLA_REG       },
+    [DS_W_OPEN_DELAY    ]{.offset = CHN_SET_OPEN_DLA_REG    },
+    [DS_W_CLOSE_DELAY   ]{.offset = CHN_SET_CLOSE_DLA_REG   },
+    [DS_W_CHN_SWITCH_STA]{.offset = CHN_SET_SWITCH_STA_REG  },
+    [DS_W_ALL_CHN_STA   ]{.offset = ALL_SET_SWITCH_REG      },
+};
+
+static mmap_modbus_t modbus_three[] = {
+    [TREE_R_DEV_CHN         ]{.offset = TREE_DEV_CHN_REG},
+    [TREE_R_INPUT_ALL_A     ]{.offset = TREE_INPUT_A_REG       },
+    [TREE_R_INPUT_ALL_B     ]{.offset = TREE_INPUT_B_REG       },
+    [TREE_R_INPUT_ALL_C     ]{.offset = TREE_INPUT_C_REG       },
+    [TREE_R_CHN_TOTAL       ]{.offset = TREE_CHN_TOTAL_REG     },
+    [TREE_R_CHN_PH_INFO     ]{.offset = TREE_CHN_PH_REG        },
+    [TREE_R_TEMP_HUM        ]{.offset = TREE_TEMP_HUM_REG      },
+    [TREE_R_SWITCH_STA      ]{.offset = TREE_CHN_SWITCH_STA_REG},
+    [TREE_R_OPEN_DELAY      ]{.offset = TREE_CHN_OPEN_DLA_REG  },
+    [TREE_R_CLOSE_DELAY     ]{.offset = TREE_CHN_CLOSE_DLA_REG },
+    [TREE_W_OPEN_DELAY      ]{.offset = TREE_CHN_SET_OPEN_DLA_REG},
+    [TREE_W_CLOSE_DELAY     ]{.offset = TREE_CHN_SET_CLOSE_DLA_REG},
+    [TREE_W_CHN_SWITCH_STA  ]{.offset = TREE_CHN_SET_SWITCH_STA_REG},
+    [TREE_W_ALL_CHN_STA     ]{.offset = TREE_ALL_SET_SWITCH_REG }
+};
+
+typedef struct { 
+    modbus_mapping_t    *map;
+}slave_handle_t;
+
+static slave_handle_t slHandle;
+
+
+modbus_mapping_t    *cascade_slave_map()
+{
+    return slHandle.map;
+}
+
+int cascade_slave_init(void)
+{
+    slave_handle_t *sh=&slHandle;
+    GlobalDeviceManager* mgr=get_dm();
+
+    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC ||
+        mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)       // single AC
+    {
+        if(sh->map)
+        {
+            free(sh->map);
+            sh->map = NULL;
+        }
+        sh->map = modbus_mapping_new_start_address(0,0,0,0,DEV_CHN_REG,5000,0,0);     //3000 ge
+        modbus_single[DS_R_DEV_CHN          ].addr = &mgr->single_mmap->dev_chn;
+        modbus_single[DS_R_OUT_INFO         ].addr = &mgr->single_mmap->all_ch;
+        modbus_single[DS_R_IN_TOTAL         ].addr = &mgr->single_mmap->total_valtage;
+        modbus_single[DS_R_TEMP_HUM         ].addr = &mgr->single_mmap->total_temp;
+        modbus_single[DS_R_SWITCH_STA       ].addr = &mgr->single_mmap->chn_status; 
+        modbus_single[DS_R_OPEN_DELAY       ].addr = &mgr->single_mmap->open_delay;
+        modbus_single[DS_R_CLOSE_DELAY      ].addr = &mgr->single_mmap->close_delay;
+        modbus_single[DS_W_OPEN_DELAY       ].addr = &mgr->single_mmap->set_chn_open_delay;
+        modbus_single[DS_W_CLOSE_DELAY      ].addr = &mgr->single_mmap->set_chn_close_delay;
+        modbus_single[DS_W_CHN_SWITCH_STA   ].addr = &mgr->single_mmap->set_chn_switch_status;
+        modbus_single[DS_W_ALL_CHN_STA      ].addr = &mgr->single_mmap->set_chn_all_switch_status;
+        printf("single dc address init 4000\n");
+    }else
+    {
+        if(sh->map)
+        {
+            free(sh->map);
+            sh->map = NULL;
+        }
+        sh->map =  modbus_mapping_new_start_address(0,0,0,0,TREE_DEV_CHN_REG,7000,0,0);
+        modbus_three[TREE_R_DEV_CHN         ].addr = &mgr->triphasic_mmap->dev_chn;
+        modbus_three[TREE_R_INPUT_ALL_A     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[0];
+        modbus_three[TREE_R_INPUT_ALL_B     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[1];
+        modbus_three[TREE_R_INPUT_ALL_C     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[2];
+        modbus_three[TREE_R_CHN_TOTAL       ].addr = &mgr->triphasic_mmap->chn_info;
+        modbus_three[TREE_R_CHN_PH_INFO     ].addr = &mgr->triphasic_mmap->pw_o_chn;
+        modbus_three[TREE_R_TEMP_HUM        ].addr = &mgr->triphasic_mmap->temperature;
+        modbus_three[TREE_R_SWITCH_STA      ].addr = &mgr->triphasic_mmap->chn_status;
+        modbus_three[TREE_R_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->open_delay;
+        modbus_three[TREE_R_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->close_delay;
+        modbus_three[TREE_W_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->set_chn_open_delay;
+        modbus_three[TREE_W_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->set_chn_close_delay;
+        modbus_three[TREE_W_CHN_SWITCH_STA  ].addr = &mgr->triphasic_mmap->set_chn_switch_status;
+        modbus_three[TREE_W_ALL_CHN_STA     ].addr = &mgr->triphasic_mmap->set_chn_all_switch_status;
+        printf("triphasic address init 6000\n");
+        //return -1;
+    }
+    return 0;
+}
+
+
+static void slave_read(slave_handle_t *sh, uint32_t addr,int num,uint32_t reg_type,uint32_t type)
+{
+    GlobalDeviceManager* mgr=get_dm();
+  
+    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC || 
+            mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC){    
+        if(addr >= DEV_CHN_REG && addr <= ALL_SET_SWITCH_REG)
+        {
+            if(type == TYPE_U16)
+            {
+                uint16_t *base_addr = (uint16_t *)modbus_single[reg_type].addr;
+                uint32_t step = addr - sh->map->start_registers;
+                base_addr = base_addr + (addr - modbus_single[reg_type].offset);
+                uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
+                if(num < 126)
+                {
+                    memcpy(map_addr, base_addr,2*num);
+                }
+            }else
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_single[reg_type].addr;
+                uint32_t step = addr - sh->map->start_registers;
+                base_addr = base_addr + (addr - modbus_single[reg_type].offset);
+                uint32_t *map_addr = (uint32_t *)&(sh->map->tab_registers[step]);
+                if(num < 126)
+                {
+                    memcpy(map_addr, base_addr,2*num);
+                }
+            }
+        }
+    }else
+    {
+        if(addr >= TREE_DEV_CHN_REG && addr <= TREE_ALL_SET_SWITCH_REG) {
+            if(type == TYPE_U16)
+            {
+                uint16_t *base_addr = (uint16_t *)modbus_three[reg_type].addr;
+                uint32_t step = addr - sh->map->start_registers;
+                base_addr = base_addr + (addr - modbus_three[reg_type].offset);
+                uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
+                if(num < 126)
+                {
+                    memcpy(map_addr, base_addr,2*num);
+                }
+            }else
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_three[reg_type].addr;
+                uint32_t step = addr - sh->map->start_registers;
+                base_addr = base_addr + (addr - modbus_three[reg_type].offset) / 2;
+                uint32_t *map_addr = (uint32_t *)&(sh->map->tab_registers[step]);
+                if(num < 126)
+                {
+                    memcpy(map_addr, base_addr,2*num);
+                }
+            }
+        }
+    }
+}
+
+
+void cascade_slave_read(uint32_t addr,uint32_t lenth)
+{
+    slave_handle_t *sh=&slHandle;
+
+    switch (addr)
+    {
+        case 4000:
+            slave_read(sh,addr,lenth,DS_R_DEV_CHN,TYPE_U16);
+        break;
+        case 4001 ... 4384:
+            slave_read(sh,addr,lenth,DS_R_OUT_INFO,TYPE_U32);
+        break;
+        case 4385 ... 4388:
+            slave_read(sh,addr,lenth,DS_R_IN_TOTAL,TYPE_U32);
+        break;
+        case 4389:
+            slave_read(sh,addr,lenth,DS_R_TEMP_HUM,TYPE_U16);
+        case 4390 ... 4453:
+            slave_read(sh,addr,lenth,DS_R_SWITCH_STA,TYPE_U16);
+        break;
+        case 4454 ... 4517:
+            slave_read(sh,addr,lenth,DS_R_OPEN_DELAY,TYPE_U16);
+        break;
+        case 4518 ... 4581:
+            slave_read(sh,addr,lenth,DS_R_CLOSE_DELAY,TYPE_U16);
+        break;
+        case 5000 ... 5063:
+            slave_read(sh,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
+        break;
+        case 5064 ... 5127:
+            slave_read(sh,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
+        break;
+        case 5128 ... 5191:
+            slave_read(sh,addr,lenth,DS_W_CHN_SWITCH_STA,TYPE_U16);
+        break;
+        case 5192 :
+            slave_read(sh,addr,lenth,DS_W_ALL_CHN_STA,TYPE_U16);
+        break;
+
+        // triple
+        case 6000:
+            slave_read(sh,addr,lenth,TREE_R_DEV_CHN,TYPE_U16);
+        break;
+        case 6001 ... 6008:
+            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_A,TYPE_U32);
+        break;
+        case 6009 ... 6016:
+            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_B,TYPE_U32);
+        break;
+        case 6017 ... 6024:
+            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_C,TYPE_U32);
+        break;
+        case 6025 ... 6664:
+            slave_read(sh,addr,lenth,TREE_R_CHN_TOTAL,TYPE_U32);
+        break;
+        case 6665 ... 8584:
+            slave_read(sh,addr,lenth,TREE_R_CHN_PH_INFO,TYPE_U32);
+        break;
+        case 8585 ... 8586:
+            slave_read(sh,addr,lenth,TREE_R_TEMP_HUM,TYPE_U16);
+        break;
+        case 8587 ... 8650:
+            slave_read(sh,addr,lenth,TREE_R_SWITCH_STA,TYPE_U16);
+        break;
+        case 8651 ... 8714:
+            slave_read(sh,addr,lenth,TREE_R_OPEN_DELAY,TYPE_U16);
+        break;
+        case 8715 ... 8778:
+            slave_read(sh,addr,lenth,TREE_R_CLOSE_DELAY,TYPE_U16);
+        break;
+
+        default:
+        break;
+    }
+}
+
+
+void cascade_slave_write(uint32_t addr, uint16_t val)
+{
+    slave_handle_t *sh=&slHandle;
+    GlobalDeviceManager* mgr=get_dm();
+    uint16_t buff[128] = {0};
+ 
+    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC 
+            || mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)   
+    {
+        switch(addr)
+        {
+            case 5000 ... 5063:
+            {
+                int start_chn = addr - modbus_single[DS_W_OPEN_DELAY].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                {
+                    if(_globalPowerMangerTemp==NULL)
+                            break;
+                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
+                        {
+                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
+                                _globalPowerMangerTemp->product_ch_start_delay=val;
+                                g_switch_set_ac_single_s_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
+                                                _globalPowerMangerTemp->product_ch_addr,val);
+                            }else
+                            {
+                                _globalPowerMangerTemp->product_ch_start_delay=val;
+                                g_switch_set_dcpdu_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
+                                        _globalPowerMangerTemp->product_ch_addr,val/1000);
+                            }
+                            if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
+                            {
+                                log_e("update pwr general data err.");
+                            }
+                            printf("val = %d start_chn = %d\n",val,start_chn);
+                          //  *(uint16_t *)((uint16_t*)(modbus_single[6].addr) + start_chn) = val;
+                            break;
+                        }                    
+                }
+            }
+            break;
+            case 5064 ... 5127:
+            {
+                 int start_chn = addr - modbus_single[DS_W_CLOSE_DELAY].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                {
+                    if(_globalPowerMangerTemp==NULL)
+                            break;
+                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
+                        {
+                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
+                                  _globalPowerMangerTemp->product_ch_stop_delay=val;
+                                g_switch_set_ac_single_s_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
+                                                _globalPowerMangerTemp->product_ch_addr,val);
+                            }else
+                            {
+                                  _globalPowerMangerTemp->product_ch_stop_delay=val;
+                                g_switch_set_dcpdu_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
+                                        _globalPowerMangerTemp->product_ch_addr,val/1000);
+                            }
+                            if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
+                            {
+                                log_e("update pwr general data err.");
+                            }
+                            printf("val = %d",val);
+                            //*(uint16_t *)((uint16_t*)(modbus_single[7].addr) + start_chn) = val;
+                            //printf("modbus_single[7].addr = %d ",modbus_single[7].addr);
+                            break;
+                        }                    
+                }
+            }
+            break;
+            case 5128 ... 5191:
+            {
+                int start_chn = addr - modbus_single[DS_W_CHN_SWITCH_STA].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                if (val == 0 || val == 1)
+                {
+                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                    {
+                        if (_globalPowerMangerTemp == NULL)
+                            break;
+                        if ((start_chn + 1) == _globalPowerMangerTemp->product_ch_id)
+                        {
+                            int ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
+                                                                _globalPowerMangerTemp->product_saddr,
+                                                                _globalPowerMangerTemp->product_ch_addr,
+                                                                val, false);
+                            //  printf("ret = %d 0x%x\n",ret,val);
+                            *(uint16_t *)((uint16_t *)(modbus_single[DS_W_CHN_SWITCH_STA].addr) + start_chn) = val;
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+            case 5192:
+            {
+                if (val == 0 || val == 1)
+                {
+                    GlobalPowerManger *_globalPowerMangerTemp = NULL;
+                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                    {
+                        if (_globalPowerMangerTemp == NULL)
+                            break;
+                        int rec = g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_ch_type, _globalPowerMangerTemp->product_saddr, val);
+                        // printf("rec = %d 0x%x\n",rec,val);
+                    }
+                    *(uint16_t *)(modbus_single[DS_W_ALL_CHN_STA].addr) = val;
+                }
+            }
+            break;
+            
+            default:
+            break;
+        }
+    }else{
+        switch(addr)
+        {
+            case 9000 ... 9063:
+            {
+                int start_chn = addr - modbus_three[TREE_W_OPEN_DELAY].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list){
+                    if(_globalPowerMangerTemp==NULL)
+                            break;
+                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
+                    {
+                        int ret = 0;
+
+                        _globalPowerMangerTemp->product_ch_start_delay = val;
+                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B
+                        )
+                        {
+                            printf("hwllo every one stop time !!!!\n");
+                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
+                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 1, val / 1000);
+                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 2, val / 1000);
+                        }
+                        else
+                        {
+                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
+                        }
+                        if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
+                        {
+                            log_e("update pwr general data err.");
+                        }
+                        break;
+                    }
+                }
+            }
+            break;
+            case 9064 ... 9127:
+            {
+                int start_chn = addr - modbus_three[TREE_W_CLOSE_DELAY].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                {
+                    if(_globalPowerMangerTemp==NULL)
+                            break;
+                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
+                    {
+                        int ret = 0;
+
+                        _globalPowerMangerTemp->product_ch_stop_delay = val;
+                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B)
+                        {
+                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
+                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 1, val / 1000);
+                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 2, val / 1000);
+                        }
+                        else
+                        {
+                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
+                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
+                        }
+                        if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
+                        {
+                            log_e("update pwr general data err.");
+                        }
+                        break;
+                    }
+                }
+            }
+            break;
+            case 9128 ... 9191:
+            {
+                int start_chn = addr - modbus_three[TREE_W_CHN_SWITCH_STA].offset;
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list){
+                    if(_globalPowerMangerTemp==NULL)
+                            break;
+                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
+                    {
+                        int t_ac_CtrlType=0;
+                        int nRet = 0;
+                        
+                        _globalPowerMangerTemp->product_ch_status = val;
+
+                        GlobalTreeACManager *_globalTACManager = NULL;
+                        list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
+                        {
+                            t_ac_CtrlType=_globalTACManager->product_ph_outputType;
+                        }
+                        if (t_ac_CtrlType == 2&&(__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
+                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B))
+                        {
+                            if(_globalPowerMangerTemp->product_ch_type == AC_SINGLE_S_TYPE || _globalPowerMangerTemp->product_ch_type == AC_SINGLE_B_TYPE)
+                            {
+                                if (val == 1)
+                                {
+                                    if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
+                                        val |= ENABLE_TAC_V_UP;
+                                    if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
+                                        val |= ENABLE_TAC_V_DOWN;
+                                    if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
+                                        val |= ENABLE_TAC_A_UP;
+                                    if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
+                                        val |= ENABLE_TAC_W_UP;
+                                    if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
+                                        val |= ENABLE_TAC_P_UP;
+                                }
+                                g_switch_set_ac_single_s_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,  _globalPowerMangerTemp->product_saddr, 
+                                                (_globalPowerMangerTemp->product_ch_addr- 1), val);
+                                break;
+                            }
+                            unsigned short phsts=0;
+                            list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
+                            {
+                                if (val == 1 && _globalTACManager->product_ph_outputStatus==1)
+                                {
+                                    phsts=1;
+                                    if (_globalTACManager->global_over_manager->product_vol_upper_enable == 1)
+                                        phsts |= ENABLE_TAC_V_UP;
+                                    if (_globalTACManager->global_over_manager->product_vol_lower_enable == 1)
+                                        phsts |= ENABLE_TAC_V_DOWN;
+                                    if (_globalTACManager->global_over_manager->product_cur_upper_enable == 1)
+                                        phsts |= ENABLE_TAC_A_UP;
+                                    if (_globalTACManager->global_over_manager->product_pwr_upper_enable == 1)
+                                        phsts |= ENABLE_TAC_W_UP;
+                                    if (_globalTACManager->global_over_manager->product_pwrcon_upper_enable == 1)
+                                        phsts |= ENABLE_TAC_P_UP;
+                                }else{
+                                    phsts=0;
+                                }
+                                nRet= g_switch_set_t_ac_phchn_ctrl(&__globalDeviceManage._globalRelaySampManger,
+                                                     _globalTACManager->product_saddr, 
+                                                     _globalTACManager->product_ch_addr - 1, 
+                                                     phsts);
+                            }
+                            break;
+                        }else
+                        {
+                            if (val == 1)
+                            {
+                                if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
+                                    val |= ENABLE_TAC_V_UP;
+                                if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
+                                    val |= ENABLE_TAC_V_DOWN;
+                                if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
+                                    val |= ENABLE_TAC_A_UP;
+                                if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
+                                    val |= ENABLE_TAC_W_UP;
+                                if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
+                                    val |= ENABLE_TAC_P_UP;
+                            }
+                            /*
+                            if (isgroup)
+                            {
+                                sts |= ENABLE_TAC_STIME;
+                                sts |= ENABLE_TAC_ETIME;
+                            }*/
+                            if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One)
+                            {
+                                g_switch_set_t_ac_phchn_ctrl(&__globalDeviceManage._globalRelaySampManger,
+                                                                _globalPowerMangerTemp->product_saddr,
+                                                                _globalPowerMangerTemp->product_ch_addr - 1,
+                                                                val);
+                            }else{
+                                g_switch_set_t_ac_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
+                                                                _globalPowerMangerTemp->product_saddr,
+                                                                _globalPowerMangerTemp->product_ch_addr - 1,
+                                                                val);
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+            case 9192:
+            {
+                if (val == 0 || val == 1)
+                {
+                    GlobalPowerManger *_globalPowerMangerTemp = NULL;
+                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                    {
+                        if (_globalPowerMangerTemp == NULL)
+                            break;
+
+                        _globalPowerMangerTemp->product_ch_status = val;
+                        int rec = g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_ch_type, _globalPowerMangerTemp->product_saddr, val);
+                        // printf("rec = %d 0x%x\n",rec,val);
+                    }
+                }
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}
+>>>>>>> 1a6c6a9ecc73b46498b40e3ded858f5abe7996e9

pro/src/common.h

@@ -1,3 +1,972 @@
+<<<<<<< HEAD
+#ifndef __COMMON_H_
+#define __COMMON_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include "sqlite3.h"
+#include "pthread.h"
+#include "list.h"
+#include "modbus_handle.h"
+#include "elog.h"
+#include "mongoose.h"
+#include "ntpclient.h"
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+#include "pduMIB_form.h"
+#include "pduMIB_scalar.h"
+#include "pduMIB_trap.h"
+#include "language_hashmap.h"
+#include "hlw8110_habdle.h"
+#include "language_common.h"
+#include <sys/shm.h>
+#include "cfg.h"
+
+
+#define MAX_RELAY_CHN       100
+
+//是否在OS环境下运行
+#define OS_HANDWARE 1
+
+#define WEB_ROOT            "../web"
+#define PARAS_FILE          "pduParas"
+
+#define DATABASE_NAME       "pdu_dat.db"
+#define DATABASE_BAK_NAME   "pdu_dat_bak.db"
+#define SNMP_MIB_NAME       "pduMIB"
+
+//高配表头串口定义-----------------------------------------------
+//控制板通信串口
+#define INTERL_MODBUS_PORT "/dev/ttyAS5"
+#define INTERL_MODBUS_BAUD 115200
+//表头级联通讯串口
+#define CASCADE_MODBUS_PORT     "/dev/ttyAS4"
+#define CASCADE_MODBUS_BAUD     115200
+//传感器通信串口
+#define INTERL_SENSOR_MODBUS_PORT "/dev/ttyAS2"
+#define INTERL_SENSOR_MODBUS_BAUD 9600
+
+
+
+#define IMAGE_PATH          "image"
+#define LOGO_FILE           "logo.png"
+#define QRCODE_FILE         "qrcode.png"
+
+
+#define AC_SINGLE_S_CUR_CHN_NUM 8
+#define AC_SINGLE_B_CUR_CHN_NUM 4
+
+#define AC_SINGLE_S_MAX_CHN_NUM 10  	//单个控制板最大数量
+#define AC_SINGLE_S_MAX_ADDRESS_NUM 16  //控制板最大数量
+
+#define AC_MAX_VOLTAGE_VAL 400
+#define AC_MAX_CURRENT_VAL 100
+#define AC_MAX_POWER_VAL 100
+
+enum
+{
+	TOTAL_VOLTAGE_TYPE 			= 0,//统计电压类型
+	TOTAL_CURRENT_TYPE 			= 1,//统计电流类型
+	TOTAL_POWER_TYPE 			= 2,//统计功率类型
+	TOTAL_POWER_CONS_TYPE 		= 3 //统计耗电量类型
+};
+
+enum
+{
+	POWER_MERITORIOUS_TYPE 			= 0,//有功功率类型
+	POWER_REACTIVE_TYPE 			= 1,//无功功率类型
+	POWER_APPARENT_TYPE 			= 2 //视在功率类型
+};
+
+enum
+{
+    SENSOR_TYPE_TEMPERATURE = 0 , //温度传感器
+    SENSOR_TYPE_SMOKE       = 1 , //烟雾传感器
+    SENSOR_TYPE_WATER       = 2 , //水浸传感器
+    SENSOR_TYPE_DOOR        = 3 , //门禁传感器
+    SENSOR_TYPE_GAS         = 4 , //气体传感器
+    SENSOR_TYPE_AIR_PRESS   = 5   //气体、气压传感器
+};
+enum
+{
+    SENSOR_VAL1_UPPER = 0,
+    SENSOR_VAL1_LOWER = 1,
+    SENSOR_VAL2_UPPER = 2,
+    SENSOR_VAL2_LOWER = 3,
+
+};
+
+enum
+{
+    SENSOR_TYPE_VALUE = 0 , //传感器类型0、4、5
+    SENSOR_TYPE_LIST =1     //传感器类型1、2、3
+};
+
+/// @brief 板子类型
+enum MODBUS_BOARD_TYPE
+{
+    AC_SINGLE_S_TYPE=1,
+    AC_SINGLE_B_TYPE,
+    AC_MULTI_S_TYPE,
+    AC_MULTI_B_TYPE,
+    DC_OUT_TYPE,
+    DC_IN_TYPE,
+    DCPDU_TYPE,
+    TREE_AC_TYPE,   //三相进三项出
+};
+
+enum AppProductType
+{
+    SmartPDU_AC=0,
+    SmartPDU_DC=1,
+    SmartPDU_Tree_AC_Tree=3,
+    SmartPDU_Tree_AC_One=4,
+    SmartPDU_Tree_AC_One_B=5,    
+};
+
+/// @brief 三相网页数据
+static char* g_product_t_ac_type_str[3] = {
+    "L1",
+    "L2",
+    "L3",
+};
+/// @brief 按位标记
+enum BIT_CTRL
+{
+    BIT_00 = 1 ,
+    BIT_01 = 2 ,
+    BIT_02 = 4 ,
+    BIT_03 = 8 ,
+    BIT_04 = 16,
+    BIT_05 = 32,
+    BIT_06 = 64,
+    BIT_07 = 128,
+    BIT_08 = 256,
+    BIT_09 = 512,
+    BIT_10 = 1024,
+    BIT_11 = 2048,
+    BIT_12 = 4096,
+    BIT_13 = 8192,
+    BIT_14 = 16384,
+    BIT_15 = 32768,
+};
+/// @brief 使能位
+enum ENABLE_BIT_CTRL
+{
+    ENABLE_V_UP     = 2 ,
+    ENABLE_V_DOWN   = 8 ,
+    ENABLE_A_UP     = 32,
+    ENABLE_W_UP     = 128,
+    ENABLE_P_UP     = 512,
+    ENABLE_ALL_UP   = BIT_11,
+    ENABLE_ALL_DOWN = BIT_12,
+};
+/// @brief 使能位三项
+enum ENABLE_TreeAC_CTRL
+{
+    ENABLE_TAC_V_UP     = 1,
+    ENABLE_TAC_V_DOWN   = 2,
+    ENABLE_TAC_A_UP     = 4,
+    ENABLE_TAC_W_UP     = 8,
+    ENABLE_TAC_P_UP     = 16,
+    ENABLE_TAC_STIME    = 32,
+    ENABLE_TAC_ETIME    = 64,
+};
+/// @brief 报警位
+enum WARNING_BIT_CTRL
+{
+    WARNING_V_UP     = 4 ,
+    WARNING_V_DOWN   = 16 ,
+    WARNING_A_UP     = 64, 
+    WARNING_W_UP     = 256,
+    WARNING_P_UP     = 1024,
+};
+
+/// @brief 报警动作
+enum ALARM_CTRL
+{
+    ALARM_CTRL_CLOSE_CH     = 1 ,
+    ALARM_CTRL_ALARM_ONLY     = 2 ,
+    ALARM_CTRL_CLOSE_ALLCH     = 3 ,
+};
+
+///////////////////////////////////////////////////////////////////////////////////
+typedef struct {
+    int             id;
+    int             up;
+    char            ip[48];
+    char            mac[24];
+    char            desc[128];
+}port_info_t;
+typedef struct {
+    #define SW_PORT_MAX         24      //28
+    #define SW_PORT_START       99329
+    port_info_t     port[SW_PORT_MAX];
+}netswitch_info_t;
+
+///////////////////////////////////////////////////////////////////////////////////
+//modbus信息管理
+typedef struct
+{
+    bool            product_modbus_type ;       //modbus模式
+    unsigned int    product_modbus_baud ;       //波特率
+    unsigned char   product_modbus_addr         ;//从Modbus地址信息
+    char            product_relay_ctrl_port[32] ;//继电器modbus控制端口
+}ModbusInfo_t;
+
+typedef struct
+{
+    int           mode;    						//1: static  0: dhcp
+    char          ip_address[64] ; 				//ip地址
+    char          mask[64]; 					//子网掩码
+    char          gateway[64]; 					//网关
+    char          dns1[64];    					//dns1
+    char          dns2[64];    					//dns2
+}NetworkInfo_t;
+
+
+/// @brief 用户登录
+typedef struct
+{
+    char user_name[64];
+    char user_password[64];
+    char user_uuid[64];
+    char user_token[64];
+    struct list_head list;
+}_User_Log;
+//设备总体管理表
+typedef struct
+{
+    int             product_id                  ;//产品ID 
+    char            product_number[16]          ;//产品编号    
+    char            product_name[32]            ;//产品名称
+    char            product_status[32]          ;//产品状态
+    unsigned char   product_type                ;//产品类型
+    unsigned char   product_pwr_type            ;//电源类型
+    char            product_version[8]          ;//软件版本
+    unsigned char   product_language            ;//多国语言
+    unsigned char   product_count               ;//级联设备数
+    unsigned short  product_samp_time           ;//采集周期 单位ms
+    unsigned short  product_save_time           ;//采集周期 单位ms
+    ModbusInfo_t    _modbus_info                ;//继电器控制端口
+    NetworkInfo_t   _network_info ;             ;//网络信息
+    ModbusInfo_t    _gmodbus_info               ;//级联端口      
+}GlobalDeviceInfo;
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+//自定义共享内存类
+typedef struct
+{
+    //电源数据
+    int bPDUSet;
+    int nSelectPowerCH;
+    int nMaxCh;
+    float fV;
+    float fA;
+    float fW;
+    float fF;
+    float fS;
+    int nStatus;
+    //传感器数据
+    int nSelectSensor;
+    float fT;//温度
+    float fH;//湿度
+} smartPDU_shm_data;
+
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+//超限管理表
+typedef struct
+{
+    char            product_vol_upper_enable                   ;//电压上限使能
+    float           product_vol_upper_threshold                ;//电压上限值
+    char            product_vol_over_upper_threshold_ctrl      ;//电压超限动作
+    char            product_vol_over_upper_threshold_ctrl_para ;//电压超限关联参数
+    char            product_vol_lower_enable                   ;//电压下限使能
+    float           product_vol_lower_threshold                ;//电压下限值
+    char            product_vol_over_lower_threshold_ctrl      ;//电压超限动作 
+    char            product_vol_over_lower_threshold_ctrl_para ;//电压超限动作   
+    char            product_cur_upper_enable                   ;//电流下限使能
+    float           product_cur_upper_threshold                ;//电流下限值
+    float           product_cur_lower_threshold;                //
+    char            product_cur_over_upper_threshold_ctrl      ;//电流超限动作 
+    char            product_cur_over_upper_threshold_ctrl_para ;//电流超限动作   
+    char            product_pwr_upper_enable                   ;//功率上限使能
+    float           product_pwr_upper_threshold                ;//功率上限值
+    char            product_pwr_over_upper_threshold_ctrl      ;//功率超限动作 
+    char            product_pwr_over_upper_threshold_ctrl_para ;//功率超限动作      
+    char            product_pwrcon_upper_enable                ;//耗电量上限使能
+    float           product_pwrcon_upper_threshold             ;//耗电量上限值
+    char            product_pwrcon_over_upper_threshold_ctrl   ;//耗电量超限动作   
+    char            product_pwrcon_over_upper_threshold_ctrl_para   ;//耗电量超限动作   
+}GlobalOverManager;
+
+
+/// @brief 定时管理
+typedef struct
+{
+    char                set_date[16]; //设置日期
+    char                ds_date[16]; //设置时间
+    char                ds_time[16]; //设置时间
+    int                 set_stats;    //状态
+    int                 ds_is_triggered;   //是否已触发
+    struct list_head    list;   
+}_PowerDSManage_t;
+
+
+typedef struct
+{
+    int                 firingSortno;   //启动序号
+    int                 closeSortno;    //关闭序号 
+}_PowerSXManage_t;
+
+typedef struct
+{
+    int                 product_id;
+    int                 mode;
+    char*               ntpName;
+    char*               ntpaddress;
+    int                 port;
+    char*               time;
+    int                 weekday;
+    int                 tzone;
+}NTPManager;
+NTPManager _globalNTPManager;
+
+typedef struct
+{
+    int                 product_id;
+    int                 mode;
+    int                 version;
+    char*               public;
+    int                 trapmode;
+}SNMPManager;
+SNMPManager _globalSNMPManager;
+
+//分组管理
+typedef struct
+{
+    int                 product_id;
+    int                 GroupID;
+    char               GroupName[64];
+    char               GroupChList[512];
+    struct list_head    list;  
+}GroupInfo;
+
+
+//电源部分
+typedef struct 
+{
+    float           voltage                                     ;//电压
+    float           current                                     ;//电流
+    float           power                                       ;//功率
+    float           freq                                        ;//频率
+    float           consumption                                 ;//耗电量
+    float           factor                                      ;//功率因素    
+    unsigned short  status                                      ;//开关状态     
+    unsigned short  NF_status                                   ;//零线状态
+    
+    port_info_t     port;                                       //
+}PowerInfo;
+
+//电源部分报警信息
+typedef struct 
+{
+    bool           w_voltage_up                                  ;//电压上限报警
+    bool           w_voltage_down                                ;//电压下限报警
+    bool           w_current                                     ;//电流上限报警
+    bool           w_power                                       ;//功率
+    bool           w_consumption                                 ;//耗电量
+    bool           w_phase_loss                                  ;//缺相报警              
+}PowerWarningInfo;
+
+//三项数据
+typedef struct
+{
+    int product_id;
+    int product_ch_id;
+    int product_ph_id;
+    int product_ph_type;//0:A相 1:B相 2:C相                
+    int product_saddr;
+    int product_ch_addr;
+    int product_ph_outputType;//三相控制方式1,三项2单项
+    int product_ph_outputStatus;//该相是否输出，1输出2不输出
+    PowerInfo           _PowerInfo;                              //存储最新的数据(兼容三项输入)
+    GlobalOverManager*  global_over_manager                        ;//超限管理
+    PowerWarningInfo    _PowerWarninginfo;                       //存储报警数据(兼容三项输入)  
+    time_t              product_log_time;                           //存储最新时间   
+    struct list_head    list_Tree_AC;                              //存储三项数据指针    
+}GlobalTreeACManager;
+//电源通道管理总表(输出)
+typedef struct 
+{
+    int                 product_id                                 ;//产品ID
+    //20240225 add
+    char                product_saddr                              ;//modbus地址记录                       
+    char                product_ch_id                              ;//通道号
+    char                product_ch_addr                            ;//通道号实际地址
+    char                product_ch_name[32]                        ;//通道名称
+    char                product_ch_type                            ;//通道类型
+    char                product_ch_status                          ;//通道状态
+    char                product_ch_NF_status                          ;//通道零线状态（三相）
+    unsigned short      product_ch_start_delay                     ;//通道延时 
+    unsigned short      product_ch_stop_delay                      ;//通道延时
+
+    GlobalOverManager*  global_over_manager                        ;//超限管理
+    struct list_head    list_DS;                                    //定时设置      
+    _PowerSXManage_t*   _PowerSXManage;                             //时序管理      
+    PowerInfo           _PowerInfo;                                 //存储最新的数据     
+    PowerWarningInfo    _PowerWarninginfo ;                         //存储报警数据     
+    time_t              product_log_time;                           //存储最新时间     
+    struct list_head    list_Tree_AC;                              //存储三项数据指针
+    struct list_head    list;  
+}   GlobalPowerManger;
+
+//电源通道管理总表(输入)
+typedef struct 
+{
+    int                 product_id                                 ;//产品ID
+    //20240225 add
+    char                product_saddr                              ;//modbus地址记录                       
+    char                product_saddr_name[32]                     ;//输入名称
+    char                product_saddr_type                         ;//输入类型
+    GlobalOverManager*  global_over_manager                        ;//超限管理
+    PowerInfo           _PowerInfo[3];                              //存储最新的数据(兼容三项输入)
+    PowerWarningInfo    _PowerWarninginfo[3];                       //存储报警数据(兼容三项输入)    
+    time_t              product_log_time;                           //存储最新时间                                        
+}GlobalPowerInManger;
+
+//电源控制板计数
+typedef struct 
+{
+    char                product_saddr                              ;//modbus地址记录                       
+    int                 product_number;                             //数量
+    int                 product_type;                               //类型
+    PowerInfo           _PowerInfo[AC_SINGLE_S_MAX_CHN_NUM];        //存储最新的数据     
+    PowerWarningInfo    _PowerWarninginfo[AC_SINGLE_S_MAX_CHN_NUM] ;//存储报警数据     
+    struct list_head    list;  //存储具有的通道指针
+    GlobalPowerInManger _globalPowerInManger;                       //总输入数据
+}GlobalPowerCtrlBoard;
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+
+//电源信息统计
+typedef struct
+{
+	float ydata[60];    //value
+    char  xAxis[60][32];//时间点
+}GetTotalInfo;
+
+//系统总数信息
+typedef struct
+{
+    int channel_total  ;//通道总数
+    int warn_total     ;//告警总数
+    int sensor_total   ;//传感器总数
+    int log_total      ;//运行日志总数
+}SystemTotalInfo;
+
+//功率趋势接口
+typedef struct
+{
+    float  ydata[3][60]     ;//0：有功功率；1：无功功率；2：视在功率；
+    char   xAxis[60][32]    ;//时间点      
+}PowerTrendInfo;
+
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+
+
+//电源监控
+typedef struct 
+{
+    int             product_id                                  ;//产品ID
+    char            product_ch_id                               ;//电源通道
+    unsigned short  product_status                              ;//当前状态
+    PowerInfo       _power_info                                 ;//采集值
+    char            samp_time[64]                               ;//采集时间
+    GetTotalInfo	_total_voltage								;//统计电压
+	GetTotalInfo	_total_current								;//统计电流
+	GetTotalInfo	_total_power								;//统计功率
+	GetTotalInfo	_total_consumption							;//统计耗电量
+    SystemTotalInfo _system_total_info                          ;//系统总数信息
+    PowerTrendInfo  _power_trend_info                           ;//功率趋势图
+    struct list_head list;
+}GlobalPowerInfo;
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+//传感器值
+typedef struct
+{
+    char            samp_time[64]                               ;//采集时间
+    int             product_id                                  ;//产品ID
+    char            sensor_id                                   ;//传感器ID
+    float           val1                                        ;//值1
+    float           val2                                        ;//值2
+    time_t          product_log_time;                           //存储最新时间     
+    struct list_head list;
+}GlobalSensorInfo;
+
+typedef struct
+{
+    bool                sensor_val1_upper_enabled ;//
+    float               sensor_val1_upper_threshold;
+    char                sensor_val1_upper_threshold_ctrl;
+    char                sensor_val1_upper_threshold_ctrl_para;
+    bool                sensor_val1_lower_enabled ;//
+    float               sensor_val1_lower_threshold;
+    char                sensor_val1_lower_threshold_ctrl;
+    char                sensor_val1_lower_threshold_ctrl_para;
+    bool                sensor_val2_upper_enabled ;//
+    float               sensor_val2_upper_threshold;
+    char                sensor_val2_upper_threshold_ctrl;
+    char                sensor_val2_upper_threshold_ctrl_para;
+    bool                sensor_val2_lower_enabled ;//
+    float               sensor_val2_lower_threshold;
+    char                sensor_val2_lower_threshold_ctrl;
+    char                sensor_val2_lower_threshold_ctrl_para;
+}GlobalSensorOverManage;
+
+//传感器报警状态表
+typedef struct
+{   
+    bool                sensor_val1_upper;
+    bool                sensor_val1_lower;
+    bool                sensor_val2_upper;
+    bool                sensor_val2_lower;
+}GlobalSensorOverInfo;
+//传感器管理总表
+typedef struct 
+{
+    int                 product_id                                 ;//产品ID    
+    char                sensor_id                                  ;//传感器ID
+    char                sensor_type                                ;//传感器类型
+    char                sensor_interface_type;                     //接口类型
+    char                sensor_name[64]                            ;//传感器名称
+    char                sensor_port_name[32]                       ;//传感器端口号
+    int                 sensor_baud                                ;//波特率
+    char                sensor_addr                                ;//modbus地址
+    int                sensor_status                              ;//传感器状态
+    char                sensor_val_count                           ;//传感器值个数
+    int                 sensor_node_number                         ;//节点号
+    GlobalSensorInfo Cur_sensor_info ;
+    GlobalSensorOverManage*  over_manager                          ;//超限管理   
+    GlobalSensorOverInfo warning_status;//报警状态
+    struct list_head    list;   
+}GlobalSensorManger;
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+
+
+
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+///温湿度数据信息管理
+typedef struct
+{
+    float  temperature;
+    float   humidity;
+}SenorTempVal;
+
+
+//采集KB值
+typedef struct 
+{
+    float   voltage_k;//电压K
+    float   voltage_b;//电压B
+    float   current_k;//电流K
+    float   current_b;//电流B
+}SwitchKbVal;
+///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
+
+//SMTP管理
+typedef struct
+{
+    int                 idx;
+    char*               receive_account;
+    char*               receive_account_info;
+    struct list_head    list;
+}SMTPreceiveAccount;
+
+typedef struct 
+{
+    int                 product_id;
+    int                 mode;    				//状态
+    char*               account;                //用户账号
+    char*               password; 		        //用户密码
+    char*               server; 			    //服务器
+    int                 port;    		        //端口
+    char                auth[16];    			//认证方式
+    SMTPreceiveAccount* receive_account;        //接收账号列表
+
+}SMTPManager;
+SMTPManager globalSMTPManager;
+
+typedef struct 
+{
+    int                 product_id;
+    int                 userID;    				//用户ID
+    char*               userName;                //用户名-登录
+    char*               userPW; 		        //用户密码
+    char*               nickName; 			    //用户名称
+    int                 roleID;    		        //角色ID
+    char*               createTime;             //用户创建时间     
+    struct list_head    list;
+
+}UserInfo;
+
+typedef struct 
+{
+    int                 product_id;
+    int                 roleID;    				//角色ID
+    char*               roleName;               //角色名称
+    int                 roleLevel; 		        //角色等级
+    char*               roleAuthority; 			//角色权限
+    int                 roleSort;    		    //显示顺序
+    char*               createTime;             //创建时间     
+    struct list_head    list;
+
+}RoleInfo;
+
+typedef struct MenuAuthority{
+    bool PowerEnabled;
+    bool SensorEnabled;
+    bool AlarmEnabled;
+    bool LogEnabled;
+    bool UserInfoEnabled;
+    bool CommEnabled;
+    bool ServiceEnabled;
+    bool MaintenanceEnabled;
+
+    //1、电源监控菜单
+    bool MonitorallEnabled;
+    bool ChannelstatusEnabled;
+    bool SwitchtatusEnabled;
+    bool MonitorhistoryEnabled;
+    //2、传感器管理菜单
+    bool SensorStatusEnabled;
+    bool SensorHistorylEnabled;
+    //3、告警管理菜单
+    bool XtjgEnabled;
+    bool YzszEnabled;
+    //4、日志信息菜单
+    bool CzrzEnabled;
+    bool YxrzEnabled;
+    //5、用户管理菜单
+    bool UserEnabled;
+    bool RoleEnabled;
+    bool MenuEnabled;
+    //6、通信管理菜单
+    bool WkszEnabled;
+    bool RsszEnabled;
+    //7、服务管理菜单
+    bool SmtpszEnabled;
+    bool SnmpszEnabled;
+    bool MqszEnabled;
+    bool NtpszEnabled;
+    bool DsszEnabled;
+    bool SxszEnabled;
+    bool FzszEnabled;
+     //8、设备维护菜单
+    bool SbcqEnabled;
+    bool GjsjEnabled;
+    bool HhccszEnabled;
+    bool PzdrdcEnabled;
+    bool ShfwEnabled;
+    bool GysbEnabled;
+}MenuAuthority;
+
+
+typedef struct CascadeDevices{
+    int                 product_id;     //级联设备ID modbus地址
+    int                 type;           //
+    char                device_name[20];    //接连设备名;
+    float               valtage;            //485
+    float               current;
+    float               power;
+    float               factor;
+    float               freq;
+    float               consumption;
+}CascadeDevices;
+
+struct modbus_slave_read_reg{
+    uint16_t deveice_type;              //设备类型
+    uint16_t slave_addr;                //设备地址
+    uint32_t voltage;                   //当前电压
+    uint32_t current;                   //当前电流
+    uint32_t power;                     //当前功率
+    uint32_t consumption_cur;           //耗电量
+    uint32_t freq;                      //频率
+    uint32_t factor;                    //功率因素
+    uint32_t temprature;                //温度值
+    uint32_t humidity;                  //湿度值
+    uint32_t warning;                   //告警
+    uint16_t power_supplay_status;      //供电状态
+    uint16_t sencor_status;             //传感器状态
+
+//    uint32_t Warinfo;
+//    uint16_t sercor_type;
+};
+
+
+
+typedef struct cascade_pw_info{
+    uint32_t           voltage                                     ;//电压
+    uint32_t           current                                     ;//电流
+    uint32_t           power                                       ;//功率
+    uint32_t           freq                                        ;//频率
+    uint32_t           consumption                                 ;//耗电量
+    uint32_t           factor                                      ;//功率因素 
+}cascade_single_chn_info;     //siggle hell 
+
+typedef struct temp_hum{
+    uint16_t temperature;
+    uint16_t humidity;
+}temp_hum_t;
+
+#pragma pack (1)
+typedef struct cascade_single_mmap{
+    uint16_t dev_chn;
+    cascade_single_chn_info all_ch[128];
+    uint32_t total_valtage;
+    uint32_t total_current;
+    uint32_t total_power;
+    //temp_hum_t total_temp;
+    uint16_t temperature;
+    uint16_t humidity;
+    uint16_t chn_status[64];
+    uint16_t open_delay[64];
+    uint16_t close_delay[64];
+    uint16_t reservers[29];
+    uint16_t set_chn_open_delay[64];
+    uint16_t set_chn_close_delay[64];
+    uint16_t set_chn_switch_status[64];
+    uint16_t set_chn_all_switch_status;
+}cascade_single_mmap_t;
+
+#pragma pack ()
+
+
+#pragma pack (1)
+
+
+#define MAX_CHN  64
+
+typedef struct cascade_triphasic_pw_out{
+    uint32_t o_voltage;
+    uint32_t o_current;
+    uint32_t o_power;
+    uint32_t o_consumption;
+    uint32_t o_status;
+}cascade_triphasic_pw_out_t;
+
+
+typedef struct cascade_triphasic_pw_o_chn{
+    cascade_triphasic_pw_out_t chn[3];        // A B C
+}cascade_triphasic_pw_o_chn_t;
+
+
+typedef struct cascade_triphasic_pw_in{
+    uint32_t i_total_voltage;
+    uint32_t i_total_current;
+    uint32_t i_total_power;
+    uint32_t i_total_consumption;
+}cascade_triphasic_pw_in_t;
+
+typedef struct cascade_triphasic_pw_i_total{
+    cascade_triphasic_pw_in_t pw_i_total[3];   // A  B  C
+}cascade_triphasic_pw_i_total_t;
+
+typedef struct cascade_triphasic_chn_info{
+    uint32_t chn_power;
+    uint32_t chn_freq;
+    uint32_t chn_consumption;
+    uint32_t chn_factor;
+    uint32_t chn_type;
+}cascade_triphasic_chn_info_t;
+
+
+typedef struct cascade_triphasic_mmap{
+    uint16_t dev_chn;
+    cascade_triphasic_pw_i_total_t i_total;
+    cascade_triphasic_chn_info_t chn_info[MAX_CHN];
+    cascade_triphasic_pw_o_chn_t pw_o_chn[MAX_CHN];
+    uint16_t temperature;
+    uint16_t humidity;
+    uint16_t chn_status[MAX_CHN];
+    uint16_t open_delay[MAX_CHN];
+    uint16_t close_delay[MAX_CHN];
+    uint16_t set_chn_open_delay[MAX_CHN];
+    uint16_t set_chn_close_delay[MAX_CHN];
+    uint16_t set_chn_switch_status[MAX_CHN];
+    uint16_t set_chn_all_switch_status;
+}cascade_triphasic_mmap_t;
+
+
+
+
+#pragma pack ()
+
+struct modbus_slave_write_reg{
+    uint16_t      voltage_high_enable:1;           //电压高阈值检测使能
+    uint16_t       voltage_low_enable:1;            //电压低阈值检测使能
+    uint16_t           current_enable:1;            //电流阈值使能
+    uint16_t             power_enable:1;            //功率阈值使能
+    uint16_t   consumption_cur_enable:1;            //功耗阈值使能
+    uint32_t    voltage_upper_threshold;            //
+    uint32_t    voltage_lower_threshold;
+    uint32_t    current_upper_threshold;
+    uint32_t      power_upper_threshold;
+    uint32_t      consumption_threshold;
+};
+enum 
+{
+    DI,
+    RS485
+};
+
+enum{
+    SWITCH_CONNETCTED,
+    SWITCH_DISCONNETCTED,
+    SWITCH_OFFLINE
+};
+
+
+#define SWITCH_CHN_1_SET        (1<<0)
+#define SWITCH_CHN_2_SET        (1<<1)
+#define SWITCH_CHN_3_SET        (1<<2)
+#define SWITCH_CHN_4_SET        (1<<3)
+#define SWITCH_CHN_5_SET        (1<<4)
+#define SWITCH_CHN_6_SET        (1<<5)
+#define SWITCH_CHN_DI_1_SET     (1<<6)
+#define SWITCH_CHN_DI_2_SET     (1<<7)
+
+
+typedef struct breaker_switch_sta{     
+    uint16_t status;
+    uint16_t gather;
+    char com[30];
+    uint8_t product_name[256];
+}breaker_switch_sta_t;
+
+typedef struct GlobalBreakerManger{
+    uint32_t all_count;
+    uint32_t online_count;
+    uint32_t mask;
+    uint8_t saddr;
+    void *manager;
+    breaker_switch_sta_t sta[8];        // 6 + 2
+    pthread_mutex_t b_mutex;
+}GlobalBreakerManger;
+
+
+typedef struct GlobalBreakerManager{
+    uint32_t        product_id;
+    uint32_t        breaker_id;
+    uint32_t        breaker_chn;
+    uint32_t        breaker_status;
+    uint32_t        breaker_gather_addr;
+    char            breaker_switch_name[128];
+    char            breaker_com[64];
+    char            breaker_gather_type[64];
+    char            breaker_chns_name[128];
+    struct  list_head  list;
+}GlobalBreakerManager;
+
+//设备总体管理
+typedef struct
+{
+    sqlite3*            db;             //数据库接口
+    pthread_mutex_t     dbThreadlock;        //写入线程锁 
+    pthread_t           appweb_thread;  //appweb线程
+    pthread_t           dev_samp_thread;//电源采集与控制线程
+    pthread_t           dev_update_thread;//电源采集与控制线程
+
+    pthread_t           io_thread;  //IO采集线程
+    pthread_t           sensor_thread; //传感器采集现成
+    bool                dev_samp_flag ; //电源采集线程标志
+    GlobalDeviceInfo*   _global_device_info;    //设备管理信息
+    GlobalPowerManger  _globalPowerManger;      //电源管理表
+    GlobalSensorManger _globalSensorManger;     //传感器管理表  
+    Modbus_Manger      sensor_modbus_manager;  //通信接口管理
+    unsigned int        useSlaveCount ;         //有效地址
+    Modbus_Manger       _globalRelaySampManger; //内部继电器使用
+    
+    unsigned char       uart_init_flag[6] ; //
+
+    bool                 ws_isok; //ws准备好
+    struct mg_connection *ws_client;   //websocket管理信息
+    HashTable*           _global_alarmLanguage; //全局的报警映射
+    int                 nTreeACLshow; //三项总数据显示L1=0,L2=1,L3=2
+    pthread_t           snmp_agent_thread;//SNMP代理线程
+    bool                _ReloadChm_flag; //重新加载端口数据
+    GlobalPowerCtrlBoard _all_ctrl_board[MAX_CHN_COUNT]; //所有控制板
+    LowConf*            _RS485LowConfData;//485Data
+      //传感器
+    struct modbus_slave_read_reg g_modebus_read;
+    struct modbus_slave_write_reg g_modebus_write;
+    smartPDU_shm_data* g_shm_Data;
+    pthread_mutex_t     _power_ds;        //定时器锁 
+    pthread_mutex_t     _power_update;        //数据刷新锁
+    pthread_mutex_t     _sensor_update;        //传感器刷新锁
+	pthread_mutex_t     _breaker_mutex;         // breaker info
+    cascade_single_mmap_t *single_mmap;
+    cascade_triphasic_mmap_t *triphasic_mmap;	
+	GlobalBreakerManager g_new_global_breaker;
+}GlobalDeviceManager;
+
+extern GlobalDeviceManager __globalDeviceManage;
+extern GlobalDeviceManager __globalDeviceManage2;
+
+extern NTPClient* globalNTPclient;
+extern unsigned long __globalSxIdx;
+
+extern _User_Log _GlobalUserLoginInfo;//全局用户登录信息
+extern UserInfo _GlobalUserInfoNew;////最近登录的信息
+extern char _GlobalUserToken[64];////最近登录的信息
+extern MenuAuthority _GlobalMenuAuthority;////角色菜单权限
+
+void initLogger(void);
+
+//打印设备信息结构
+void printf_global_device_info(GlobalDeviceInfo* _globalDeviceInfo);
+//打印设备超限电源管理
+void printf_global_power_manage_info(GlobalPowerManger* _globalPowerManger);
+//打印设备超限电源通道管理
+//void printf_global_power_chn_manage_info(GlobalPowerChnManger* _globalPowerChnManger);
+
+void printf_power_info(GlobalPowerInfo* _globalPowerInfo);
+
+
+int getTotalMemorySize(unsigned int* totalSize);
+char* getLocalIpAddress(char* dev);
+char* get_mac_address(const char *iface_name) ;
+void get_disk_occupy(char ** reused);
+int set_local_timeandzone(struct tm* t, int zone);
+char* getUserNamebyToken(char* Token);
+int is_process_running(const char *process_name);
+bool CheckLoginStatus(char* Token);
+
+// 辅助函数：判断是否是闰年  
+int is_leap_year(int year);  
+// 辅助函数：获取某月的天数  
+int days_in_month(int year, int month);
+// 函数：增加一天到日期  
+void add_day_to_date(char *date_str, int *year, int *month, int *day);
+
+void SetMenuAuthority(int RoleID);
+
+=======
 #ifndef __COMMON_H_
 #define __COMMON_H_
 
@@ -740,9 +1709,7 @@ typedef struct cascade_single_mmap{
     uint32_t total_valtage;
     uint32_t total_current;
     uint32_t total_power;
-    //temp_hum_t total_temp;
-    uint16_t temperature;
-    uint16_t humidity;
+    temp_hum_t total_temp;
     uint16_t chn_status[64];
     uint16_t open_delay[64];
     uint16_t close_delay[64];
@@ -965,4 +1932,5 @@ void add_day_to_date(char *date_str, int *year, int *month, int *day);
 
 void SetMenuAuthority(int RoleID);
 
+>>>>>>> 1a6c6a9ecc73b46498b40e3ded858f5abe7996e9
 #endif