SmartPDCode/pro/src/cascade_slave.c

#include "modbus.h"
#include "common.h"
#include "list.h"
#include "switch_ctrl.h"
#include "cascade.h"
#include "sqlite_handle.h"



#define DEV_CHN_REG                 (4000)  
#define OUT_INFO_REG                (4001)     
#define IN_TOTAL_REG                (4768)  
#define TEM_HUMAN_REG               (4777)       
#define CHN_SWITCH_REG              (4779)
#define CHN_OPEN_DLA_REG            (4843)
#define CHN_CLOSE_DLA_REG           (4907)
#define SENSOR_REG                  (4971)
#define DRY_REG                     (4987)
#define BREAKER                     (4991)     
#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)


#ifdef NORTH_USER_SPECILS

    #define  SPAECIL_USER_TOTAL_CONSUMER                  (40  )
    #define  SPAECIL_USER_TOTAL_POWER                     (49  )
    #define  SPAECIL_USER_STATUS                          (100 )
    #define  SPAECIL_USER_STATUS_64                       (103 )
    #define  SPAECIL_USER_WANING                          (2000)
    #define  SPAECIL_USER_FATAL_64                        (2005)
    #define  SPAECIL_USER_SET_1                           (3001)
    #define  SPAECIL_USER_SET_64                          (3004)  

enum{
    N_SPAECIL_CON = 0,
    N_SPAECIL_STA,
    N_SPAECIL_WANING,
    N_SPAECIL_SET,
};



static mmap_modbus_t north_specil[] = {
    [N_SPAECIL_CON       ]{.offset = SPAECIL_USER_TOTAL_CONSUMER             },
    [N_SPAECIL_STA       ]{.offset = SPAECIL_USER_STATUS                     },
    [N_SPAECIL_WANING    ]{.offset = SPAECIL_USER_WANING                     },
    [N_SPAECIL_SET       ]{.offset = SPAECIL_USER_SET_1                     },
};


#endif


enum{
    TYPE_U16,
    TYPE_U32
};
enum{
    NO_OPPERATION = 0,
    OPEN,
    CLOSE,
};

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_R_SENSOR,
    DS_R_DRY,
    DS_R_BREAKER,
    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_SENSOR_REG                 (8779)
#define TREE_DRY_REG                    (8795)
#define TREE_BREKAER                    (8799)

#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_R_SENSOR,
    TREE_R_DRY,
    TREE_R_BREAKER,
    TREE_W_OPEN_DELAY,
    TREE_W_CLOSE_DELAY,
    TREE_W_CHN_SWITCH_STA,
    TREE_W_ALL_CHN_STA
};




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


static mmap_modbus_t modbus_single[] = {
    [DS_R_DEV_CHN       ]{.offset = DEV_CHN_REG             },
    [DS_R_OUT_INFO      ]{.offset = OUT_INFO_REG            },
    [DS_R_IN_TOTAL      ]{.offset = IN_TOTAL_REG            },
    [DS_R_TEMP_HUM      ]{.offset = TEM_HUMAN_REG           },
    [DS_R_SWITCH_STA    ]{.offset = CHN_SWITCH_REG          },
    [DS_R_OPEN_DELAY    ]{.offset = CHN_OPEN_DLA_REG        },
    [DS_R_CLOSE_DELAY   ]{.offset = CHN_CLOSE_DLA_REG       },
    [DS_R_SENSOR        ]{.offset = SENSOR_REG              },
    [DS_R_DRY           ]{.offset = DRY_REG                 }, 
    [DS_R_BREAKER       ]{.offset = BREAKER                 },               
    [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_R_SENSOR          ]{.offset = TREE_SENSOR_REG         },
    [TREE_R_DRY             ]{.offset = TREE_DRY_REG             }, 
    [TREE_R_BREAKER         ]{.offset = TREE_BREKAER            },
    [TREE_W_OPEN_DELAY      ]{.offset = TREE_CHN_SET_OPEN_DLA_REG},
    [TREE_W_CLOSE_DELAY     ]{.offset = TREE_CHN_SET_CLOSE_DLA_REG},
    [TREE_W_CHN_SWITCH_STA  ]{.offset = TREE_CHN_SET_SWITCH_STA_REG},
    [TREE_W_ALL_CHN_STA     ]{.offset = TREE_ALL_SET_SWITCH_REG }
};

typedef struct { 
    modbus_mapping_t    *map;
}slave_handle_t;

static slave_handle_t slHandle;


modbus_mapping_t    *cascade_slave_map()
{
    return slHandle.map;
}

int cascade_slave_init(void)
{
    slave_handle_t *sh=&slHandle;
    GlobalDeviceManager* mgr=get_dm();

    if(mgr->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
        mgr->_globalDevInfo.product.pwr_type == SmartPDU_DC)       // single AC
    {
        if(sh->map)
        {
            free(sh->map);
            sh->map = NULL;
        }
        sh->map = modbus_mapping_new_start_address(0,0,0,0,DEV_CHN_REG,5000,0,0);     //3000 ge
        modbus_single[DS_R_DEV_CHN          ].addr = &mgr->single_mmap->dev_chn;
        modbus_single[DS_R_OUT_INFO         ].addr = &mgr->single_mmap->all_ch;
        modbus_single[DS_R_IN_TOTAL         ].addr = &mgr->single_mmap->total_valtage;
        modbus_single[DS_R_TEMP_HUM         ].addr = &mgr->single_mmap->total_temp;
        modbus_single[DS_R_SWITCH_STA       ].addr = &mgr->single_mmap->chn_status; 
        modbus_single[DS_R_OPEN_DELAY       ].addr = &mgr->single_mmap->open_delay;
        modbus_single[DS_R_CLOSE_DELAY      ].addr = &mgr->single_mmap->close_delay;
        modbus_single[DS_R_SENSOR           ].addr = &mgr->single_mmap->cas_sensor[0];
        modbus_single[DS_R_DRY              ].addr = &mgr->single_mmap->d_node[0];
        modbus_single[DS_R_BREAKER          ].addr = &mgr->single_mmap->breaker_value;
        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;
        }
#ifndef NORTH_USER_SPECILS
        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_R_SENSOR          ].addr = &mgr->triphasic_mmap->cas_sensor[0];
        modbus_three[TREE_R_DRY             ].addr = &mgr->triphasic_mmap->d_node[0];
        modbus_three[TREE_R_BREAKER         ].addr = &mgr->triphasic_mmap->breaker_value;
        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;
#else
        sh->map =  modbus_mapping_new_start_address(0,0,0,0,SPAECIL_USER_TOTAL_CONSUMER,4000,0,0);
        north_specil[N_SPAECIL_CON          ].addr = &mgr->north_user.total_elec_energy;
        north_specil[N_SPAECIL_STA          ].addr = &mgr->north_user.status_1_16;
        north_specil[N_SPAECIL_WANING       ].addr = &mgr->north_user.total_wanning;
        north_specil[N_SPAECIL_SET          ].addr = &mgr->north_user.set_1_16 ;
#endif
        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)
#ifdef NORTH_USER_SPECILS
{
    slave_handle_t *sh=&slHandle;
    GlobalDeviceManager* mgr=get_dm();
    /*
        #define  SPAECIL_USER_TOTAL_CONSUMER                  (40  )
        #define  SPAECIL_USER_TOTAL_POWER                     (49  )
        #define  SPAECIL_USER_STATUS                          (100 )
        #define  SPAECIL_USER_STATUS_64                       (103 )
        #define  SPAECIL_USER_WANING                          (2000)
        #define  SPAECIL_USER_FATAL_64                        (2005)
        #define  SPAECIL_USER_SET_1                           (3001)
        #define  SPAECIL_USER_SET_64                          (3004)  
    */
    switch(addr)
    {
        case SPAECIL_USER_TOTAL_CONSUMER ... SPAECIL_USER_TOTAL_POWER:
        {
            int step = addr - SPAECIL_USER_TOTAL_CONSUMER;
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[addr - SPAECIL_USER_TOTAL_CONSUMER]);
            uint16_t *offset_addr = (uint16_t*)(north_specil[N_SPAECIL_CON].addr) + step;
            memcpy(map_addr,offset_addr,lenth*2);
        }
        break;
        case SPAECIL_USER_STATUS ... SPAECIL_USER_STATUS_64:
        {
            int step = addr - SPAECIL_USER_STATUS;
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[addr - SPAECIL_USER_TOTAL_CONSUMER]);
            uint16_t *offset_addr = (uint16_t*)(north_specil[N_SPAECIL_STA].addr) + step;
            memcpy(map_addr,offset_addr,lenth*2);
        }
        break;
        case SPAECIL_USER_WANING ... SPAECIL_USER_FATAL_64:
        {
            int step = addr - SPAECIL_USER_WANING;
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[addr - SPAECIL_USER_TOTAL_CONSUMER]);
            uint16_t *offset_addr = (uint16_t*)(north_specil[N_SPAECIL_WANING].addr) + step;
            memcpy(map_addr,offset_addr,lenth*2);
        }
        break;
        default:
            break;
    }
}
#else
{
    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 SENSOR_REG ... (DRY_REG-1):
            slave_read(sh,addr,lenth,DS_R_SENSOR,TYPE_U32);
        break;
        case DRY_REG ... BREAKER:
            slave_read(sh,addr,lenth,DS_R_DRY,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;
        case TREE_SENSOR_REG ... (TREE_DRY_REG-1):
            slave_read(sh,addr,lenth,TREE_R_SENSOR,TYPE_U32);
        break;
        case TREE_DRY_REG ... TREE_BREKAER:
            slave_read(sh,addr,lenth,TREE_R_DRY,TYPE_U16);
        break;
        default:
        break;
    }
}
#endif





void cascade_slave_write(uint32_t addr, uint16_t val)
#ifdef NORTH_USER_SPECILS
{
    GlobalDeviceManager* mgr=get_dm();
    if(mgr->_globalDevInfo.product.pwr_type == SmartPDU_AC 
            || mgr->_globalDevInfo.product.pwr_type == SmartPDU_DC) 
    {

    }else
    {
        switch(addr)
        {
            case SPAECIL_USER_SET_1 ... SPAECIL_USER_SET_64:
            {
                int step = addr - SPAECIL_USER_SET_1;
                uint16_t * offset_addr = (uint16_t*)(north_specil[N_SPAECIL_STA].addr + step);
                uint16_t buff[16] = {0};
                if(*offset_addr != val)
                {
                    uint16_t data = (*offset_addr ^ val); 
                    for(int i = 0; i < 16;i++)
                    {
                        if(data & (1 << i))
                        {
                            //buff[i] = 1;
                            if(val & (1 << i))
                            {
                                // open
                                buff[i] = OPEN;
                            }else
                            {
                                // close
                                buff[i] = CLOSE;
                            }
                        }
                    }
                    for(int i = 0; i < 16;i++)
                    {
                        if(buff[i])
                        {
                            int start_chn = step*16 + i;
                            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;
                                    uint16_t write_data =  buff[i] == OPEN ? 1 : 0;
                                    _globalPowerMangerTemp->product_ch_status = write_data;

                                    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_Two
                                    ||__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 (write_data == 1)
                                            {
                                                if (_globalPowerMangerTemp->global_over_manager.product_vol_upper_enable == 1)
                                                    write_data |= ENABLE_TAC_V_UP;
                                                if (_globalPowerMangerTemp->global_over_manager.product_vol_lower_enable == 1)
                                                    write_data |= ENABLE_TAC_V_DOWN;
                                                if (_globalPowerMangerTemp->global_over_manager.product_cur_upper_enable == 1)
                                                    write_data |= ENABLE_TAC_A_UP;
                                                if (_globalPowerMangerTemp->global_over_manager.product_pwr_upper_enable == 1)
                                                    write_data |= ENABLE_TAC_W_UP;
                                                if (_globalPowerMangerTemp->global_over_manager.product_pwrcon_upper_enable == 1)
                                                    write_data |= ENABLE_TAC_P_UP;
                                            }
                                            g_switch_set_ac_single_s_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,  _globalPowerMangerTemp->product_saddr, 
                                                            (_globalPowerMangerTemp->product_ch_addr- 1), write_data);
                                            break;
                                        }
                                        unsigned short phsts=0;
                                        list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                                        {
                                            if (write_data == 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);
                                        }
                                        g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, write_data);
                                        break;
                                    }else
                                    {
                                        if (write_data == 1)
                                        {
                                            if (_globalPowerMangerTemp->global_over_manager.product_vol_upper_enable == 1)
                                                write_data |= ENABLE_TAC_V_UP;
                                            if (_globalPowerMangerTemp->global_over_manager.product_vol_lower_enable == 1)
                                                write_data |= ENABLE_TAC_V_DOWN;
                                            if (_globalPowerMangerTemp->global_over_manager.product_cur_upper_enable == 1)
                                                write_data |= ENABLE_TAC_A_UP;
                                            if (_globalPowerMangerTemp->global_over_manager.product_pwr_upper_enable == 1)
                                                write_data |= ENABLE_TAC_W_UP;
                                            if (_globalPowerMangerTemp->global_over_manager.product_pwrcon_upper_enable == 1)
                                                write_data |= 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,
                                                                            write_data);
                                        }else{
                                            g_switch_set_t_ac_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                            _globalPowerMangerTemp->product_saddr,
                                                                            _globalPowerMangerTemp->product_ch_addr - 1,
                                                                            write_data);
                                        }
                                    }
                                }
                            }
                            ////////////////////////////////////////////////////////////////
                            // if(buff[i] == OPEN)
                            // {
                            //     *offset_addr |= (1 << i); 
                            // }else
                            // {
                            //     *offset_addr &= ~(1 << i);
                            // }
                            buff[i] = 0;
                        }
                    }
                }

            }
            break;
            default:
                break;
        }
    }
}
#else
{
    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_Two
                        ||__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_Two
                        ||__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_Two
                        ||__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);
                            }
                            g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, val);
                            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);

                        g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, val);
                    }
                }
            }
            break;
            default:
            break;
        }
    }
}
#endif