#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; iaddr = 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; }