3相从机服务，IO断路器检测接口

pro/src/app.c

@@ -176,10 +176,8 @@ void* power_thread(void* arg)
                     _globalDeviceManager->single_mmap->open_delay[_chn] = _globalPowerMangerTemp->product_ch_start_delay;
                     _globalDeviceManager->single_mmap->close_delay[_chn] = _globalPowerMangerTemp->product_ch_stop_delay;
                 }
-            }else{
-
             }
-            _chn+=1;
+            
             memcpy(&_globalPowerWarningInfo,
             &_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
             sizeof(PowerInfo));
@@ -368,7 +366,7 @@ void* power_thread(void* arg)
                 {     
                     GlobalTreeACManager* _pTreeACPowerPhData = NULL ;  
                     memset(&_globalPowerInfo._power_info, 0, sizeof(_globalPowerInfo._power_info));
-                    
+                    int k = 0;
                     list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                     {
                         if (__globalDeviceManage._global_device_info->product_pwr_type==SmartPDU_Tree_AC_One&&_pTreeACPowerMangerTemp->product_ph_outputStatus==2)
@@ -386,14 +384,22 @@ void* power_thread(void* arg)
                         _globalPowerInfo._power_info.freq = _pTreeACPowerMangerTemp->_PowerInfo.freq;
                         _globalPowerInfo._power_info.consumption += _pTreeACPowerMangerTemp->_PowerInfo.consumption;
                         _globalPowerInfo._power_info.factor = _pTreeACPowerMangerTemp->_PowerInfo.factor;
+
+                        __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption * 1000;
+                        __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_current = _pTreeACPowerMangerTemp->_PowerInfo.current * 1000;
+                        __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_power = _pTreeACPowerMangerTemp->_PowerInfo.power * 1000;
+                        __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage * 1000;
+                        __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_type = _pTreeACPowerMangerTemp->product_ph_type;
+                        
                         if(_globalPowerInfo._power_info.status==0)
                         {
                             _globalPowerInfo._power_info.status=_pTreeACPowerMangerTemp->_PowerInfo.status;
-                    }
-                    else
-                    {
+                        }
+                        else
+                        {
                             _globalPowerInfo._power_info.status=0;
                         }
+                        __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_status = _globalPowerInfo._power_info.status;
                         time_t now;
                         time(&now);
                         t = localtime(&now);
@@ -416,6 +422,7 @@ void* power_thread(void* arg)
                             }
                         }
                     }
+                    
                     _globalTotalPowerInfo._power_info.voltage = _globalPowerInfo._power_info.voltage ;
                     _globalTotalPowerInfo._power_info.current += _globalPowerInfo._power_info.current ;
                     _globalTotalPowerInfo._power_info.power += _globalPowerInfo._power_info.power ;
@@ -424,6 +431,18 @@ void* power_thread(void* arg)
                     _globalTotalPowerInfo._power_info.factor = _globalPowerInfo._power_info.factor ;
                     _globalPowerInfo.product_status = _globalPowerInfo._power_info.status ;
                     _globalPowerMangerTemp->product_ch_status = _globalPowerInfo._power_info.status ;
+
+                    // tong dao zong ti xin xi
+                    __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_consumption  = _globalTotalPowerInfo._power_info.consumption * 1000;
+                    __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_freq  = _globalTotalPowerInfo._power_info.freq * 1000;
+                    __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_power  = _globalTotalPowerInfo._power_info.power * 1000;
+                    __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_factor  = _globalTotalPowerInfo._power_info.factor * 1000;
+                    
+                    _globalDeviceManager->triphasic_mmap->open_delay[_chn] = _globalPowerMangerTemp->product_ch_start_delay;
+                    _globalDeviceManager->triphasic_mmap->close_delay[_chn] = _globalPowerMangerTemp->product_ch_stop_delay;
+
+
+
                     //累加总电源信息
                     _globalTotalPowerInfo.product_id = _globalDeviceManager->_global_device_info->product_id;
                     _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
@@ -509,6 +528,8 @@ void* power_thread(void* arg)
             }
             break;
             }
+
+            _chn+=1;
             //nanosleep(&reqSleep, NULL); 
             //usleep(usleepTime);
             #endif
@@ -597,6 +618,11 @@ void* power_thread(void* arg)
                     _pTreeACPowerMangerTemp->_PowerInfo.consumption += _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].consumption;
                     _pTreeACPowerMangerTemp->_PowerInfo.factor = _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].factor;
                 }
+                _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption *1000;
+                _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_power = _pTreeACPowerMangerTemp->_PowerInfo.power *1000;
+                _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage *1000;
+                _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_current = _pTreeACPowerMangerTemp->_PowerInfo.current *1000;
+
                 time_t now;
                 time(&now);
                 t = localtime(&now);
@@ -618,6 +644,7 @@ void* power_thread(void* arg)
                     }
                 }
             }
+            __globalDeviceManage.triphasic_mmap->dev_chn = __globalDeviceManage._global_device_info->product_pwr_type << 8 | _chn;
         }
 
         //插入总电源信息
@@ -850,6 +877,16 @@ void* sensor_thread(void* arg)
                 _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id;
                 _globalSensorInfo.val1 = temperature;
                 _globalSensorInfo.val2 = humidity;
+                if(_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_AC ||
+                _globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_DC)
+                {
+                    _globalDeviceManager->single_mmap->total_temp = temperature *1000;
+                    _globalDeviceManager->single_mmap->total_humidity = humidity * 1000;
+                }else
+                {
+                    _globalDeviceManager->triphasic_mmap->temperature = temperature *100;
+                    _globalDeviceManager->triphasic_mmap->humidity = humidity * 100;
+                }
                 _globalSensorInfo.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;;
                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                 _globalDeviceManager->g_modebus_read.temprature=temperature;
@@ -1161,16 +1198,28 @@ int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
     //使用的通道
     _globalDeviceManager->useSlaveCount = 0 ;
     
-
-    _globalDeviceManager->single_mmap =(cascade_single_mmap_t*)malloc(sizeof(cascade_single_mmap_t));
-    if(_globalDeviceManager->single_mmap==NULL)
+    if(_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_AC ||
+        _globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_DC)       // single AC
     {
-        log_e("_global_device_info malloc error.!");
-        //printf("_global_device_info malloc error.\n");
-        return -1 ;       
-    }  
-    memset(_globalDeviceManager->single_mmap, 0, sizeof(cascade_single_mmap_t));
-
+        _globalDeviceManager->single_mmap =(cascade_single_mmap_t*)malloc(sizeof(cascade_single_mmap_t));
+        if(_globalDeviceManager->single_mmap==NULL)
+        {
+            log_e("_global_device_info malloc error.!");
+            //printf("_global_device_info malloc error.\n");
+            return -1 ;       
+        }  
+        memset(_globalDeviceManager->single_mmap, 0, sizeof(cascade_single_mmap_t));
+    }else   // tree
+    {
+        _globalDeviceManager->triphasic_mmap =(cascade_triphasic_mmap_t*)malloc(sizeof(cascade_triphasic_mmap_t));
+        if(_globalDeviceManager->triphasic_mmap== NULL)
+        {
+            log_e("_global_device_info malloc error.!");
+            //printf("_global_device_info malloc error.\n");
+            return -1 ;       
+        }  
+        memset(_globalDeviceManager->triphasic_mmap, 0, sizeof(cascade_triphasic_mmap_t));
+    }
     //链接数据库获取配置信息
     sys_get_path(path, DATABASE_NAME);
     log_i("database: %s\n", path);

pro/src/breaker_detection.c

@@ -0,0 +1,106 @@
+#include "fcntl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+
+
+int breaker_init(int gpio)
+{
+    char buff[1024] = {0};
+    sprintf(buff,"/sys/class/gpio/gpio%d",gpio);
+    //open the file
+    int fd = open(buff,O_RDONLY);
+    if(fd < 0)
+    {
+        printf("Failed to open gpio %d and create!!!!\n",gpio);
+        sprintf(buff,"%s","/sys/class/gpio/export");
+        fd = open(buff,O_WRONLY);
+        if(fd < 0)
+        {
+            printf("Failed to open export file and create!!!!\n");
+            goto err_1;
+        }
+        sprintf(buff,"%d",gpio);
+        write(fd,buff,strlen(buff));
+        close(fd);
+        fd = 0;
+        printf("determin io input deriction!!!");
+
+        sprintf(buff,"/sys/class/gpio/gpio%d/direction",gpio);
+        fd = open(buff,O_WRONLY);
+        if(fd < 0)
+        {
+            printf("Failed to open gpio %d and create!!!!\n",gpio);
+            goto err_2;
+        }
+        write(fd,"in",2);
+    }
+    close(fd);
+
+    return 0;
+
+err_2:
+    {
+        sprintf(buff,"%s","/sys/class/gpio/unexport");
+        fd = open(buff,O_WRONLY);
+        sprintf(buff,"%d",gpio);
+        write(fd,buff,strlen(buff));
+        close(fd);
+    }
+err_1:
+    return -1;
+}
+
+
+int breaker_read_status(int gpio)
+{
+    char value_path[1024] = {0};
+   char buf[3];  // 用于存储读取到的GPIO值，通常为'0'或'1'  
+    ssize_t bytesRead;  
+    int fd;  
+    // 构造GPIO值的路径  
+    sprintf(value_path, "/sys/class/gpio/gpio%d/value", gpio);  
+  
+    // 打开GPIO值文件以读取  
+    fd = open(value_path, O_RDONLY);  
+    if (fd == -1) {  
+        perror("Failed to open GPIO value for reading");  
+        return -1;  
+    }  
+  
+    // 读取GPIO的值  
+    bytesRead = read(fd, buf, sizeof(buf) - 1);  
+    if (bytesRead == -1) {  
+        perror("Failed to read from GPIO value");  
+        close(fd);  
+        return -1;  
+    }  
+  
+    // 确保字符串以null终止  
+    buf[bytesRead] = '\0';  
+    close(fd);
+    // 打印读取到的GPIO值  
+   // printf("GPIO %d value: %s\n", GPIO_PE3, buf);  
+    if (buf[0]=='0')
+    {
+        return 0;
+    }else{
+        return 1;
+    }
+    
+      
+}
+int breaker_deinit(int gpio)
+{
+    char buff[1024] = {0};
+    int fd = 0;
+    sprintf(buff,"%s","/sys/class/gpio/unexport");
+    fd = open(buff,O_WRONLY);
+    sprintf(buff,"%d",gpio);
+    write(fd,buff,strlen(buff));
+    close(fd);
+    return 0;
+}

pro/src/breaker_detection.h

@@ -0,0 +1,28 @@
+#ifndef __BREAKER_DETECTION_H__
+#define __BREAKER_DETECTION_H__
+
+
+#define BREAKER_IO_BASE    (96)
+
+#define BREAKER_IO_1      (BREAKER_IO_BASE+(16))          // 112   may use
+#define BREAKER_IO_2      (BREAKER_IO_BASE+(17))          // 113
+#define BREAKER_IO_3      (BREAKER_IO_BASE+(18))          // 114   may use
+#define BREAKER_IO_4      (BREAKER_IO_BASE+(19))          // 115
+
+
+
+
+
+
+
+
+
+
+
+
+int breaker_init(int gpio);
+int breaker_deinit(int gpio);
+int breaker_read_status(int gpio);
+
+#endif
+

pro/src/cascade_slave.c

@@ -6,6 +6,76 @@
 
 
 
+#define DEV_CHN_REG                 (4000)  
+#define OUT_INFO_REG                (4001)     
+#define IN_TOTAL_REG                (4768)  
+#define TEM_HUMAN_REG               (4777)       
+#define CHN_SWITCH_REG              (4779)
+#define CHN_OPEN_DLA_REG            (4843)
+#define CHN_CLOSE_DLA_REG           (4907)
+#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;
@@ -16,19 +86,35 @@ static inline GlobalDeviceManager* get_dm2(void)
 }
 
 static mmap_modbus_t modbus_single[] = {
-    {.offset = 4000},
-    {.offset = 4001},
-    {.offset = 4769},
-    {.offset = 4779},
-    {.offset = 4843},
-    {.offset = 4971},
-    {.offset = 5000},
-    {.offset = 5064},
-    {.offset = 5128},
-    {.offset = 5192},
+    [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 }
+};
 
 int cascade_slave_map_init(cascade_handle_t *cas)
 {
@@ -37,187 +123,184 @@ int cascade_slave_map_init(cascade_handle_t *cas)
     if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC ||
         mgr->_global_device_info->product_pwr_type == SmartPDU_DC)       // single AC
     {
-        cas->map = modbus_mapping_new_start_address(0,0,0,0,4000,5000,0,0);     //3000 ge
-        modbus_single[0].addr = &mgr->single_mmap->dev_chn;
-        modbus_single[1].addr = &mgr->single_mmap->all_ch;
-        modbus_single[2].addr = &mgr->single_mmap->total_valtage;
-        modbus_single[3].addr = &mgr->single_mmap->chn_status;
-        modbus_single[4].addr = &mgr->single_mmap->open_delay;
-        modbus_single[5].addr = &mgr->single_mmap->close_delay;
-        modbus_single[6].addr = &mgr->single_mmap->set_chn_open_delay;
-        modbus_single[7].addr = &mgr->single_mmap->set_chn_close_delay;
-        modbus_single[8].addr = &mgr->single_mmap->set_chn_switch_status;
-        modbus_single[9].addr = &mgr->single_mmap->set_chn_all_switch_status;
+        cas->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
     {
-        return -1;
+
+        cas->map =  modbus_mapping_new_start_address(0,0,0,0,TREE_R_DEV_CHN,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;
 }
 
 
 
-void cascade_slave_read(cascade_handle_t *cas,uint32_t addr,uint32_t lenth)
-{
 
+
+static void slave_read(cascade_handle_t *cas,uint32_t addr,int num,uint32_t reg_type,uint32_t type)
+{   
     GlobalDeviceManager* mgr = get_dm();
     if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC || 
-            mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
-    {
-        switch (addr)
+            mgr->_global_device_info->product_pwr_type == SmartPDU_DC){    
+        if(addr >= DEV_CHN_REG && addr <= ALL_SET_SWITCH_REG)
         {
-            case 4000:
-                {
-                    uint16_t *base_addr = (uint16_t *)modbus_single[0].addr;
-                    uint32_t step = addr - cas->map->start_registers;
-                    base_addr = base_addr + (addr - modbus_single[0].offset);
-                    uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                    printf("step = %d   base_addr = 0x%x  map_addr = 0x%x\n", step,base_addr,map_addr);
-                    if(lenth < 126)
-                    {
-                        pthread_mutex_lock(&cas->mutex);
-                        memcpy(map_addr, base_addr,2*lenth);
-                        pthread_mutex_unlock(&cas->mutex);
-                    }
-                }
-                break;
-            case 4001 ... 4768:
+            if(type == TYPE_U16)
             {
-                uint32_t *base_addr = (uint32_t *)modbus_single[1].addr;
+                uint16_t *base_addr = (uint16_t *)modbus_single[reg_type].addr;
                 uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[1].offset);
+                base_addr = base_addr + (addr - modbus_single[reg_type].offset);
                 uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                printf("step = %d   base_addr = 0x%x  map_addr = 0x%x\n", step,base_addr,map_addr);
-                if(lenth < 126)
+                if(num < 126)
                 {
-                        pthread_mutex_lock(&cas->mutex);
-                        memcpy(map_addr, base_addr,2*lenth);
-                        pthread_mutex_unlock(&cas->mutex);
+                    pthread_mutex_lock(&cas->mutex);
+                    memcpy(map_addr, base_addr,2*num);
+                    pthread_mutex_unlock(&cas->mutex);
                 }
-            }
-            break;
-            case 4769 ... 4778:
+            }else
             {
-                uint32_t *base_addr = (uint32_t *)modbus_single[2].addr;
+                uint32_t *base_addr = (uint32_t *)modbus_single[reg_type].addr;
                 uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[2].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if(lenth < 126)
+                base_addr = base_addr + (addr - modbus_single[reg_type].offset);
+                uint32_t *map_addr = (uint32_t *)&(cas->map->tab_registers[step]);
+                if(num < 126)
                 {
-                        pthread_mutex_lock(&cas->mutex);
-                        memcpy(map_addr, base_addr,2*lenth);
-                        pthread_mutex_unlock(&cas->mutex);
+                    pthread_mutex_lock(&cas->mutex);
+                    memcpy(map_addr, base_addr,2*num);
+                    pthread_mutex_unlock(&cas->mutex);
                 }
             }
-            break;
-            case 4779 ... 4842:
-            {
-                uint16_t *base_addr = (uint16_t *)modbus_single[3].addr;
-                uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[3].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if(lenth < 126)
-                {
-                        pthread_mutex_lock(&cas->mutex);
-                        memcpy(map_addr, base_addr,2*lenth);
-                        pthread_mutex_unlock(&cas->mutex);
-                }               
-            }
-            break;
-            case 4843 ... 4906:
+        }
+    }else
+    {
+        if(addr >= TREE_DEV_CHN_REG && addr <= TREE_ALL_SET_SWITCH_REG) {
+            if(type == TYPE_U16)
             {
-                uint16_t *base_addr = (uint16_t *)modbus_single[4].addr;
+                uint16_t *base_addr = (uint16_t *)modbus_three[reg_type].addr;
                 uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[4].offset);
+                base_addr = base_addr + (addr - modbus_three[reg_type].offset);
                 uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
+                if(num < 126)
                 {
                     pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
+                    memcpy(map_addr, base_addr,2*num);
                     pthread_mutex_unlock(&cas->mutex);
                 }
-            }
-            break;
-            case 4907 ... 4970:
+            }else
             {
-                uint16_t *base_addr = (uint16_t *)modbus_single[5].addr;
+                uint32_t *base_addr = (uint32_t *)modbus_three[reg_type].addr;
                 uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[5].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
+                base_addr = base_addr + (addr - modbus_three[reg_type].offset);
+                uint32_t *map_addr = (uint32_t *)&(cas->map->tab_registers[step]);
+                if(num < 126)
                 {
                     pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
+                    memcpy(map_addr, base_addr,2*num);
                     pthread_mutex_unlock(&cas->mutex);
                 }
             }
+        }
+    }
+}
+
+void cascade_slave_read(cascade_handle_t *cas,uint32_t addr,uint32_t lenth)
+{
+
+        switch (addr)
+        {
+            case 4000:
+                slave_read(cas,addr,lenth,DS_R_DEV_CHN,TYPE_U16);
             break;
-            case 4971 ... 4999:
-            {
-                
-            }
+            case 4001 ... 4768:
+                slave_read(cas,addr,lenth,DS_R_OUT_INFO,TYPE_U32);
+            break;
+            case 4769 ... 4776:
+                slave_read(cas,addr,lenth,DS_R_IN_TOTAL,TYPE_U32);
+            break;
+            case 4777 ... 4778:
+                slave_read(cas,addr,lenth,DS_R_TEMP_HUM,TYPE_U32);
+            case 4779 ... 4842:
+                slave_read(cas,addr,lenth,DS_R_SWITCH_STA,TYPE_U16);
+            break;
+            case 4843 ... 4906:
+                slave_read(cas,addr,lenth,DS_R_OPEN_DELAY,TYPE_U16);
+            break;
+            case 4907 ... 4970:
+                slave_read(cas,addr,lenth,DS_R_CLOSE_DELAY,TYPE_U16);
             break;
             case 5000 ... 5063:
-            {
-                uint16_t *base_addr = (uint16_t *)modbus_single[6].addr;
-                uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[6].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
-                {
-                    pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
-                    pthread_mutex_unlock(&cas->mutex);
-                }
-            }
+                slave_read(cas,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
             break;
             case 5064 ... 5127:
-            {
-                uint16_t *base_addr = (uint16_t *)modbus_single[7].addr;
-                uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[7].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
-                {
-                    pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
-                    pthread_mutex_unlock(&cas->mutex);
-                }
-            }
+                slave_read(cas,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
             break;
             case 5128 ... 5191:
-            {
-                uint16_t *base_addr = (uint16_t *)modbus_single[8].addr;
-                uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[8].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
-                {
-                    pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
-                    pthread_mutex_unlock(&cas->mutex);
-                }
-            }
+                slave_read(cas,addr,lenth,DS_W_CHN_SWITCH_STA,TYPE_U16);
             break;
             case 5192 :
-            {
-                uint16_t *base_addr = (uint16_t *)modbus_single[9].addr;
-                uint32_t step = addr - cas->map->start_registers;
-                base_addr = base_addr + (addr - modbus_single[9].offset);
-                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
-                if (lenth < 126)
-                {
-                    pthread_mutex_lock(&cas->mutex);
-                    memcpy(map_addr, base_addr, 2 * lenth);
-                    pthread_mutex_unlock(&cas->mutex);
-                }
-            }
+                slave_read(cas,addr,lenth,DS_W_ALL_CHN_STA,TYPE_U16);
+            break;
+
+            // triple
+            case 6000:
+                slave_read(cas,addr,lenth,TREE_R_DEV_CHN,TYPE_U16);
+            break;
+            case 6001 ... 6008:
+                slave_read(cas,addr,lenth,TREE_R_INPUT_ALL_A,TYPE_U32);
+            break;
+            case 6009 ... 6016:
+                slave_read(cas,addr,lenth,TREE_R_INPUT_ALL_B,TYPE_U32);
+            break;
+            case 6017 ... 6024:
+                slave_read(cas,addr,lenth,TREE_R_INPUT_ALL_C,TYPE_U32);
+            break;
+            case 6025 ... 6664:
+                slave_read(cas,addr,lenth,TREE_R_CHN_TOTAL,TYPE_U32);
+            break;
+            case 6665 ... 8584:
+                slave_read(cas,addr,lenth,TREE_R_CHN_PH_INFO,TYPE_U32);
+            break;
+            case 8585 ... 8586:
+                slave_read(cas,addr,lenth,TREE_R_TEMP_HUM,TYPE_U16);
+            break;
+            case 8587 ... 8650:
+                slave_read(cas,addr,lenth,TREE_R_SWITCH_STA,TYPE_U16);
+            break;
+            case 8651 ... 8714:
+                slave_read(cas,addr,lenth,TREE_R_OPEN_DELAY,TYPE_U16);
+            break;
+            case 8715 ... 8778:
+                slave_read(cas,addr,lenth,TREE_R_CLOSE_DELAY,TYPE_U16);
             break;
         default:
             break;
         }
-    }
 }
 
 
@@ -226,13 +309,14 @@ void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val)
 {   
     GlobalDeviceManager* mgr = get_dm();
     uint16_t buff[128] = {0};
-    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC || mgr->_global_device_info->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)
         {
             case 5000 ... 5063:
             {
-                int start_chn = addr - modbus_single[6].offset;
+                int start_chn = addr - modbus_single[DS_W_OPEN_DELAY].offset;
                 GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                 list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                 {
@@ -263,7 +347,7 @@ void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val)
             break;
             case 5064 ... 5127:
             {
-                 int start_chn = addr - modbus_single[7].offset;
+                 int start_chn = addr - modbus_single[DS_W_CLOSE_DELAY].offset;
                 GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                 list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                 {
@@ -295,7 +379,7 @@ void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val)
             break;
             case 5128 ... 5191:
             {
-                int start_chn = addr - modbus_single[8].offset;
+                int start_chn = addr - modbus_single[DS_W_CHN_SWITCH_STA].offset;
                 GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                 if (val == 0 || val == 1)
                 {
@@ -310,7 +394,7 @@ void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val)
                                                                 _globalPowerMangerTemp->product_ch_addr,
                                                                 val, false);
                             //  printf("ret = %d 0x%x\n",ret,val);
-                            *(uint16_t *)((uint16_t *)(modbus_single[8].addr) + start_chn) = val;
+                            *(uint16_t *)((uint16_t *)(modbus_single[DS_W_CHN_SWITCH_STA].addr) + start_chn) = val;
                             break;
                         }
                     }
@@ -329,11 +413,180 @@ void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t 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);
                     }
-                    *(uint16_t *)(modbus_single[9].addr) = 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;
+                        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree)
+                        {
+                            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;
+                        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree)
+                        {
+                            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_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 t_ac_CtrlType=0;
+                        int nRet = 0;
+                        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._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree)
+                        {
+                            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._global_device_info->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;
+                        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;
         }

pro/src/common.h

@@ -669,26 +669,67 @@ typedef struct cascade_single_mmap{
 
 #pragma pack ()
 
-typedef struct pw_info_dc{
-    uint32_t o_valtage;
+
+#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;
-}pw_info_dc_t;
+    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_dc_mmap{
+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;
-    uint32_t i_valtage;
-    uint32_t i_current;
-    uint32_t i_power;
-    uint32_t i_consumption;
-    pw_info_dc_t o_pw_info[64];
-}cascade_dc_mmap_t;
+    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;            //电压低阈值检测使能
@@ -741,6 +782,7 @@ typedef struct
     pthread_mutex_t     _power_ds;        //定时器锁 
     pthread_mutex_t     _power_update;        //数据刷新锁
     cascade_single_mmap_t *single_mmap;
+    cascade_triphasic_mmap_t *triphasic_mmap;
 }GlobalDeviceManager;
 GlobalDeviceManager __globalDeviceManage;
 GlobalDeviceManager __globalDeviceManage2;