合并李毅代码

pro/CMakeLists.txt

@@ -71,6 +71,7 @@ set(PDU_SRC_LIST
 	${PROJECT_SOURCE_DIR}/src/xlist.c
 	${PROJECT_SOURCE_DIR}/src/thread.c
 	${PROJECT_SOURCE_DIR}/src/cascade.c
+        ${PROJECT_SOURCE_DIR}/src/cascade_slave.c
 	${PROJECT_SOURCE_DIR}/src/main.c
 
 	${PROJECT_SOURCE_DIR}/src/language_hashmap.c

pro/src/app.c

@@ -141,6 +141,7 @@ void* power_thread(void* arg)
             usleep(usleepTime);
         }
         bool SaveDBFlag=false; //数据库存储记录，只要有通道存，就存一次总通道数据  
+        int _chn = 0;
         list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
         {
             #if(1)
@@ -160,6 +161,38 @@ void* power_thread(void* arg)
             memcpy(&_globalPowerInfo._power_info,
             &_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
             sizeof(PowerInfo));
+            if(_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_AC)
+            {
+                // printf("we get current SmartPDU_AC channel %d data,and consumption=%0.2f voltage=%0.2f current=%0.2f ...\n",
+                //                                                             _chn,
+                //                                                             _globalPowerInfo._power_info.consumption
+                //                                                             ,_globalPowerInfo._power_info.voltage
+                //                                                             ,_globalPowerInfo._power_info.current
+                //                                                             );
+                _globalDeviceManager->single_mmap->all_ch[_chn].consumption = _globalPowerInfo._power_info.consumption * 1000;
+                _globalDeviceManager->single_mmap->all_ch[_chn].voltage = _globalPowerInfo._power_info.voltage * 1000;
+                _globalDeviceManager->single_mmap->all_ch[_chn].factor = _globalPowerInfo._power_info.factor * 1000;
+                _globalDeviceManager->single_mmap->all_ch[_chn].freq = _globalPowerInfo._power_info.freq * 1000;
+                _globalDeviceManager->single_mmap->all_ch[_chn].power = _globalPowerInfo._power_info.power *1000;
+                _globalDeviceManager->single_mmap->all_ch[_chn].current = _globalPowerInfo._power_info.current *1000;
+                _globalDeviceManager->single_mmap->chn_status[_chn] = _globalPowerInfo._power_info.status;
+            }else if(_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_DC)
+            {
+                // printf("we get current SmartPDU_DC channel %d data,and consumption=%0.2f voltage=%0.2f current=%0.2f ...\n",
+                //                                                             _chn
+                //                                                             ,_globalPowerInfo._power_info.consumption
+                //                                                             ,_globalPowerInfo._power_info.voltage
+                //                                                             ,_globalPowerInfo._power_info.current
+                //                                                             );
+                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_consumption = _globalPowerInfo._power_info.consumption *1000;
+                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_valtage = _globalPowerInfo._power_info.voltage * 1000;
+                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_current = _globalPowerInfo._power_info.current * 1000;
+                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_power = _globalPowerInfo._power_info.power *1000;
+                
+            }else{
+
+            }
+            _chn+=1;
             memcpy(&_globalPowerWarningInfo,
             &_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
             sizeof(PowerInfo));
@@ -561,6 +594,22 @@ void* power_thread(void* arg)
             isErrorBreak=false;
 
         }
+
+        //all 
+        if(__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_AC)
+        {
+            __globalDeviceManage.single_mmap->total_current = _globalTotalPowerInfo._power_info.current;
+            __globalDeviceManage.single_mmap->total_power = _globalTotalPowerInfo._power_info.power;
+            __globalDeviceManage.single_mmap->total_valtage = _globalTotalPowerInfo._power_info.voltage;
+            __globalDeviceManage.single_mmap->dev_chn = __globalDeviceManage._global_device_info->product_pwr_type << 8 | _chn;
+        }else if(__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_DC)
+        {
+            __globalDeviceManage.dc_mmap->i_valtage = _globalTotalPowerInfo._power_info.voltage;
+            __globalDeviceManage.dc_mmap->i_power = _globalTotalPowerInfo._power_info.power;
+            __globalDeviceManage.dc_mmap->i_current = _globalTotalPowerInfo._power_info.current;
+            __globalDeviceManage.dc_mmap->i_consumption = _globalTotalPowerInfo._power_info.consumption;
+            __globalDeviceManage.dc_mmap->dev_chn = __globalDeviceManage._global_device_info->product_pwr_type << 8 | _chn;
+        }
         //输入数据再处理（三项）
         //memset(_pTreeACPowerMangerTemp,0,sizeof(GlobalTreeACManager));
         if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
@@ -774,7 +823,11 @@ 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->single_mmap->total_humidity = humidity * 1000;
+                    _globalDeviceManager->single_mmap->total_temp = temperature * 1000;
+                }
                 if (_globalDeviceManager->_global_device_info->product_type == 2)
                  {
                     // modbus_mapping_t *mb_mapping = _globalDeviceManager->_global_Slave_Modbus.mmp;
@@ -846,7 +899,7 @@ void* shm_thread(void *arg)
         fd = shm_open("/smartPDU_shm", O_RDWR, 0666);
         if (fd < 0)
         {
-            //printf("error open shm object\n");
+            printf("error open shm object\n");
             sleep(5); // 延时5秒后再次创建
             continue;
         }
@@ -1059,6 +1112,24 @@ int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
     log_i("device memory init ok.\n");
     //使用的通道
     _globalDeviceManager->useSlaveCount = 0 ;
+    
+    _globalDeviceManager->dc_mmap = (cascade_dc_mmap_t*)malloc(sizeof(cascade_dc_mmap_t));
+    if(_globalDeviceManager->dc_mmap==NULL)
+    {
+        log_e("_global_device_info malloc error.!");
+        //printf("_global_device_info malloc error.\n");
+        return -1 ;       
+    }
+    memset(_globalDeviceManager->dc_mmap, 0, sizeof(cascade_dc_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->dc_mmap, 0, sizeof(cascade_single_mmap_t));
 
     //链接数据库获取配置信息
     sys_get_path(path, DATABASE_NAME);

pro/src/cascade.c

@@ -17,36 +17,20 @@
 #define LOGW            printf
 #endif
 
-#define CASCADE_MAX     10//32
 #define MB_MAX_LEN      250
 
 
-#define MB_MASTER       1
-#define MB_DEBUG
+#define MB_PARA_SIM
+#define SLAVE_DATA_SIM
 
 
+#ifdef MB_PARA_SIM
+    #define MB_MASTER       0
+#endif
 
-typedef struct {
-    
-    int                 inited;
-    pthread_mutex_t     mutex;          //used for list lock     
-    
-    Modbus_Manger       m;
-    int                 addr;
-    slave_t             slaves[CASCADE_MAX+1];
-
-    modbus_mapping_t    *map;
-    modbus_mapping_t    *map2;
 
-    cmd_data_t          cmd;
-    int                 scanAddr;
 
-    board_info_t        info;
-    _OverChnPwrAckInfo  chInfo;
-    _OverAllPwrAckInfo  allInfo;
 
-    power_info_t        pwrInfo;
-}cascade_handle_t;
 
 int cur_dev_addr=1;
 static cascade_handle_t casHandle={.inited=0};
@@ -62,9 +46,8 @@ static inline GlobalDeviceManager* get_dm2(void)
 }
 static inline ModbusInfo_t *get_mb(void)
 {
+#ifdef MB_PARA_SIM
     static ModbusInfo_t mbinfo={
-
-#ifdef MB_DEBUG
     #if (MB_MASTER==1)
         .product_modbus_type=0,
     #else
@@ -117,34 +100,53 @@ static int slave_find(cascade_handle_t *cas, int addr)
     return 0;
 }
 
-static int slave_get_info(cascade_handle_t *cas)
+static int slave_get_info(cascade_handle_t *cas, int hardread)
 {
-    int i,r;
+    int i,j,r;
     uint8_t type,maxChn;
+    GlobalPowerManger *tmp=NULL;
     GlobalDeviceManager *dm=get_dm();
     board_info_t *info=&cas->info;
 
     memset(info, 0, sizeof(board_info_t));
 
-#ifdef MB_DEBUG
-    for(i=1; i<MAX_CHN_COUNT; i++) {
-        info->board[info->cnt].addr   = i;
-        info->board[info->cnt].type   = 2;
-        info->board[info->cnt].maxChn = 5;
+#ifdef SLAVE_DATA_SIM
+    for(j=1; j<10; j++) {
+        info->board[info->cnt].addr   = 1;
+        info->board[info->cnt].type   = 3;
+        info->board[info->cnt].ch_addr = 4;
         info->cnt++;
     }
 #else
-    for(i=1; i<MAX_CHN_COUNT; i++) {
-        r = g_switch_get_type(&dm->_globalRelaySampManger, i, &type, &maxChn,
-                               dm->_global_device_info->product_pwr_type);
-        if(r==0) {
-            info->board[info->cnt].addr   = i;
-            info->board[info->cnt].type   = type;
-            info->board[info->cnt].maxChn = maxChn;
+    if(hardread) {
+        for(i=1; i<MAX_CHN_COUNT; i++) {
+            r = g_switch_get_type(&dm->_globalRelaySampManger, i, &type, &maxChn,
+                                dm->_global_device_info->product_pwr_type);
+            if(r==0) {
+                for(j=0; j<maxChn; j++) {
+                    info->board[info->cnt].addr   = i;
+                    info->board[info->cnt].type   = type;
+                    info->board[info->cnt].ch_addr = j+1;
+                    info->cnt++;
+                }
+            }
+        }
+    }
+    else {
+        list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
+        {
+            if(tmp->product_saddr==0) {
+                continue;
+            }
+
+            info->board[info->cnt].addr   = tmp->product_saddr;
+            info->board[info->cnt].type   = tmp->product_ch_type;
+            info->board[info->cnt].ch_addr = tmp->product_ch_addr;
             info->cnt++;
         }
     }
 #endif
+    LOGD("___ slave_get_info addr, cnt: %d\n", info->cnt);
 
     return 0;
 }
@@ -219,7 +221,7 @@ static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32
 
             cas->addr = addr;
             g_modbus_set_slave(&cas->m, addr);
-            slave_get_info(cas);
+            cascade_slave_map_init(cas);
         }
         else {
             cas->addr = 0;
@@ -310,6 +312,10 @@ static int mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
 
         memswap(h->data, h->dlen+h->dlen%2);
     }
+    else {
+        h->dlen = 2;
+        h->data = &data[4];
+    }
 
     return 0;
 }
@@ -436,7 +442,6 @@ static int mb_receive(cascade_handle_t *cas)
         if(h.data) {
             cmd_data_t *cmd = (cmd_data_t*)h.data;
             cas->cmd = *cmd;
-            print_cmd("slave", cmd);
 
             precmd  = cmd->cmd;
             sendlen = 0;
@@ -444,6 +449,7 @@ static int mb_receive(cascade_handle_t *cas)
 
         if(h.reg==CASCADE_REG_WRITE) {
         
+            LOGD("____ CASCADE_REG_WRITE, %d\n", cas->cmd.cmd);
             switch(cas->cmd.cmd) {
                 case CASCADE_CMD_OPEN:
                 case CASCADE_CMD_CLOSE:
@@ -481,17 +487,20 @@ static int mb_receive(cascade_handle_t *cas)
 
             r = _mb_reply(cas, buff, r, cas->map2);
         }
-        else if(h.reg==CASCADE_REG_READ) {
+        else {
             if(h.regcnt==1) {
+                LOGD("____ CASCADE SCAN\n");
                 r = _mb_reply(cas, buff, r, cas->map2);
             }
             else {
+
+                LOGD("____ CASCADE_REG_READ %d\n", cas->cmd.cmd);
                 switch(cas->cmd.cmd) {
 
                     case CASCADE_CMD_GET_INFO:
                     {
                         LOGD("_____ slave CASCADE_CMD_GET_INFO\n");
-                        //slave_get_info(cas);      //this function will cost long time, marked it
+                        slave_get_info(cas, 0);      //hardread will cost long time
                         memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), (char*)&cas->info, h.regcnt*2);
                     }
                     break;
@@ -525,13 +534,18 @@ static int mb_receive(cascade_handle_t *cas)
                 }
             }
         }
-        else {
-            r = _mb_reply(cas, buff, r, cas->map2);
-        }
     }
     else {
         Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;
-        //g_switch_set_all_ctrl(mm,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
+
+        LOGD("___ slave XXXXXXXXXXX\n");
+
+        if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
+            cascade_slave_read(cas, h.reg, h.regcnt);
+        }
+        else if(h.func==MODBUS_FC_WRITE_SINGLE_REGISTER) {
+            cascade_slave_write(cas, h.reg, h.regcnt);
+        }
 
         r = _mb_reply(cas, buff, r, cas->map);
     }
@@ -608,32 +622,29 @@ static int power_add(cascade_handle_t *cas)
     GlobalPowerManger* pm=NULL;
     board_info_t *info=&cas->info;
 
+    LOGD("__**___ master add channel to the list, cnt: %d\n", info->cnt);
     cascade_lock();
 
     power_clear(cas);
-    LOGD("_____ master add channel to the list, cnt: %d\n", info->cnt);
-
     for(i=0; i<info->cnt; i++) {
-        for (j=0; j<info->board[i].maxChn; j++) {
-            pm = (GlobalPowerManger*)calloc(1, sizeof(GlobalPowerManger));
-            if(!pm) {
-                return -1;
-            }
-            
-            pm->product_id = dm2->_global_device_info->product_id;
-            pm->product_saddr = info->board[i].addr;
-            pm->product_ch_id = chn;
-            pm->product_ch_addr = j+1;
-            sprintf(pm->product_ch_name,"CH%d",pm->product_ch_id);
-            pm->product_ch_type = info->board[i].type;
-            pm->product_ch_status = 0;
-
-            pm->product_ch_start_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
-            pm->product_ch_stop_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
-        
-            list_add_tail(&pm->list,&dm2->_globalPowerManger.list);
-            chn++;
+        pm = (GlobalPowerManger*)calloc(1, sizeof(GlobalPowerManger));
+        if(!pm) {
+            return -1;
         }
+        
+        pm->product_id = dm2->_global_device_info->product_id;
+        pm->product_saddr = info->board[i].addr;
+        pm->product_ch_id = i;
+        pm->product_ch_addr = info->board[i].ch_addr;
+        sprintf(pm->product_ch_name,"CH%d",pm->product_ch_id);
+        pm->product_ch_type = info->board[i].type;
+        pm->product_ch_status = 0;
+
+        pm->product_ch_start_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
+        pm->product_ch_stop_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
+    
+        list_add_tail(&pm->list,&dm2->_globalPowerManger.list);
+        chn++;
     }
     cascade_unlock();
 

pro/src/cascade.h

@@ -5,6 +5,7 @@
 #include "common.h"
 #include "json_handle.h"
 
+#define CASCADE_MAX                     10//32
 #define ERR_MAX                         5
 
 #define MAX_READ_REGS                   1000
@@ -102,9 +103,9 @@ typedef struct {
 typedef struct {
     struct {
         uint8_t     addr;
+        uint8_t     ch_addr;
         uint8_t     type;
-        uint8_t     maxChn;
-    }board[MAX_CHN_COUNT];
+    }board[128];
     uint8_t         cnt;
 }board_info_t;
 
@@ -146,6 +147,36 @@ typedef struct {
 
 #pragma pack ()
 
+////////slave define////////////////////
+typedef struct mmap_modbus{
+    int offset;
+    void *addr;             //libmodbus source   addr 
+}mmap_modbus_t;
+//////////////////////////////////////
+
+typedef struct {
+    
+    int                 inited;
+    pthread_mutex_t     mutex;          //used for list lock     
+    
+    Modbus_Manger       m;
+    int                 addr;
+    slave_t             slaves[CASCADE_MAX+1];
+
+    modbus_mapping_t    *map;
+    modbus_mapping_t    *map2;
+
+    cmd_data_t          cmd;
+    int                 scanAddr;
+
+    board_info_t        info;
+    _OverChnPwrAckInfo  chInfo;
+    _OverAllPwrAckInfo  allInfo;
+
+    power_info_t        pwrInfo;
+}cascade_handle_t;
+
+
 extern int cur_dev_addr;
 
 int cascade_init(void);
@@ -158,6 +189,11 @@ int cascade_free_dlist(dev_list_t *dl);
 int cascade_lock(void);
 int cascade_unlock(void);
 
+int cascade_slave_map_init(cascade_handle_t *cas);
+void cascade_slave_read(cascade_handle_t *cas, uint32_t addr,uint32_t lenth);
+void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val);
+
+
 #endif
 
 

pro/src/cascade_slave.c

@@ -0,0 +1,337 @@
+#include "modbus.h"
+#include "common.h"
+#include "list.h"
+#include "switch_ctrl.h"
+#include "cascade.h"
+
+
+
+static inline GlobalDeviceManager* get_dm(void)
+{
+    return &__globalDeviceManage;
+}
+static inline GlobalDeviceManager* get_dm2(void)
+{
+    return &__globalDeviceManage2;
+}
+
+
+static mmap_modbus_t modbus_single[]={
+    {.offset = 4000},
+    {.offset = 4001},
+    {.offset = 4769},
+    {.offset = 4777},
+
+};
+
+ static mmap_modbus_t modbus_dc[]={
+    {.offset = 6000},
+    {.offset = 6001},
+    {.offset = 6002},
+    {.offset = 6003},
+    {.offset = 6004},
+    {.offset = 6005},
+ };
+
+
+
+int cascade_slave_map_init(cascade_handle_t *cas)
+{
+    GlobalDeviceManager* mgr = get_dm();
+
+    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC)       // 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;
+        printf("single address init 4000\n");
+    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
+    {
+        cas->map = modbus_mapping_new_start_address(0,0,0,0,6000,5000,0,0);     //3000 ge
+        modbus_dc[0].addr = &mgr->dc_mmap->dev_chn;
+        modbus_dc[1].addr = &mgr->dc_mmap->i_valtage;
+        modbus_dc[2].addr = &mgr->dc_mmap->i_current;
+        modbus_dc[3].addr = &mgr->dc_mmap->i_power;
+        modbus_dc[4].addr = &mgr->dc_mmap->i_consumption;
+        modbus_dc[5].addr = &mgr->dc_mmap->o_pw_info;
+        printf("dc address init 4000\n");
+    }else
+    {
+        return -1;
+    }
+    return 0;
+}
+
+
+
+void cascade_slave_read(cascade_handle_t *cas,uint32_t addr,uint32_t lenth)
+{
+
+    GlobalDeviceManager* mgr = get_dm();
+    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC)
+    {
+        switch (addr)
+        {
+            case 4000:
+                {
+                    uint32_t *base_addr = (uint32_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:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_single[1].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_single[1].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 4769 ... 4776:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_single[2].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)
+                {
+                        pthread_mutex_lock(&cas->mutex);
+                        memcpy(map_addr, base_addr,2*lenth);
+                        pthread_mutex_unlock(&cas->mutex);
+                }
+            }
+            break;
+            case 4777 ... 4841:
+            {
+                uint32_t *base_addr = (uint32_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;
+        default:
+            break;
+        }
+    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
+    {
+        switch (addr)
+        {
+            case 6000:
+                {
+                    uint32_t *base_addr = (uint32_t *)modbus_dc[0].addr;
+                    uint32_t step = addr - cas->map->start_registers;
+                    base_addr = base_addr + (addr - modbus_dc[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 6001:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_dc[1].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_dc[1].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 6002:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_dc[2].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_dc[2].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 6003:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_dc[3].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_dc[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 6004:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_dc[4].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_dc[4].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 6005 ... 6260:
+            {
+                uint32_t *base_addr = (uint32_t *)modbus_dc[5].addr;
+                uint32_t step = addr - cas->map->start_registers;
+                base_addr = base_addr + (addr - modbus_dc[5].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;
+            default:
+                break;
+        }
+    }
+}
+
+
+
+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)   
+    {
+        switch(addr)
+        {
+            case 5128 ... 5191:
+            {
+                int start_chn = addr - 5128 + 1;
+                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=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);
+                            break;
+                        }
+                }
+
+            }
+            break;
+            case 5192:
+            {
+                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;
+        }
+    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
+    {
+        switch (addr)
+        {
+            case 6756 ... 6819:
+            {
+                int start_chn = addr - 6756 + 1;
+                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=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp,
+                            _globalPowerMangerTemp->product_saddr,
+                            _globalPowerMangerTemp->product_ch_addr, 
+                            val,false);
+                            break;
+                        }
+                    }
+            }
+            break;
+            case 7012:
+            {
+                
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                {
+                    if(_globalPowerMangerTemp==NULL)
+                    break;
+                    if(val == 0x1)
+                        g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
+                }
+            }
+            break;
+            case 7013:
+            {
+                
+                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
+                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+                {
+                    if(_globalPowerMangerTemp==NULL)
+                    break;
+                    if(val == 0x1)
+                        g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,0);
+                }
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}

pro/src/common.h

@@ -25,7 +25,7 @@
 #include <sys/shm.h>
 //#define RS485_TYPE
 
-#define MAX_CHN_COUNT       5//16
+#define MAX_CHN_COUNT       16
 #define MAX_RELAY_CHN       100
 
 //是否在OS环境下运行
@@ -622,6 +622,50 @@ struct modbus_slave_read_reg{
 //    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 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;
+    uint32_t total_temp;
+    uint32_t total_humidity;
+    uint16_t chn_status[64];
+}cascade_single_mmap_t;
+
+
+typedef struct pw_info_dc{
+    uint32_t o_valtage;
+    uint32_t o_current;
+    uint32_t o_power;
+    uint32_t o_consumption;
+}pw_info_dc_t;
+
+
+
+typedef struct cascade_dc_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;
+
+
+
 struct modbus_slave_write_reg{
     uint16_t      voltage_high_enable:1;           //电压高阈值检测使能
     uint16_t       voltage_low_enable:1;            //电压低阈值检测使能
@@ -672,6 +716,8 @@ typedef struct
     struct modbus_slave_write_reg g_modebus_write;
     smartPDU_shm_data* g_shm_Data;
    
+    cascade_dc_mmap_t *dc_mmap;
+    cascade_single_mmap_t *single_mmap;
 }GlobalDeviceManager;
 GlobalDeviceManager __globalDeviceManage;
 GlobalDeviceManager __globalDeviceManage2;