SmartPDCode/ip/src/cascade_slave.c

#include "modbus.h"
#include "common.h"
#include "list.h"
#include "switch_ctrl.h"
#include "cascade.h"
#include "sqlite_handle.h"
#include "sys.h"
#include "thread.h"
#include "sensor_handle.h"
#include "pthread.h"
#include "modbus.h"

#define DEV_CHN_REG                 (4000)  
#define OUT_INFO_REG                (4001)     
#define IN_TOTAL_REG                (4768)  
#define TEM_HUMAN_REG               (4777)       
#define CHN_SWITCH_REG              (4779)
#define CHN_OPEN_DLA_REG            (4843)
#define CHN_CLOSE_DLA_REG           (4907)
#define CHN_SET_OPEN_DLA_REG        (5000)
#define CHN_SET_CLOSE_DLA_REG       (5064)
#define CHN_SET_SWITCH_STA_REG      (5128)
#define ALL_SET_SWITCH_REG          (5192)



enum{
    TYPE_U16,
    TYPE_U32
};


enum {
    DS_R_DEV_CHN = 0,
    DS_R_OUT_INFO,
    DS_R_IN_TOTAL,
    DS_R_TEMP_HUM,
    DS_R_SWITCH_STA,
    DS_R_OPEN_DELAY,
    DS_R_CLOSE_DELAY,
    DS_W_OPEN_DELAY,
    DS_W_CLOSE_DELAY,
    DS_W_CHN_SWITCH_STA,
    DS_W_ALL_CHN_STA
};


#define TREE_DEV_CHN_REG                (6000)  
#define TREE_INPUT_A_REG                (6001)     
#define TREE_INPUT_B_REG                (6009)  
#define TREE_INPUT_C_REG                (6017)       
#define TREE_CHN_TOTAL_REG              (6025)
#define TREE_CHN_PH_REG                 (6665)
#define TREE_TEMP_HUM_REG               (8585)
#define TREE_CHN_SWITCH_STA_REG         (8587)
#define TREE_CHN_OPEN_DLA_REG           (8651)
#define TREE_CHN_CLOSE_DLA_REG          (8715)
#define TREE_CHN_SET_OPEN_DLA_REG       (9000)
#define TREE_CHN_SET_CLOSE_DLA_REG      (9064)
#define TREE_CHN_SET_SWITCH_STA_REG     (9128)
#define TREE_ALL_SET_SWITCH_REG         (9192)

enum {
    TREE_R_DEV_CHN,
    TREE_R_INPUT_ALL_A,
    TREE_R_INPUT_ALL_B,
    TREE_R_INPUT_ALL_C,
    TREE_R_CHN_TOTAL,
    TREE_R_CHN_PH_INFO,
    TREE_R_TEMP_HUM,
    TREE_R_SWITCH_STA,
    TREE_R_OPEN_DELAY,
    TREE_R_CLOSE_DELAY,
    TREE_W_OPEN_DELAY,
    TREE_W_CLOSE_DELAY,
    TREE_W_CHN_SWITCH_STA,
    TREE_W_ALL_CHN_STA
};


#define DEV_CHN_REG                     (4000)
#define DEV_IP_MAC                      (4001)
#define POWER_INFO_REG                  (4007)          //32*16
#define POWER_LENTH                     (542)
#define WARNING_485_IP                  (4600)
#define W_LENTH                          (32)


#define IP_SET_SADDR_VOLTAGE_MAX               (4600)
#define IP_SET_SADDR_VOLTAGE_MIN               (4700)
#define IP_SET_CUREENT_MAX                     (4800)
#define IP_SET_POWER_MAX                       (4900)
#define IP_SET_CONSUMER_MAX                    (5000)



 








enum{
    DS_IP_DEV_CHN,
    DS_IP_MAC,
    DS_POWER_INFO_REG,
    DS_WANNING_REG,
};



static inline GlobalDeviceManager* get_dm(void)
{
    return &__globalDeviceManage;
}
static inline GlobalDeviceManager* get_dm2(void)
{
    return &__globalDeviceManage2;
}

static mmap_modbus_t modbus_single[] = {
    [DS_R_DEV_CHN       ]{.offset = DEV_CHN_REG             },
    [DS_R_OUT_INFO      ]{.offset = OUT_INFO_REG            },
    [DS_R_IN_TOTAL      ]{.offset = IN_TOTAL_REG            },
    [DS_R_TEMP_HUM      ]{.offset = TEM_HUMAN_REG           },
    [DS_R_SWITCH_STA    ]{.offset = CHN_SWITCH_REG          },
    [DS_R_OPEN_DELAY    ]{.offset = CHN_OPEN_DLA_REG        },
    [DS_R_CLOSE_DELAY   ]{.offset = CHN_CLOSE_DLA_REG       },
    [DS_W_OPEN_DELAY    ]{.offset = CHN_SET_OPEN_DLA_REG    },
    [DS_W_CLOSE_DELAY   ]{.offset = CHN_SET_CLOSE_DLA_REG   },
    [DS_W_CHN_SWITCH_STA]{.offset = CHN_SET_SWITCH_STA_REG  },
    [DS_W_ALL_CHN_STA   ]{.offset = ALL_SET_SWITCH_REG      },
};

static mmap_modbus_t modbus_three[] = {
    [TREE_R_DEV_CHN         ]{.offset = TREE_DEV_CHN_REG},
    [TREE_R_INPUT_ALL_A     ]{.offset = TREE_INPUT_A_REG       },
    [TREE_R_INPUT_ALL_B     ]{.offset = TREE_INPUT_B_REG       },
    [TREE_R_INPUT_ALL_C     ]{.offset = TREE_INPUT_C_REG       },
    [TREE_R_CHN_TOTAL       ]{.offset = TREE_CHN_TOTAL_REG     },
    [TREE_R_CHN_PH_INFO     ]{.offset = TREE_CHN_PH_REG        },
    [TREE_R_TEMP_HUM        ]{.offset = TREE_TEMP_HUM_REG      },
    [TREE_R_SWITCH_STA      ]{.offset = TREE_CHN_SWITCH_STA_REG},
    [TREE_R_OPEN_DELAY      ]{.offset = TREE_CHN_OPEN_DLA_REG  },
    [TREE_R_CLOSE_DELAY     ]{.offset = TREE_CHN_CLOSE_DLA_REG },
    [TREE_W_OPEN_DELAY      ]{.offset = TREE_CHN_SET_OPEN_DLA_REG},
    [TREE_W_CLOSE_DELAY     ]{.offset = TREE_CHN_SET_CLOSE_DLA_REG},
    [TREE_W_CHN_SWITCH_STA  ]{.offset = TREE_CHN_SET_SWITCH_STA_REG},
    [TREE_W_ALL_CHN_STA     ]{.offset = TREE_ALL_SET_SWITCH_REG }
};

static mmap_modbus_t ip[] ={
    [DS_IP_DEV_CHN         ]{.offset = DEV_CHN_REG              },
    [DS_IP_MAC             ]{.offset = DEV_IP_MAC               },
    [DS_POWER_INFO_REG     ]{.offset = POWER_INFO_REG           },
    [DS_WANNING_REG        ]{.offset = WARNING_485_IP           },
};


typedef struct { 
    modbus_mapping_t    *map;
}slave_handle_t;

static slave_handle_t slHandle;


modbus_mapping_t    *cascade_slave_map()
{
    return slHandle.map;
}
#if 0
int cascade_slave_init(void)
{
    slave_handle_t *sh=&slHandle;
    GlobalDeviceManager* mgr=get_dm();

    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC ||
        mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)       // single AC
    {
        if(sh->map)
        {
            free(sh->map);
            sh->map = NULL;
        }
        sh->map = modbus_mapping_new_start_address(0,0,0,0,DEV_CHN_REG,5000,0,0);     //3000 ge
        modbus_single[DS_R_DEV_CHN          ].addr = &mgr->single_mmap->dev_chn;
        modbus_single[DS_R_OUT_INFO         ].addr = &mgr->single_mmap->all_ch;
        modbus_single[DS_R_IN_TOTAL         ].addr = &mgr->single_mmap->total_valtage;
        modbus_single[DS_R_TEMP_HUM         ].addr = &mgr->single_mmap->total_temp;
        modbus_single[DS_R_SWITCH_STA       ].addr = &mgr->single_mmap->chn_status; 
        modbus_single[DS_R_OPEN_DELAY       ].addr = &mgr->single_mmap->open_delay;
        modbus_single[DS_R_CLOSE_DELAY      ].addr = &mgr->single_mmap->close_delay;
        modbus_single[DS_W_OPEN_DELAY       ].addr = &mgr->single_mmap->set_chn_open_delay;
        modbus_single[DS_W_CLOSE_DELAY      ].addr = &mgr->single_mmap->set_chn_close_delay;
        modbus_single[DS_W_CHN_SWITCH_STA   ].addr = &mgr->single_mmap->set_chn_switch_status;
        modbus_single[DS_W_ALL_CHN_STA      ].addr = &mgr->single_mmap->set_chn_all_switch_status;
        printf("single dc address init 4000\n");
    }else
    {
        if(sh->map)
        {
            free(sh->map);
            sh->map = NULL;
        }
        sh->map =  modbus_mapping_new_start_address(0,0,0,0,TREE_DEV_CHN_REG,7000,0,0);
        modbus_three[TREE_R_DEV_CHN         ].addr = &mgr->triphasic_mmap->dev_chn;
        modbus_three[TREE_R_INPUT_ALL_A     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[0];
        modbus_three[TREE_R_INPUT_ALL_B     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[1];
        modbus_three[TREE_R_INPUT_ALL_C     ].addr = &mgr->triphasic_mmap->i_total.pw_i_total[2];
        modbus_three[TREE_R_CHN_TOTAL       ].addr = &mgr->triphasic_mmap->chn_info;
        modbus_three[TREE_R_CHN_PH_INFO     ].addr = &mgr->triphasic_mmap->pw_o_chn;
        modbus_three[TREE_R_TEMP_HUM        ].addr = &mgr->triphasic_mmap->temperature;
        modbus_three[TREE_R_SWITCH_STA      ].addr = &mgr->triphasic_mmap->chn_status;
        modbus_three[TREE_R_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->open_delay;
        modbus_three[TREE_R_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->close_delay;
        modbus_three[TREE_W_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->set_chn_open_delay;
        modbus_three[TREE_W_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->set_chn_close_delay;
        modbus_three[TREE_W_CHN_SWITCH_STA  ].addr = &mgr->triphasic_mmap->set_chn_switch_status;
        modbus_three[TREE_W_ALL_CHN_STA     ].addr = &mgr->triphasic_mmap->set_chn_all_switch_status;
        printf("triphasic address init 6000\n");
        //return -1;
    }
    return 0;
}


static void slave_read(slave_handle_t *sh, uint32_t addr,int num,uint32_t reg_type,uint32_t type)
{
    GlobalDeviceManager* mgr=get_dm();
  
    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC || 
            mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC){    
        if(addr >= DEV_CHN_REG && addr <= ALL_SET_SWITCH_REG)
        {
            if(type == TYPE_U16)
            {
                uint16_t *base_addr = (uint16_t *)modbus_single[reg_type].addr;
                uint32_t step = addr - sh->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[reg_type].offset);
                uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
                if(num < 126)
                {
                    memcpy(map_addr, base_addr,2*num);
                }
            }else
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[reg_type].addr;
                uint32_t step = addr - sh->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[reg_type].offset) / 2;
                uint32_t *map_addr = (uint32_t *)&(sh->map->tab_registers[step]);
                if(num < 126)
                {
                    memcpy(map_addr, base_addr,2*num);
                }
            }
        }
    }else
    {
        if(addr >= TREE_DEV_CHN_REG && addr <= TREE_ALL_SET_SWITCH_REG) {
            if(type == TYPE_U16)
            {
                uint16_t *base_addr = (uint16_t *)modbus_three[reg_type].addr;
                uint32_t step = addr - sh->map->start_registers;
                base_addr = base_addr + (addr - modbus_three[reg_type].offset);
                uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
                if(num < 126)
                {
                    memcpy(map_addr, base_addr,2*num);
                }
            }else
            {
                uint32_t *base_addr = (uint32_t *)modbus_three[reg_type].addr;
                uint32_t step = addr - sh->map->start_registers;
                base_addr = base_addr + (addr - modbus_three[reg_type].offset) / 2;
                uint32_t *map_addr = (uint32_t *)&(sh->map->tab_registers[step]);
                if(num < 126)
                {
                    memcpy(map_addr, base_addr,2*num);
                }
            }
        }
    }
}


void cascade_slave_read(uint32_t addr,uint32_t lenth)
{
    slave_handle_t *sh=&slHandle;

    switch (addr)
    {
        case 4000:
            slave_read(sh,addr,lenth,DS_R_DEV_CHN,TYPE_U16);
        break;
        case 4001 ... 4768:
            slave_read(sh,addr,lenth,DS_R_OUT_INFO,TYPE_U32);
        break;
        case 4769 ... 4776:
            slave_read(sh,addr,lenth,DS_R_IN_TOTAL,TYPE_U32);
        break;
        case 4777 ... 4778:
            slave_read(sh,addr,lenth,DS_R_TEMP_HUM,TYPE_U16);
        case 4779 ... 4842:
            slave_read(sh,addr,lenth,DS_R_SWITCH_STA,TYPE_U16);
        break;
        case 4843 ... 4906:
            slave_read(sh,addr,lenth,DS_R_OPEN_DELAY,TYPE_U16);
        break;
        case 4907 ... 4970:
            slave_read(sh,addr,lenth,DS_R_CLOSE_DELAY,TYPE_U16);
        break;
        case 5000 ... 5063:
            slave_read(sh,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
        break;
        case 5064 ... 5127:
            slave_read(sh,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
        break;
        case 5128 ... 5191:
            slave_read(sh,addr,lenth,DS_W_CHN_SWITCH_STA,TYPE_U16);
        break;
        case 5192 :
            slave_read(sh,addr,lenth,DS_W_ALL_CHN_STA,TYPE_U16);
        break;

        // triple
        case 6000:
            slave_read(sh,addr,lenth,TREE_R_DEV_CHN,TYPE_U16);
        break;
        case 6001 ... 6008:
            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_A,TYPE_U32);
        break;
        case 6009 ... 6016:
            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_B,TYPE_U32);
        break;
        case 6017 ... 6024:
            slave_read(sh,addr,lenth,TREE_R_INPUT_ALL_C,TYPE_U32);
        break;
        case 6025 ... 6664:
            slave_read(sh,addr,lenth,TREE_R_CHN_TOTAL,TYPE_U32);
        break;
        case 6665 ... 8584:
            slave_read(sh,addr,lenth,TREE_R_CHN_PH_INFO,TYPE_U32);
        break;
        case 8585 ... 8586:
            slave_read(sh,addr,lenth,TREE_R_TEMP_HUM,TYPE_U16);
        break;
        case 8587 ... 8650:
            slave_read(sh,addr,lenth,TREE_R_SWITCH_STA,TYPE_U16);
        break;
        case 8651 ... 8714:
            slave_read(sh,addr,lenth,TREE_R_OPEN_DELAY,TYPE_U16);
        break;
        case 8715 ... 8778:
            slave_read(sh,addr,lenth,TREE_R_CLOSE_DELAY,TYPE_U16);
        break;

        default:
        break;
    }
}


void cascade_slave_write(uint32_t addr, uint16_t val)
{
    slave_handle_t *sh=&slHandle;
    GlobalDeviceManager* mgr=get_dm();
    uint16_t buff[128] = {0};
 
    if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC 
            || mgr->_globalDevInfo.product_pwr_type == SmartPDU_DC)   
    {
        switch(addr)
        {
            case 5000 ... 5063:
            {
                int start_chn = addr - modbus_single[DS_W_OPEN_DELAY].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                            break;
                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                        {
                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
                                _globalPowerMangerTemp->product_ch_start_delay=val;
                                g_switch_set_ac_single_s_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                                _globalPowerMangerTemp->product_ch_addr,val);
                            }else
                            {
                                _globalPowerMangerTemp->product_ch_start_delay=val;
                                g_switch_set_dcpdu_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                        _globalPowerMangerTemp->product_ch_addr,val/1000);
                            }
                            if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
                            {
                                log_e("update pwr general data err.");
                            }
                            printf("val = %d start_chn = %d\n",val,start_chn);
                          //  *(uint16_t *)((uint16_t*)(modbus_single[6].addr) + start_chn) = val;
                            break;
                        }                    
                }
            }
            break;
            case 5064 ... 5127:
            {
                 int start_chn = addr - modbus_single[DS_W_CLOSE_DELAY].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                            break;
                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                        {
                            if(mgr->_globalDevInfo.product_pwr_type == SmartPDU_AC){
                                  _globalPowerMangerTemp->product_ch_stop_delay=val;
                                g_switch_set_ac_single_s_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                                _globalPowerMangerTemp->product_ch_addr,val);
                            }else
                            {
                                  _globalPowerMangerTemp->product_ch_stop_delay=val;
                                g_switch_set_dcpdu_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_saddr,
                                        _globalPowerMangerTemp->product_ch_addr,val/1000);
                            }
                            if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
                            {
                                log_e("update pwr general data err.");
                            }
                            printf("val = %d",val);
                            //*(uint16_t *)((uint16_t*)(modbus_single[7].addr) + start_chn) = val;
                            //printf("modbus_single[7].addr = %d ",modbus_single[7].addr);
                            break;
                        }                    
                }
            }
            break;
            case 5128 ... 5191:
            {
                int start_chn = addr - modbus_single[DS_W_CHN_SWITCH_STA].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                if (val == 0 || val == 1)
                {
                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        if (_globalPowerMangerTemp == NULL)
                            break;
                        if ((start_chn + 1) == _globalPowerMangerTemp->product_ch_id)
                        {
                            int ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                                _globalPowerMangerTemp->product_saddr,
                                                                _globalPowerMangerTemp->product_ch_addr,
                                                                val, false);
                            //  printf("ret = %d 0x%x\n",ret,val);
                            *(uint16_t *)((uint16_t *)(modbus_single[DS_W_CHN_SWITCH_STA].addr) + start_chn) = val;
                            break;
                        }
                    }
                }
            }
            break;
            case 5192:
            {
                if (val == 0 || val == 1)
                {
                    GlobalPowerManger *_globalPowerMangerTemp = NULL;
                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        if (_globalPowerMangerTemp == NULL)
                            break;
                        int rec = g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_ch_type, _globalPowerMangerTemp->product_saddr, val);
                        // printf("rec = %d 0x%x\n",rec,val);
                    }
                    *(uint16_t *)(modbus_single[DS_W_ALL_CHN_STA].addr) = val;
                }
            }
            break;
            
            default:
            break;
        }
    }else{
        switch(addr)
        {
            case 9000 ... 9063:
            {
                int start_chn = addr - modbus_three[TREE_W_OPEN_DELAY].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list){
                    if(_globalPowerMangerTemp==NULL)
                            break;
                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                    {
                        int ret = 0;

                        _globalPowerMangerTemp->product_ch_start_delay = val;
                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B
                        )
                        {
                            printf("hwllo every one stop time !!!!\n");
                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 1, val / 1000);
                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 2, val / 1000);
                        }
                        else
                        {
                            ret = g_switch_set_t_ac_start_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
                        }
                        if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                        break;
                    }
                }
            }
            break;
            case 9064 ... 9127:
            {
                int start_chn = addr - modbus_three[TREE_W_CLOSE_DELAY].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                            break;
                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                    {
                        int ret = 0;

                        _globalPowerMangerTemp->product_ch_stop_delay = val;
                        if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B)
                        {
                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 1, val / 1000);
                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3 + 2, val / 1000);
                        }
                        else
                        {
                            ret = g_switch_set_t_ac_stop_time_delay(&__globalDeviceManage._globalRelaySampManger, 
                                                        _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr - 1) * 3, val / 1000);
                        }
                        if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                        break;
                    }
                }
            }
            break;
            case 9128 ... 9191:
            {
                int start_chn = addr - modbus_three[TREE_W_CHN_SWITCH_STA].offset;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list){
                    if(_globalPowerMangerTemp==NULL)
                            break;
                    if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                    {
                        int t_ac_CtrlType=0;
                        int nRet = 0;
                        
                        _globalPowerMangerTemp->product_ch_status = val;

                        GlobalTreeACManager *_globalTACManager = NULL;
                        list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                        {
                            t_ac_CtrlType=_globalTACManager->product_ph_outputType;
                        }
                        if (t_ac_CtrlType == 2&&(__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_Tree
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One
                        ||__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One_B))
                        {
                            if(_globalPowerMangerTemp->product_ch_type == AC_SINGLE_S_TYPE || _globalPowerMangerTemp->product_ch_type == AC_SINGLE_B_TYPE)
                            {
                                if (val == 1)
                                {
                                    if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                                        val |= ENABLE_TAC_V_UP;
                                    if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                                        val |= ENABLE_TAC_V_DOWN;
                                    if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                                        val |= ENABLE_TAC_A_UP;
                                    if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                                        val |= ENABLE_TAC_W_UP;
                                    if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                                        val |= ENABLE_TAC_P_UP;
                                }
                                g_switch_set_ac_single_s_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,  _globalPowerMangerTemp->product_saddr, 
                                                (_globalPowerMangerTemp->product_ch_addr- 1), val);
                                break;
                            }
                            unsigned short phsts=0;
                            list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                            {
                                if (val == 1 && _globalTACManager->product_ph_outputStatus==1)
                                {
                                    phsts=1;
                                    if (_globalTACManager->global_over_manager->product_vol_upper_enable == 1)
                                        phsts |= ENABLE_TAC_V_UP;
                                    if (_globalTACManager->global_over_manager->product_vol_lower_enable == 1)
                                        phsts |= ENABLE_TAC_V_DOWN;
                                    if (_globalTACManager->global_over_manager->product_cur_upper_enable == 1)
                                        phsts |= ENABLE_TAC_A_UP;
                                    if (_globalTACManager->global_over_manager->product_pwr_upper_enable == 1)
                                        phsts |= ENABLE_TAC_W_UP;
                                    if (_globalTACManager->global_over_manager->product_pwrcon_upper_enable == 1)
                                        phsts |= ENABLE_TAC_P_UP;
                                }else{
                                    phsts=0;
                                }
                                nRet= g_switch_set_t_ac_phchn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                     _globalTACManager->product_saddr, 
                                                     _globalTACManager->product_ch_addr - 1, 
                                                     phsts);
                            }
                            break;
                        }else
                        {
                            if (val == 1)
                            {
                                if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                                    val |= ENABLE_TAC_V_UP;
                                if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                                    val |= ENABLE_TAC_V_DOWN;
                                if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                                    val |= ENABLE_TAC_A_UP;
                                if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                                    val |= ENABLE_TAC_W_UP;
                                if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                                    val |= ENABLE_TAC_P_UP;
                            }
                            /*
                            if (isgroup)
                            {
                                sts |= ENABLE_TAC_STIME;
                                sts |= ENABLE_TAC_ETIME;
                            }*/
                            if (__globalDeviceManage._globalDevInfo.product_pwr_type == SmartPDU_Tree_AC_One)
                            {
                                g_switch_set_t_ac_phchn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                _globalPowerMangerTemp->product_saddr,
                                                                _globalPowerMangerTemp->product_ch_addr - 1,
                                                                val);
                            }else{
                                g_switch_set_t_ac_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                _globalPowerMangerTemp->product_saddr,
                                                                _globalPowerMangerTemp->product_ch_addr - 1,
                                                                val);
                            }
                        }
                    }
                }
            }
            break;
            case 9192:
            {
                if (val == 0 || val == 1)
                {
                    GlobalPowerManger *_globalPowerMangerTemp = NULL;
                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        if (_globalPowerMangerTemp == NULL)
                            break;

                        _globalPowerMangerTemp->product_ch_status = val;
                        int rec = g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_ch_type, _globalPowerMangerTemp->product_saddr, val);
                        // printf("rec = %d 0x%x\n",rec,val);
                    }
                }
            }
            break;
            default:
            break;
        }
    }
}

#endif



int cascade_slave_init(void)
{
    slave_handle_t *sh=&slHandle;
    GlobalDeviceManager* mgr=get_dm();
    if(sh->map)
    {
        free(sh->map);
        sh->map = NULL;
    }
    sh->map = modbus_mapping_new_start_address(0,0,0,0,DEV_CHN_REG,2000,0,0);     //3000 ge
    ip[DS_IP_DEV_CHN          ].addr = &mgr->mmp->dev_chn;
    ip[DS_IP_MAC              ].addr = &mgr->mmp->mac[0];
    ip[DS_POWER_INFO_REG      ].addr = &mgr->mmp->data[0];
    ip[DS_WANNING_REG         ].addr = &mgr->mmp->waning[0];
    return 0;
}


void cascade_slave_read(uint32_t addr,uint32_t lenth)
{
    slave_handle_t *sh=&slHandle;
    switch(addr)
    {
        case DEV_CHN_REG:
        {
            uint16_t *base_addr = (uint16_t *)ip[DS_IP_DEV_CHN].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - ip[DS_IP_DEV_CHN].offset);
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
            if(lenth < 126)
            {
                memcpy(map_addr, base_addr,2*lenth);
            }
        }
        break;
        case DEV_IP_MAC:
        {
            uint16_t *base_addr = (uint16_t *)ip[DS_IP_MAC].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - ip[DS_IP_MAC].offset);
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
            if(lenth < 126)
            {
                memcpy(map_addr, base_addr,2*lenth);
            }
        }
        case POWER_INFO_REG ... (POWER_INFO_REG+POWER_LENTH):
        {
            uint16_t *base_addr = (uint16_t *)ip[DS_POWER_INFO_REG].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - ip[DS_POWER_INFO_REG].offset);
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
            if(lenth < 126)
            {
                memcpy(map_addr, base_addr,2*lenth);
            }
        }
        break;
        case WARNING_485_IP ... (WARNING_485_IP+W_LENTH):
        {
            uint16_t *base_addr = (uint16_t *)ip[DS_WANNING_REG].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - ip[DS_WANNING_REG].offset);
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
            if(lenth < 126)
            {
                memcpy(map_addr, base_addr,2*lenth);
            }
        }
        break;
        default:
        break;
    }
}


static void memswap(uint8_t *buf, int len)
{
    int i;
    uint8_t tmp;

    for(i=0; i<len; i+=2) {
        tmp = buf[i];
        buf[i] = buf[i+1];
        buf[i+1] = tmp;
    }
}

static int _mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
{
    h->addr = data[0];
    h->func = data[1];
    h->reg  = data[2]<<8 | data[3];
    h->regcnt = data[4]<<8 | data[5];

    h->dlen = 0;
    h->data = NULL;
    if(datalen>8) {
        h->dlen = data[6];
        h->data = data+7;

        memswap(h->data, h->dlen+h->dlen%2);
    }
    //print_hdr("sss", h);

    return 0;
}

int cascade_set_ip_modbus(ModbusInfo_t *info)
{ 
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    g_modbus_deinit(&_globalDeviceManager->sensor_modbus_manager);
    if(info->product_modbus_type > 0)
    {
        int ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                            INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                            info->product_modbus_baud, // _globalSensorMangerTemp->sensor_baud,
                            info->product_modbus_type,
                            info->product_modbus_addr,
                            "ip to user",
                            1);
        g_modbus_set_slave(&_globalDeviceManager->sensor_modbus_manager,info->product_modbus_addr);
    }else
    {
        int ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                    INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                    info->product_modbus_baud, // _globalSensorMangerTemp->sensor_baud,
                    info->product_modbus_type,
                    info->product_modbus_addr,
                    "sensor",
                    1);
               
    }
    _globalDeviceManager->_globalDevInfo._gmodbus_info.product_modbus_type = info->product_modbus_type;   
    return 0;
}






void* ip_cascade_thread(void *arg)
{
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    GlobalDeviceInfo *devInfo = &_globalDeviceManager->_globalDevInfo;
    uint8_t query[512] = {0};

    int ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                        INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                        devInfo->_gmodbus_info.product_modbus_baud, // _globalSensorMangerTemp->sensor_baud,
                        devInfo->_gmodbus_info.product_modbus_type,
                        devInfo->_gmodbus_info.product_modbus_addr,
                        "ip to user",
                        1);
    g_modbus_set_slave(&_globalDeviceManager->sensor_modbus_manager,devInfo->_gmodbus_info.product_modbus_addr);
    cascade_slave_init();
    int r = 0;
    mb_hdr_t h;
    while (_globalDeviceManager->dev_samp_flag)
    {
        r = g_modbus_receive(&_globalDeviceManager->sensor_modbus_manager,query);
        if(r > 0)
        {
            _mb_hdr(query,r,&h);
            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
                cascade_slave_read(h.reg, h.regcnt);
                g_modbus_reply(&_globalDeviceManager->sensor_modbus_manager,query,r,cascade_slave_map());
            }
        }else
        {
            log_d("modbus err!!!!\n");
        }
        
    }
    pthread_exit(NULL);
}

int tcp_modbus_receive(Modbus_Manger_Tcp *tcp, uint8_t *req)
{
    int ret = 0 ;
    pthread_mutex_lock(&tcp->mutex);
    ret = modbus_receive(tcp->ctx, req);
    pthread_mutex_unlock(&tcp->mutex);
    return ret ;
}
int tcp_modbus_reply(Modbus_Manger_Tcp *tcp, uint8_t *req, int reqlen, modbus_mapping_t *map)
{
    int ret = 0 ;
    pthread_mutex_lock(&tcp->mutex);
    ret = modbus_reply(tcp->ctx, req, reqlen, map);
    pthread_mutex_unlock(&tcp->mutex);
    return ret ;
}
int tcp_modbus_set_slave(Modbus_Manger_Tcp *tcp, int saddr)
{
    int ret = 0 ;
    pthread_mutex_lock(&tcp->mutex);
    ret = modbus_set_slave(tcp->ctx, saddr);
    pthread_mutex_unlock(&tcp->mutex);
    return ret ;
}



Modbus_Manger_Tcp* tcp_modbus_init(const char* ip, uint16_t port,uint8_t addr,int power_type)
{
    Modbus_Manger_Tcp* tcp  = NULL;
    tcp = (Modbus_Manger_Tcp*)malloc(sizeof(Modbus_Manger_Tcp));
    if(!tcp)
    {
        log_d("malloc modubus manger faield!!!\n");
        goto err1;
    }
    memset(tcp, 0, sizeof(Modbus_Manger_Tcp));
    
    tcp->ctx = modbus_new_tcp(NULL, port);
    if(!tcp->ctx)
    {
        log_d("malloc modbus_tcp ctx faield!!!\n");
        goto err2;
    }
    
    struct timeval response_timeout;
    response_timeout.tv_sec = 1;
    response_timeout.tv_usec = 0;
    modbus_set_response_timeout(tcp->ctx, 0,800000);
    modbus_set_byte_timeout(tcp->ctx,0,50000);
    modbus_set_error_recovery(tcp->ctx,MODBUS_ERROR_RECOVERY_PROTOCOL);
    modbus_set_slave(tcp->ctx,addr);
    pthread_mutex_init(&tcp->mutex,NULL);
    strcpy(tcp->ip,ip);
    tcp->port = port;
    tcp->slave_id = addr;
    tcp->power_type = power_type;
    return tcp;
err2:
    free(tcp);
err1:
    return tcp;
}

void  tcp_modbus_deinit(Modbus_Manger_Tcp **tcp)
{
    Modbus_Manger_Tcp** tmp = tcp;
    if(tmp)
    {
        if(*tmp)
        {
            modbus_close((*tmp)->ctx);
            modbus_free((*tmp)->ctx);

            free(*tmp);
            *tmp = 0;   
        }
    }
    
}


static void *pthread_handle_tcp(void *arg)
{
    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};
    int ret = 0;
    //Modbus_Manger_Tcp *tcp = (Modbus_Manger_Tcp *)(arg);
    int fd = *(int*)(arg);
    Modbus_Manger_Tcp *mb =tcp_modbus_init("0.0.0.0",CASCADE_SLAVE_PORT,1,0);
    struct timeval response_timeout;
    response_timeout.tv_sec = 1;
    response_timeout.tv_usec = 0;
    modbus_set_response_timeout(mb->ctx, 0,800000);
    modbus_set_byte_timeout(mb->ctx,0,50000);
    modbus_set_error_recovery(mb->ctx,MODBUS_ERROR_RECOVERY_PROTOCOL);
    //mb->ctx->s = fd;
    mdbus_tcp_setfd(mb->ctx,fd);
    int rc = 0;
    mb_hdr_t h;
    while(1)
    {
        rc = modbus_receive(mb->ctx,query);
        //log_d("recive modbus rc=%d\n",rc);
        if(rc > 0)
        {
            _mb_hdr(&query[6],rc,&h);
            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
                cascade_slave_read(h.reg, h.regcnt);
                modbus_reply(mb->ctx,query,rc,cascade_slave_map());
            }    
            }else if(rc < 0)
            {
                log_d("thread out!!!!!\n");
                break;
            }else
            {
                continue;
            }
    }
    close(fd);
    modbus_close(mb->ctx);
    modbus_free(mb->ctx);
    mb->ctx = 0;
    free(mb);
    mb = NULL;
    pthread_exit(NULL);
}



void* tcp_modbus_thread(void *arg)
{
    //GlobalDeviceManager *mgr = (GlobalDeviceManager *)(arg);
    
    GlobalDeviceManager *mgr = get_dm();
    Modbus_Manger_Tcp *tcp = mgr->md_tcp;
    tcp->connection = modbus_tcp_listen(tcp->ctx,CASCADE_SLAVE_CONNECTION);
    ;
    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};
    
    log_d("start tcp modbus thread!!!\n");
    int rc = 0;
    pthread_t thread_id = 0;
    int recive_fd = 0;
    while(1)
    {
        if(tcp->ctx){

            struct sockaddr_in addr;
            socklen_t addrlen;
            addrlen = sizeof(addr);
#ifdef HAVE_ACCEPT4
                /* Inherit socket flags and use accept4 call */
                recive_fd = accept4(tcp->connection, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC);
#else
                recive_fd = accept(tcp->connection, (struct sockaddr *)&addr, &addrlen);
#endif
            if(recive_fd > 0)
            {
                pthread_create(&thread_id,NULL,pthread_handle_tcp,(void*)(&recive_fd));
                pthread_detach(thread_id);
            }
        }
    }

}



void sensor_or_cascade_init()
{
    //GlobalDeviceManager* dm =get_dm();
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    //INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);
    //INIT_LIST_HEAD(&dm->_globalSensorManger.list);
    GlobalDeviceInfo *devInfo = &_globalDeviceManager->_globalDevInfo;
    //uint8_t query[512] = {0};
    int ret = 0;
    // ret = dev_get_sensor_manage_info(_globalDeviceManager->db,
    //                                 _globalDeviceManager->_globalDevInfo.product_id,
    //                                 &_globalDeviceManager->_globalSensorManger);


    //dev_get_sensor_info
    // GlobalSensorManger *temp = (GlobalSensorManger*)malloc(sizeof(GlobalSensorManger));
    // if(!temp)
    //     return;
    // dev_get_sensor_info(_globalDeviceManager->db,0,0,temp);

    // list_add_tail(&temp->list,&_globalDeviceManager->_globalSensorManger.list);
          
    //dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"sensor");
    cascade_slave_init();
    if(devInfo->_gmodbus_info.product_modbus_type > 0)
    {
        int ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                        INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                        devInfo->_gmodbus_info.product_modbus_baud, // _globalSensorMangerTemp->sensor_baud,
                        devInfo->_gmodbus_info.product_modbus_type,
                        devInfo->_gmodbus_info.product_modbus_addr,
                        "ip to user",
                        1);
        g_modbus_set_slave(&_globalDeviceManager->sensor_modbus_manager,devInfo->_gmodbus_info.product_modbus_addr);
    }else
    {
        int ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                    INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                    INTERL_SENSOR_MODBUS_BAUD, // _globalSensorMangerTemp->sensor_baud,
                    0,
                    0,
                    "ip to user",
                    1);
    }
    pthread_mutex_init(&_globalDeviceManager->_sensor_update,NULL);


    thread_start(THREAD_ID_SENSOR, thread_sensor_or_485, _globalDeviceManager, 5*MB, 0);
}

extern void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType);

void * thread_sensor_or_485(void*arg)
{
    thread_handle_t *h=(thread_handle_t*)arg;
    //GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)h->arg;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    GlobalSensorManger *_globalSensorMangerTemp;
    int ret = 0;
    GlobalSensorInfo _globalSensorInfo;
    struct tm *t;
    struct timeval tv;
    struct timezone tz;
    int r = 0;
    mb_hdr_t mb_h;
    GlobalDeviceInfo *devInfo = &_globalDeviceManager->_globalDevInfo;
    uint8_t query[512] = {0};

    float temperature = 0.0;
    float humidity = 0.0;
    int nSaveIndex = 1;
    char strTable[] = "Table_SensorInfo";
    char strTemp[64] = {0};
   // dev_search_last_Index(_globalDeviceManager->db, &nSaveIndex, strTable); // 查询日志最大点
   // int nMaxIndex = 2000000000;
   // int nDeleteNumber = 1000 / 120000 * 3600 * 24 * 30 * 10; // 1/60s;

    while(_globalDeviceManager->dev_samp_flag)
    {
        if(devInfo->_gmodbus_info.product_modbus_type > 0)
        {
            //printf("12323451541545135435\n");
            //dev_search_last_Index(_globalDeviceManager->db, &nSaveIndex, strTable);
            // pthread_mutex_lock(&__globalDeviceManage._sensor_update);

            // pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
            list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
            {
                if(_globalSensorMangerTemp->product_id == 0){
                    switch (_globalSensorMangerTemp->sensor_type)
                    {
                        case SENSOR_TYPE_TEMPERATURE:
                        {
                            _globalSensorInfo.val1 = 0.0;
                            _globalSensorInfo.val2 = 0.0;
                            _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                            _globalDeviceManager->g_modebus_read.temprature=0.0;
                            _globalDeviceManager->g_modebus_read.humidity=0.0;
                            _globalSensorMangerTemp->sensor_status = 1;
                        }
                        default:
                        break;
                    }
                    break;
                }
            }
            r = g_modbus_receive(&_globalDeviceManager->sensor_modbus_manager,query);
            if(r > 0)
            {
                _mb_hdr(query,r,&mb_h);
                if(mb_h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
                    cascade_slave_read(mb_h.reg, mb_h.regcnt);
                    g_modbus_reply(&_globalDeviceManager->sensor_modbus_manager,query,r,cascade_slave_map());
                }
            }else
            {
                log_d("modbus err!!!!\n");
            }

        }else
        {
            //printf("--------------------------\n");
            // if (nSaveIndex > nMaxIndex)
            // {
            //     dev_change_last_Index(_globalDeviceManager->db, &nSaveIndex, nDeleteNumber, strTable);
            // }
            // pthread_mutex_lock(&__globalDeviceManage._sensor_update);
            //list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
            //{
            //     if(_globalSensorMangerTemp->product_id == 0)
            //     {
            //         switch (_globalSensorMangerTemp->sensor_type)
            //         {
            //             case SENSOR_TYPE_TEMPERATURE: // 温湿度
            //             {
            //                 // printf("get \n");
            //                 float temperature = 0.0;
            //                 float humidity = 0.0;
            //                 ret = _g_sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
            //                                                     _globalSensorMangerTemp->sensor_addr,
            //                                                     &temperature,
            //                                                     &humidity);

            //                 if (ret == -1)
            //                 {
            //                     _globalSensorMangerTemp->sensor_status = 1;
            //                 }
            //                 else
            //                 {
            //                     _globalSensorMangerTemp->sensor_status = 0;
            //                 }
            //                 // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
            //                 // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
            //                 gettimeofday(&tv, &tz);
            //                 t = localtime(&tv.tv_sec);
            //                 sprintf(_globalSensorInfo.samp_time, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
            //                         t->tm_year + 1900, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
            //                 _globalSensorInfo.product_id = __globalDeviceManage._globalDevInfo.product_id;
            //                 _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id;
            //                 _globalSensorInfo.val1 = temperature;
            //                 _globalSensorInfo.val2 = humidity;

            //                 _globalSensorInfo.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;
            //                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
            //                 _globalDeviceManager->g_modebus_read.temprature=temperature *1000;
            //                 _globalDeviceManager->g_modebus_read.humidity=humidity *1000;
            //             }
            //             break;
            //             default:
            //             break;
            //         }
            //             // 通用功能
            //             //  写入数据库
            //             gettimeofday(&tv, NULL);
            //             time_t now;
            //             time(&now);
            //             t = localtime(&now);
            //             char buffer[80];
            //             strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
            //             memset(_globalSensorMangerTemp->Cur_sensor_info.samp_time, 0, sizeof(_globalSensorMangerTemp->Cur_sensor_info.samp_time));
            //             strftime(_globalSensorMangerTemp->Cur_sensor_info.samp_time, sizeof(_globalSensorMangerTemp->Cur_sensor_info.samp_time), "%Y-%m-%d %H:%M:%S", t);
            //             sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
            //             strcat(_globalSensorMangerTemp->Cur_sensor_info.samp_time, buffer);
            //             if (difftime(now, _globalSensorMangerTemp->Cur_sensor_info.product_log_time) > (30000 / 1000))
            //             {
            //                 _globalSensorMangerTemp->Cur_sensor_info.product_log_time = now;
            //                 // 插入数据库
            //                 ret = dev_insert_sensor_info(_globalDeviceManager->db, &_globalSensorMangerTemp->Cur_sensor_info, &nSaveIndex);
            //                 if (ret != 0)
            //                 {
            //                     log_e("sensor_temp_write database error.");
            //                 }
            //             }
            //             if (_globalSensorMangerTemp->sensor_status == 0)
            //             {
            //                 sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL1_UPPER);
            //                 sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL1_LOWER);
            //                 sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL2_UPPER);
            //                 sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL2_LOWER);
            //             }
            //             break;
            //     }
            // }
            // pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
            sleep(1);

        }
    }
    pthread_exit(NULL);
    return NULL;
}