断路器，级联，bug解决，web 显示！！！！！

pro/CMakeLists.txt

@@ -84,6 +84,7 @@ set(PDU_SRC_LIST
 	${PROJECT_SOURCE_DIR}/src/pduMIB_scalar.c
 	${PROJECT_SOURCE_DIR}/src/pduMIB_trap.c
 	${PROJECT_SOURCE_DIR}/src/hlw8110_handle.c
+	${PROJECT_SOURCE_DIR}/src/breaker_detection.c
 	)
 
 set(NO_WARNNING_FLAGS "-Wno-unused-function -Wno-unused-variable -Wno-unused-but-set-variable")

pro/src/app.c

@@ -15,7 +15,7 @@
 #include "cascade.h"
 #include "upg.h"
 #include "sys.h"
-
+#include "breaker_detection.h"
 #include <sys/mman.h>
 #include <string.h>
 #include <fcntl.h>
@@ -1022,6 +1022,35 @@ void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType)
     }
 }
 
+void* breaker_thread(void *arg)
+{
+    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
+    GlobalBreakerManager *temp = NULL;
+    pthread_mutex_init(&_globalDeviceManager->_breaker_mutex,NULL);
+    uint16_t value = 0;
+    while (_globalDeviceManager->dev_samp_flag)
+    {
+        pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+        list_for_each_entry(temp, &_globalDeviceManager->g_new_global_breaker.list,list)
+        {
+            if(temp->breaker_gather_addr != 0)
+            {
+                //485
+                breaker_485_get_chn_status((void*)&_globalDeviceManager->_globalRelaySampManger,
+                    temp->breaker_gather_addr,BREADER_485_ADDR_CHN_REG+temp->breaker_chn,&value);
+                temp->breaker_status = value;
+              //  printf("temp->breaker_gather_addr = %d temp->breaker_chn=%d getchn value = %d\n",temp->breaker_gather_addr,temp->breaker_chn,value);
+            }else
+            {
+                //DI
+            }
+        }
+        pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+        sleep(1);
+    }
+    pthread_exit(NULL);
+}
+
 /// @brief 传感器采集线程
 /// @param arg 
 /// @return 
@@ -2164,7 +2193,7 @@ int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
     
     //初始化传感器列表
     INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);
-
+    INIT_LIST_HEAD(&_globalDeviceManager->g_new_global_breaker.list);
     //获取传感器管理信息 
     /////////////////////////////////////////
     ///todo:此信息需要和数据库更新以后在关联
@@ -2179,12 +2208,22 @@ int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
         log_d("get sensor info ok.");
 
     dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[_globalDeviceManager->_global_device_info->product_language],"sensor");
+    ret =dev_get_breaker_manage_info(_globalDeviceManager->db,_globalDeviceManager->_global_device_info->product_id,
+                &_globalDeviceManager->g_new_global_breaker);
+
+    if(ret!=0)
+    {
+        log_e("not find breaker info.");
+    }
+    else
+        log_d("get breaker info ok.");
     //创建modbus采集线程 继电器控制线程
     #if(OS_HANDWARE==1)
     _globalDeviceManager->dev_samp_flag = true;
     thread_start(THREAD_ID_POWER, power_thread, _globalDeviceManager, 20*MB, 0);
     thread_start(THREAD_ID_SENSOR, sensor_thread, _globalDeviceManager, 10*MB, 0);
     thread_start(THREAD_ID_SHMW, shm_thread, _globalDeviceManager, 10*MB, 0);
+	thread_start(THREAD_ID_BREAKER, breaker_thread, _globalDeviceManager, 5*MB, 0);
         dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[_globalDeviceManager->_global_device_info->product_language],"Server Thread");
     
    #endif

pro/src/appweb_handle.c

@@ -3598,6 +3598,345 @@ static void equipmentMintenance(void *conn)
         dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._global_device_info->product_id, 3, temp);
 
         sys_reboot();
+    }else if(strcmp(_Over_equipment_mintenance.type,"listKgSbQuery")==0)    // part of device infomation 
+    {
+        _OverBackBreakerInfo breaker_info;
+        if (dev_get_device_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info) != 0)
+        {
+            log_e("get device info error.\n");
+            http_reply(conn, 400, NULL);
+            return;
+        }
+        printf("get listKgSbQuery infomation!!!\n");
+        breaker_info.product_id = __globalDeviceManage._global_device_info->product_id;
+        breaker_info.product_name = __globalDeviceManage._global_device_info->product_name;
+        breaker_info.product_number = __globalDeviceManage._global_device_info->product_number;
+        breaker_info.product_type = __globalDeviceManage._global_device_info->product_type;
+        ack_str = over_breaker_product_list_info_to_json(&__globalDeviceManage,&breaker_info,false);
+    }else if(strcmp(_Over_equipment_mintenance.type,"listKgTdQuery")==0)
+    {
+        _OverBreakerChnInfo _over_breaker_chn_info;
+        INIT_LIST_HEAD(&_over_breaker_chn_info.list);
+        //_OverBraekerChnInfo *temp = NULL;
+        GlobalPowerManger * _globalPowerTemp = NULL;
+        int cur_dev_addr = 0;
+        if(_Over_equipment_mintenance.product_id)
+            cur_dev_addr = atoi(_Over_equipment_mintenance.product_id);
+        if(cur_dev_addr)   //slave
+        {
+            // 
+
+        }else{  //zhuji
+            printf("get listKgTdQuery infomation!!!\n");
+            list_for_each_entry(_globalPowerTemp, &__globalDeviceManage._globalPowerManger.list, list)
+            {
+                _OverBreakerChnInfo *temp = (_OverBreakerChnInfo *) malloc(sizeof(_OverBreakerChnInfo));
+                temp->product_id = __globalDeviceManage._global_device_info->product_id;
+                strcpy(temp->product_name,__globalDeviceManage._global_device_info->product_name);
+                strcpy(temp->product_number,__globalDeviceManage._global_device_info->product_number);
+                strcpy(temp->product_ch_name,_globalPowerTemp->product_ch_name);
+                temp->product_ch_id = _globalPowerTemp->product_ch_id;
+                printf("%s %s %s  %d\n",temp->product_name,temp->product_number,temp->product_ch_name,temp->product_ch_id);
+                list_add_tail(&temp->list,&_over_breaker_chn_info.list);
+            }
+        }
+            //参数转换json
+        ack_str = over_all_breaker_chn_info_to_json(&_over_breaker_chn_info,0);
+
+        //释放资源
+        _OverBreakerChnInfo* node;
+        _OverBreakerChnInfo* next;
+        list_for_each_entry_safe(node, next, &_over_breaker_chn_info.list, list)
+        {
+            list_del(&node->list);
+            free(node);
+        } 
+    }else if(strcmp(_Over_equipment_mintenance.type,"listSwitchtatusQuery") == 0)
+    {
+        _OverBreakerSwitchInfo _over_breaker_switch_info;
+        INIT_LIST_HEAD(&_over_breaker_switch_info.list);
+        if(_Over_equipment_mintenance.product_id)
+            cur_dev_addr = atoi(_Over_equipment_mintenance.product_id);
+        if(cur_dev_addr)   //slave
+        {
+            cmd_data_t cmd = {0};
+            int r=0;
+
+            cmd.cmd = CASCADE_CMD_GET_BREAKER_INFO;
+            cmd.obj = OBJ_OVERALL;
+            cascade_request(&cmd);
+
+            // cmd.cmd = CASCADE_CMD_BREAKER_QUERY;
+            // cmd.obj = OBJ_OVERALL;
+            // cascade_request(&cmd);
+            ack_str=ctrl_sts_ack_to_json();
+            // GlobalBreakerManager *temp = NULL;
+            // GlobalDeviceManager *dm = &__globalDeviceManage2;
+            // pthread_mutex_lock(&dm->_breaker_mutex);
+            // list_for_each_entry(temp, &dm->g_new_global_breaker.list, list)
+            // {
+            //     char buff[120];
+            //     printf("get  listSwitchtatusQuery infomation!!!\n");
+            //     _OverBreakerSwitchInfo *info = (_OverBreakerSwitchInfo *) 
+            //                         malloc(sizeof(_OverBreakerSwitchInfo));
+            //     memset(info,0,sizeof(_OverBreakerSwitchInfo));
+            //     info->product_id = temp->product_id;
+            //     sprintf(buff,"Breaker %d",temp->breaker_id);
+            //     strcpy(info->product_ch_name,buff);
+            //     sprintf(buff,"%s %d",__globalDeviceManage._global_device_info->product_name,temp->breaker_id);
+            //     strcpy(info->productName,buff);
+            //     strcpy(info->product_number,__globalDeviceManage._global_device_info->product_number);
+            //     strcpy(info->productChids,temp->breaker_chns_name);
+            //     info->switch_id = temp->breaker_id;
+            //     info->status = temp->breaker_status;
+            //     strcpy(info->cjfs,temp->breaker_gather_type);
+            //     strcpy(info->switch_name,temp->breaker_switch_name);
+            //     strcpy(info->comkh,temp->breaker_com);
+            //     sprintf(buff,"%d",temp->breaker_gather_addr);
+            //     strcpy(info->cjdz,buff);
+            //     sprintf(buff,"%d",temp->breaker_chn);
+            //     strcpy(info->jdh,buff);
+            //     printf("%s %s %s %s %d %d %s %s %s %s\n",
+            //     info->product_ch_name,info->productName,info->product_number,info->productChids,info->switch_id,
+            //     info->status,info->cjfs,info->comkh,info->cjdz,info->jdh);
+            //     list_add_tail(&info->list,&_over_breaker_switch_info.list);
+            // }
+            // pthread_mutex_unlock(&dm->_breaker_mutex);
+            // ack_str = over_all_breaker_switch_info_to_json(&_over_breaker_switch_info,0);
+            // _OverBreakerSwitchInfo* node;
+            // _OverBreakerSwitchInfo* next;
+
+
+
+
+            // list_for_each_entry_safe(node, next, &_over_breaker_switch_info.list, list)
+            // {
+            //     list_del(&node->list);
+            //     free(node);
+            //} 
+        }else   //current 
+        {
+            GlobalBreakerManager *temp = NULL;
+            pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+            list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list)
+            {
+                char buff[20];
+                //printf("get  listSwitchtatusQuery infomation!!!\n");
+                _OverBreakerSwitchInfo *info = (_OverBreakerSwitchInfo *) 
+                                    malloc(sizeof(_OverBreakerSwitchInfo));
+                memset(info,0,sizeof(_OverBreakerSwitchInfo));
+                info->product_id = temp->product_id;
+                sprintf(buff,"Breaker %d",temp->breaker_id);
+                strcpy(info->product_ch_name,buff);
+                strcpy(info->productName,__globalDeviceManage._global_device_info->product_name);
+                strcpy(info->product_number,__globalDeviceManage._global_device_info->product_number);
+                strcpy(info->productChids,temp->breaker_chns_name);
+                info->switch_id = temp->breaker_id;
+                info->status = temp->breaker_status;
+                strcpy(info->cjfs,temp->breaker_gather_type);
+                strcpy(info->switch_name,temp->breaker_switch_name);
+                strcpy(info->comkh,temp->breaker_com);
+                sprintf(buff,"%d",temp->breaker_gather_addr);
+                strcpy(info->cjdz,buff);
+                sprintf(buff,"%d",temp->breaker_chn);
+                strcpy(info->jdh,buff);
+                // printf("%s %s %s %s %d %d %s %s %s %s\n",
+                // info->product_ch_name,info->productName,info->product_number,info->productChids,info->switch_id,
+                // info->status,info->cjfs,info->comkh,info->cjdz,info->jdh);
+                list_add_tail(&info->list,&_over_breaker_switch_info.list);
+            }
+            pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+            printf("_glos_asdsd  addr=0x%x\n",(uint32_t)(&__globalDeviceManage));
+            ack_str = over_all_breaker_switch_info_to_json(&_over_breaker_switch_info,0);
+
+            //释放资源
+            _OverBreakerSwitchInfo* node;
+            _OverBreakerSwitchInfo* next;
+            list_for_each_entry_safe(node, next, &_over_breaker_switch_info.list, list)
+            {
+                list_del(&node->list);
+                free(node);
+            } 
+        }
+    }else if(strcmp(_Over_equipment_mintenance.type,"switchSave") == 0)
+    {
+        if(_Over_equipment_mintenance.product_id)
+            cur_dev_addr = atoi(_Over_equipment_mintenance.product_id);
+        
+        if(cur_dev_addr)   //slave
+        {
+            cmd_data_t cmd;
+            cmd.datas.data.cjdz =  atoi(_Over_equipment_mintenance.cjdz);
+            cmd.datas.data.jdh = atoi(_Over_equipment_mintenance.jdh);
+            strcpy(cmd.datas.data.breaker_chns,_Over_equipment_mintenance.productChids);
+            strcpy(cmd.datas.data.cjfs,_Over_equipment_mintenance.cjfs);
+            strcpy(cmd.datas.data.com,_Over_equipment_mintenance.comkh);
+            cmd.cmd = CASCADE_CMD_BREAKER_SAVE_ADD;
+            cmd.obj = OBJ_OVERALL;
+            cascade_request(&cmd);
+            ack_str=ctrl_sts_ack_to_json();
+        }else
+        {
+            char buff[124] = {0};
+            char id[MAX_BREAKER_ID] = {0};
+            //bianli shujujiegou
+            GlobalBreakerManager *temp = NULL;
+            int i = 1;
+             pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+            list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list)
+            {
+                id[temp->breaker_id] = 1; 
+            }
+            pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+            for(;i < MAX_BREAKER_ID;i++)
+            {
+                if(id[i] == 0)
+                    break;
+            }
+            if(i != MAX_BREAKER_ID)
+            {
+                GlobalBreakerManager *breakerManager = (GlobalBreakerManager*) malloc(sizeof(GlobalBreakerManager));
+                memset(breakerManager,0,sizeof(GlobalBreakerManager));
+                breakerManager->product_id = __globalDeviceManage._global_device_info->product_id;
+                breakerManager->breaker_gather_addr = atoi(_Over_equipment_mintenance.cjdz);
+                strcpy(breakerManager->breaker_com,_Over_equipment_mintenance.comkh);
+                strcpy(breakerManager->breaker_gather_type,_Over_equipment_mintenance.cjfs);
+                
+
+                strcpy(breakerManager->breaker_chns_name,_Over_equipment_mintenance.productChids);
+                sprintf(buff,"Breadker_%d",breakerManager->breaker_id);
+                strcpy(breakerManager->breaker_switch_name,buff);
+                breakerManager->breaker_id =  i;  
+                uint32_t jdh = atoi(_Over_equipment_mintenance.jdh);
+                if(jdh <= MAX_BREAKER_CHN)
+                {
+                    char jdh_flag = 0;
+                    char chn[MAX_BREAKER_CHN] = {0};
+                    pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+                    list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list)
+                    {
+                        if(temp->breaker_gather_addr == breakerManager->breaker_gather_addr)
+                        {
+                            chn[temp->breaker_chn-1] = 1;
+                        }
+                    }
+                    pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+                    if(chn[jdh-1] != 1)
+                    {
+                        breakerManager->breaker_chn = jdh;
+                    }else
+                    {
+                        jdh_flag = 1;
+                    }
+                     
+                    if(jdh_flag == 1)
+                    {
+                        free(breakerManager);
+                        breakerManager = NULL;
+                        ack_str = ctrl_breaker_err_ack_to_json("channel or id is existing!!!!");
+                        
+                    }else{
+                        dev_insert_breaker_genera_manage(__globalDeviceManage.db,breakerManager);
+                        pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+                        list_add_tail(&breakerManager->list,&__globalDeviceManage.g_new_global_breaker.list);
+                        pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+                        ack_str=ctrl_sts_ack_to_json();
+                    }
+                }else {
+                        free(breakerManager);
+                        breakerManager = NULL;
+                        ack_str = ctrl_breaker_err_ack_to_json("jdh error!!!!");
+                    }
+               
+
+            }else
+            {
+                ack_str = ctrl_breaker_err_ack_to_json("ID More 48 !!!!");
+            }
+        }
+    }else if(strcmp(_Over_equipment_mintenance.type,"switchUpdate") == 0)
+    {
+        if(_Over_equipment_mintenance.product_id)
+            cur_dev_addr = atoi(_Over_equipment_mintenance.product_id);
+        if(cur_dev_addr)  ///slave
+        {
+            cmd_data_t cmd;
+            cmd.datas.data1.switch_id = _Over_equipment_mintenance.switchId;
+            strcpy(cmd.datas.data1.breaker_chns,_Over_equipment_mintenance.productChids);
+            strcpy(cmd.datas.data1.switch_name,_Over_equipment_mintenance.switchName);
+            cmd.cmd = CASCADE_CMD_BREAKER_SAVE_UPDATE;
+            cmd.obj = OBJ_OVERALL;
+            cascade_request(&cmd);
+            ack_str=ctrl_sts_ack_to_json();
+        }else
+        {
+            GlobalBreakerManager *temp = NULL;
+            int switch_id = _Over_equipment_mintenance.switchId;
+            pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+            list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list)
+            {
+                if(temp->breaker_id == switch_id)
+                {
+                    strcpy(temp->breaker_switch_name,_Over_equipment_mintenance.switchName);
+                    strcpy(temp->breaker_chns_name,_Over_equipment_mintenance.productChids);
+                    dev_update_breaker_genera_manage(__globalDeviceManage.db,
+                    __globalDeviceManage._global_device_info->product_id,switch_id,temp);
+                    break;
+                }
+            }
+            pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+            ack_str=ctrl_sts_ack_to_json();
+        }
+    }else if(strcmp(_Over_equipment_mintenance.type,"switchDelete") == 0)
+    {
+        if(_Over_equipment_mintenance.product_id)
+            cur_dev_addr = atoi(_Over_equipment_mintenance.product_id);
+        if(cur_dev_addr)  ///slave
+        {
+            cmd_data_t cmd;
+            cmd.datas.data2.switch_id =  _Over_equipment_mintenance.switchId;
+            cmd.cmd = CASCADE_CMD_BREAKER_SAVE_DELETE;
+            cmd.obj = OBJ_OVERALL;
+            cascade_request(&cmd);
+            GlobalBreakerManager* node = NULL;
+            GlobalBreakerManager* next = NULL;
+            pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+            list_for_each_entry_safe(node,next,&__globalDeviceManage2.g_new_global_breaker.list, list)
+            {
+                if(node->breaker_id == _Over_equipment_mintenance.switchId)
+                {
+                    // dev_delete_breaker_manage(__globalDeviceManage2.db,__globalDeviceManage._global_device_info->product_id,
+                    //             _Over_equipment_mintenance.switchId);
+                    list_del(&node->list);
+                    free(node);
+                    break;
+                }
+            }
+            pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+
+            ack_str=ctrl_sts_ack_to_json();
+        }else
+        {
+            int switch_id = _Over_equipment_mintenance.switchId;
+            //GlobalBreakerManager *temp = NULL;
+            GlobalBreakerManager* node;
+            GlobalBreakerManager* next;
+            pthread_mutex_lock(&__globalDeviceManage._breaker_mutex);
+            list_for_each_entry_safe(node,next,&__globalDeviceManage.g_new_global_breaker.list, list)
+            {
+                if(node->breaker_id == switch_id)
+                {
+                    dev_delete_breaker_manage(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,switch_id);
+                    list_del(&node->list);
+                    free(node);
+                    node = NULL;
+                    break;
+                }
+            }
+            pthread_mutex_unlock(&__globalDeviceManage._breaker_mutex);
+            ack_str=ctrl_sts_ack_to_json();
+        }
+
     }
     else if(strcmp(_Over_equipment_mintenance.type,"restoreFactorySettings")==0) {  //restore to factory
 

pro/src/breaker_detection.c

@@ -3,7 +3,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-
+#include "breaker_detection.h"
+#include "modbus_handle.h"
 
 
 
@@ -103,4 +104,58 @@ int breaker_deinit(int gpio)
     write(fd,buff,strlen(buff));
     close(fd);
     return 0;
+}
+
+
+int breaker_485_get_chn_status(void* manger,int saddr,int channel,unsigned short *statue)
+{
+    int ret = 0 ;
+    unsigned short data_temp = 0;
+    ret = g_modbus_read_reg(manger,saddr,channel,&data_temp);
+    if(ret<=0)
+    {
+        printf("erriiiirrr!!!\n");
+        return -1 ;
+    }
+        
+    if(data_temp)
+    {
+        *statue = 0;
+    }else
+    {
+        *statue = 1;
+    }
+    return 0;
+}
+
+int breaker_485_get_all_chn_status(void* manger,int saddr,unsigned short *status)
+{
+    int ret = 0 ;
+    unsigned short data_temp[6] = {0};
+    if(ret <= 0)
+        return -1 ;
+    ret = g_modbus_read_x_reg(manger,saddr,BREADER_485_ADDR_CHN_REG+1,BREAKER_485_CHN_MAX,data_temp);
+    for(int i =0;i < 6;i++)
+    {
+        if(data_temp[i])
+        {
+            status[i] = 0;
+        }else
+        {
+            status[i] = 1;
+        }
+    }
+    return 0;
+}
+
+int breaker_485_get_chns(void* manger,int saddr,unsigned short* cnt)
+{
+    int ret = 0 ;
+    unsigned short data_temp = 0;
+    ret = g_modbus_read_x_reg(manger,saddr,BREADER_485_ADDR_CHN_REG,1,&data_temp);
+    if(ret<=0)
+        return -1 ;
+
+    *cnt = data_temp & 0x00ff;
+    return 0;
 }

pro/src/breaker_detection.h

@@ -10,12 +10,22 @@
 #define BREAKER_IO_4      (BREAKER_IO_BASE+(19))          // 115
 
 
+#define BREAKER_485_CHN_MAX   (6)
 
 
+enum{
+    BREAKER_485_CHN1 = 1,
+    BREAKER_485_CHN2,
+    BREAKER_485_CHN3,
+    BREAKER_485_CHN4,
+    BREAKER_485_CHN5,
+    BREAKER_485_CHN6,
+};
 
 
+#define BREADER_485_ADDR     (64)
 
-
+#define BREADER_485_ADDR_CHN_REG        (2200)
 
 
 
@@ -24,5 +34,9 @@ int breaker_init(int gpio);
 int breaker_deinit(int gpio);
 int breaker_read_status(int gpio);
 
+int breaker_485_get_chns(void* manger,int saddr,unsigned short* cnt);
+int breaker_485_get_chn_status(void* manger,int saddr,int channel,unsigned short *statue);
+int breaker_485_get_all_chn_status(void* manger,int saddr,unsigned short *status);
+
 #endif
 

pro/src/cascade.c

@@ -46,12 +46,13 @@ typedef struct {
     int                 scanAddr;
 
     slave_info_t        sInfo;      //current slave infomation
-
+    breaker_info_t      sBreaker;
     handle_t            list;
 }cascade_handle_t;
 
 int cur_dev_addr=0;
 static cascade_handle_t casHandle={.inited=0};
+static cascade_handle_t casHandle_breaker={.inited=0};
 static void* cmd_thread(void *arg);
 
 //////////////////////////////////////////////////
@@ -198,6 +199,40 @@ static int slave_get_info(cascade_handle_t *cas)
     return 0;
 }
 
+static int slave_breaker_info(cascade_handle_t *cas)
+{
+    GlobalDeviceManager *dm=get_dm();
+    GlobalBreakerManager *temp = NULL;
+    breaker_info_t *breaker=&cas->sBreaker;
+    int cnt = 0;
+    //list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list)
+    pthread_mutex_lock(&dm->_breaker_mutex);
+    if(!list_empty(&dm->g_new_global_breaker.list)) {
+        printf("isnot empty!!!!!\n");
+        list_for_each_entry(temp,&dm->g_new_global_breaker.list, list)
+        {   
+            // printf("temp addr %ld temp->next = %ld temp->prev = %ld\n",tmp,tmp->list.prev,tmp->list.next);
+            breaker ->breaker_chn[cnt].product_id = temp->product_id;
+            breaker->breaker_chn[cnt].breaker_addrs = temp->breaker_gather_addr;
+            breaker->breaker_chn[cnt].breaker_status = temp->breaker_status;
+            breaker->breaker_chn[cnt].breaker_chn = temp->breaker_chn;
+            breaker->breaker_chn[cnt].breaker_id = temp->breaker_id;
+            strcpy(breaker->breaker_chn[cnt].breaker_gather_type, temp->breaker_gather_type);
+            strcpy(breaker->breaker_chn[cnt].breaker_com, temp->breaker_com);
+            strcpy(breaker->breaker_chn[cnt].breaker_switch_name, temp->breaker_switch_name);
+            strcpy(breaker->breaker_chn[cnt].breaker_chns_name, temp->breaker_chns_name);
+            cnt++;
+        }
+        
+    }
+    breaker->cnt = cnt;
+    pthread_mutex_unlock(&dm->_breaker_mutex);
+    
+    LOGD("___ slave_breaker_info, breaker_all: saddr=0x%x %d\n",(uint32_t)dm,breaker->cnt);
+
+    return 0;
+}
+
 static int get_pwr_info(int chId, GlobalPowerManger *power)
 {
     int i;
@@ -221,6 +256,170 @@ static int get_pwr_info(int chId, GlobalPowerManger *power)
 
     return -1;
 }
+
+
+static int slave_breaker_update(cascade_breaker_update_t *data)
+{
+    int ret = -1;
+    if(data)
+    {
+        GlobalDeviceManager *dm=get_dm();
+        GlobalBreakerManager *temp= NULL;
+        GlobalBreakerManager *pos= NULL;
+        pthread_mutex_lock(&dm->_breaker_mutex);
+        if(!list_empty(&dm->g_new_global_breaker.list)) {
+            
+            list_for_each_entry_safe(temp,pos,&dm->g_new_global_breaker.list,list)
+            {
+                if(temp->breaker_id == data->switch_id)
+                {
+                    strcpy(temp->breaker_switch_name,data->switch_name);
+                    strcpy(temp->breaker_chns_name,data->breaker_chns);
+                    dev_update_breaker_genera_manage(dm->db,
+                    dm->_global_device_info->product_id,data->switch_id,temp);
+                    ret = 0;
+                    break;
+                }
+            }
+        }
+        pthread_mutex_unlock(&dm->_breaker_mutex);
+        
+    }
+    return ret;
+}
+
+static int slave_breaker_delete(cascade_braeker_delete_t *data)
+{
+    int ret = -1;
+    if(data)
+    {
+        GlobalDeviceManager *dm=get_dm();
+        GlobalBreakerManager *temp= NULL;
+        GlobalBreakerManager *pos= NULL;
+        pthread_mutex_lock(&dm->_breaker_mutex);
+        if(!list_empty(&dm->g_new_global_breaker.list)) {
+            
+            list_for_each_entry_safe(temp,pos,&dm->g_new_global_breaker.list,list)
+            {
+                printf("new data !!!!\n");
+
+                if(temp == NULL)
+                {
+                    continue;
+                }
+                if(temp->breaker_id == data->switch_id)
+                {
+                    dev_delete_breaker_manage(dm->db,dm->_global_device_info->product_id,data->switch_id);
+                    list_del(&temp->list);
+                    free(temp);
+                    if(!list_empty(&dm->g_new_global_breaker.list))
+                    {
+                        printf("hellosda\n");
+                    }
+                    ret = 0;
+                    break;
+                }
+            }
+            
+        }
+        pthread_mutex_unlock(&dm->_breaker_mutex);
+    }
+    return ret;
+}
+
+
+
+static int slave_breaker_add(cascade_breaker_add_t *data)
+{
+    int r = -1;
+    if(!data)
+    {
+        goto quit;
+    }
+    
+    GlobalDeviceManager *dm=get_dm();
+    char buff[124] = {0};
+    char id[MAX_BREAKER_ID] = {0};
+            //bianli shujujiegou
+    GlobalBreakerManager *temp = NULL;
+    int i = 1;
+    pthread_mutex_lock(&dm->_breaker_mutex);
+    list_for_each_entry(temp, &dm->g_new_global_breaker.list, list)
+    {           
+        id[temp->breaker_id] = 1; 
+    }
+    pthread_mutex_unlock(&dm->_breaker_mutex);
+    for(;i < MAX_BREAKER_ID;i++)
+    {
+        if(id[i] == 0)
+        break;
+    }
+        if(i > MAX_BREAKER_ID)
+        {
+            goto quit;
+        }
+        GlobalBreakerManager *breakerManager = (GlobalBreakerManager*) malloc(sizeof(GlobalBreakerManager));
+        memset(breakerManager,0,sizeof(GlobalBreakerManager));
+        breakerManager->product_id = __globalDeviceManage._global_device_info->product_id;
+        breakerManager->breaker_gather_addr = data->cjdz;
+        strcpy(breakerManager->breaker_com,data->com);
+        strcpy(breakerManager->breaker_gather_type,data->cjfs);
+        strcpy(breakerManager->breaker_chns_name,data->breaker_chns);
+
+        breakerManager->breaker_id =  i; 
+        sprintf(buff,"Breaker_%d",breakerManager->breaker_id);
+        strcpy(breakerManager->breaker_switch_name,buff);
+        
+
+        uint32_t jdh = data->jdh;
+
+        if(jdh > MAX_BREAKER_CHN)
+        {
+            goto quit2;
+        }
+
+        char jdh_flag = 0;
+
+        char chn[MAX_BREAKER_CHN] = {0};
+        pthread_mutex_lock(&dm->_breaker_mutex);
+        list_for_each_entry(temp, &dm->g_new_global_breaker.list, list)
+        {
+            if(temp->breaker_gather_addr == breakerManager->breaker_gather_addr)
+            {
+                chn[temp->breaker_chn-1] = 1;
+            }
+        }
+        pthread_mutex_unlock(&dm->_breaker_mutex);
+
+        if(chn[jdh-1] != 1)
+        {
+            breakerManager->breaker_chn = jdh;
+        }else
+        {
+            jdh_flag = 1;
+        }
+        
+        if(jdh_flag == 1)
+        {
+            goto quit2;
+        }else{
+            dev_insert_breaker_genera_manage(dm->db,breakerManager);
+            pthread_mutex_lock(&dm->_breaker_mutex);
+            list_add_tail(&breakerManager->list,&dm->g_new_global_breaker.list);
+            pthread_mutex_unlock(&dm->_breaker_mutex);
+            r = 0;
+        }
+
+    return r;
+
+quit2:
+    free(breakerManager);
+    breakerManager = NULL;
+quit:
+    return r;
+}
+
+
 static int slave_save(cascade_handle_t *cas)
 {
     int r;
@@ -543,6 +742,26 @@ static int mb_receive(cascade_handle_t *cas)
                     slave_save(cas);
                 }
                 break;
+                case CASCADE_CMD_BREAKER_SAVE_ADD:
+                {
+                    LOGD("_____ slave CASCADE_CMD_BREAKER_SAVE_ADD\n");
+                    LOGD("%d %d %s %s %s\n",cmd->datas.data.jdh,cmd->datas.data.cjdz,cmd->datas.data.cjfs,cmd->datas.data.com,cmd->datas.data.breaker_chns);
+                    slave_breaker_add(&cmd->datas.data);
+
+                }
+                break;
+                case CASCADE_CMD_BREAKER_SAVE_UPDATE:
+                {
+                    LOGD("_____ slave CASCADE_CMD_BREAKER_SAVE_UPDATE\n");
+                    LOGD("%d %s %s\n",cmd->datas.data1.switch_id,cmd->datas.data1.switch_name,cmd->datas.data1.breaker_chns);
+                    slave_breaker_update(&cmd->datas.data1);
+                }
+                break;
+                case CASCADE_CMD_BREAKER_SAVE_DELETE:
+                {
+                    LOGD("_____ slave CASCADE_CMD_BREAKER_SAVE_DELETE\n");
+                    slave_breaker_delete(&cmd->datas.data2);
+                }
             }
 
             r = _mb_reply(cas, buff, rc, cas->map);
@@ -563,6 +782,13 @@ static int mb_receive(cascade_handle_t *cas)
                     memcpy(cas->map->tab_registers+(h.reg-CASCADE_REG_OFFSET), (char*)&cas->sInfo+sendlen, h.regcnt*2);
                 }
                 break;
+                case CASCADE_CMD_BREAKER_QUERY:
+                {
+                    LOGD("_____ slave CASCADE_CMD_GET_INFO\n");
+                    slave_breaker_info(cas);
+                    memcpy(cas->map->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->sBreaker)+sendlen, h.regcnt*2);
+                }
+                break;
 
                 case CASCADE_CMD_QUERY_CH:
                 {
@@ -580,6 +806,13 @@ static int mb_receive(cascade_handle_t *cas)
                 case CASCADE_CMD_QUERY_HIS:break;
                 case CASCADE_CMD_QUERY_TOTAL:break;
                 case CASCADE_CMD_QUERY_TOTAL_PWR:break;
+                case CASCADE_CMD_GET_BREAKER_INFO:
+                {
+                    LOGD("_____ slave breaker CASCADE_CMD_GET_INFO\n");
+                    slave_breaker_info(cas);
+                    memcpy(cas->map->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->sBreaker)+sendlen, h.regcnt*2);
+                }
+                break;
             }
 
             r = _mb_reply(cas, buff, rc, cas->map);
@@ -659,6 +892,14 @@ static int power_init(cascade_handle_t *cas)
 
     return 0;
 }
+static int breaker_slave_init(void)
+{
+    //GlobalDeviceManager *dm=get_dm();
+    GlobalDeviceManager *dm2=get_dm2();
+    INIT_LIST_HEAD(&dm2->g_new_global_breaker.list);
+    pthread_mutex_init(&dm2->_breaker_mutex,NULL);
+    return 0;
+}
 static int power_deinit(cascade_handle_t *cas)
 {
     GlobalDeviceManager *dm2=get_dm2();
@@ -721,6 +962,33 @@ static int power_clear(cascade_handle_t *cas)
 
     return 0;
 }
+
+static int breaker_clear(cascade_handle_t *cas)
+{
+    GlobalDeviceManager *dm2=get_dm2();
+
+    GlobalBreakerManager *temp = NULL;
+    GlobalBreakerManager *pos = NULL;
+    pthread_mutex_lock(&dm2->_breaker_mutex);
+    if(!list_empty(&dm2->g_new_global_breaker.list)) {
+        list_for_each_entry_safe(temp,pos,&dm2->g_new_global_breaker.list,list)
+        {
+            if(temp == NULL)
+            {
+                continue;
+            }
+            list_del(&temp->list);
+            free(temp);
+        }
+    }
+    INIT_LIST_HEAD(&dm2->g_new_global_breaker.list);
+    pthread_mutex_unlock(&dm2->_breaker_mutex);
+    return 0;
+}
+
+
+
+
 static int power_add(cascade_handle_t *cas)
 {
     int i,j,nTac_chn=0,r=-1;
@@ -820,6 +1088,76 @@ static int power_add(cascade_handle_t *cas)
 quit:
     return r;
 }
+
+
+static int breaker_add(cascade_handle_t *cas)
+{
+    int i,j,r=-1;
+    //GlobalDeviceManager *dm1=get_dm();
+    GlobalDeviceManager *dm2=get_dm2();
+    GlobalBreakerManager *tmp=NULL;
+    breaker_info_t *info=&cas->sBreaker;
+    //cascade_lock();
+    breaker_clear(cas);
+    pthread_mutex_lock(&dm2->_breaker_mutex);
+    for(i=0; i<info->cnt; i++) {
+        tmp = (GlobalBreakerManager*) malloc(sizeof(GlobalBreakerManager));
+        if(!tmp) {
+            LOGE("tmp malloc error.\n");
+            goto quit;
+        }
+        memset(tmp, 0, sizeof(GlobalBreakerManager));
+        tmp->product_id = cur_dev_addr;
+        tmp->breaker_chn = info->breaker_chn[i].breaker_chn;
+        tmp->breaker_status = info->breaker_chn[i].breaker_status;
+        tmp->breaker_gather_addr = info->breaker_chn[i].breaker_addrs;
+        tmp->breaker_id = info->breaker_chn[i].breaker_id;
+        strcpy(tmp->breaker_gather_type, info->breaker_chn[i].breaker_gather_type);
+        strcpy(tmp->breaker_com, info->breaker_chn[i].breaker_com);
+        strcpy(tmp->breaker_chns_name, info->breaker_chn[i].breaker_chns_name);
+        strcpy(tmp->breaker_switch_name, info->breaker_chn[i].breaker_switch_name);
+        list_add_tail(&tmp->list,&dm2->g_new_global_breaker.list);
+    }
+    pthread_mutex_unlock(&dm2->_breaker_mutex);
+    //cascade_unlock();
+    r = 0;
+quit:
+    return r;
+}
+
+static int breaker_update(cascade_handle_t *cas)
+{
+    GlobalBreakerManager *tmp=NULL;
+    GlobalBreakerManager *tmp3=NULL;
+    GlobalDeviceManager *dm2=get_dm2();
+    breaker_info_t *info=&cas->sBreaker;
+    int cnt = 0;
+    LOGD("______ breaker_update, %d\n", info->cnt);
+    if(info->cnt==0) {
+        LOGE("___ sBreaker.cnt is 0\n");
+        return -1;
+    }
+
+    if(!list_empty(&dm2->g_new_global_breaker.list)) {
+        cnt = 0;
+        pthread_mutex_lock(&dm2->_breaker_mutex);
+        list_for_each_entry_safe(tmp,tmp3,&dm2->g_new_global_breaker.list,list)
+        {
+            tmp->breaker_id = info->breaker_chn[cnt].breaker_id;
+            tmp->breaker_status = info->breaker_chn[cnt].breaker_status;
+            tmp->breaker_gather_addr = info->breaker_chn[cnt].breaker_addrs;
+            strcpy(tmp->breaker_gather_type, info->breaker_chn[cnt].breaker_gather_type);
+            strcpy(tmp->breaker_com, info->breaker_chn[cnt].breaker_com);
+            strcpy(tmp->breaker_chns_name, info->breaker_chn[cnt].breaker_chns_name);
+            strcpy(tmp->breaker_switch_name, info->breaker_chn[cnt].breaker_switch_name);
+            cnt++;
+        }
+        pthread_mutex_unlock(&dm2->_breaker_mutex);
+    } 
+    return 0;
+}
+
+
 static int power_update(cascade_handle_t *cas)
 {
     int cnt=0;
@@ -981,7 +1319,35 @@ static int master_cmd(cascade_handle_t *cas, cmd_data_t *cmd)
             }
         }
         break;
-
+        case CASCADE_CMD_GET_BREAKER_INFO:
+        {
+            wdata.dlen = sizeof(cmd_data_t);
+            wdata.data = (uint8_t*)cmd;
+            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*CH_MAX;
+            rdata.data = (uint8_t*)&cas->sBreaker;
+            LOGD("_____ master send CASCADE_CMD_GET_BREAKER_INFO\n");
+            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+            if(r==0) {
+                LOGD("______cas->info.cnt: %d\n", cas->sBreaker.cnt);
+                rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*(CH_MAX-cas->sBreaker.cnt);
+                rdata.data = (uint8_t*)&cas->sBreaker;
+                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+                if(r==0) {
+                   // power_add(cas);
+                   breaker_add(cas);
+                }
+            }
+        }
+        break;
+        case CASCADE_CMD_BREAKER_SAVE_UPDATE:
+        case CASCADE_CMD_BREAKER_SAVE_DELETE:
+        case CASCADE_CMD_BREAKER_SAVE_ADD:
+        {
+            wdata.dlen = sizeof(cmd_data_t);
+            wdata.data = (uint8_t*)cmd;
+            r = mb_write(cas, cur_dev_addr, &wdata);
+        }
+        break;
         default:
         cas->cmd = *cmd;
         r = 0;
@@ -1020,13 +1386,40 @@ static int master_query(cascade_handle_t *cas)
             r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
             if(r==0) {
                 power_update(cas);
+                cmd->cmd = CASCADE_CMD_BREAKER_QUERY;
             }
             else {
                 LOGE("____ master query CASCADE_CMD_QUERY_CH failed\n");
             }
         }
         break;
-
+        case CASCADE_CMD_BREAKER_QUERY:
+        {
+            
+            wdata.dlen = sizeof(cmd_data_t);
+            wdata.data = (uint8_t*)cmd;
+            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*CH_MAX;
+            rdata.data = (uint8_t*)&cas->sBreaker;
+            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+            LOGD("____ master query CASCADE_CMD_BREAKER_QUERY, cnt: %d\n", cas->sBreaker.cnt);
+            if(cas->sBreaker.cnt == 0)
+            {
+                breaker_clear(cas);
+                return -1;
+            }
+            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*(CH_MAX-cas->sBreaker.cnt);
+            rdata.data = (uint8_t*)&cas->sBreaker;
+            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+            if(r == 0)
+            {
+                breaker_add(cas);
+                cmd->cmd = CASCADE_CMD_QUERY_CH;
+            }else
+            {
+                LOGE("____ master query CASCADE_CMD_BREAKER_QUERY failed\n");
+            }
+        }
+        break;
         case CASCADE_CMD_QUERY_VOL:
         {
             if(cmd->obj==OBJ_CHANNEL) {
@@ -1163,11 +1556,15 @@ static void* cascade_thread(void *arg)
     LOGD("__ cascade %s\n", info->product_modbus_type?"slave":"master");
     while(h->quit==0) {
         if(info->product_modbus_type==0) {      //主模
+            cascade_lock();
             r = master_query(cas);
+            cascade_unlock();
             sleep(1);
         }
         else {                                  //从模式，等待主设备发起数据请�?
+            cascade_lock();
             r = slave_receive(cas);
+            cascade_unlock();
         }  
     }
     
@@ -1279,10 +1676,13 @@ int cascade_init(void)
     int r=0;
     list_cfg_t lc;
     cascade_handle_t *cas=&casHandle;
+
+
     
     memset(cas, 0, sizeof(casHandle));
 
     power_init(cas);
+	breaker_slave_init();
     slave_init(cas);
 
     r = pthread_mutex_init(&cas->mutex, NULL);

pro/src/cascade.h

@@ -8,6 +8,10 @@
 
 
 
+
+#define MAX_BREAKER_CHN                 (6)
+#define MAX_BREAKER_ID                  (49) 
+
 #define CASCADE_MAX                     32
 #define ERR_MAX                         5
 #define CH_MAX                          128
@@ -25,6 +29,11 @@
 #define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+1)
 #define CASCADE_REG_SCAN                (CASCADE_REG_OFFSET+2)
 
+// #define CASCADE_REG_BREAKER             0x40
+
+// #define CASCADE_REG_BREAKER_READ            (CASCADE_REG_BREAKER+0)
+// #define CASCADE_REG_BREAKER_WRITE       (CASCADE_REG_BREAKER+1)
+
 
 
 enum {
@@ -44,6 +53,12 @@ enum {
     CASCADE_CMD_QUERY_TOTAL,
     CASCADE_CMD_QUERY_TOTAL_PWR,
 
+    CASCADE_CMD_BREAKER_QUERY,
+    CASCADE_CMD_GET_BREAKER_INFO,
+    CASCADE_CMD_BREAKER_SAVE_ADD,
+    CASCADE_CMD_BREAKER_SAVE_UPDATE,
+    CASCADE_CMD_BREAKER_SAVE_DELETE,
+
     CASCADE_CMD_MAX,
 };
 
@@ -151,12 +166,56 @@ typedef struct {
     channel_info_t  ch[CH_MAX];
 }slave_info_t;
 
+
+// slave breaker information
+typedef struct{
+    //uint8_t  breaker_addrs;
+    uint8_t  product_id;
+    uint8_t  breaker_chn;
+    uint16_t breaker_status;
+    uint16_t breaker_addrs;
+    int breaker_id;
+    char breaker_gather_type[6];
+    char breaker_com[20];
+    char breaker_switch_name[64];
+    char breaker_chns_name[64];    //
+}breaker_channel_info_t;
+
+
+typedef struct {
+    int cnt;
+    breaker_channel_info_t breaker_chn[CH_MAX];
+}breaker_info_t;
+
+
+typedef struct{
+    uint8_t jdh;
+    uint8_t cjdz;
+    char com[32];
+    char cjfs[20];
+    char breaker_chns[64];
+}cascade_breaker_add_t;
+
+typedef struct{
+    int switch_id;
+    char switch_name[32];
+    char breaker_chns[64];
+}cascade_breaker_update_t;
+typedef struct {
+    int switch_id;
+}cascade_braeker_delete_t;
+
 typedef struct {
     uint8_t         cmd;
     uint8_t         obj;
     uint8_t         chId;
-    char            time_s[24];   //start time
-    char            time_e[24];   //end time
+    // char            time_s[24];   //start time
+    // char            time_e[24];   //end time
+    union{
+        cascade_breaker_add_t     data;
+        cascade_breaker_update_t data1;
+        cascade_braeker_delete_t data2;
+    }datas;
 }cmd_data_t;
 
 typedef struct {

pro/src/cascade_slave.c

@@ -137,6 +137,11 @@ int cascade_slave_init(void)
     if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC ||
         mgr->_global_device_info->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;
@@ -152,6 +157,11 @@ int cascade_slave_init(void)
         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];

pro/src/common.c

@@ -504,7 +504,7 @@ void SetMenuAuthority(int RoleID)
         // 1、电源监控菜单
         _GlobalMenuAuthority.MonitorallEnabled = true;
         _GlobalMenuAuthority.ChannelstatusEnabled = true;
-        _GlobalMenuAuthority.SwitchtatusEnabled = false;
+        _GlobalMenuAuthority.SwitchtatusEnabled = true;
         _GlobalMenuAuthority.MonitorhistoryEnabled = true;
         // 2、传感器管理菜单
         _GlobalMenuAuthority.SensorStatusEnabled = true;

pro/src/common.h

@@ -808,6 +808,61 @@ struct modbus_slave_write_reg{
     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;
+
 
 
 //设备总体管理
@@ -848,8 +903,10 @@ typedef struct
     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;
+    cascade_triphasic_mmap_t *triphasic_mmap;	
+	GlobalBreakerManager g_new_global_breaker;
 }GlobalDeviceManager;
 
 extern GlobalDeviceManager __globalDeviceManage;

pro/src/json_handle.c

@@ -1036,13 +1036,79 @@ cJSON* json_to_over_equipment_mintenance(const char* str,_Equipment_Mintenance*
     if(cjson_type!=NULL)
         _over_equipment_mintenance->type = cjson_type->valuestring;
 
-    cJSON* cjson_productName = cJSON_GetObjectItem(cjson,"productName");
-    if(cjson_productName!=NULL)
-        _over_equipment_mintenance->product_name = cjson_productName->valuestring;
 
-    cJSON* cjson_productNumber = cJSON_GetObjectItem(cjson,"productNumber");
-    if(cjson_productNumber!=NULL)
-        _over_equipment_mintenance->product_number = cjson_productNumber->valuestring;
+    if(strcmp(_over_equipment_mintenance->type,"switchSave") == 0)
+    {
+    
+        cJSON* cjson_cjfs = cJSON_GetObjectItem(cjson,"cjfs");
+        if(cjson_cjfs!=NULL)
+            _over_equipment_mintenance->cjfs = cjson_cjfs->valuestring;
+
+        cJSON* cjson_comkh = cJSON_GetObjectItem(cjson,"comkh");
+        if(cjson_comkh!=NULL)
+            _over_equipment_mintenance->comkh = cjson_comkh->valuestring;
+
+        cJSON* cjson_cjdz = cJSON_GetObjectItem(cjson,"cjdz");
+        if(cjson_cjdz!=NULL)
+            _over_equipment_mintenance->cjdz = cjson_cjdz->valuestring;
+
+
+        cJSON* cjson_jdh = cJSON_GetObjectItem(cjson,"jdh");
+        if(cjson_jdh!=NULL)
+            _over_equipment_mintenance->jdh = cjson_jdh->valuestring;
+            
+        cJSON* cjson_productChIds = cJSON_GetObjectItem(cjson,"productChIds");
+        if(cjson_productChIds!=NULL)
+            _over_equipment_mintenance->productChids = cjson_productChIds->valuestring;
+
+        cJSON* cjson_productId = cJSON_GetObjectItem(cjson,"productId");
+        if(cjson_productId!=NULL)
+            _over_equipment_mintenance->product_id = cjson_productId->valuestring;
+        
+        
+        // cJSON* cjson_jdh = cJSON_GetObjectItem(cjson,"jdh");
+        // if(cjson_jdh!=NULL)
+        //     _over_equipment_mintenance->jdh = cjson_jdh->valuestring;
+    } else if(strcmp(_over_equipment_mintenance->type,"switchUpdate") == 0){
+        cJSON* cjson_productId = cJSON_GetObjectItem(cjson,"productId");
+        if(cjson_productId!=NULL)
+            _over_equipment_mintenance->product_id = cjson_productId->valuestring;
+        cJSON* cjson_productChIds = cJSON_GetObjectItem(cjson,"productChIds");
+        if(cjson_productChIds!=NULL)
+            _over_equipment_mintenance->productChids = cjson_productChIds->valuestring;
+        
+        cJSON* cjson_switchId = cJSON_GetObjectItem(cjson,"switchId");
+        if(cjson_switchId!=NULL)
+            _over_equipment_mintenance->switchId = cjson_switchId->valueint;
+        
+        cJSON* cjson_switchName = cJSON_GetObjectItem(cjson,"switchName");
+        if(cjson_switchName != NULL)
+            _over_equipment_mintenance->switchName = cjson_switchName->valuestring;
+    }else if (strcmp(_over_equipment_mintenance->type,"switchDelete") == 0){
+        cJSON* cjson_switchId = cJSON_GetObjectItem(cjson,"switchId");
+        if(cjson_switchId!=NULL)
+            _over_equipment_mintenance->switchId = cjson_switchId->valueint;
+
+        cJSON* cjson_productId = cJSON_GetObjectItem(cjson,"productId");
+        if(cjson_productId!=NULL)
+            _over_equipment_mintenance->product_id = cjson_productId->valuestring;
+    }else if(strcmp(_over_equipment_mintenance->type,"listSwitchtatusQuery") == 0)
+    {
+        cJSON* cjson_productId = cJSON_GetObjectItem(cjson,"productId");
+        if(cjson_productId!=NULL)
+            _over_equipment_mintenance->product_id = cjson_productId->valuestring;
+    }else
+    {
+        
+        cJSON* cjson_productName = cJSON_GetObjectItem(cjson,"productName");
+        if(cjson_productName!=NULL)
+            _over_equipment_mintenance->product_name = cjson_productName->valuestring;
+
+        cJSON* cjson_productNumber = cJSON_GetObjectItem(cjson,"productNumber");
+        if(cjson_productNumber!=NULL)
+            _over_equipment_mintenance->product_number = cjson_productNumber->valuestring;
+    }
+    
 
     return cjson;
 }
@@ -1160,6 +1226,69 @@ char* over_all_monitor_to_json(_OverBackStsInfo* _over_back_sts_info)
     return str;
 }
 
+/// @brief return breaker device list information
+/// @param _over_back_sts_info 
+/// @return 
+char* over_breaker_product_list_info_to_json(GlobalDeviceManager *dm, _OverBackBreakerInfo* _over_back_sts_info,bool curFlag)
+{
+    int i,r;
+    char* str = NULL;
+    dev_list_t dl;
+    char temp[100] = {0};
+
+    // 创建 JSON 对象
+    cJSON* root = cJSON_CreateObject();   
+    if(root) {
+        cJSON_AddNumberToObject(root, "code", 200); 
+        
+        cJSON* root_array = cJSON_CreateArray();
+        if(root_array) {
+            r = cascade_get_dlist(&dl);
+            if(r==0) {
+                for(i=0; i<dl.cnt; i++) {
+                    cJSON* data_filed = cJSON_CreateObject();
+                    if(data_filed) {
+                        if(dl.slave[i].addr==0) {
+                            sprintf(temp, "%s", _over_back_sts_info->product_name);
+                        }
+                        else{
+                            sprintf(temp, "%s %d", _over_back_sts_info->product_name, dl.slave[i].addr);
+                        }
+
+                        cJSON_AddStringToObject(data_filed, "productName", temp);
+
+                        sprintf(temp, "%d", dl.slave[i].addr);
+                        cJSON_AddStringToObject(data_filed, "productId", temp);
+                        //cJSON_AddNumberToObject(data_filed, "productId", dl.slave[i].addr);
+
+                        cJSON_AddStringToObject(data_filed, "productNumber", _over_back_sts_info->product_number);
+                    
+                        cJSON_AddNumberToObject(data_filed, "productType", _over_back_sts_info->product_type);
+
+                        cJSON_AddItemToArray(root_array, data_filed);
+                    }
+                    //如果是listSbWhQuery请求，只推送当前PDU信息
+                    if (curFlag)
+                    {
+                        break;
+                    }
+                }
+                cascade_free_dlist(&dl);
+            }
+            cJSON_AddItemToObject(root, "data", root_array);
+        }
+        cJSON_AddStringToObject(root, "msg", "操作成功");
+
+        str = cJSON_Print(root);
+
+        cJSON_Delete(root);
+    }
+    
+    return str;
+}
+
+
+
 /// @brief 返回设备列表
 /// @param _over_back_sts_info 
 /// @return 
@@ -1434,6 +1563,21 @@ char* ctrl_sts_ack_to_json(void)
     return str;
 }
 
+char* ctrl_breaker_err_ack_to_json(char *string)
+{
+    char* str = NULL;
+    // 创建 JSON 对象
+    cJSON* root = cJSON_CreateObject(); 
+    // 添加基本键值对
+    cJSON_AddNumberToObject(root, "code", 201);       
+    //添加结果
+    cJSON_AddStringToObject(root, "msg", string);    
+    //转换
+    str = cJSON_Print(root);    
+    //释放资源
+    cJSON_Delete(root);
+    return str;
+}
 
 /// @brief 返回历史信息
 /// @param _globalPowerInfo 
@@ -2336,6 +2480,151 @@ cJSON* json_to_sensor_manage(const char* str,_OverSensorRequest* _overSensorRequ
     return cjson;
 }
 
+/// @brief return breaker chn information
+/// @param _over_all_pwr_back_info 
+/// @return 
+char* over_all_breaker_chn_info_to_json(_OverBreakerChnInfo* _over_all_breaker_back_info,int nWSType)
+{
+    char* str = NULL;
+    struct list_head *pos;
+    _OverBreakerChnInfo* _temp = NULL;
+
+    char temp_buf[16] = {0};
+    // 创建 JSON 对象
+    cJSON* root = cJSON_CreateObject();   
+    // 添加基本键值对
+
+
+        // 添加基本键值对  
+    cJSON* sdata_filed = cJSON_CreateObject();
+    // 创建数据
+    cJSON *data_root_array = cJSON_CreateArray();
+    if (nWSType)
+    {
+        cJSON_AddNumberToObject(sdata_filed, "code", 200);
+    }
+    else
+    {
+        cJSON_AddNumberToObject(root, "code", 200);
+    }
+    list_for_each_entry(_temp, &_over_all_breaker_back_info->list, list)
+    {
+        char temp[32] = {0};
+        cJSON* data_filed = cJSON_CreateObject();
+        cJSON_AddStringToObject(data_filed, "productName",_temp->product_name);
+        cJSON_AddNumberToObject(data_filed,"productId",_temp->product_id);
+        cJSON_AddStringToObject(data_filed, "productNumber",_temp->product_name);
+        cJSON_AddStringToObject(data_filed, "productChName",_temp->product_ch_name);
+        cJSON_AddNumberToObject(data_filed,"productChId",_temp->product_ch_id);
+        cJSON_AddItemToObject(data_root_array, "data", data_filed);
+    }
+    if (nWSType)
+    {
+        // 添加汇总
+        cJSON_AddItemToObject(sdata_filed, "data", data_root_array);
+        // 添加结果
+        cJSON_AddStringToObject(sdata_filed, "msg", "操作成功");
+        cJSON_AddItemToObject(root, "data", sdata_filed);
+        // 添加内容
+        cJSON_AddStringToObject(root, "message", "操作成功");
+        cJSON_AddStringToObject(root, "socketIdx", "PDU-WebSocket");
+        cJSON_AddBoolToObject(root, "success", true);
+        cJSON_AddStringToObject(root, "type", "sensorStatusMonitoring");
+    }else
+    {
+        cJSON_AddItemToObject(root, "data", data_root_array);
+        // 添加内容
+        cJSON_AddStringToObject(root, "message", "操作成功");
+    }
+    //转换
+    str = cJSON_Print(root);    
+    //释放资源
+    cJSON_Delete(root);
+    return str;
+}
+
+/// @brief return breaker switch information
+/// @param _over_all_pwr_back_info 
+/// @return 
+char* over_all_breaker_switch_info_to_json(_OverBreakerSwitchInfo* _over_all_breaker_switch_info,int nWSType)
+{
+    char* str = NULL;
+    struct list_head *pos;
+    _OverBreakerSwitchInfo* _temp = NULL;
+
+    char temp_buf[16] = {0};
+    // 创建 JSON 对象
+    cJSON* root = cJSON_CreateObject();   
+    // 添加基本键值对
+
+
+        // 添加基本键值对  
+    cJSON* sdata_filed = cJSON_CreateObject();
+    // 创建数据
+    cJSON *data_root_array = cJSON_CreateArray();
+    if (nWSType)
+    {
+        cJSON_AddNumberToObject(sdata_filed, "code", 200);
+    }
+    else
+    {
+        cJSON_AddNumberToObject(root, "code", 200);
+    }
+    list_for_each_entry(_temp, &_over_all_breaker_switch_info->list, list)
+    {
+        char temp[32] = {0};
+        cJSON* data_filed = cJSON_CreateObject();
+        cJSON_AddStringToObject(data_filed, "productName",_temp->productName);
+        cJSON_AddNumberToObject(data_filed,"productId",_temp->product_id);
+        cJSON_AddStringToObject(data_filed, "productNumber",_temp->product_number);
+        cJSON_AddStringToObject(data_filed, "productChNames",_temp->product_ch_name);
+        cJSON_AddStringToObject(data_filed,"productChIds",_temp->productChids);
+        cJSON_AddNumberToObject(data_filed,"switchId",_temp->switch_id);
+        cJSON_AddNumberToObject(data_filed, "switchStatus",_temp->status);
+        cJSON_AddStringToObject(data_filed, "switchName",_temp->switch_name);
+        cJSON_AddStringToObject(data_filed,"cjfs",_temp->cjfs);
+        cJSON_AddStringToObject(data_filed,"comkh",_temp->comkh);
+        cJSON_AddStringToObject(data_filed,"cjdz",_temp->cjdz);
+        cJSON_AddStringToObject(data_filed,"jdh",_temp->jdh);
+        cJSON_AddItemToObject(data_root_array, "data", data_filed);
+    }
+
+    if(list_empty(&_over_all_breaker_switch_info->list))
+    {
+        cJSON* data_filed = cJSON_CreateObject();
+        // cJSON_AddStringToObject(data_filed, "productName",_temp->productName);
+        // cJSON_AddNumberToObject(data_filed,"productId",_temp->product_id);
+        // cJSON_AddStringToObject(data_filed, "productNumber",_temp->product_number);
+        // cJSON_AddStringToObject(data_filed, "productChNames",_temp->product_ch_name);
+        cJSON_AddItemToObject(data_root_array, "data", data_filed);
+    }
+    if (nWSType)
+    {
+        // 添加汇总
+        cJSON_AddItemToObject(sdata_filed, "data", data_root_array);
+        // 添加结果
+        cJSON_AddStringToObject(sdata_filed, "msg", "操作成功");
+        cJSON_AddItemToObject(root, "data", sdata_filed);
+        // 添加内容
+        cJSON_AddStringToObject(root, "message", "提示信息");
+        cJSON_AddStringToObject(root, "socketIdx", "PDU-WebSocket");
+        cJSON_AddBoolToObject(root, "success", true);
+        cJSON_AddStringToObject(root, "type", "switchEquipmentMintenance");
+    }else
+    {
+        cJSON_AddItemToObject(root, "data", data_root_array);
+        // 添加内容
+        cJSON_AddStringToObject(root, "message", "操作成功");
+    }
+    
+    //转换
+    str = cJSON_Print(root);    
+    //释放资源
+    cJSON_Delete(root);
+    return str;
+}
+
+
 /// @brief 返回传感器信息
 /// @param _over_all_pwr_back_info 
 /// @return 
@@ -2452,6 +2741,60 @@ char* over_all_sensor_info_to_json(_OverSensorBackInfo* _over_all_sensor_back_in
     cJSON_Delete(root);
     return str;
 }
+char *breaker_status_ack_to_json(GlobalDeviceManager *gm,int slave)
+{   
+    char *strRet = NULL;
+    GlobalBreakerManager *_globalbreakerManger = &gm->g_new_global_breaker;
+    GlobalBreakerManager* temp = NULL;
+    _OverBreakerSwitchInfo _over_breaker_switch_info;
+    INIT_LIST_HEAD(&_over_breaker_switch_info.list);
+    
+    pthread_mutex_lock(&gm->_breaker_mutex);
+    list_for_each_entry(temp, &_globalbreakerManger->list, list)
+    {
+        char buff[120] = {0};
+//        printf("get  listSwitchtatusQuery infomation!!!\n");
+        _OverBreakerSwitchInfo *info = (_OverBreakerSwitchInfo *) 
+                                    malloc(sizeof(_OverBreakerSwitchInfo));
+                memset(info,0,sizeof(_OverBreakerSwitchInfo));
+                info->product_id = temp->product_id;
+                sprintf(buff,"Breaker_%d",temp->breaker_id);
+                strcpy(info->product_ch_name,buff);
+                if(slave)
+                {
+                    sprintf(buff,"%s %d",__globalDeviceManage._global_device_info->product_name, slave);
+                    strcpy(info->productName,buff);
+                }else
+                    strcpy(info->productName,__globalDeviceManage._global_device_info->product_name);
+                strcpy(info->product_number,__globalDeviceManage._global_device_info->product_number);
+                strcpy(info->productChids,temp->breaker_chns_name);
+                info->switch_id = temp->breaker_id;
+                info->status = temp->breaker_status;
+                strcpy(info->cjfs,temp->breaker_gather_type);
+                strcpy(info->switch_name,temp->breaker_switch_name);
+                strcpy(info->comkh,temp->breaker_com);
+                sprintf(buff,"%d",temp->breaker_gather_addr);
+                strcpy(info->cjdz,buff);
+                sprintf(buff,"%d",temp->breaker_chn);
+                strcpy(info->jdh,buff);
+                //printf("push %s %d %d %s %s %s %s\n",info->productChids,info->switch_id,info->status,info->cjfs,info->comkh,info->cjdz,info->jdh);
+                list_add_tail(&info->list,&_over_breaker_switch_info.list);
+    }
+    pthread_mutex_unlock(&gm->_breaker_mutex);
+    strRet = over_all_breaker_switch_info_to_json(&_over_breaker_switch_info,1);
+                //释放资源
+    _OverBreakerSwitchInfo* node;
+    _OverBreakerSwitchInfo* next;
+    list_for_each_entry_safe(node, next, &_over_breaker_switch_info.list, list)
+    {
+        list_del(&node->list);
+        free(node);
+    } 
+    return strRet;
+}
+
+
+
 /**
  * @brief 将传感器状态应答转换为 JSON 字符串
  *

pro/src/json_handle.h

@@ -81,6 +81,50 @@ typedef struct
     _Get_System_Total system_total;
 }_OverBackStsInfo;
 
+/// @brief breaker device information
+
+typedef struct 
+{
+    char *product_name;
+    int product_id;
+    char *product_number; 
+    char product_type;
+}_OverBackBreakerInfo;
+
+/// @brief breaker channel list information
+
+typedef struct
+{
+    char product_name[32];
+    int product_id;
+    char product_number[32]; 
+    char product_ch_name[32];
+    int product_ch_id;
+    struct list_head list;
+}_OverBreakerChnInfo;
+
+
+/// @brief breaker channel switch information
+typedef struct 
+{
+    char productName[32];
+    char product_number[32];
+    int product_id;
+    char product_ch_name[32];
+    int product_ch_id;
+    int status;
+    int switch_id;
+    char switch_name[64];
+    char cjfs[20];
+    char comkh[20];
+    char cjdz[20];
+    char jdh[20];
+    char productChids[64];
+    struct list_head list;
+}_OverBreakerSwitchInfo;
+
+
+
 /// @brief 电源总体监控请求信息
 typedef struct 
 {
@@ -444,6 +488,15 @@ typedef struct
     char*   product_name;
     char*   product_id;
     char*   product_number;
+    /// @brief  breaker infomation
+    char *cjfs;
+    char *comkh;
+    char *cjdz;
+    char *jdh;
+    char *productChids;
+    /////
+    int   switchId;
+    char *switchName;
 }_Equipment_Mintenance;
 
  /// @brief 用户角色管理
@@ -466,6 +519,7 @@ typedef struct
 
 
 char* ctrl_sts_ack_to_json(void);
+char* ctrl_breaker_err_ack_to_json(char *string);
 
 void get_rand_str(char* s,int num);
 char* json_to_Token_info(const char* strHead);
@@ -553,5 +607,12 @@ char* GetRoleNameByID(int _RoleID,RoleInfo* __RoleInfo_t);
 int GetRoleIDByName(char* _RoleName,RoleInfo* __RoleInfo_t);
 char* service_userQuery_ack_to_json(char* _userName,UserInfo* __UserInfo_t,RoleInfo* __RoleInfo_t);
 char* service_userRole_ack_to_json(char* _userName,UserInfo* __UserInfo_t,RoleInfo* __RoleInfo_t);
+
+
+
+char* over_breaker_product_list_info_to_json(GlobalDeviceManager *dm,_OverBackBreakerInfo* _over_back_sts_info,bool curFlag);
+char* over_all_breaker_chn_info_to_json(_OverBreakerChnInfo* _over_all_breaker_back_info,int nWSType);
+char* over_all_breaker_switch_info_to_json(_OverBreakerSwitchInfo* _over_all_breaker_switch_info,int nWSType);
+char *breaker_status_ack_to_json(GlobalDeviceManager *gm,int slave);
 #endif
 

pro/src/sqlite_handle.c

@@ -1541,6 +1541,174 @@ int dev_update_power_manage_over_info(sqlite3 *db,int product_id,int product_ch_
     return 0 ;
 }
 
+/// @brief get breakers manager infomation
+/// @param db 
+/// @param product_id 
+/// @param _globalBreakerManager 
+/// @return 
+
+int dev_get_breaker_manage_info(sqlite3 *db,int product_id,GlobalBreakerManager* _globalBreakerManager)
+{
+    int res = 0 ;
+    int rowIndex = 1 ;
+    char *errorMsg = NULL;
+    int nrow = 0;               //满足条件的记录数目
+    int ncolumn = 0;            //每条记录包含的字段数据
+    char** pResult = NULL;  //用来指向sql执行结果的指针
+    char* err_msg=NULL;
+    char select_sql[1024] = {0};
+    GlobalBreakerManager* _globalBreakerManagerTemp = NULL;
+    sprintf(select_sql,"SELECT* FROM Table_BreakerManage WHERE product_id=%d;",product_id);
+    res = sqlite3_get_table(db, select_sql, &pResult, &nrow, &ncolumn, &err_msg);
+    if(res != SQLITE_OK) {
+        log_e("sqlite handle error: %s\n%s\n", err_msg,select_sql); sqlite3_free(err_msg);
+        return -2 ;
+    }   
+    if(nrow==0) {
+        sqlite3_free_table(pResult);
+        return -1 ;
+    } 
+    for (size_t i = 1; i <= nrow; i++)
+    {
+        _globalBreakerManagerTemp = (GlobalBreakerManager*)malloc(sizeof(GlobalBreakerManager));
+        if(_globalBreakerManagerTemp==NULL)
+            return -1 ;
+        memset(_globalBreakerManagerTemp,0,sizeof(GlobalBreakerManager));    
+        _globalBreakerManagerTemp->product_id = atoi(pResult[i*ncolumn + 0]);
+        _globalBreakerManagerTemp->breaker_id = atoi(pResult[i*ncolumn + 1]);
+        strcpy(_globalBreakerManagerTemp->breaker_gather_type,pResult[i*ncolumn+2]);
+        strcpy(_globalBreakerManagerTemp->breaker_com,pResult[i*ncolumn+3]);
+        _globalBreakerManagerTemp->breaker_gather_addr = atoi(pResult[i*ncolumn+4]);
+        _globalBreakerManagerTemp->breaker_chn = atoi(pResult[i*ncolumn+5]);
+        printf("%d  %d  %s %s %d %d\n",_globalBreakerManagerTemp->product_id,
+                        _globalBreakerManagerTemp->breaker_id,
+                        _globalBreakerManagerTemp->breaker_gather_type,
+                        _globalBreakerManagerTemp->breaker_com,
+                        _globalBreakerManagerTemp->breaker_gather_addr,
+                        _globalBreakerManagerTemp->breaker_chn);
+        if(pResult[i*ncolumn+6])
+            strcpy(_globalBreakerManagerTemp->breaker_switch_name,pResult[i*ncolumn+6]);
+        if(pResult[i*ncolumn+7])
+            strcpy(_globalBreakerManagerTemp->breaker_chns_name,pResult[i*ncolumn+7]);
+        printf("isnot failed!!!\n");
+        list_add_tail(&_globalBreakerManagerTemp->list, &_globalBreakerManager->list);
+    }
+    sqlite3_free_table(pResult);
+    return 0 ;  
+}
+
+
+/// @brief delete a breaker manager 
+/// @param db 
+/// @param product_id 
+/// @param breaker_id 
+/// @return 
+int dev_delete_breaker_manage(sqlite3 *db,int product_id,int breaker_id)
+{
+    int res ;
+    char select_sql[1024] = {0};
+    char *errorMsg = NULL;
+    int nrow = 0;               //满足条件的记录数目
+    int ncolumn = 0;            //每条记录包含的字段数据
+    char** pResult = NULL;  //用来指向sql执行结果的指针
+    char* err_msg=NULL;   
+
+    sprintf(select_sql,"DELETE FROM Table_BreakerManage WHERE product_id=%d AND breaker_id=%d;",
+                product_id,
+                breaker_id
+    );
+    res = sqlite3_get_table(db, select_sql, &pResult, &nrow, &ncolumn, &err_msg);
+    if(res != SQLITE_OK) {
+        log_e("sqlite handle error: %s\n%s\n", err_msg,select_sql); sqlite3_free(err_msg);
+        return -1 ;
+    }
+    sqlite3_free_table(pResult);
+    return 0;
+}
+
+
+/// @brief  insert a breaker infomation
+/// @param db 
+/// @param _globalBreakerManger 
+/// @return 
+int dev_insert_breaker_genera_manage(sqlite3 *db,GlobalBreakerManager* _globalBreakerManager)
+{
+    int res ;
+    char select_sql[2000] = {0};
+    char *errorMsg = NULL;
+    int nrow = 0;               //满足条件的记录数目
+    int ncolumn = 0;            //每条记录包含的字段数据
+    char** pResult = NULL;  //用来指向sql执行结果的指针
+    char* err_msg=NULL;
+
+
+
+    sprintf(select_sql,"INSERT INTO Table_BreakerManage "
+                        "(product_id,breaker_id,breaker_gather_type,"
+                        "breaker_com,breaker_gather_addr,breaker_chn,"
+                        "breaker_switch_name,breaker_chns_name)"
+                        "VALUES (%d,%d,'%s','%s',%d,%d,'%s','%s');",
+                _globalBreakerManager->product_id,
+                // _globalSensorManger->sensor_id,
+                _globalBreakerManager->breaker_id,
+                _globalBreakerManager->breaker_gather_type,
+                _globalBreakerManager->breaker_com,
+                _globalBreakerManager->breaker_gather_addr,
+                _globalBreakerManager->breaker_chn,
+                _globalBreakerManager->breaker_switch_name,
+                _globalBreakerManager->breaker_chns_name
+);
+
+    log_d(select_sql);
+
+    res = sqlite_SQL_RUN(db, select_sql, &pResult, &nrow, &ncolumn, &err_msg);
+    if(res != SQLITE_OK) {
+        log_e("sqlite handle error: %s\n%s\n", err_msg,select_sql); sqlite3_free(err_msg);
+        return -1 ;
+    }
+    sqlite3_free_table(pResult);
+    return 0;
+}
+
+/// @brief update a breaker information
+/// @param db 
+/// @param product_id 
+/// @param breaker_id 
+/// @param _globalBreakerManger 
+/// @return 
+int dev_update_breaker_genera_manage(sqlite3 *db,int product_id,int breaker_id,GlobalBreakerManager* _globalBreakerManager)
+{
+    int res = 0 ;
+    int rowIndex = 1 ;
+    char *errorMsg = NULL;
+    int nrow = 0;               //满足条件的记录数目
+    int ncolumn = 0;            //每条记录包含的字段数据
+    char** pResult = NULL;  //用来指向sql执行结果的指针
+    char* err_msg=NULL;
+    char select_sql[1024] = {0};
+    sprintf(select_sql,"UPDATE Table_BreakerManage SET product_id=%d,breaker_id=%d,\
+    breaker_gather_type='%s',breaker_com='%s',breaker_gather_addr=%d,\
+    breaker_chn=%d,breaker_switch_name='%s',breaker_chns_name='%s' WHERE product_id=%d AND breaker_id=%d;",
+            _globalBreakerManager->product_id,
+            _globalBreakerManager->breaker_id,
+            _globalBreakerManager->breaker_gather_type,
+            _globalBreakerManager->breaker_com,
+            _globalBreakerManager->breaker_gather_addr,
+            _globalBreakerManager->breaker_chn,
+            _globalBreakerManager->breaker_switch_name,
+            _globalBreakerManager->breaker_chns_name,
+            product_id,
+            breaker_id);
+    res = sqlite_SQL_RUN(db, select_sql, &pResult, &nrow, &ncolumn, &err_msg);
+    if(res != SQLITE_OK) {
+        log_e("sqlite handle error: %s\n%s\n", err_msg,select_sql); sqlite3_free(err_msg);
+        return -1 ;
+    }
+    sqlite3_free_table(pResult);  
+    return 0 ;
+}
+
+
 
 /// @brief 获取传感器管理信息
 /// @param db 

pro/src/sqlite_handle.h

@@ -132,4 +132,9 @@ int dev_Alarm_T_AC_message(GlobalDeviceManager* __globalDeviceManger,GlobalTreeA
 int dev_sensor_Alarm_send_message(GlobalDeviceManager* __globalDeviceManger,GlobalSensorManger* __globalPowerTemp,int _AlarmType);
 
 int dev_Alarm_Run_message(GlobalDeviceManager* __globalDeviceManger,const char* strRunMSG, const char *strOther);
+
+int dev_get_breaker_manage_info(sqlite3 *db,int product_id,GlobalBreakerManager* _globalBreakerManager);
+int dev_insert_breaker_genera_manage(sqlite3 *db,GlobalBreakerManager* _globalBreakerManager);
+int dev_update_breaker_genera_manage(sqlite3 *db,int product_id,int breaker_id,GlobalBreakerManager* _globalBreakerManager);
+int dev_delete_breaker_manage(sqlite3 *db,int product_id,int breaker_id);
 #endif

pro/src/thread.h

@@ -24,6 +24,7 @@ enum {
     THREAD_ID_CASCADE,
     THREAD_ID_SCAN,
     THREAD_ID_SHMW,
+    THREAD_ID_BREAKER,
     
     THREAD_ID_MAX=30
 };

pro/src/websocket_handle.c

@@ -182,6 +182,17 @@ static void web_update(ws_handle_t *wh)
            // pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
             ws_send_data(wh, json_str, strlen(json_str));
             cJSON_free(json_str);
+        }
+		        // // breaker info
+        {
+            if(cur_dev_addr==0) { 
+                json_str = breaker_status_ack_to_json(gdm,0);
+            }else
+            {
+                json_str = breaker_status_ack_to_json(gdm2,cur_dev_addr);
+            }
+            ws_send_data(wh, json_str, strlen(json_str));
+            cJSON_free(json_str);
         }
     }
 }