SmartPDCode/pro/src/app.c

#include "app.h"
#include "common.h"
#include "switch_ctrl.h"
#include "appweb_handle.h"
#include "modbus_handle.h"
#include "sqlite_handle.h"
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include "elog.h"
#include "sensor_handle.h"
#include "websocket_handle.h"
#include "paras.h"
#include "thread.h"
#include "cascade.h"
#include "upg.h"
#include "sys.h"
#include "cfg.h"
#include "lock.h"
#include "mail.h"
#include "mqtt.h"
#include "netswitch.h"
#include "breaker_detection.h"
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <math.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "pduMIB_trap.h"
#include "Cellular.h"
#include "wifi.h"
#include <sys/msg.h>
#include "stdlib.h"
#include "led.h"
#include "beep.h"


static void* power_thread(void* arg)
{
    int ret = 0 ;
    bool isFirstRun=false;//标记地第一轮运行
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalPowerInfo _globalPowerInfo ;
    GlobalPowerInfo _globalTotalPowerInfo ; //总电源信息
    GlobalTreeACManager* pTreeAPowerInfo;    //三相子电源信息
    GlobalTreeACManager* _pTreeACPowerMangerTemp = NULL ;                
    PowerWarningInfo _globalPowerWarningInfo ;
    PowerWarningInfo _globalTACWarningInfo;
    float Vavg[3]={0.0,0.0,0.0};
    int VavgTimes[3]={0,0,0};
    struct tm* t ;
    struct timeval tv;
    struct timezone tz ;
    int lastIndex=0,lastIndex3=0;
    char *tabPower="Table_PowerInfo",*tabPower3="Table_PhasePowerInfo";
    thread_handle_t *h=(thread_handle_t*)arg;
    GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)h->arg;
    _PowerDSManage_t* _powerDsManageTemp = NULL ;
    ProductInfo_t *prod=&_globalDeviceManager->_globalDevInfo.product;
    unsigned int samp_time = _globalDeviceManager->_globalDevInfo.product.samp_time;
    unsigned int usleepTime = samp_time*1000;
    unsigned int sSaveTime = _globalDeviceManager->_globalDevInfo.product.save_time;
    log_d("samp_time:%dms save_time:%dms\n", samp_time,sSaveTime);

    bool isErrorBreak=false;
    _globalDeviceManager->_ReloadChm_flag=false;

    dev_search_last_Index(_globalDeviceManager->db, &lastIndex, tabPower);       // 查询日志最大点
    dev_search_last_Index(_globalDeviceManager->db, &lastIndex3, tabPower3);      // 查询日志最大点
    //初始化启动延时
    log_d("START_INI_DELAY");
    list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
    {
        ret = g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay);
        if (ret<0)
        {
            //usleep(300000);
            g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay);
        }   
        //usleep(300000);  
        ret=g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay);
        if (ret<0)
        {
           // usleep(300000);
            g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay);
        }
        //usleep(300000);
        if (_globalPowerMangerTemp->product_ch_type == DOUBLE_AC_TYPE)
        {
            GlobalTreeACManager *_globalTACManager = NULL;
            list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
            {
                short nCtrlType = 2;
                if (_globalTACManager->product_ph_outputStatus == 1)
                {
                    nCtrlType = 0;
                }
                g_switch_set_t_ac_ph_ctrl_mode(&__globalDeviceManage._globalRelaySampManger, _globalTACManager->product_saddr, _globalTACManager->product_ch_addr - 1, nCtrlType);
            }
        }
    }
    // 初始化阈值信息
    log_d("START_INI_TRESTHOLD");
    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)
    {
        log_d("TRESTHOLD_TAC_INI");
        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
        {
            GlobalTreeACManager *_pTreeACPowerMangerTemp = NULL;
            list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
            {
                _pTreeACPowerMangerTemp->global_over_manager = _globalPowerMangerTemp->global_over_manager;
                ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger,
                                                        _globalPowerMangerTemp->product_ch_type,
                                                        _pTreeACPowerMangerTemp->product_saddr,
                                                        _pTreeACPowerMangerTemp->product_ch_addr,
                                                        _globalPowerMangerTemp, 0);
            }
        }
    }
    else
    {
        log_d("TRESTHOLD_AC/DC_INI");
        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
        {
            ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger,
                                                    _globalPowerMangerTemp->product_ch_type,
                                                    _globalPowerMangerTemp->product_saddr,
                                                    _globalPowerMangerTemp->product_ch_addr,
                                                    _globalPowerMangerTemp,0);
         log_i("TRESTHOLD ch:%d  VUP:%0.2f VDOWN:%0.2f CurUP:%0.2f PUP:%0.2f ConsUP:%0.2f",_globalPowerMangerTemp->product_ch_id,_globalPowerMangerTemp->global_over_manager.product_vol_upper_threshold,_globalPowerMangerTemp->global_over_manager.product_vol_lower_threshold,
                    _globalPowerMangerTemp->global_over_manager.product_cur_upper_threshold,_globalPowerMangerTemp->global_over_manager.product_pwr_upper_threshold,_globalPowerMangerTemp->global_over_manager.product_pwrcon_upper_threshold);
        }
    }
    //采集线程
    while (h->quit==0)
    {
        if (_globalDeviceManager->_ReloadChm_flag || _globalDeviceManager->upgread_flag)
        {
            sleep(1);
            continue;
        }
        
        memset(&_globalTotalPowerInfo, 0, sizeof(GlobalPowerInfo));
        memset(&_globalPowerWarningInfo, 0, sizeof(PowerWarningInfo));
        for (size_t i = 0; i <= _globalDeviceManager->brdMax; i++)
        {
            if(h->quit)
            {
                break;
            }

            if (_globalDeviceManager->pCtrlBoard[i].product_saddr == 0)
            {
                continue;
            }
            ret=g_switch_get_all_out_info(&_globalDeviceManager->_globalRelaySampManger,
                                        _globalDeviceManager->pCtrlBoard[i].product_type,
                                        _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                        _globalDeviceManager->pCtrlBoard[i].product_number,
                                        _globalDeviceManager->pCtrlBoard[i]._PowerInfo,
                                            _globalDeviceManager->pCtrlBoard[i]._PowerWarninginfo);
            if (ret<0)
            {
                usleep(usleepTime);
                ret = g_switch_get_all_out_info(&_globalDeviceManager->_globalRelaySampManger,
                                                _globalDeviceManager->pCtrlBoard[i].product_type,
                                                _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                                _globalDeviceManager->pCtrlBoard[i].product_number,
                                                _globalDeviceManager->pCtrlBoard[i]._PowerInfo,
                                                _globalDeviceManager->pCtrlBoard[i]._PowerWarninginfo);
               //暂时屏蔽，可能导致采集数据为0，后续需要优化处理逻辑或等E235控制板串口性能提升后再放开处理逻辑
               // if(ret <0 )
              //  {
                 //   memset(&_globalDeviceManager->pCtrlBoard[i]._PowerInfo, 0, sizeof(PowerInfo)*AC_SINGLE_S_MAX_CHN_NUM );
                //}
            }
            // 输入总信息(三相)(后续应同步所有类型)
            if (_globalDeviceManager->pCtrlBoard[i].product_saddr != 0 && (_globalDeviceManager->pCtrlBoard[i].product_type == TREE_AC_TYPE||_globalDeviceManager->pCtrlBoard[i].product_type ==DOUBLE_AC_TYPE))
            {
                usleep(usleepTime);
                ret = g_switch_get_t_ac_in_info(&_globalDeviceManager->_globalRelaySampManger,
                                                _globalDeviceManager->pCtrlBoard[i].product_saddr, // saadr
                                                _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo,
                                                _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerWarninginfo);
                if (ret < 0)
                {
                    usleep(usleepTime);
                    ret = g_switch_get_t_ac_in_info(&_globalDeviceManager->_globalRelaySampManger,
                                                    _globalDeviceManager->pCtrlBoard[i].product_saddr, // saadr
                                                    _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo,
                                                    _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerWarninginfo);
                    //暂时屏蔽，可能导致采集数据为0，后续需要优化处理逻辑或等E235控制板串口性能提升后再放开处理逻辑
                    //if(ret <0 )
                   // {
                     //   memset(&_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo, 0, sizeof(PowerInfo) *3);
                   // }
                }
                //计算控制板每相输入总功率因数

                for (size_t p = 0; p < 3; p++)
                {
                    float nYGPower = 0;
                    float nSZPower = 0;
                    for (size_t s = 0; s < AC_SINGLE_S_MAX_CHN_NUM; s++)
                    {
                        if (_globalDeviceManager->pCtrlBoard[i].product_type == TREE_AC_TYPE)
                        {
                            if (s % 3 == p)
                            {
                                nSZPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power;
                                nYGPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power * _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].factor;
                            }
                        }
                        else if (_globalDeviceManager->pCtrlBoard[i].product_type == DOUBLE_AC_TYPE)
                        {
                            if (_globalDeviceManager->pCtrlBoard[i].nLeft_phType == p && s < 4)
                            {
                                nSZPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power;
                                nYGPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power * _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].factor;
                            }
                            if (_globalDeviceManager->pCtrlBoard[i].nRight_phType == p && (s >= 4 && s < 8))
                            {
                                nSZPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power;
                                nYGPower += _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].power * _globalDeviceManager->pCtrlBoard[i]._PowerInfo[s].factor;
                            }
                        }
                    }
                    if (nSZPower > 0)
                    {
                        _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor = nYGPower / nSZPower;
                    }
                    else
                        _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor = 0;

                    if (_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor > 1)
                    {
                        _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor = 1;
                    }
                    else if (_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor < 0)
                    {
                        _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[p].factor = 0;
                    }
                }

                ret = g_switch_set_t_ac_alarm_missing_ph(&_globalDeviceManager->_globalRelaySampManger,
                                                         _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                                         _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger.product_MissingPH);
                if (ret < 0)
                {
                    usleep(usleepTime);
                    ret = g_switch_set_t_ac_alarm_missing_ph(&_globalDeviceManager->_globalRelaySampManger,
                                                             _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                                             _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger.product_MissingPH);
                }
            }            
            //usleep(usleepTime);
        }
        bool SaveDBFlag=false; //数据库存储记录，只要有通道存，就存一次总通道数据  
        int _chn = 0;
        memset(Vavg,0.0,sizeof(Vavg));
        memset(VavgTimes,0,sizeof(VavgTimes));
        
        lock_s_hold(LOCK_ID_POWER_UPDATE);
        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B)
        {
            list_for_each_entry(pTreeAPowerInfo, &_globalDeviceManager->_globalPowerManger.list_Tree_AC, list_Tree_AC)
            {
                int nTreeACType = pTreeAPowerInfo->product_ph_type;
                if (nTreeACType < 0 || nTreeACType > 3) // 不是ABC相的情况直接跳过
                {
                    continue;
                }
                memset(&pTreeAPowerInfo->_PowerInfo, 0, sizeof(PowerInfo));
            }
        }

        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
        {
            //获取通道类型
            if(h->quit)
            {
                break;
            }

            if (!(_globalPowerMangerTemp->product_saddr <= _globalDeviceManager->brdMax && _globalPowerMangerTemp->product_saddr > 0))
            {
            	continue;
            }
            if (!(_globalPowerMangerTemp->product_ch_addr < AC_SINGLE_S_MAX_CHN_NUM && _globalPowerMangerTemp->product_ch_addr > 0))
            {
                continue;
            }
            //log_d("ch%d cpy address:%d,chraddr:%d.\n",_globalPowerMangerTemp->product_ch_id,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr);
            memcpy(&_globalPowerInfo._power_info,
            &_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
            sizeof(PowerInfo));
            if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
                _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
            {
                if (_chn<64)
                {
                    _globalDeviceManager->single_mmap->all_ch[_chn].consumption = _globalPowerInfo._power_info.consumption * 1000;
                    _globalDeviceManager->single_mmap->all_ch[_chn].voltage = _globalPowerInfo._power_info.voltage * 1000;
                    _globalDeviceManager->single_mmap->all_ch[_chn].factor = _globalPowerInfo._power_info.factor * 1000;
                    _globalDeviceManager->single_mmap->all_ch[_chn].freq = _globalPowerInfo._power_info.freq * 1000;
                    _globalDeviceManager->single_mmap->all_ch[_chn].power = _globalPowerInfo._power_info.power * 1000;
                    _globalDeviceManager->single_mmap->all_ch[_chn].current = _globalPowerInfo._power_info.current * 1000;
                    _globalDeviceManager->single_mmap->chn_status[_chn] = _globalPowerInfo._power_info.status;
                    _globalDeviceManager->single_mmap->open_delay[_chn] = _globalPowerMangerTemp->product_ch_start_delay;
                    _globalDeviceManager->single_mmap->close_delay[_chn] = _globalPowerMangerTemp->product_ch_stop_delay;
                }
            }
            
            memcpy(&_globalPowerWarningInfo,
            &_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
            sizeof(PowerWarningInfo));

            switch (_globalPowerMangerTemp->product_ch_type)
            {
              case AC_SINGLE_S_TYPE:
              case AC_SINGLE_B_TYPE:
                  {
                    //累加总电源信息
                    _globalTotalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
                    _globalTotalPowerInfo.product_status = 0 ;
                    _globalTotalPowerInfo._power_info.voltage =  _globalTotalPowerInfo._power_info.voltage > _globalPowerInfo._power_info.voltage ? _globalTotalPowerInfo._power_info.voltage : _globalPowerInfo._power_info.voltage;
                    _globalTotalPowerInfo._power_info.current += _globalPowerInfo._power_info.current ;
                    _globalTotalPowerInfo._power_info.power += _globalPowerInfo._power_info.power ;
                    _globalTotalPowerInfo._power_info.freq =  _globalTotalPowerInfo._power_info.freq > _globalPowerInfo._power_info.freq ? _globalTotalPowerInfo._power_info.freq : _globalPowerInfo._power_info.freq;
                    _globalTotalPowerInfo._power_info.consumption += _globalPowerInfo._power_info.consumption ;
                    _globalTotalPowerInfo._power_info.factor = _globalTotalPowerInfo._power_info.factor > _globalPowerInfo._power_info.factor ? _globalTotalPowerInfo._power_info.factor : _globalPowerInfo._power_info.factor;

                    //补全信息
                    _globalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalPowerInfo.product_ch_id = _globalPowerMangerTemp->product_ch_id ;
                    _globalPowerInfo.product_status = _globalPowerInfo._power_info.status ;

                    gettimeofday(&tv, NULL);
                    //t = localtime(&tv.tv_sec);

                    time_t now;
                    time(&now);
                    t = localtime(&now);

                    char buffer[80];
                    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                    memset(_globalPowerInfo.samp_time,0,sizeof(_globalPowerInfo.samp_time));
                    strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                    sprintf(buffer,".%03ld",tv.tv_usec/1000);
                    strcat(_globalPowerInfo.samp_time,buffer);

                    if (difftime(now,_globalPowerMangerTemp->product_log_time)>(sSaveTime/1000))
                    {
                        _globalPowerMangerTemp->product_log_time=now;
                        SaveDBFlag=true;
                        /* code */
                        //插入数据库
                        if(dev_insert_power_info(_globalDeviceManager->db,&_globalPowerInfo,&lastIndex)!=0)
                        {
                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }

                    }
                    
                    //判断阈值状态
                    if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*高电压 */
                       if (_globalPowerWarningInfo.w_voltage_up) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);       
                    }
                    if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                        /*低电压 */
                       if(_globalPowerWarningInfo.w_voltage_down) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_DOWN);
                    }
                    if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                       if(_globalPowerWarningInfo.w_current) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
                    }
                    if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                       if(_globalPowerWarningInfo.w_power) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
                    }
                    if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                        if(_globalPowerWarningInfo.w_consumption)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
                    }
                    //动作
                    if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B)
                    {
                        GlobalTreeACManager *_pTreeACPowerPhData = NULL;
                        memset(&_globalPowerInfo._power_info, 0, sizeof(_globalPowerInfo._power_info));
                        int k = 0;
                        list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                        {
                            //筛选控制中的数据
                            if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B && _pTreeACPowerMangerTemp->product_ph_outputStatus == 2)
                            {
                                continue;
                            }
                            memcpy(&_pTreeACPowerMangerTemp->_PowerInfo, &_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._PowerInfo[_pTreeACPowerMangerTemp->product_ch_addr - 1], sizeof(PowerInfo));
                            memcpy(&_pTreeACPowerMangerTemp->_PowerWarninginfo, &_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._PowerWarninginfo[_pTreeACPowerMangerTemp->product_ch_addr - 1], sizeof(PowerWarningInfo));
                            gettimeofday(&tv, NULL);
                            // t = localtime(&tv.tv_sec);
                            // 计算总三项总数据
                            _globalPowerInfo._power_info.voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage;
                            _globalPowerInfo._power_info.current += _pTreeACPowerMangerTemp->_PowerInfo.current;
                            _globalPowerInfo._power_info.power += _pTreeACPowerMangerTemp->_PowerInfo.power;
                            _globalPowerInfo._power_info.freq = _pTreeACPowerMangerTemp->_PowerInfo.freq;
                            _globalPowerInfo._power_info.consumption += _pTreeACPowerMangerTemp->_PowerInfo.consumption;
                            _globalPowerInfo._power_info.factor = _pTreeACPowerMangerTemp->_PowerInfo.factor;
                            //
                            pTreeAPowerInfo = NULL;
                            list_for_each_entry(pTreeAPowerInfo, &_globalDeviceManager->_globalPowerManger.list_Tree_AC, list_Tree_AC)
                            {
                                int nTreeACType = pTreeAPowerInfo->product_ph_type;
                                if (nTreeACType < 0 || nTreeACType > 3) // 不是ABC相的情况直接跳过
                                {
                                    continue;
                                }
                                if (nTreeACType == _pTreeACPowerMangerTemp->product_ph_type)
                                {
                                    if (_pTreeACPowerMangerTemp->_PowerInfo.voltage > 0)
                                    {
                                        if (VavgTimes[nTreeACType] == 0)
                                        {
                                            Vavg[nTreeACType] = _pTreeACPowerMangerTemp->_PowerInfo.voltage;
                                        }
                                        else
                                        {
                                            Vavg[nTreeACType] = (Vavg[nTreeACType] * VavgTimes[nTreeACType] + _pTreeACPowerMangerTemp->_PowerInfo.voltage) / (VavgTimes[nTreeACType] + 1);
                                        }

                                        pTreeAPowerInfo->_PowerInfo.voltage = Vavg[nTreeACType];
                                        pTreeAPowerInfo->_PowerInfo.current += _pTreeACPowerMangerTemp->_PowerInfo.current;
                                        pTreeAPowerInfo->_PowerInfo.power += _pTreeACPowerMangerTemp->_PowerInfo.power;
                                        pTreeAPowerInfo->_PowerInfo.freq = _pTreeACPowerMangerTemp->_PowerInfo.freq;
                                        pTreeAPowerInfo->_PowerInfo.consumption += _pTreeACPowerMangerTemp->_PowerInfo.consumption;
                                        pTreeAPowerInfo->_PowerInfo.factor = _pTreeACPowerMangerTemp->_PowerInfo.factor;
                                        VavgTimes[nTreeACType] += 1;
                                    }
                                }
                            }

                            if (__globalDeviceManage.triphasic_mmap)
                            {
                                __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption * 1000;
                                __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_current = _pTreeACPowerMangerTemp->_PowerInfo.current * 1000;
                                __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_power = _pTreeACPowerMangerTemp->_PowerInfo.power * 1000;
                                __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage * 1000;
                                __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_type = _pTreeACPowerMangerTemp->product_ph_type;
                            }

                            if (_globalPowerInfo._power_info.status == 0)
                            {
                                _globalPowerInfo._power_info.status = _pTreeACPowerMangerTemp->_PowerInfo.status;
                            }
                            else
                            {
                                _globalPowerInfo._power_info.status = 0;
                            }
                            if (__globalDeviceManage.triphasic_mmap)
                            {
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_status = _globalPowerInfo._power_info.status;
                            }

                            time_t now;
                            time(&now);
                            t = localtime(&now);

                            char buffer[80];
                            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                            memset(_globalPowerInfo.samp_time, 0, sizeof(_globalPowerInfo.samp_time));
                            strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                            sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
                            strcat(_globalPowerInfo.samp_time, buffer);

                            if (difftime(now, _pTreeACPowerMangerTemp->product_log_time) > (sSaveTime / 1000))
                            {
                                _pTreeACPowerMangerTemp->product_log_time = now;
                                /* code */
                                strcpy(_pTreeACPowerMangerTemp->samp_time, _globalPowerInfo.samp_time);
                                if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3) != 0)
                                {
                                    log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                                }
                            }
                        }
                        if (__globalDeviceManage.triphasic_mmap)
                        {
                            __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_consumption = _globalTotalPowerInfo._power_info.consumption * 1000;
                            __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_freq = _globalTotalPowerInfo._power_info.freq * 1000;
                            __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_power = _globalTotalPowerInfo._power_info.power * 1000;
                            __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_factor = _globalTotalPowerInfo._power_info.factor * 1000;
                        }
                        if (_globalDeviceManager->triphasic_mmap)
                        {
                            _globalDeviceManager->triphasic_mmap->chn_status[_chn] = _globalPowerInfo._power_info.status;
                            _globalDeviceManager->triphasic_mmap->open_delay[_chn] = _globalPowerMangerTemp->product_ch_start_delay;
                            _globalDeviceManager->triphasic_mmap->close_delay[_chn] = _globalPowerMangerTemp->product_ch_stop_delay;
                        }
                    }
                }
                break;
                case DC_OUT_TYPE:
                {
                
                }
                break;
                case DC_IN_TYPE:
                {
                   
                }
                break;                
                case DCPDU_TYPE:
                {
                    /*
                    memset(&_globalPowerInfo,0,sizeof(GlobalPowerInfo));
                    //拿数据
                    ret = g_switch_get_dcpdu_out_info(&_globalDeviceManager->_globalRelaySampManger,
                                                     _globalPowerMangerTemp->product_saddr,//saadr
                                                     (_globalPowerMangerTemp->product_ch_addr-1),   //考虑多通道编码 %8
                                                     &_globalPowerInfo._power_info,&_globalPowerWarningInfo);
                    if(ret<0)
                    {
                        log_d("ch%d get data error.\n",_globalPowerMangerTemp->product_ch_id);
                        isErrorBreak=true;
                        break;
                    }*/
                    _globalTotalPowerInfo._power_info.voltage = _globalTotalPowerInfo._power_info.voltage > _globalPowerInfo._power_info.voltage ? _globalTotalPowerInfo._power_info.voltage : _globalPowerInfo._power_info.voltage;
                    _globalTotalPowerInfo._power_info.current += _globalPowerInfo._power_info.current ;
                    _globalTotalPowerInfo._power_info.power += _globalPowerInfo._power_info.power ;
                    _globalTotalPowerInfo._power_info.freq =  _globalTotalPowerInfo._power_info.freq;
                    _globalTotalPowerInfo._power_info.consumption += _globalPowerInfo._power_info.consumption ;
                    _globalTotalPowerInfo._power_info.factor = _globalPowerInfo._power_info.factor ;
                    _globalPowerInfo.product_status = _globalPowerInfo._power_info.status ;
                    _globalPowerMangerTemp->product_ch_status = _globalPowerInfo._power_info.status ;

                    //累加总电源信息
                    _globalTotalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
                    _globalTotalPowerInfo.product_status = 0 ;
                    //补全信息
                    _globalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalPowerInfo.product_ch_id = _globalPowerMangerTemp->product_ch_id ;

                    gettimeofday(&tv, NULL);
                    //t = localtime(&tv.tv_sec);

                    time_t now;
                    time(&now);
                    t = localtime(&now);

                    char buffer[80];
                    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);


                    memset(_globalPowerInfo.samp_time,0,sizeof(_globalPowerInfo.samp_time));
                    strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                    sprintf(buffer,".%03ld",tv.tv_usec/1000);
                    strcat(_globalPowerInfo.samp_time,buffer);

                    // sprintf(_globalPowerInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03d",
                    // t->tm_year+1900,t->tm_mon,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,tv.tv_usec/1000);
                    
                    if (difftime(now,_globalPowerMangerTemp->product_log_time)>(sSaveTime/1000))
                    {
                        _globalPowerMangerTemp->product_log_time=now;
                        SaveDBFlag=true;
                        /* code */
                        //插入数据库
                        if(dev_insert_power_info(_globalDeviceManager->db,&_globalPowerInfo,&lastIndex)!=0)
                        {
                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }
                    }
                    
                    //插入数据库
                     if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*未知故障 */
                       if(_globalPowerWarningInfo.w_voltage_up) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                        /*低电压 */
                       if(_globalPowerWarningInfo.w_voltage_down) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_DOWN);
                    }
                    if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                        if(_globalPowerWarningInfo.w_current)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
                    }
                    if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                        if(_globalPowerWarningInfo.w_power)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
                    }
                    if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                        if(_globalPowerWarningInfo.w_consumption)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
                    }

                    //else
                   //log_i("%s ch%d insert data ok status:%d.\n",_globalPowerInfo.samp_time,_globalPowerMangerTemp->product_ch_id,_globalPowerInfo.product_status);
                    //判断阈值状态

                    //unsigned int start_delay[8], stop_delay[8];
                    //ret = g_switch_get_dcpdu_start_time_delay(&_globalDeviceManager->_globalRelaySampManger, _globalPowerMangerTemp->product_saddr, start_delay);
                    //if (ret == 0) _globalPowerMangerTemp->product_ch_start_delay = start_delay[_globalPowerMangerTemp->product_ch_addr - 1] * 1000;
                    //ret = g_switch_get_dcpdu_stop_time_delay(&_globalDeviceManager->_globalRelaySampManger, _globalPowerMangerTemp->product_saddr, stop_delay);
                    //if (ret == 0) _globalPowerMangerTemp->product_ch_stop_delay = stop_delay[_globalPowerMangerTemp->product_ch_addr - 1] * 1000;
                    //GlobalOverManager overmanager;
                    //memset(&overmanager, 0, sizeof(overmanager));
                    //memcpy(_globalPowerMangerTemp->global_over_manager, &overmanager, sizeof(overmanager));
                    //ret = g_switch_get_dcpdu_threshold(&_globalDeviceManager->_globalRelaySampManger, _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr-1), &overmanager);
                    //_globalPowerMangerTemp->global_over_manager.product_vol_upper_threshold = overmanager.product_vol_upper_threshold;
                    //_globalPowerMangerTemp->global_over_manager.product_vol_lower_threshold = overmanager.product_vol_lower_threshold;                        
                    //_globalPowerMangerTemp->global_over_manager.product_cur_upper_threshold = overmanager.product_cur_upper_threshold;
                    //_globalPowerMangerTemp->global_over_manager.product_cur_lower_threshold = overmanager.product_cur_lower_threshold;
                    //动作
                }
                break;           
                case TREE_AC_TYPE:
                case DOUBLE_AC_TYPE:
                {     
                    GlobalTreeACManager* _pTreeACPowerPhData = NULL ;  
                    
                    memset(&_globalPowerInfo._power_info, 0, sizeof(_globalPowerInfo._power_info));
                    float nchYGpower = 0;
                    list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                    {
                        if ((__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_Tree)&&_pTreeACPowerMangerTemp->product_ph_outputStatus==2)
                        {
                            continue;
                        }                        
                        memcpy(&_pTreeACPowerMangerTemp->_PowerInfo,&_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._PowerInfo[_pTreeACPowerMangerTemp->product_ch_addr - 1],sizeof(PowerInfo)); 
                        memcpy(&_globalTACWarningInfo,&_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._PowerWarninginfo[_pTreeACPowerMangerTemp->product_ch_addr - 1],sizeof(PowerWarningInfo));
                        gettimeofday(&tv, NULL);
                        // t = localtime(&tv.tv_sec);
                      
                        //计算总三项总数据
                        _globalPowerInfo._power_info.voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage;
                        _globalPowerInfo._power_info.current += _pTreeACPowerMangerTemp->_PowerInfo.current;
                        _globalPowerInfo._power_info.power += _pTreeACPowerMangerTemp->_PowerInfo.power;
                        _globalPowerInfo._power_info.freq =_globalPowerInfo._power_info.freq> _pTreeACPowerMangerTemp->_PowerInfo.freq?_globalPowerInfo._power_info.freq:_pTreeACPowerMangerTemp->_PowerInfo.freq;
                        _globalPowerInfo._power_info.consumption += _pTreeACPowerMangerTemp->_PowerInfo.consumption;
                       // _globalPowerInfo._power_info.factor = _pTreeACPowerMangerTemp->_PowerInfo.factor > _globalPowerInfo._power_info.factor ? _pTreeACPowerMangerTemp->_PowerInfo.factor : _globalPowerInfo._power_info.factor;
                       nchYGpower+=_pTreeACPowerMangerTemp->_PowerInfo.factor*_pTreeACPowerMangerTemp->_PowerInfo.power;
                       

                        time_t now;
                        time(&now);
                        t = localtime(&now);

                        char buffer[80];
                        strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                        memset(_globalPowerInfo.samp_time, 0, sizeof(_globalPowerInfo.samp_time));
                        strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                        sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
                        strcat(_globalPowerInfo.samp_time, buffer);

                        if (difftime(now, _pTreeACPowerMangerTemp->product_log_time) > (sSaveTime / 1000))
                        {
                            _pTreeACPowerMangerTemp->product_log_time = now;
                            /* code */
                            strcpy(_pTreeACPowerMangerTemp->samp_time, _globalPowerInfo.samp_time);
                            if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3) != 0)
                            {
                                log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                            }
                        }

                        // 判断阈值状态
                        if (_globalTACWarningInfo.w_voltage_up != _pTreeACPowerMangerTemp->_PowerWarninginfo.w_voltage_up )
                        {
                            _pTreeACPowerMangerTemp->_PowerWarninginfo.w_voltage_up = _globalTACWarningInfo.w_voltage_up;
                            /*高电压 */
                           if( _globalTACWarningInfo.w_voltage_up) dev_Alarm_T_AC_message(_globalDeviceManager, _pTreeACPowerMangerTemp, ENABLE_TAC_V_UP);
                        }
                        if (_globalTACWarningInfo.w_voltage_down != _pTreeACPowerMangerTemp->_PowerWarninginfo.w_voltage_down )
                        {
                            _pTreeACPowerMangerTemp->_PowerWarninginfo.w_voltage_down = _globalTACWarningInfo.w_voltage_down;
                            /*低电压 */
                            if( _globalTACWarningInfo.w_voltage_down)dev_Alarm_T_AC_message(_globalDeviceManager, _pTreeACPowerMangerTemp, ENABLE_TAC_V_DOWN);
                        }
                        if (_globalTACWarningInfo.w_current != _pTreeACPowerMangerTemp->_PowerWarninginfo.w_current )
                        {
                            _pTreeACPowerMangerTemp->_PowerWarninginfo.w_current = _globalTACWarningInfo.w_current;
                            /*高电流 */
                            if( _globalTACWarningInfo.w_current)dev_Alarm_T_AC_message(_globalDeviceManager, _pTreeACPowerMangerTemp, ENABLE_TAC_A_UP);
                        }
                        if (_globalTACWarningInfo.w_power != _pTreeACPowerMangerTemp->_PowerWarninginfo.w_power )
                        {
                            _pTreeACPowerMangerTemp->_PowerWarninginfo.w_power = _globalTACWarningInfo.w_power;
                            /*高功率 */
                            if( _globalTACWarningInfo.w_power)dev_Alarm_T_AC_message(_globalDeviceManager, _pTreeACPowerMangerTemp, ENABLE_TAC_W_UP);
                        }
                        if (_globalTACWarningInfo.w_consumption != _pTreeACPowerMangerTemp->_PowerWarninginfo.w_consumption)
                        {
                            _pTreeACPowerMangerTemp->_PowerWarninginfo.w_consumption = _globalTACWarningInfo.w_consumption;
                            /*高耗电 */
                            if(_globalTACWarningInfo.w_consumption)dev_Alarm_T_AC_message(_globalDeviceManager, _pTreeACPowerMangerTemp, ENABLE_TAC_P_UP);
                        }

                    }

                    // 处理通道开关状态
                    int allphOutNum=0;
                    int allphOpenNum=0;
                    list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                    {
                      //计算输出通道数和开启的输出通道数，两者相同，则认为该通道为开启状态
                        if (_pTreeACPowerMangerTemp->product_ph_outputStatus == 1)
                        {
                            allphOutNum++;
                            if (_pTreeACPowerMangerTemp->_PowerInfo.status==1)
                            {
                                allphOpenNum++;
                            }
                            _globalPowerInfo._power_info.NF_status = _pTreeACPowerMangerTemp->_PowerInfo.NF_status;
                        }
                    }

                    if (allphOpenNum == allphOutNum)
                    {
                        _globalPowerInfo._power_info.status = 1;
                    }
                    else
                    {
                        _globalPowerInfo._power_info.status = 0;
                    }

                    // 计算通道总功率因数
                    if (_globalPowerInfo._power_info.power > 0)
                    {
                        _globalPowerInfo._power_info.factor = nchYGpower / _globalPowerInfo._power_info.power;
                    }
                    else
                    {
                        _globalPowerInfo._power_info.factor = 0;
                    }
                    if (_globalPowerInfo._power_info.factor > 1)
                        _globalPowerInfo._power_info.factor = 1;
                    else if (_globalPowerInfo._power_info.factor < 0)
                        _globalPowerInfo._power_info.factor = 0;

                    // 处理级联相信息
                    int k = 0;
                    list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                    {
                        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One && _pTreeACPowerMangerTemp->product_ph_outputStatus == 2)
                        {
                            continue;
                        }
                        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Two && _pTreeACPowerMangerTemp->product_ph_type != _globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr].nLeft_phType && _pTreeACPowerMangerTemp->product_ph_type != _globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr].nRight_phType)
                        {
                            continue;
                        }
                        _globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq=_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq> _pTreeACPowerMangerTemp->_PowerInfo.freq?_globalDeviceManager->pCtrlBoard[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq:_pTreeACPowerMangerTemp->_PowerInfo.freq;
                        if (__globalDeviceManage.triphasic_mmap)
                        {
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption * 1000;
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_current = _pTreeACPowerMangerTemp->_PowerInfo.current * 1000;
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_power = _pTreeACPowerMangerTemp->_PowerInfo.power * 1000;
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage * 1000;
                            __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_type = _pTreeACPowerMangerTemp->product_ph_type;
#ifdef NORTH_USER_SPECILS
                            uint8_t wanning = 0;
                            if (_globalTACWarningInfo.w_voltage_up == true)
                            {
                                wanning++;
                            }
                            if (_globalTACWarningInfo.w_voltage_down == true)
                            {
                                wanning++;
                            }
                            if (_globalTACWarningInfo.w_current == true)
                            {
                                wanning++;
                            }
                            if (_globalTACWarningInfo.w_consumption == true)
                            {
                                wanning++;
                            }
                            if (_globalTACWarningInfo.w_power == true)
                            {
                                wanning++;
                            }
                            // uint16_t mask = 0xFFFF & (0 << (_chn % 16));
                            uint16_t data_temp = 0;

                            switch (_chn)
                            {
                            case 0 ... 15:
                            {
                                data_temp = __globalDeviceManage.north_user.fault_1_16;
                                data_temp &= ~(1 << (_chn % 16));
                                if (wanning > 0)
                                {
                                    data_temp |= (1 << (_chn % 16));
                                }
                                __globalDeviceManage.north_user.fault_1_16 = data_temp;
                            }
                            break;
                            case 16 ... 31:
                            {
                                data_temp = __globalDeviceManage.north_user.fault_17_32;
                                data_temp &= ~(1 << (_chn % 16));
                                if (wanning > 0)
                                {
                                    data_temp |= (1 << (_chn % 16));
                                }
                                __globalDeviceManage.north_user.fault_17_32 = data_temp;
                            }
                            break;
                            case 32 ... 47:
                            {
                                data_temp = __globalDeviceManage.north_user.fault_33_48;
                                data_temp &= ~(1 << (_chn % 16));
                                if (wanning > 0)
                                {
                                    data_temp |= (1 << (_chn % 16));
                                }
                                __globalDeviceManage.north_user.fault_33_48 = data_temp;
                            }
                            break;
                            case 48 ... 63:
                            {
                                data_temp = __globalDeviceManage.north_user.fault_49_64;
                                data_temp &= ~(1 << (_chn % 16));
                                if (wanning > 0)
                                {
                                    data_temp |= (1 << (_chn % 16));
                                }
                                __globalDeviceManage.north_user.fault_49_64 = data_temp;
                            }
                            break;
                            default:
                                break;
                            }
#endif
                        }
  
                        if (__globalDeviceManage.triphasic_mmap)
                        {
                            __globalDeviceManage.triphasic_mmap->pw_o_chn[_chn].chn[k].o_status = _pTreeACPowerMangerTemp->_PowerInfo.status;
                        }

                        k = k + 1;
                    }

                    // 计算总电源信息
                    _globalTotalPowerInfo._power_info.voltage = _globalPowerInfo._power_info.voltage*sqrt(3);
                    _globalTotalPowerInfo._power_info.current += _globalPowerInfo._power_info.current ;
                    _globalTotalPowerInfo._power_info.power += _globalPowerInfo._power_info.power ;
                    _globalTotalPowerInfo._power_info.freq = _globalPowerInfo._power_info.freq> _globalTotalPowerInfo._power_info.freq?  _globalPowerInfo._power_info.freq:_globalTotalPowerInfo._power_info.freq;
                    _globalTotalPowerInfo._power_info.consumption += _globalPowerInfo._power_info.consumption ;
                    _globalTotalPowerInfo._power_info.factor = _globalPowerInfo._power_info.factor>_globalTotalPowerInfo._power_info.factor ? _globalPowerInfo._power_info.factor:_globalTotalPowerInfo._power_info.factor;
                    _globalPowerInfo.product_status = _globalPowerInfo._power_info.status ;
                    _globalPowerMangerTemp->product_ch_status = _globalPowerInfo._power_info.status ;
                     _globalPowerMangerTemp->product_ch_NF_status = _globalPowerInfo._power_info.NF_status ;

                    // 级联通道总体信息
                     if (__globalDeviceManage.triphasic_mmap)
                     {
                         __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_consumption = _globalTotalPowerInfo._power_info.consumption * 1000;
                         __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_freq = _globalTotalPowerInfo._power_info.freq * 1000;
                         __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_power = _globalTotalPowerInfo._power_info.power * 1000;
                         __globalDeviceManage.triphasic_mmap->chn_info[_chn].chn_factor = _globalTotalPowerInfo._power_info.factor * 1000;
                     }
                     if (_globalDeviceManager->triphasic_mmap)
                     {
                         _globalDeviceManager->triphasic_mmap->chn_status[_chn] = _globalPowerInfo._power_info.status;
                         _globalDeviceManager->triphasic_mmap->open_delay[_chn] = _globalPowerMangerTemp->product_ch_start_delay;
                         _globalDeviceManager->triphasic_mmap->close_delay[_chn] = _globalPowerMangerTemp->product_ch_stop_delay;
#ifdef NORTH_USER_SPECILS
                        switch (_chn)
                        {
                            case 0 ... 15:
                            {
                                if(_globalDeviceManager->triphasic_mmap->chn_status[_chn])
                                {
                                    __globalDeviceManage.north_user.status_1_16 |= (1 << (_chn %16));
                                }else
                                {
                                    __globalDeviceManage.north_user.status_1_16 &= ~(1 << (_chn %16));
                                }
                            }
                            break;
                            case 16 ... 31:
                            {
                                if(_globalDeviceManager->triphasic_mmap->chn_status[_chn])
                                {
                                    __globalDeviceManage.north_user.status_17_32 |= (1 << (_chn %16));
                                }else
                                {
                                    __globalDeviceManage.north_user.status_17_32 &= ~(1 << (_chn %16));
                                }
                            }
                            break;
                            case 32 ... 47:
                            {
                                if(_globalDeviceManager->triphasic_mmap->chn_status[_chn])
                                {
                                    __globalDeviceManage.north_user.status_33_48 |= (1 << (_chn %16));
                                }else
                                {
                                    __globalDeviceManage.north_user.status_33_48 &= ~(1 << (_chn %16));
                                }
                            }
                            break;
                            case 48 ... 63:
                            {
                                if(_globalDeviceManager->triphasic_mmap->chn_status[_chn])
                                {
                                    __globalDeviceManage.north_user.status_49_64 |= (1 << (_chn %16));
                                }else
                                {
                                    __globalDeviceManage.north_user.status_49_64 &= ~(1 << (_chn %16));
                                }
                            }
                            break;
                        }
#endif
                     }

                    //累加总电源信息
                    _globalTotalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
                    _globalTotalPowerInfo.product_status = 0 ;
                    //补全信息
                    _globalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product.id;
                    _globalPowerInfo.product_ch_id = _globalPowerMangerTemp->product_ch_id ;

                    gettimeofday(&tv, NULL);
                    //t = localtime(&tv.tv_sec);

                    time_t now;
                    time(&now);
                    t = localtime(&now);

                    char buffer[80];
                    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                    memset(_globalPowerInfo.samp_time,0,sizeof(_globalPowerInfo.samp_time));
                    strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                    sprintf(buffer,".%03ld",tv.tv_usec/1000);
                    strcat(_globalPowerInfo.samp_time,buffer);

                    // sprintf(_globalPowerInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03d",
                    // t->tm_year+1900,t->tm_mon,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,tv.tv_usec/1000);
                    
                    if (difftime(now,_globalPowerMangerTemp->product_log_time)>(sSaveTime/1000))
                    {
                        _globalPowerMangerTemp->product_log_time=now;
                        SaveDBFlag=true;                       
                        /* code */
                        //插入数据库
                        if(dev_insert_power_info(_globalDeviceManager->db,&_globalPowerInfo,&lastIndex)!=0)
                        {

                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }
                    }
                    //判断阈值状态
                    if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*高电压 */
                       if(_globalPowerWarningInfo.w_voltage_up) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                        /*低电压 */
                       if(_globalPowerWarningInfo.w_voltage_down) dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_DOWN);
                    }
                    if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                        if(_globalPowerWarningInfo.w_current)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
                    }
                    if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                        if(_globalPowerWarningInfo.w_power)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
                    }
                    if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                        if(_globalPowerWarningInfo.w_consumption)dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
                    }
                    bool nMissPH=0;
                    //memcpy(nMissPH,_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._globalPowerInManger.product_MissingPH,sizeof(nMissPH));   
                    nMissPH=_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._globalPowerInManger.product_MissingPH[0];
                    if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossA!= (bool)nMissPH)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossA = (bool)nMissPH;
                        
                        /*缺项 */
                        if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossA)
                            dev_Alarm_send_message(_globalDeviceManager, _globalPowerMangerTemp, 0);
                    }
                    _globalPowerWarningInfo.w_phase_lossA=nMissPH;                        
                    nMissPH=_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._globalPowerInManger.product_MissingPH[1];
                    if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossB != (bool)nMissPH)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossB = (bool)nMissPH;
                        /*缺项 */
                        if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossB)
                            dev_Alarm_send_message(_globalDeviceManager, _globalPowerMangerTemp, 1);
                    }
                    _globalPowerWarningInfo.w_phase_lossB=nMissPH;                        
                    nMissPH=_globalDeviceManager->pCtrlBoard[(int)_globalPowerMangerTemp->product_saddr]._globalPowerInManger.product_MissingPH[2];
                    if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossC != (bool)nMissPH)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossC = (bool)nMissPH;
 
                        /*缺项 */
                        if (_globalPowerMangerTemp->_PowerWarninginfo.w_phase_lossC)
                            dev_Alarm_send_message(_globalDeviceManager, _globalPowerMangerTemp, 2);
                    }
                    _globalPowerWarningInfo.w_phase_lossC=nMissPH;
                    /*
                    GlobalOverManager overmanager;
                    memset(&overmanager, 0, sizeof(overmanager));
                    //memcpy(_globalPowerMangerTemp->global_over_manager, &overmanager, sizeof(overmanager));
                    ret = g_switch_get_t_ac_threshold(&_globalDeviceManager->_globalRelaySampManger, _globalPowerMangerTemp->product_saddr, (_globalPowerMangerTemp->product_ch_addr-1), &overmanager);
                    if (ret >= 0)
                    {
                        _globalPowerMangerTemp->global_over_manager.product_vol_upper_threshold = overmanager.product_vol_upper_threshold;
                        _globalPowerMangerTemp->global_over_manager.product_vol_lower_threshold = overmanager.product_vol_lower_threshold;
                        _globalPowerMangerTemp->global_over_manager.product_cur_upper_threshold = overmanager.product_cur_upper_threshold;
                        _globalPowerMangerTemp->global_over_manager.product_pwr_upper_threshold = overmanager.product_pwr_upper_threshold;
                        _globalPowerMangerTemp->global_over_manager.product_pwrcon_upper_threshold = overmanager.product_pwrcon_upper_threshold;
                    }
                    */
            }
            break;
            }

            _chn+=1;
            //nanosleep(&reqSleep, NULL); 
            //usleep(usleepTime);


            //-- 临时加的通道是否可控 lyz 2025.05.01----
#ifdef PRJ_YST_AC_I1_O1
            if (_globalPowerMangerTemp->product_ch_id>6 && _globalPowerMangerTemp->product_ch_id<=10)
            {
                _globalPowerInfo._power_info.OperAllowFlag=1;
            }   
#endif


#ifdef PRJ_2405_AC_I1_O1_OLED
            if (_globalPowerMangerTemp->product_ch_id==4 )
            {
                _globalPowerInfo._power_info.OperAllowFlag=1;
            }   
#endif

            //全局记录一份数据
            if (!isErrorBreak)
            {
                memcpy(&_globalPowerMangerTemp->_PowerInfo,&_globalPowerInfo._power_info,sizeof(PowerInfo)); 
                memcpy(&_globalPowerMangerTemp->_PowerWarninginfo,&_globalPowerWarningInfo,sizeof(PowerWarningInfo)); 
            }
            isErrorBreak=false;
            //判断是否存在定时需要触发
            time_t now;
            time(&now);
            t = localtime(&now);
            char buffer[80];
            int nNowt=t->tm_hour*3600+t->tm_min*60+t->tm_sec;
            int nDst=0,nHours=0,nMin=0,nSecond=0;
            strftime(buffer, sizeof(buffer), "%Y-%m-%d", t);
            list_for_each_entry(_powerDsManageTemp, &_globalPowerMangerTemp->list_DS, list)
            {
                if (strcmp(_powerDsManageTemp->ds_date, buffer) == 0&&_powerDsManageTemp->ds_is_triggered==0)
                {
                    sscanf(_powerDsManageTemp->ds_time, "%d:%d:%d", &nHours, &nMin, &nSecond);
                    nDst=nHours *3600+nMin*60+nSecond;
                    int ntoSec=abs(nNowt-nDst);
                    if (ntoSec < 5) // 小于3秒则触发
                    {
                        ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                        _globalPowerMangerTemp->product_saddr,
                                                        _globalPowerMangerTemp->product_ch_addr,
                                                        _powerDsManageTemp->set_stats, false);
                        if (ret < 0)
                        {
                            ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                            _globalPowerMangerTemp->product_saddr,
                                                            _globalPowerMangerTemp->product_ch_addr,
                                                            _powerDsManageTemp->set_stats, false);
                        }
                        _powerDsManageTemp->ds_is_triggered = 1;
                        dev_update_power_ds(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id, _powerDsManageTemp);
                       
                        char strLog[200];
                         sprintf(strLog, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        dev_Alarm_Run_message(_globalDeviceManager,strLog,"scheduled task triggered!");
                    }
                }                
            }
        }


        //all 
        if(__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_AC
         || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_DC)
        {
            __globalDeviceManage.single_mmap->total_current = _globalTotalPowerInfo._power_info.current*1000;
            __globalDeviceManage.single_mmap->total_power = _globalTotalPowerInfo._power_info.power*1000;
            __globalDeviceManage.single_mmap->total_valtage = _globalTotalPowerInfo._power_info.voltage*1000;
            __globalDeviceManage.single_mmap->total_consumer = _globalTotalPowerInfo._power_info.consumption * 1000;
            // printf("total_valtage = %d  consumer = %d power = %d\n",__globalDeviceManage.single_mmap->total_valtage,
            //         __globalDeviceManage.single_mmap->total_current
            //         ,__globalDeviceManage.single_mmap->total_power);
            __globalDeviceManage.single_mmap->dev_chn = __globalDeviceManage._globalDevInfo.product.pwr_type << 8 | _chn;
            memcpy(&__globalDeviceManage.pCtrlBoard[0]._globalPowerInManger._PowerInfo[0],&_globalTotalPowerInfo._power_info,sizeof(PowerInfo)); 
        }
        //输入数据再处理（三项）
        //memset(_pTreeACPowerMangerTemp,0,sizeof(GlobalTreeACManager));
        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)
        {
            _pTreeACPowerMangerTemp = NULL;
            list_for_each_entry(_pTreeACPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list_Tree_AC, list_Tree_AC)
            {
                int nTreeACType = _pTreeACPowerMangerTemp->product_ph_type;
                if (nTreeACType < 0 || nTreeACType > 3) // 不是ABC相的情况直接跳过
                {
                    continue;
                }
                memset(&_globalDeviceManager->_globalPowerManger._PowerInfo, 0, sizeof(PowerInfo));      
                memset(&_pTreeACPowerMangerTemp->_PowerInfo, 0, sizeof(_globalPowerInfo._power_info));

                float nTotalYGPower=0;//相总的有功功率
                for (size_t i = 0; i <= _globalDeviceManager->brdMax; i++)
                {
                    if (_globalDeviceManager->pCtrlBoard[i].product_saddr == 0 || (_globalDeviceManager->pCtrlBoard[i].product_type != TREE_AC_TYPE&&_globalDeviceManager->pCtrlBoard[i].product_type != DOUBLE_AC_TYPE))
                    {
                        continue;
                    }
                    if (_globalDeviceManager->pCtrlBoard[i].product_type == DOUBLE_AC_TYPE)
                    {
                        int nFromIndex = 0;
                        if (_globalDeviceManager->pCtrlBoard[i].nLeft_phType == nTreeACType)
                        {
                            nFromIndex=0;
                            // 如果存在电压则置位如果都没有电压则保持0
                            if (_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].voltage != 0)
                            {
                                _pTreeACPowerMangerTemp->_PowerInfo.voltage = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].voltage;
                            }
                            _pTreeACPowerMangerTemp->_PowerInfo.current += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].current;
                            _pTreeACPowerMangerTemp->_PowerInfo.power += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].power;
                            _pTreeACPowerMangerTemp->_PowerInfo.freq = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].freq > _pTreeACPowerMangerTemp->_PowerInfo.freq ? _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].freq : _pTreeACPowerMangerTemp->_PowerInfo.freq;
                            _pTreeACPowerMangerTemp->_PowerInfo.consumption += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].consumption;
                            nTotalYGPower += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].factor * _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].power;
                        }
                        if (_globalDeviceManager->pCtrlBoard[i].nRight_phType == nTreeACType)
                        {
                            nFromIndex=1;
                            // 如果存在电压则置位如果都没有电压则保持0
                            if (_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].voltage != 0)
                            {
                                _pTreeACPowerMangerTemp->_PowerInfo.voltage = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].voltage;
                            }
                            _pTreeACPowerMangerTemp->_PowerInfo.current += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].current;
                            _pTreeACPowerMangerTemp->_PowerInfo.power += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].power;
                            _pTreeACPowerMangerTemp->_PowerInfo.freq = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].freq > _pTreeACPowerMangerTemp->_PowerInfo.freq ? _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].freq : _pTreeACPowerMangerTemp->_PowerInfo.freq;
                            _pTreeACPowerMangerTemp->_PowerInfo.consumption += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].consumption;
                            nTotalYGPower += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].factor * _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nFromIndex].power;
                        }
                    }
                    else
                    {
                        // 如果存在电压则置位如果都没有电压则保持0
                        if (_globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].voltage != 0)
                        {
                            _pTreeACPowerMangerTemp->_PowerInfo.voltage = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].voltage;
                        }
                        _pTreeACPowerMangerTemp->_PowerInfo.current += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].current;
                        _pTreeACPowerMangerTemp->_PowerInfo.power += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].power;
                        // if (_globalTotalPowerInfo._power_info.freq != 0)
                        //  {
                        //   _pTreeACPowerMangerTemp->_PowerInfo.freq = _globalTotalPowerInfo._power_info.freq;
                        // }
                        _pTreeACPowerMangerTemp->_PowerInfo.freq = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].freq > _pTreeACPowerMangerTemp->_PowerInfo.freq ? _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].freq : _pTreeACPowerMangerTemp->_PowerInfo.freq;
                        _pTreeACPowerMangerTemp->_PowerInfo.consumption += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].consumption;
                        //_pTreeACPowerMangerTemp->_PowerInfo.factor = _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].factor;
                        nTotalYGPower += _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].factor * _globalDeviceManager->pCtrlBoard[i]._globalPowerInManger._PowerInfo[nTreeACType].power;
                    }
                }
                //计算每相总功率因数
                if (_pTreeACPowerMangerTemp->_PowerInfo.power>0)
                {
                        float nfactor=nTotalYGPower /   _pTreeACPowerMangerTemp->_PowerInfo.power;
                        if(nfactor>0&& nfactor<=1)  _pTreeACPowerMangerTemp->_PowerInfo.factor=nfactor;
                        else _pTreeACPowerMangerTemp->_PowerInfo.factor=1;
                }
                else _pTreeACPowerMangerTemp->_PowerInfo.factor=1;

                if (_globalDeviceManager->triphasic_mmap)
                {
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_power = _pTreeACPowerMangerTemp->_PowerInfo.power * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_current = _pTreeACPowerMangerTemp->_PowerInfo.current * 1000;
                    memcpy(&__globalDeviceManage.pCtrlBoard[0]._globalPowerInManger._PowerInfo[nTreeACType],&_pTreeACPowerMangerTemp->_PowerInfo,sizeof(PowerInfo)); 
#ifdef NORTH_USER_SPECILS
                    __globalDeviceManage.north_user.wire_voltage[nTreeACType] = 
                                        _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_voltage * 1.732 / 100;
                    __globalDeviceManage.north_user.wire_current[nTreeACType] = 
                                        _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_current / 10;
#endif               
                }
                time_t now;
                time(&now);
                t = localtime(&now);

                char buffer[80];
                strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                memset(_globalPowerInfo.samp_time, 0, sizeof(_globalPowerInfo.samp_time));
                strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
                strcat(_globalPowerInfo.samp_time, buffer);
                if (difftime(now, _pTreeACPowerMangerTemp->product_log_time) > (sSaveTime / 1000))
                {
                    _pTreeACPowerMangerTemp->product_log_time = now;
                    /* code */
                    strcpy(_pTreeACPowerMangerTemp->samp_time, _globalPowerInfo.samp_time);
                    if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3) != 0)
                    {
                        log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                    }
                }
                //更新总数据
                // 如果存在电压则置位如果都没有电压则保持0
                if (_pTreeACPowerMangerTemp->_PowerInfo.voltage != 0)
                {
                    _globalDeviceManager->_globalPowerManger._PowerInfo.voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage;
                }
                _globalDeviceManager->_globalPowerManger._PowerInfo.current += _pTreeACPowerMangerTemp->_PowerInfo.current;
                _globalDeviceManager->_globalPowerManger._PowerInfo.power += _pTreeACPowerMangerTemp->_PowerInfo.power;
                _globalDeviceManager->_globalPowerManger._PowerInfo.freq = _pTreeACPowerMangerTemp->_PowerInfo.freq > _globalDeviceManager->_globalPowerManger._PowerInfo.freq ? _pTreeACPowerMangerTemp->_PowerInfo.freq:_globalDeviceManager->_globalPowerManger._PowerInfo.freq;
                _globalDeviceManager->_globalPowerManger._PowerInfo.consumption += _pTreeACPowerMangerTemp->_PowerInfo.consumption;
                _globalDeviceManager->_globalPowerManger._PowerInfo.factor = _pTreeACPowerMangerTemp->_PowerInfo.factor;
                memcpy(&__globalDeviceManage.pCtrlBoard[0]._globalPowerInManger._PowerInfo[nTreeACType],&_pTreeACPowerMangerTemp->_PowerInfo,sizeof(PowerInfo));
            }

            if (__globalDeviceManage.triphasic_mmap)
            {
                __globalDeviceManage.triphasic_mmap->dev_chn = __globalDeviceManage._globalDevInfo.product.pwr_type << 8 | _chn;
#ifdef NORTH_USER_SPECILS
                    uint32_t c_data = 0;
                    uint32_t p_data = 0;
                    for(int i = 0; i < 3;i++)
                    {
                        c_data +=  (_globalDeviceManager->triphasic_mmap->i_total.pw_i_total[i].i_total_consumption);
                        p_data +=  (_globalDeviceManager->triphasic_mmap->i_total.pw_i_total[i].i_total_power);                      
                    }
                    float c_a = (float)c_data /1000.0;
                    float p_a = (float)p_data /1000.0;
                    __globalDeviceManage.north_user.total_elec_energy = c_a * 100;
                    __globalDeviceManage.north_user.total_power = p_a / 10;
                    __globalDeviceManage.north_user.frequency = _globalDeviceManager->_globalPowerManger._PowerInfo.freq * 100;         
#endif
            }
        }
        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B)
        {
            _pTreeACPowerMangerTemp = NULL;      
            list_for_each_entry(_pTreeACPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list_Tree_AC, list_Tree_AC)
            {
                int nTreeACType = _pTreeACPowerMangerTemp->product_ph_type;
                if (nTreeACType < 0 || nTreeACType > 3) // 不是ABC相的情况直接跳过
                {
                    continue;
                }
                if (_globalDeviceManager->triphasic_mmap)
                {
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_consumption = _pTreeACPowerMangerTemp->_PowerInfo.consumption * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_power = _pTreeACPowerMangerTemp->_PowerInfo.power * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_voltage = _pTreeACPowerMangerTemp->_PowerInfo.voltage * 1000;
                    _globalDeviceManager->triphasic_mmap->i_total.pw_i_total[nTreeACType].i_total_current = _pTreeACPowerMangerTemp->_PowerInfo.current * 1000;
                    __globalDeviceManage.pCtrlBoard[0]._globalPowerInManger._PowerInfo[nTreeACType]=_globalTotalPowerInfo._power_info;
                }

                time_t now;
                time(&now);
                t = localtime(&now);

                char buffer[80];
                strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                memset(_globalPowerInfo.samp_time, 0, sizeof(_globalPowerInfo.samp_time));
                strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
                strcat(_globalPowerInfo.samp_time, buffer);
                if (difftime(now, _pTreeACPowerMangerTemp->product_log_time) > (sSaveTime / 1000))
                {
                    _pTreeACPowerMangerTemp->product_log_time = now;
                    /* code */
                    strcpy(_pTreeACPowerMangerTemp->samp_time, _globalPowerInfo.samp_time);
                    if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3) != 0)
                    {
                        log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                    }
                }
            }
            if (_globalDeviceManager->triphasic_mmap)
            {
                __globalDeviceManage.triphasic_mmap->dev_chn = __globalDeviceManage._globalDevInfo.product.pwr_type << 8 | _chn;
            }
        }

        //插入总电源信息
        gettimeofday(&tv, &tz);
        t = localtime(&tv.tv_sec);
        sprintf(_globalTotalPowerInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03ld",
        t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,tv.tv_usec/1000);
        //更新总电源信息
      //  if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_AC 
     //   || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_DC)
       // {
            _globalDeviceManager->_globalPowerManger._PowerInfo = _globalTotalPowerInfo._power_info;
        //}
        //总电源信息插入数据库
        if (SaveDBFlag)
        {
            if (dev_insert_power_info(_globalDeviceManager->db, &_globalTotalPowerInfo, &lastIndex) != 0)
            {
                log_d("ch%d insert data error.\n", _globalTotalPowerInfo.product_ch_id);
            }
        }
        //判断总电源超限状态及动作防护
        {
            bool nTotalVup = _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_up;
            bool nTotalVdown = _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_down;
            bool nTotalAup = _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_current;
            bool nTotalPower = _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_power;
            bool nTotalConsumption = _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_consumption;
#ifdef NORTH_USER_SPECILS
                uint8_t total_wanning = 0;
#endif
            if (_globalTotalPowerInfo._power_info.voltage >= _globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_upper_threshold &&
                abs(_globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_upper_threshold) >= 0.05)
            {
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_up = true;
#ifdef NORTH_USER_SPECILS
                total_wanning ++;
#endif
            }
            else
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_up = false;

            if (_globalTotalPowerInfo._power_info.voltage <= _globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_lower_threshold &&
                abs(_globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_lower_threshold) >= 0.05)
            {
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_down = true;
#ifdef NORTH_USER_SPECILS
                total_wanning ++;
#endif
            }
            else
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_down = false;

            if (_globalTotalPowerInfo._power_info.current >= _globalDeviceManager->_globalPowerManger.global_over_manager.product_cur_upper_threshold &&
                abs(_globalDeviceManager->_globalPowerManger.global_over_manager.product_cur_upper_threshold) >= 0.05)
            {
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_current = true;
#ifdef NORTH_USER_SPECILS
                total_wanning ++;
#endif
            }
            else
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_current = false;

            if (_globalTotalPowerInfo._power_info.power >= _globalDeviceManager->_globalPowerManger.global_over_manager.product_pwr_upper_threshold &&
                abs(_globalDeviceManager->_globalPowerManger.global_over_manager.product_pwr_upper_threshold) >= 0.05)
            {
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_power = true;
#ifdef NORTH_USER_SPECILS
                total_wanning ++;
#endif
            }
            else
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_power = false;

            if (_globalTotalPowerInfo._power_info.consumption >= _globalDeviceManager->_globalPowerManger.global_over_manager.product_pwrcon_upper_threshold &&
                abs(_globalDeviceManager->_globalPowerManger.global_over_manager.product_pwrcon_upper_threshold) >= 0.05)
            {
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_consumption = true;
#ifdef NORTH_USER_SPECILS
                total_wanning ++;
#endif
            }
            else
                _globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_consumption = false;
#ifdef NORTH_USER_SPECILS
            if (__globalDeviceManage.triphasic_mmap)
            {
                if(total_wanning)
                    __globalDeviceManage.north_user.total_wanning = 1;
                else
                    __globalDeviceManage.north_user.total_wanning = 0;
            }
#endif

            // 报警信息及动作
            if (_globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_up && !nTotalVup)
            {
                dev_Alarm_send_message(_globalDeviceManager,  &_globalDeviceManager->_globalPowerManger, WARNING_V_UP);
            }
            if (_globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_voltage_down && !nTotalVdown)
            {
                dev_Alarm_send_message(_globalDeviceManager,  &_globalDeviceManager->_globalPowerManger, WARNING_V_DOWN);
            }
            if (_globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_current && !nTotalAup)
            {
                dev_Alarm_send_message(_globalDeviceManager, &_globalDeviceManager->_globalPowerManger, WARNING_A_UP);
            }
            if (_globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_power && !nTotalPower)
            {
                dev_Alarm_send_message(_globalDeviceManager,  &_globalDeviceManager->_globalPowerManger, WARNING_W_UP);
            }
            if (_globalDeviceManager->_globalPowerManger._PowerWarninginfo.w_consumption && !nTotalConsumption)
            {
                dev_Alarm_send_message(_globalDeviceManager,  &_globalDeviceManager->_globalPowerManger, WARNING_P_UP);
            }
        }
        lock_s_release(LOCK_ID_POWER_UPDATE);
  
        //1ms
        usleep(5*1000);  
        //延时
        //usleep(samp_time*1000);
    }
    
    log_e("Error!!!!!!!!!!!!!!Thread End");
    pthread_exit(NULL);
}


/// @brief 传感器硬件接口初始化
/// @param _globalDeviceManager
/// @return
int dev_sensor_init(GlobalDeviceManager *_globalDeviceManager)
{
    int ret = 0;

    ret = g_modbus_init(&_globalDeviceManager->sensor_modbus_manager,
                        INTERL_SENSOR_MODBUS_PORT, // _globalSensorMangerTemp->sensor_port_name,
                        INTERL_SENSOR_MODBUS_BAUD, // _globalSensorMangerTemp->sensor_baud,
                        MASTER_MODE,
                        0,
                        "sensor",
                        1,
                        50);

    if (ret != 0)
    {
        log_e("sensor modbus init error.\n");
    }
    else  log_i("sensor modbus init ok.\n");

    return 0;
}

/**
 * @brief 报警控制通道
 *
 * 这是一个用于报警控制通道的函数。
 */
void AlarmCtrlChn(int nChID, int nCtrl)
{
    char buff[256];
    int ret = 0;
    log_d("AlarmCtrlChn:%d,nCtrl=%d",nChID,nCtrl);
    GlobalPowerManger *_globalPowerMangerTemp = NULL;
    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
    {
        if (_globalPowerMangerTemp == NULL)
            break;
        if (nChID == _globalPowerMangerTemp->product_ch_id)
        {
            log_d("switch ctrl:%d", _globalPowerMangerTemp->product_ch_id);
            ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                            _globalPowerMangerTemp->product_saddr,
                                            _globalPowerMangerTemp->product_ch_addr,
                                            nCtrl, false);
            if (ret < 0)
            {
                ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                _globalPowerMangerTemp->product_saddr,
                                                _globalPowerMangerTemp->product_ch_addr,
                                                nCtrl, false);
            }

            sprintf(buff, "Over limit protection |$关闭$|$通道$|%d", _globalPowerMangerTemp->product_ch_id);
            int nAlarmID=dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_SENSOR, buff);

            struct tm *t;
            time_t now;
            time(&now);
            t = localtime(&now);
            char buffer[80];
            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
            AlarmTrapinfo pAlarmTrapinfo; ////Trap information
            pAlarmTrapinfo.ID = _globalPowerMangerTemp->product_ch_id;
            pAlarmTrapinfo.Alarmid = nAlarmID;
            strcpy(pAlarmTrapinfo.AlarmContext, buff);
            strcpy(pAlarmTrapinfo.AlarmDate, buffer);
            //if (_globalSNMPManager.trapmode == 1)
                //send_pduSensorAlarm_trap(1, (void *)&pAlarmTrapinfo);

            break;
        }
    }
}
void AlarmCtrlAll(int nCtrl)
{
        //总关
        int nSendAddr=0;
        char buff[256];
        log_d("AlarmCtrlAll:Ctrl=%d",nCtrl);
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue;
            nSendAddr=_globalPowerMangerTemp->product_saddr;
            log_i("Close All address Start");
            int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,nCtrl);
            if(rec<0)log_i("Close All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno));
        }      
        sprintf(buff,"Over limit protection |$关闭$|$所有$|$通道$");
        int nAlarmID=dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_SENSOR, buff);

        struct tm *t;
        time_t now;
        time(&now);
        t = localtime(&now);
        char buffer[80];
        strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
        AlarmTrapinfo pAlarmTrapinfo; ////Trap information
        pAlarmTrapinfo.ID = _globalPowerMangerTemp->product_ch_id;
        pAlarmTrapinfo.Alarmid = nAlarmID;
        strcpy(pAlarmTrapinfo.AlarmContext, buff);
        strcpy(pAlarmTrapinfo.AlarmDate, buffer);
        //if (_globalSNMPManager.trapmode == 1)
           // send_pduSensorAlarm_trap(1, (void *)&pAlarmTrapinfo);
}
/**
 * @brief 传感器报警函数
 *
 * 根据给定的报警类型和全局传感器管理器，执行相应的传感器报警操作。
 *
 * @param _globalSensorMangerTemp 全局传感器管理器指针
 * @param nAlarmType 报警类型（如SENSOR_VAL1_UPPER、SENSOR_VAL1_LOWER等）
 */
void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType)
{
    int *penable = NULL;   //使能
    int *pSave = NULL;     //是否已报警
    float *pValthreshold = NULL;//阈值
    float *pValData = NULL;     //当前值
    int  *nCtrlType = NULL; //报警方式
    char  *nCtrlValue= NULL; //控制通道
    char strCtrlValue[512]={0};
    if (!_globalSensorMangerTemp)
    {
        return;
    }
    switch (nAlarmType)
    {
    case SENSOR_VAL1_UPPER:
        penable = &_globalSensorMangerTemp->over_manager.sensor_val1_upper_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager.sensor_val1_upper_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val1_upper;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val1;
        nCtrlType = &_globalSensorMangerTemp->over_manager.sensor_val1_upper_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager.sensor_val1_upper_threshold_ctrl_para;
        break;
    case SENSOR_VAL1_LOWER:
        penable = &_globalSensorMangerTemp->over_manager.sensor_val1_lower_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager.sensor_val1_lower_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val1_lower;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val1;
        nCtrlType = &_globalSensorMangerTemp->over_manager.sensor_val1_lower_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager.sensor_val1_lower_threshold_ctrl_para;
        break;
    case SENSOR_VAL2_UPPER:
        penable = &_globalSensorMangerTemp->over_manager.sensor_val2_upper_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager.sensor_val2_upper_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val2_upper;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val2;
        nCtrlType = &_globalSensorMangerTemp->over_manager.sensor_val2_upper_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager.sensor_val2_upper_threshold_ctrl_para;
        break;
    case SENSOR_VAL2_LOWER:
        penable = &_globalSensorMangerTemp->over_manager.sensor_val2_lower_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager.sensor_val2_lower_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val2_lower;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val2;
        nCtrlType = &_globalSensorMangerTemp->over_manager.sensor_val2_lower_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager.sensor_val2_lower_threshold_ctrl_para;
        break;

    default:
        return;
    }
    if (!(pValthreshold && penable && pValData && pSave))
    {
        return;
    }
    strcpy(strCtrlValue,nCtrlValue);
    if (nAlarmType == SENSOR_VAL1_UPPER || nAlarmType == SENSOR_VAL2_UPPER)//上限
    {
        if (*penable == 1 && *pValthreshold < *pValData)
        {
            if (!*pSave)
            {
                *pSave = true;
                log_d("Sensor_Alarm CtrlType=%d,value=%s",*nCtrlType,strCtrlValue);
                dev_sensor_Alarm_send_message(&__globalDeviceManage, _globalSensorMangerTemp, nAlarmType);
                if (*nCtrlType == ALARM_CTRL_CLOSE_CH)
                {
                    char *pCHlist;
                    char *pCHListSave;
                    pCHlist = strtok_r(strCtrlValue, ",", &pCHListSave);
                    // 其他版本功能
                    while (pCHlist != NULL)
                    {
                        AlarmCtrlChn(atoi(pCHlist),0);
                        pCHlist = strtok_r(NULL, ",", &pCHListSave);
                    }                    
                }
                else if (*nCtrlType == ALARM_CTRL_CLOSE_ALLCH)
                {
                    AlarmCtrlAll(0);
                }
            }
        }
        else
        {
            *pSave = false;
        }
    }
    else    //下限
    {
        if (*penable == 1 && *pValthreshold > *pValData)
        {
            if (!*pSave)
            {
                *pSave = true;
                log_d("Sensor_Alarm CtrlType=%d,value=%s",*nCtrlType,strCtrlValue);
                dev_sensor_Alarm_send_message(&__globalDeviceManage, _globalSensorMangerTemp, nAlarmType);
                if (*nCtrlType == ALARM_CTRL_CLOSE_CH)
                {
                    char *pCHlist;
                    char *pCHListSave;
                    pCHlist = strtok_r(strCtrlValue, ",", &pCHListSave);
                    // 其他版本功能
                    while (pCHlist != NULL)
                    {
                        AlarmCtrlChn(atoi(pCHlist), 0);
                        pCHlist = strtok_r(NULL, ",", &pCHListSave);
                    }
                }else if (*nCtrlType == ALARM_CTRL_CLOSE_ALLCH)
                {
                    AlarmCtrlAll(0);
                }
            }
        }
        else
        {
            *pSave = false;
        }
    }
}

static void* breaker_thread(void *arg)
{
    int r;
    int ret=0;
    thread_handle_t *h=(thread_handle_t*)(arg);
    GlobalDeviceManager *_globalDeviceManager=(GlobalDeviceManager *)h->arg;
    unsigned int usleepTime = 30000;
    GlobalBreakerManager *temp = NULL;
    uint16_t value = 0;
    breaker_scanner_t* breaker_scann = get_breaker_scanner(); 
    uint32_t        pre_breaker_status;

    while (h->quit==0)
    {
        lock_s_hold(LOCK_ID_BREAKER);
        list_for_each_entry(temp, &_globalDeviceManager->g_new_global_breaker.list,list)
        {
            if(h->quit) {
                break;
            }
            pre_breaker_status=temp->breaker_status ;
            // if(temp->breaker_gather_addr != 0)
            // {
            //     value = 0;
            //     r = breaker_485_get_chn_status((void*)&_globalDeviceManager->_globalRelaySampManger,
            //     temp->breaker_gather_addr,BREADER_485_ADDR_CHN_REG+temp->breaker_chn,&value);
            //     if(r==0) {
            //         temp->breaker_status = value;
            //     }
            //   //  printf("temp->breaker_gather_addr = %d temp->breaker_chn=%d getchn value = %d\n",temp->breaker_gather_addr,temp->breaker_chn,value);
            // }else
            // {
            //     //DI
            // }
            if( temp->breaker_gather_addr>=BREADER_485_ADDR && temp->breaker_gather_addr<BREADER_485_ADDR+BREAKER_BOARD_MAX)
            {
                if( breaker_scann->breaker_flag[temp->breaker_gather_addr-BREADER_485_ADDR] == 1)
                {
                    int chn = temp->breaker_chn;
                    if (chn>=1&& chn<=BREAKER_485_CHN_MAX)
                    {
                        temp->breaker_status = breaker_scann->board[temp->breaker_gather_addr-BREADER_485_ADDR].ch_status[chn-1];
                        if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC 
                            || _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
                        {
                            if(temp->breaker_id <= 16)
                            {
                                if(temp->breaker_status){
                                    _globalDeviceManager->single_mmap->breaker_value |= (1 << (temp->breaker_id-1));
                                }
                                else{
                                
                                    _globalDeviceManager->single_mmap->breaker_value &= (~(1 << (temp->breaker_id-1)));
                                }
                            }
                                
                        }else
                        {
                            if(temp->breaker_id <= 16)
                            {
                                if(temp->breaker_status)
                                    _globalDeviceManager->triphasic_mmap->breaker_value |= (1 << (temp->breaker_id-1));
                                else
                                    _globalDeviceManager->triphasic_mmap->breaker_value &= (~(1 << (temp->breaker_id-1)));
                            }
                        }
#if USE_SMART_DETECTION_CTRL
                        if( temp->breaker_status == 0 && chn >=2 && chn <= 5)               //close
                        {
                           uint16_t close_id = temp->breaker_id;
                           if(close_id > 6)
                           {
                                close_id -= 2;              // 2 路断路器
                           }else
                           {
                                close_id -= 1;            // 1 路断路器 
                           }
                           GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                            {
                                if((close_id == _globalPowerMangerTemp->product_ch_id) && (_globalPowerMangerTemp->product_ch_status== 1))
                                {
                                    int ret= g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                              _globalPowerMangerTemp,
                                                              _globalPowerMangerTemp->product_saddr,
                                                              _globalPowerMangerTemp->product_ch_addr, 
                                                              0,false);
                                    if(ret < 0)
                                    {
                                         ret= g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                              _globalPowerMangerTemp,
                                                              _globalPowerMangerTemp->product_saddr,
                                                              _globalPowerMangerTemp->product_ch_addr, 
                                                              0,false);
                                    }
                                    log_d("close channel = %d\n",close_id);
                                    break;
                                }                                
                            }
                        }
#endif
                    }
                }else
                {
                    temp->breaker_status = 0;
                }
            }

            if (temp->breaker_gather_addr>0&&temp->breaker_gather_addr<=_globalDeviceManager->brdMax)
            {
                for (size_t i = 0; i <= _globalDeviceManager->brdMax; i++)
                {
                    if (_globalDeviceManager->pCtrlBoard[i].product_saddr != temp->breaker_gather_addr)
                    {
                        continue;
                    }
                    ret = g_switch_get_breaker_info(&_globalDeviceManager->_globalRelaySampManger,
                                                    _globalDeviceManager->pCtrlBoard[i].product_type,
                                                    _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                                    temp);
                    if (ret < 0)
                    {
                        usleep(usleepTime);
                        ret = g_switch_get_breaker_info(&_globalDeviceManager->_globalRelaySampManger,
                                                        _globalDeviceManager->pCtrlBoard[i].product_type,
                                                        _globalDeviceManager->pCtrlBoard[i].product_saddr,
                                                        temp);
                    }
                    break;
                }
                if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC 
                    || _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC )
                {
                    if(temp->breaker_id <= 16)
                    {
                        if(temp->breaker_status)
                            _globalDeviceManager->single_mmap->breaker_value |= (1 << (temp->breaker_id-1));
                        else
                            _globalDeviceManager->single_mmap->breaker_value &= (~(1 << (temp->breaker_id-1)));
                    }
                    
                }else
                {
                    if(temp->breaker_id <= 16){
                        if(temp->breaker_status)
                            _globalDeviceManager->triphasic_mmap->breaker_value |= (1 << (temp->breaker_id-1));
                        else
                            _globalDeviceManager->triphasic_mmap->breaker_value &= (~(1 << (temp->breaker_id-1)));
                    }
                    
                }
                
            }
            if(temp->breaker_gather_addr == 0)
            {
                hlw8110_read_Status(NULL,(int*)(&temp->breaker_status));
            }
#ifdef USE_BREAKER_ALARM
            if (pre_breaker_status && !temp->breaker_status)
            {
                time_t now;
                time(&now);
                struct tm *t;
                t = localtime(&now);

                char buffer[80];
                strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
                char AlarmText[256];
                snprintf(AlarmText, sizeof(AlarmText), "断路器 %d 断开", temp->breaker_id);

                int nAlarmID = dev_insert_alarm_info(_globalDeviceManager->db, temp->product_id, 0, buffer, AlarmText);

                set_led_beep(LED_MODE_WARN2, BEEP_MODE_WARN2);
            }
#endif
        }
        lock_s_release(LOCK_ID_BREAKER);
        sleep(1);
    }
    pthread_exit(NULL);
}


static void set_sensor_val_modbus(GlobalDeviceManager *_globalDeviceManager,GlobalSensorInfo *info,int saddr)
{
    if(saddr>=4 || saddr<0)
        return;
    if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
    _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
    {
        if(_globalDeviceManager->single_mmap) {
            _globalDeviceManager->single_mmap->cas_sensor[saddr].s_1 = info->val1 * 1000;
            if(info->val2 == -1)
                 _globalDeviceManager->single_mmap->cas_sensor[saddr].s_2 = 0xFFFFFFFF;
            else
                _globalDeviceManager->single_mmap->cas_sensor[saddr].s_2 = info->val2 * 1000;
        }
    }else{
        if (_globalDeviceManager->triphasic_mmap)
        {
            _globalDeviceManager->triphasic_mmap->cas_sensor[saddr].s_1 = info->val1 * 1000;
            if(info->val2 == -1)
                 _globalDeviceManager->triphasic_mmap->cas_sensor[saddr].s_2 = 0xFFFFFFFF;
            else
                _globalDeviceManager->triphasic_mmap->cas_sensor[saddr].s_2 = info->val2 * 1000;
        }
    }
}
static void set_dry_val_modbus(GlobalDeviceManager *_globalDeviceManager,int val,int saddr)
{
    if(saddr>=4 || saddr<0)
        return;
    if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
    _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
    {
        if(_globalDeviceManager->single_mmap) {
            _globalDeviceManager->single_mmap->d_node[saddr]= val;
        }
    }else{
        if (_globalDeviceManager->triphasic_mmap)
        {
            _globalDeviceManager->triphasic_mmap->d_node[saddr]= val;
        }
    }
}

static int compare_uint8_s(const void *a,const void *b)
{
    uint8_t arg1 = *(const uint8_t *)a;
    uint8_t arg2 = *(const uint8_t *)b;
    
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}


/// @brief 传感器采集线程
/// @param arg 
/// @return 
static void* sensor_thread(void* arg)
{
#if 1
    thread_handle_t *th=(thread_handle_t*)arg;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)th->arg;
    unsigned int samp_time = _globalDeviceManager->_globalDevInfo.product.samp_time;
    GlobalSensorManger *_globalSensorMangerTemp;
    int ret = 0;
    GlobalSensorInfo _globalSensorInfo;
    struct tm *t;
    struct timeval tv;
    struct timezone tz;
    // 硬件初始化
    // 初始化modbus
    // 初始化gpio
    dev_sensor_init(_globalDeviceManager);

    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); // 查询日志最大点

    // printf("asdasdasdasdasd   %d\n",nSaveIndex);
    int nMaxIndex = 2000000000;
    int nDeleteNumber = 1000 / 120000 * 3600 * 24 * 30 * 10; // 1/60s;
    struct sensor_addr {
        int count;
        uint8_t serser_addr[255];
    }sen={
        .count = 0,
        .serser_addr = {0},
    };
    //  printf("senseor   !!!!!\n");

    //初始化GPIO
    /*
    log_d("GPIO 开始初始化");
    list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
    {
        if (_globalSensorMangerTemp->sensor_interface_type == 2) // 干节点传感器
        {
            memset(strTemp, 0, sizeof(strTemp));
            sprintf(strTemp, "echo %d > /sys/class/gpio/export",_globalSensorMangerTemp->sensor_addr+GPIO_PD11);
            system(strTemp);
            memset(strTemp, 0, sizeof(strTemp));
            sprintf(strTemp, "echo in  > /sys/class/gpio/gpio%d/direction",_globalSensorMangerTemp->sensor_addr+GPIO_PD11);
            system(strTemp);
        }
    }
    log_d("GPIO 初始化成功");
    */
    // 采集线程
    while (th->quit==0)
    {

        if (nSaveIndex > nMaxIndex)
        {
            dev_change_last_Index(_globalDeviceManager->db, &nSaveIndex, nDeleteNumber, strTable);
        }
        //int val = 0;
        sen.count = 0;
        list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
        {
            if(_globalSensorMangerTemp->sensor_interface_type == 1)  //485 类型传感器
            {
                sen.serser_addr[sen.count] = _globalSensorMangerTemp->sensor_addr;
                sen.count ++;
            }
        }
        if(sen.count > 0)
            qsort(sen.serser_addr,sen.count,sizeof(uint8_t),compare_uint8_s);

        //_globalDeviceManager->g_modebus_read.temprature = 0;
       // _globalDeviceManager->g_modebus_read.humidity = 0;
      //  _globalDeviceManager->g_modebus_read.fCO2 = 0;

        uint32_t Max_Temprature=0;
        uint32_t Max_Temprature2=0;
        uint32_t Max_humi=0;
        uint32_t Max_CO2=0;

        lock_s_hold(LOCK_ID_SENSOR);
        list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
        {
            _globalSensorInfo.val1 = 0.0f;
            _globalSensorInfo.val2 = 0.0f;

            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+1, 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.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;
            switch (_globalSensorMangerTemp->sensor_type)
            {

            case SENSOR_TYPE_TEMP_HUMI: // 温湿度
            {
                // printf("get \n");
                float temperature = 0.0;
                float humidity = 0.0;
#ifdef PRJ_ANDERSON
                ret = sensor_get_temperature_value_anderson((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                               _globalSensorMangerTemp->sensor_addr,
                                                               &temperature,
                                                               &humidity);
#else
                ret = sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &humidity);
#endif
                if (ret == -1)
                {
                    //log_i("485 Timeout sensorAddr=%d, ret=%d\n", _globalSensorMangerTemp->sensor_addr, ret);
                    _globalSensorMangerTemp->sensor_check_count++;

                    if (_globalSensorMangerTemp->sensor_check_count >= SENSOR_MAX_CHECK_COUNT)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                        _globalSensorMangerTemp->sensor_check_count = SENSOR_MAX_CHECK_COUNT;
                    }
                    else
                    {
                        _globalSensorInfo.val1 = _globalSensorMangerTemp->Cur_sensor_info.val1;
                        _globalSensorInfo.val2 = _globalSensorMangerTemp->Cur_sensor_info.val2;
                    }
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                    _globalSensorInfo.val1 = temperature;
                    _globalSensorInfo.val2 = humidity;
                    _globalSensorMangerTemp->sensor_check_count=0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                
                if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
                _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
                {
                    if(_globalDeviceManager->single_mmap) {
                        _globalDeviceManager->single_mmap->total_temp.temperature = _globalSensorInfo.val1 *100;
                        _globalDeviceManager->single_mmap->total_temp.humidity = _globalSensorInfo.val2 *100;
                    }
                }else
                {
                    if (_globalDeviceManager->triphasic_mmap)
                    {
                        _globalDeviceManager->triphasic_mmap->temperature = temperature * 100;
                        _globalDeviceManager->triphasic_mmap->humidity = humidity * 100;
                    }
                }
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;

                Max_Temprature=  _globalSensorInfo.val1*100>Max_Temprature? _globalSensorInfo.val1*100:Max_Temprature;
                Max_humi=  _globalSensorInfo.val2*100>Max_humi? _globalSensorInfo.val2*100:Max_humi;

                for(int i =0 ; i < NOARTH_MAX_SENSOR;i++)           //最多4个
                {
                    if(_globalSensorMangerTemp->sensor_addr == sen.serser_addr[i])
                    {
                        set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,i);
                        break;
                    }
                }
                    
            }
            break;

    #if (CHIP_TYPE != CHIP_T113s)
            case SENSOR_TYPE_SMOKE: // 烟雾
            case SENSOR_TYPE_WATER: // 水浸
            case SENSOR_TYPE_ACCESS: // 门禁 IO信号
            {
                if (_globalSensorMangerTemp->sensor_interface_type==2)//干节点传感器
                {
                    int nStatus=-1;
#ifdef NEW_GPIO //注意新的带RGB接口的表头采用新的GPIO定义，旧表头用旧的GPIO定义 liyz 2025.05.01
                    g_switch_get_gpio_status(_globalSensorMangerTemp->sensor_addr + GPIO_PE14, &nStatus);
#else
                    g_switch_get_gpio_status(_globalSensorMangerTemp->sensor_addr + GPIO_PD11, &nStatus);
#endif
                    _globalSensorInfo.val1=nStatus;
                    _globalSensorInfo.val2=-1;
                    if (nStatus == 0)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                    }
                    else
                    {
                        _globalSensorMangerTemp->sensor_status = 0;
                    }

                    //干节点传感器alarm状态报警
                    bool alarmflag=false;
                    int alarmType=-1;
                    if (_globalSensorMangerTemp->sensor_type==SENSOR_TYPE_ACCESS)
                    {
                        if (nStatus==0 &&_globalSensorMangerTemp->Cur_sensor_info.val1!=0 )
                        {
                            alarmflag=true;
                        } 
                    }
                    else
                    {
                        if (nStatus == 1 && _globalSensorMangerTemp->Cur_sensor_info.val1 == 0)
                        {
                            alarmflag = true;
                        }
                    }
                    if (alarmflag)dev_sensor_Alarm_send_message(&__globalDeviceManage, _globalSensorMangerTemp, -1);
                    

                    _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                    set_dry_val_modbus(_globalDeviceManager,_globalSensorMangerTemp->sensor_status,_globalSensorMangerTemp->sensor_addr);
                }                
            }
            break;
#endif

            case SENSOR_TYPE_GAS: // 气体
            {
                float CO2 = 0.0;
                ret = sensor_get_co2_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                              _globalSensorMangerTemp->sensor_addr,
                                              &CO2);
                if (ret == -1)
                {
                    _globalSensorMangerTemp->sensor_check_count++;

                    if (_globalSensorMangerTemp->sensor_check_count >= SENSOR_MAX_CHECK_COUNT)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                        _globalSensorMangerTemp->sensor_check_count = SENSOR_MAX_CHECK_COUNT;
                    }
                    else
                    {
                        _globalSensorInfo.val1 = _globalSensorMangerTemp->Cur_sensor_info.val1;
                        _globalSensorInfo.val2 = _globalSensorMangerTemp->Cur_sensor_info.val2;
                    }
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                    _globalSensorInfo.val1 = CO2;
                    _globalSensorInfo.val2 = 0;
                    _globalSensorMangerTemp->sensor_check_count = 0;
                }
                _globalSensorMangerTemp->Cur_sensor_info = _globalSensorInfo;

                Max_CO2 = _globalSensorInfo.val1 * 100 > Max_CO2 ? _globalSensorInfo.val1 * 100 : Max_CO2;

                for(int i = 0 ; i < NOARTH_MAX_SENSOR;i++)           //最多4个
                {
                    if(_globalSensorMangerTemp->sensor_addr == sen.serser_addr[i])
                    {
                        set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,i);
                        break;
                    }
                }   
            }
            break;


            case SENSOR_TYPE_AIR_PRESS: // 气流
            {
                    _globalSensorInfo.val1=0;
                    _globalSensorInfo.val2=0;
                    _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
            }
            break;
            case SENSOR_TYPE_AIR_COND: // 空调
            {
                _globalSensorInfo.val1 = 0;
                _globalSensorInfo.val2 =0;
                _globalSensorMangerTemp->Cur_sensor_info = _globalSensorInfo;
            }
            break;

            case SENSOR_TYPE_TEMP://温度传感器
            {
                sensor_dat_t sdat;
                ret = sensor_get_data(SENSOR_TYPE_TEMP, SENSOR_TYPE_TEMP_BTG50H8EL3200, _globalSensorMangerTemp->sensor_addr, 0, &sdat);
                if (ret == -1){
                    _globalSensorMangerTemp->sensor_check_count++;

                    if (_globalSensorMangerTemp->sensor_check_count >= SENSOR_MAX_CHECK_COUNT)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                        _globalSensorMangerTemp->sensor_check_count = SENSOR_MAX_CHECK_COUNT;
                    }
                    else
                    {
                        _globalSensorInfo.val1 = _globalSensorMangerTemp->Cur_sensor_info.val1;
                        _globalSensorInfo.val2 = _globalSensorMangerTemp->Cur_sensor_info.val2;
                    }
                }
                else {
                    _globalSensorMangerTemp->sensor_status = 0;
                    _globalSensorInfo.val1 = sdat.val[0];
                    _globalSensorInfo.val2 = 0.0f;
                    _globalSensorMangerTemp->sensor_check_count = 0;
                }
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;

                Max_Temprature=  _globalSensorInfo.val1*100>Max_Temprature? _globalSensorInfo.val1*100:Max_Temprature;

                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
            }
            break;


            case SENSOR_TYPE_LEAK://泄漏传感器
            {
                sensor_dat_t sdat;
                ret = sensor_get_data(SENSOR_TYPE_LEAK, SENSOR_TYPE_LEAK_XWDC01A, _globalSensorMangerTemp->sensor_addr, 0, &sdat);
                if (ret == -1){
                    _globalSensorMangerTemp->sensor_check_count++;

                    if (_globalSensorMangerTemp->sensor_check_count >= SENSOR_MAX_CHECK_COUNT)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                        _globalSensorMangerTemp->sensor_check_count = SENSOR_MAX_CHECK_COUNT;
                    }
                    else
                    {
                        _globalSensorInfo.val1 = _globalSensorMangerTemp->Cur_sensor_info.val1;
                        _globalSensorInfo.val2 = _globalSensorMangerTemp->Cur_sensor_info.val2;
                    }
                }
                else {
                    _globalSensorMangerTemp->sensor_status = 0;
                    _globalSensorInfo.val1 = sdat.flag;
                    _globalSensorInfo.val2 = 0.0f;
                    _globalSensorMangerTemp->sensor_check_count = 0;
                }
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                for(int i = 0 ; i < NOARTH_MAX_SENSOR;i++)           //最多4个
                {
                    if(_globalSensorMangerTemp->sensor_addr == sen.serser_addr[i])
                    {
                        set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,i);
                        break;
                    }
                }   
                //set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);

                //printf("_______SENSOR_TYPE_LEAK: addr:%d, %d, %d, ____%f\n", _globalSensorMangerTemp->sensor_addr, ret, sdat.flag, sensor_info.val1);
                // if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
                //             _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
                // {
                //     log_w("_globalSensorMangerTemp->sensor_addr = %d\n",_globalSensorMangerTemp->sensor_addr);
                //    // _globalDeviceManager->single_mmap->cas_sensor[_globalSensorMangerTemp->sensor_addr-1].s_1 = _globalSensorInfo.val1;
                //    // _globalDeviceManager->single_mmap->cas_sensor[_globalSensorMangerTemp->sensor_addr-1].s_2 = 0xFFFFFFFF;
                // }else
                // {
                //    // _globalDeviceManager->triphasic_mmap->cas_sensor[_globalSensorMangerTemp->sensor_addr-1].s_1 = _globalSensorInfo.val1;
                //    // _globalDeviceManager->triphasic_mmap->cas_sensor[_globalSensorMangerTemp->sensor_addr-1].s_2 = 0xFFFFFFFF;
                // }
            }
            break;

            case SENSOR_TYPE_TEMP_DOUBLE://双头传感器
            {
                float temperature = 0.0;
                float temperature2 = 0.0;
                ret = sensor_get_d_temperature_value_anderson((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &temperature2);

                if (ret == -1)
                {
                    _globalSensorMangerTemp->sensor_check_count++;

                    if (_globalSensorMangerTemp->sensor_check_count >= SENSOR_MAX_CHECK_COUNT)
                    {
                        _globalSensorMangerTemp->sensor_status = 1;
                        _globalSensorMangerTemp->sensor_check_count = SENSOR_MAX_CHECK_COUNT;
                    }
                    else
                    {
                        _globalSensorInfo.val1 = _globalSensorMangerTemp->Cur_sensor_info.val1;
                        _globalSensorInfo.val2 = _globalSensorMangerTemp->Cur_sensor_info.val2;
                    }
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                    _globalSensorInfo.val1 = temperature;
                    _globalSensorInfo.val2 = temperature2;
                    _globalSensorMangerTemp->sensor_check_count = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;

                Max_Temprature=  _globalSensorInfo.val1*100>Max_Temprature? _globalSensorInfo.val1*100:Max_Temprature;
                Max_Temprature2=  _globalSensorInfo.val2*100>Max_Temprature2? _globalSensorInfo.val2*100:Max_Temprature2;

                for(int i = 0 ; i < NOARTH_MAX_SENSOR;i++)           //最多4个
                {
                    if(_globalSensorMangerTemp->sensor_addr == sen.serser_addr[i])
                    {
                        set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,i);
                        break;
                    }
                }   
                //set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
            }
            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) > (_globalDeviceManager->_globalDevInfo.product.save_time / 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);
            }
            if (_globalSensorMangerTemp->sensor_interface_type == 1) // 485 类型传感器
            {
                usleep(20000);
            }
            else usleep(1000);
        }
        lock_s_release(LOCK_ID_SENSOR);

        _globalDeviceManager->g_modebus_read.temprature = Max_Temprature;
        _globalDeviceManager->g_modebus_read.temprature2 = Max_Temprature2;
        _globalDeviceManager->g_modebus_read.humidity = Max_humi;
        _globalDeviceManager->g_modebus_read.fCO2 = Max_CO2;

        sleep(1);
    }
#endif
    pthread_exit(NULL);
}

/// @brief QT通讯内存共享线程(小屏幕)
/// @param arg 
/// @return 
static void* shm_thread(void *arg)
{
    int fd = 0;
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    smartPDU_shm_data pShmData;
    memset(&pShmData, 0, sizeof(pShmData));
    while (_globalDeviceManager->dev_samp_flag)
    {
        fd = shm_open("/smartPDU_shm", O_RDWR, 0666);
        if (fd < 0)
        {
            log_e("error open shm object\n");
            sleep(5); // 延时5秒后再次创建
            continue;
        }
        _globalDeviceManager->g_shm_Data = (smartPDU_shm_data *)mmap(NULL, sizeof(smartPDU_shm_data), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (!_globalDeviceManager->g_shm_Data)
        {
            log_e("mmap failed!\n");
            close(fd);
            sleep(5); // 延时5秒后再次创建
            continue;
        }
        log_i("QT_shm_Init ok\n");
        while (_globalDeviceManager->dev_samp_flag)
        {
            if (_globalDeviceManager->g_shm_Data)
            { // 初始化成功
                memcpy(&pShmData, _globalDeviceManager->g_shm_Data, sizeof(smartPDU_shm_data));
                if (_globalDeviceManager->g_shm_Data->bPDUSet > 0) // 已更新
                {
                    lock_s_hold(LOCK_ID_POWER_UPDATE);
                    int nselect=_globalDeviceManager->g_shm_Data->nSelectPowerCH;
                    int nIndex=0;
                    if (nselect==0)
                    {
                        //输入数据
                        int nselectPH = _globalDeviceManager->g_shm_Data->nSelectPh;
                        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) &&
                            _globalDeviceManager->g_shm_Data->bT_ACType == 1 && nselectPH > 0)
                        {//三项输入数据
                            GlobalTreeACManager *_pTreeACPowerPhData = NULL;
                            int k = 0;
                            list_for_each_entry(_pTreeACPowerPhData, &_globalDeviceManager->_globalPowerManger.list_Tree_AC, list_Tree_AC)
                            {
                                k += 1;
                                if (nselectPH <= k)
                                    break;
                            }
                            if (_pTreeACPowerPhData)
                            {
                                _globalDeviceManager->g_shm_Data->fV = _pTreeACPowerPhData->_PowerInfo.voltage;
                                _globalDeviceManager->g_shm_Data->fA = _pTreeACPowerPhData->_PowerInfo.current;
                                _globalDeviceManager->g_shm_Data->fW = _pTreeACPowerPhData->_PowerInfo.power;
                                _globalDeviceManager->g_shm_Data->fF = _pTreeACPowerPhData->_PowerInfo.factor;
                                _globalDeviceManager->g_shm_Data->fS = _pTreeACPowerPhData->_PowerInfo.consumption;
                                _globalDeviceManager->g_shm_Data->nStatus = _pTreeACPowerPhData->_PowerInfo.status;
                                _globalDeviceManager->g_shm_Data->fT = _globalDeviceManager->g_modebus_read.temprature/100.0f;
                                _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity/100.0f;
                                _globalDeviceManager->g_shm_Data->fCO2 = _globalDeviceManager->g_modebus_read.fCO2/100.0f;
                            }
                        }
                        else
                        {
                            //其他输入数据
                            _globalDeviceManager->g_shm_Data->fV = _globalDeviceManager->_globalPowerManger._PowerInfo.voltage;
                            _globalDeviceManager->g_shm_Data->fA = _globalDeviceManager->_globalPowerManger._PowerInfo.current;
                            _globalDeviceManager->g_shm_Data->fW = _globalDeviceManager->_globalPowerManger._PowerInfo.power;
                            _globalDeviceManager->g_shm_Data->fF = _globalDeviceManager->_globalPowerManger._PowerInfo.factor;
                            _globalDeviceManager->g_shm_Data->fS = _globalDeviceManager->_globalPowerManger._PowerInfo.consumption;
                            _globalDeviceManager->g_shm_Data->nStatus = _globalDeviceManager->_globalPowerManger._PowerInfo.status;
                            _globalDeviceManager->g_shm_Data->fT = _globalDeviceManager->g_modebus_read.temprature/100.0f;
                            _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity/100.0f;
                            _globalDeviceManager->g_shm_Data->fCO2 = _globalDeviceManager->g_modebus_read.fCO2/100.0f;
                        }
                    }
                    else
                    {
                        int nselectPH = _globalDeviceManager->g_shm_Data->nSelectPh;
                        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
                        {
                            nIndex += 1;
                            if (nselect <= nIndex)
                            break;
                        }
                        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) && 
                        _globalDeviceManager->g_shm_Data->bT_ACType == 1&&nselectPH>0)
                        {
                            nIndex=0;
                            GlobalTreeACManager *_pTreeACPowerPhData = NULL;
                            int k = 0;
                            list_for_each_entry(_pTreeACPowerPhData, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                            {
                                k += 1;
                                if (nselectPH <= k)
                                    break;
                            }
                            if (_pTreeACPowerPhData)
                            {
                                _globalDeviceManager->g_shm_Data->fV = _pTreeACPowerPhData->_PowerInfo.voltage;
                                _globalDeviceManager->g_shm_Data->fA = _pTreeACPowerPhData->_PowerInfo.current;
                                _globalDeviceManager->g_shm_Data->fW = _pTreeACPowerPhData->_PowerInfo.power;
                                _globalDeviceManager->g_shm_Data->fF = _pTreeACPowerPhData->_PowerInfo.factor;
                                _globalDeviceManager->g_shm_Data->fS = _pTreeACPowerPhData->_PowerInfo.consumption;
                                _globalDeviceManager->g_shm_Data->nStatus = _pTreeACPowerPhData->_PowerInfo.status;
                                _globalDeviceManager->g_shm_Data->fT = _globalDeviceManager->g_modebus_read.temprature/100.0f;
                                _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity/100.0f;
                                _globalDeviceManager->g_shm_Data->fCO2 = _globalDeviceManager->g_modebus_read.fCO2/100.0f;
                            }
                        }
                        else
                        {
                            _globalDeviceManager->g_shm_Data->fV = _globalPowerMangerTemp->_PowerInfo.voltage;
                            _globalDeviceManager->g_shm_Data->fA = _globalPowerMangerTemp->_PowerInfo.current;
                            _globalDeviceManager->g_shm_Data->fW = _globalPowerMangerTemp->_PowerInfo.power;
                            _globalDeviceManager->g_shm_Data->fF = _globalPowerMangerTemp->_PowerInfo.factor;
                            _globalDeviceManager->g_shm_Data->fS = _globalPowerMangerTemp->_PowerInfo.consumption;
                            _globalDeviceManager->g_shm_Data->nStatus = _globalPowerMangerTemp->_PowerInfo.status;
                            _globalDeviceManager->g_shm_Data->fT = _globalDeviceManager->g_modebus_read.temprature/100.0f;
                            _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity/100.0f;
                            _globalDeviceManager->g_shm_Data->fCO2 = _globalDeviceManager->g_modebus_read.fCO2/100.0f;
                        }
                    }
                    lock_s_release(LOCK_ID_POWER_UPDATE);
                }
                else if (_globalDeviceManager->g_shm_Data->bPDUSet == 0)
                { // 等于于0则更新pdu数据
                    int nMaxCh=0;
                    list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
                    {
                        nMaxCh+=1;
                    }
                    _globalDeviceManager->g_shm_Data->nMaxCh = nMaxCh;
                    strcpy(_globalDeviceManager->g_shm_Data->strVer,VERSION);
                    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))
                    {
                        _globalDeviceManager->g_shm_Data->bT_ACType = 1;
                    }
                    else
                    {
                        _globalDeviceManager->g_shm_Data->bT_ACType = 0;
                    }

                    _globalDeviceManager->g_shm_Data->bPDUSet = 1;
                }
                else
                { // 小于0 则主程序已析构退出重新等待加载
                    munmap(_globalDeviceManager->g_shm_Data, sizeof(smartPDU_shm_data));
                    _globalDeviceManager->g_shm_Data = NULL;
                    close(fd);
                    break;
                }
            }
            usleep(200000);
        }
    }
    if (_globalDeviceManager->g_shm_Data)
    {
        munmap(_globalDeviceManager->g_shm_Data, sizeof(smartPDU_shm_data));
        close(fd);
    }
	
	pthread_exit(NULL);
}


/// @brief QT通讯内存共享线程(5寸屏)
/// @param arg 
/// @return 
static int shm_New_CtrlBoard(void *arg)
{
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    log_i("shm_CtrlBoard Start\n");
    // 尝试清理旧对象（忽略错误）
    shm_unlink(SHM_NAME_5_inch_screen); // 如果不存在会返回 -1，但无需处理
    // 创建新的共享内存对象
    int shm_fd = shm_open(SHM_NAME_5_inch_screen, O_CREAT | O_RDWR, 0666);

    if (shm_fd == -1) {
        log_i("shm_CtrlBoard OpenError\n");
        perror("shm_open");
        return 1;
    }
    log_i("shm_CtrlBoard OpenEnd\n");
    /* 设置共享内存对象的大小 */
    size_t  nSize= sizeof(GlobalPowerCtrlBoard)*(_globalDeviceManager->brdMax+1)+sizeof(int)+sizeof(size_t);
    if (ftruncate(shm_fd,nSize) == -1) {
        perror("ftruncate");
        return 2;
    }
    log_i("shm_CtrlBoard ftruncate End\n");
    //new
    log_i("shm_CtrlBoard mmap Start\n");

    smartPDU_shm_5_inch_data* pShare_Data = (smartPDU_shm_5_inch_data *)mmap(NULL, nSize, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    
    if (pShare_Data==MAP_FAILED) {
        perror("mmap");
        log_i("shm_CtrlBoard mmap Error\n");
        return 3;
    }

    log_i("shm_CtrlBoard mmap initEnd\n");
    if (pShare_Data)
    {
        _globalDeviceManager->pCtrlBoard= pShare_Data->m_pData;
        pShare_Data->array_size=_globalDeviceManager->brdMax + 1;
        pShare_Data->nIPD=getpid();
        log_i("shm_CtrlBoard mmap end-ID=%d ,size= %d\n",pShare_Data->nIPD,pShare_Data->array_size);
    }
    return 0;
}


/**
 * @brief 处理控制消息
 *
 * 根据传入的消息类型和控制指令，执行相应的操作
 *
 * @param arg 指向消息数据的指针
 *
 * @return 返回值 0 表示成功，-1 表示失败
 */
static int msg_read_Ctrl(void* arg)
{
    if (arg==NULL)
    {
        return -1;
        /* code */
    }
    char buff[256]= {0};
    MsgData* msg = (MsgData*)arg;
    int ret=-1;
    switch (msg->CtrlType)
    {
    case Msg_Ch_Ctrl:
    {
        int nChID = msg->nValue[0];
        int nCtrl = msg->nValue[1];
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_globalPowerMangerTemp == NULL)
                break;
            if (nChID == _globalPowerMangerTemp->product_ch_id)
            {
                log_d("switch ctrl:%d ctrlstatus:%d ", _globalPowerMangerTemp->product_ch_id,nCtrl);
                log_d("switch product_saddr:%d product_ch_addr:%d ", _globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr);
                ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                _globalPowerMangerTemp->product_saddr,
                                                _globalPowerMangerTemp->product_ch_addr,
                                                nCtrl, false);
                if (ret < 0)
                {
                    log_d("switch product_saddr:%d product_ch_addr:%d ", _globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr);
                    ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                    _globalPowerMangerTemp->product_saddr,
                                                    _globalPowerMangerTemp->product_ch_addr,
                                                    nCtrl, false);
                    if (ret < 0)
                    {
                        log_e("switch product_saddr:%d product_ch_addr:%d Error",_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr);
                    }

                }
                if (nCtrl == 1)
                {
                    sprintf(buff, "$开启$|$通道$|%d", _globalPowerMangerTemp->product_ch_id);
                    dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff);
                }
                else
                {
                    sprintf(buff, "$开启$|$通道$|%d", _globalPowerMangerTemp->product_ch_id);
                    dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff);
                }
            }
        }
    }
    break;
    case Msg_All_Ctrl:
    {   
        //控制所有通道开关
        int nCtrl = msg->nValue[0];
        int nSendAddr = 0;
        char buff[256];

        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue;
            nSendAddr=_globalPowerMangerTemp->product_saddr;
            log_i("Open All address Start");
            int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,nCtrl);
            if(rec<0)log_i("Open All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno));
            
        }
        if (nCtrl == 1)
        {
            sprintf(buff, "|$开启$|$所有$|$通道$");
            dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff);
        }
        else
        {
            sprintf(buff, "|$关闭$|$所有$|$通道$");
            dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff);
        }
    }
    break;
    default:
        return -1; // 未识别类消息类型，返回-1表错误
        break;
    }
    return 0;
}

/**
 * @brief 初始化消息队列
 *
 * 根据给定的键值key尝试创建消息队列。如果队列不存在，则创建一个新的消息队列；如果队列已存在，则检查队列中是否有残留消息，
 * 如果有残留消息或者没有等待该消息队列的进程，则清理该队列并重新创建。
 *
 * @param key 消息队列的键值
 *
 * @return 成功时返回消息队列的标识符，失败时返回-1
 */
int safe_msg_init(key_t key) 
{
    int msgid;
    struct msqid_ds queue_info;
    
    // 尝试创建全新队列
    msgid = msgget(key, 0666 | IPC_CREAT | IPC_EXCL);
    if (msgid != -1) {
        return msgid; // 全新创建成功
    }
    
    // 若队列已存在
    if (errno == EEXIST) {
        // 获取现有队列
        if ((msgid = msgget(key, 0666)) == -1) {
            perror("msgget existing");
            return -1;
        }
        
        // 检查队列是否残留消息
        if (msgctl(msgid, IPC_STAT, &queue_info) == -1) {
            perror("msgctl stat");
            return -1;
        }
        
        // 判断是否需要清理
        if (queue_info.msg_qnum > 0 || queue_info.msg_lspid == 0) {
            log_w("Cleaning stale queue (msgs:%lu)\n", queue_info.msg_qnum);
            
            // 删除旧队列
            if (msgctl(msgid, IPC_RMID, NULL) == -1) {
                log_e("msgctl rmid");
                return -1;
            }
            
            // 重新创建
            msgid = msgget(key, 0666 | IPC_CREAT | IPC_EXCL);
            if (msgid == -1) {
                log_e("msgget recreate");
                return -1;
            }
            return msgid;
        }
        return msgid;
    }
    
    log_e("msgget init");
    return -1;
}

/**
 * @brief 接收消息处理线程
 *
 * 该函数用于接收并处理消息。它会不断循环接收类型为2的消息，并在接收到消息后打印其内容。
 * 如果接收过程中出现错误（除了ENOMSG错误），则会打印错误信息。
 *
 * @param arg 指向线程参数的指针
 *
 * @return 返回NULL
 */
static void *recv_handler(void *arg)
{
    GlobalPowerManger *_globalPowerMangerTemp = NULL;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    Msg_thread_args *args = &_globalDeviceManager->_MSG_args;
    // 初始化消息队列
    key_t key;
    int msgid;
    // 生成键值前确保文件存在
    const char *path = "/root/run/app/smartPDU_MSGQ";

    while (args->needInit)
    {
        if (access(path, F_OK) == -1)
        {
            int fd = open(path, O_CREAT, 0666);
            if (fd == -1)
            {
                log_e("smartPDU_MSGQ_create key file");
                sleep(500); // 延时5秒后再次创建
                continue;
            }
            close(fd);
        }

        if ((key = ftok(path, 'Q')) == -1)
        {
            log_e("smartPDU_MSGQ ftok");
            sleep(500); // 延时5秒后再次创建
            continue;
        }
        
        // 安全初始化队列
        if ((msgid = safe_msg_init(key)) == -1)
        {
            log_e("Message queue init failed\n");
            sleep(500); // 延时5秒后再次创建
            continue;
        }
        
        log_i("Message queue init success ID=%d\n",msgid);
        log_i("Message queue init success args-ID=%d\n",args->msgid);
        args->msgid=msgid;
        args->running=1;
        MsgData msg;
        while (args->running)
        {
            memset(&msg, 0, sizeof(MsgData));
            ssize_t ret = msgrcv(args->msgid, &msg, sizeof(msg)-sizeof(long),
                                 1,           // 接收类型为2的消息
                                 IPC_NOWAIT); // 非阻塞模式

            if (ret > 0)
            {
                log_i("Received from Qt Type= %d, val1= %d val2= %d\n", msg.MsgType,msg.nValue[0],msg.nValue[1]);
                msg_read_Ctrl(&msg);
            }
            else if (errno != ENOMSG)
            {
                log_e("msgrcv error");
                usleep(100000); // 无数据则延时100ms轮询间隔
            }else{
                usleep(100000); // 无数据则延时100ms轮询间隔
            }
        }
    }
    return NULL;
}
/**
 * @brief 消息发送处理函数
 *
 * 该函数用于处理消息发送的逻辑。
 *
 * @param arg 函数参数，通常为空指针
 * @param _msg 指向待发送的消息数据的指针
 * 
*/
static void send_handler(void *arg, MsgData* _msg)
{
    if (_msg == NULL) {
        return;
    }
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)arg;
    Msg_thread_args args = _globalDeviceManager->_MSG_args;    
    if (args.running == 0)
    {
        return;
    }
    
    MsgData msg = *_msg;
    msg.MsgType = 1; // 设置消息类型为1

    ssize_t ret = msgsnd(args.msgid, &msg, sizeof(msg)-sizeof(long), 0);
    if (ret < 0) {
        log_e("msgsnd failed, errno: %d", errno);
        // 可根据需要添加重试逻辑
    }
}


//#define USE_NTPD
static void* ntp_thread(void *arg)
{
    int r=0,flag=0;
    NTPClient  *pc=NULL;
    time_t time1=0,time2=0,utc_time;
    thread_handle_t *h=(thread_handle_t*)arg;
    NTPManager *pntp=&_globalNTPManager;

    #define NTP_TIMEOUT         5
    #define NTP_INTERVAL_TIME   300
    time1 = time(NULL);
    while (h->quit == 0)
    {
        if (pntp->mode > 0)
        {
            //printf("___ntp_sync_flag: %d, interval: %d\n",  ntp_sync_flag, abs(time1-time2));
            if (ntp_sync_flag || (abs(time1 - time2) >= NTP_INTERVAL_TIME))
            {
                if(pc==NULL) {
                    pc = createNTPClient(pntp->ntpaddress, pntp->port, NTP_TIMEOUT);
                }

                if (pc)
                {
                    if (getCurrentTimeFromNTP(pc, &utc_time) == 0)
                    {
                        time_t host_time = time(NULL);
                        log_d("host_time: %ld, ntp_time: %ld", host_time, utc_time);
                        if(host_time != utc_time) {
                            set_utctime(utc_time);
                            //set_utctime_zone(utc_time, pntp->tzone);
                            
                        }
                    }
                    else
                    {
                        log_e("getCurrentTimeFromNTP failed!");
                    }
                    destroyNTPClient(pc);
                    pc = NULL;
                }
                ntp_sync_flag = 0;
                time2 = time1;
            }
        }
        time1 = time(NULL);
        sleep(1);
    }
    destroyNTPClient(pc);

    pthread_exit(NULL);
}
int ntp_config(NTPManager *nm)
{
    int r=0;

#ifdef USE_NTPD
    if(nm->mode==1) {
        char cmd[400];
        char *conf="/etc/ntp.conf";

        sprintf(cmd, "sed -e /^server.*$/d -e \"$ a server %s minpoll 4 maxpoll 5\" -i %s", nm->ntpaddress, conf);
        printf("___cmd: %s\n", cmd);
        r = system(cmd);
        system("/etc/init.d/S49ntp restart");
    }
    else {
        system("/etc/init.d/S49ntp stop");
    }
#else
    //system("/etc/init.d/S49ntp stop");
    if(nm->mode==1) {
        ntp_sync_flag = 1;
    }
#endif

    return r;
}
static int ntp_init(void)
{
    int r=0,flag=0;
    time_t time1=0,time2=0,utc_time;
    GlobalDeviceManager *dm=&__globalDeviceManage;
    NTPManager *pntp=&_globalNTPManager;
    
    r = dev_get_ntp_info(dm->db,  pntp);
    if (r) {
        pntp->mode = 1;
        strcpy(pntp->ntpaddress, "cn.pool.ntp.org");
        strcpy(pntp->ntpName, "cn-pool");
        pntp->port = 123;
        pntp->product_id = dm->_globalDevInfo.product.id;
        time_t t = time(NULL);
        struct tm* ptm = localtime(&t);
        sprintf(pntp->time, "%04d-%02d-%02d %02d:%02d:%02d", ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
        struct tm* ptm_gm = gmtime(&t);
        pntp->tzone = 8;
        pntp->weekday = (ptm->tm_wday == 0) ? 7 : ptm->tm_wday;
        if (dev_insert_ntp_info(dm->db,  pntp)) {
            log_e("insert npt info failed");
        }
    }
    else {
        log_d("get ntp info from database succeeded");
    }
    dev_Alarm_Run_message(dm, language_alarm_Init_Success[0], "NTP");

    ntp_config(pntp);
#ifndef USE_NTPD
    thread_start(THREAD_ID_NTP, ntp_thread, dm);
#endif

    return 0;
}


int snmp_config(SNMPManager *m, int quit)
{
    char path[200];
    char *conf="/snmp/conf/snmpd.conf";

    char user[100],pass[200],cmd[400],trapinfo[200];
    sys_get_path(path, conf);

    sprintf(trapinfo, "trap2sink \"%s\" %s \"%s\"", m->nmsIP, "public", "162");
    //delete
    sprintf(cmd, "sed -e /^trap2sink.*$/d -i %s", path);
    system(cmd);
    sprintf(cmd, "sed -e \"$ a %s\" -i %s", trapinfo, path);
    system(cmd);

    if (strlen(m->crypt.auth.alg) > 1)
    {
        // createUser afafafaf MD5 "md5123456" DES "des123456

        // delete
        sprintf(cmd, "sed -e /^createUser.*$/d -e /^rouser.*$/d -i %s", path);
        system(cmd);

        if (m->version == 2)
        {
            sprintf(user, "rouser \"%s\"", m->crypt.user);
            sprintf(pass, "createUser \"%s\" %s \"%s\"", m->crypt.user, m->crypt.auth.alg, m->crypt.auth.passwd);
            if (strlen(m->crypt.priv.alg) > 1)
            {
                sprintf(cmd, " %s \"%s\"", m->crypt.priv.alg, m->crypt.priv.passwd);
                strcat(pass, cmd);
            }

            sprintf(cmd, "sed -e \"$ a %s\" -e \"$ a %s\" -i %s", pass, user, path);
            system(cmd);
        }
    }
#if (CHIP_TYPE == CHIP_T113s)
    system("reboot");
  //  system("/mnt/UDISK/app/snmp/bin/snmpd -Cc /mnt/UDISK/app/snmp/conf/snmpd.conf -Lo &");
    sleep(2);
    
#else
    system("/etc/init.d/S90PDUApp restart snmpd");
#endif
    if(quit) sys_exit();

    return 0;
}


static void* snmp_thread(void *arg)
{
    //int ret = 0 ;
    thread_handle_t *h=(thread_handle_t*)arg;
    GlobalDeviceManager *dm=(GlobalDeviceManager*)h->arg;
    
    /* we are a subagent */
    char path[PATH_MAX];
    /* we are a subagent */
    
    netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE, 1);
    
    /* initialize the agent library */
    sys_get_path(path, SNMP_MIB_NAME);
    init_agent(path);
    
    /* initialize your mib code here */
    init_pduMIB_form();
    init_pduMIB_scalar();
    
    /* pduMIB will be used to read pduMIB.conf files. */
    init_snmp(path);
    init_snmp_alarm();

    dev_get_snmp_info(dm->db, &_globalSNMPManager);
    dev_Alarm_Run_message(dm, language_alarm_Init_Success[0], "SNMP");
	
    int reconfig=0;
    while(h->quit==0) {
        if (reconfig) {  
            free_config();  
            read_configs();  
            reconfig = 0;  
        }  
        if(!dm->upgread_flag)
        {
            agent_check_and_process(1);/* block every 1 second */
        }else
        {
            sleep(1);
        }
    }
    /* at shutdown time */
    snmp_shutdown(path);
    
    /* deinitialize your mib code here */    
    /* shutdown the agent library */
    shutdown_agent();

    pthread_exit(NULL);
}


/// @brief 全局结构体初始化
/// @return 
int app_init(void)
{
    int ret = 0 ;
    int type = 0 ;
    int chn = 0 ;
    char path[PATH_MAX];
    int io_thread_flag = 0 ;
    int sensor_thread_flag = 0 ;
    int nTac_chn=0;
    GlobalDeviceManager* _globalDeviceManager=&__globalDeviceManage;

    INIT_LIST_HEAD(&_GlobalUserLoginInfo.list);
    INIT_LIST_HEAD(&_globalDeviceManager->_globalPowerManger.list);
    INIT_LIST_HEAD(&_globalDeviceManager->_globalPowerManger.list_Tree_AC);
    INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);
    INIT_LIST_HEAD(&_globalDeviceManager->g_new_global_breaker.list);

    //使用的通道
    _globalDeviceManager->useSlaveCount = 0 ;
    _globalDeviceManager->brdMax = _globalDeviceManager->_globalDevInfo.ptotal.brdMax;
#ifdef USE_SHM_5_inch_screen
    int shm_Error=shm_New_CtrlBoard(_globalDeviceManager);
    switch (shm_Error)
    {
    case 0:
        log_i("shm_New_CtrlBoard success\n");
        break;
    case 1:
        log_e("shm_open error\n");
        break;
    case 2:
        log_e("ftruncate error\n");
        break;
    case 3:
        log_e("mmap error\n");
        break;
    }
#else
    _globalDeviceManager->pCtrlBoard = malloc(sizeof(GlobalPowerCtrlBoard)*(_globalDeviceManager->brdMax+1));
    if(!_globalDeviceManager->pCtrlBoard) {
        log_e("pCtrlBoard malloc failed, brdMax: %d\n", _globalDeviceManager->brdMax);
        return -1 ;
    }
#endif
    g_switch_init(_globalDeviceManager->brdMax);
    
    //链接数据库获取配置信息
    sys_get_path(path, DATABASE_NAME);
    log_i("database: %s\n", path);
    ret = sqlite_init(&_globalDeviceManager->db,&_globalDeviceManager->dbThreadlock, path);
    if(ret<0)
    {
        log_e("database %s open error.\n", path);
        return -1 ;
    }
    log_i("database %s open ok.\n", path);


#if 1
    if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
        _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)       // single AC
    {
        _globalDeviceManager->single_mmap =(cascade_single_mmap_t*)malloc(sizeof(cascade_single_mmap_t));
        if(_globalDeviceManager->single_mmap==NULL)
        {
            log_e("single_mmap malloc error.!");
            return -1 ;       
        }  
        memset(_globalDeviceManager->single_mmap, 0, sizeof(cascade_single_mmap_t));
    }else   // tree
    {
        _globalDeviceManager->triphasic_mmap =(cascade_triphasic_mmap_t*)malloc(sizeof(cascade_triphasic_mmap_t));
        if(_globalDeviceManager->triphasic_mmap== NULL)
        {
            log_e("triphasic_mmap malloc error.!");
            return -1 ;       
        }  
        memset(_globalDeviceManager->triphasic_mmap, 0, sizeof(cascade_triphasic_mmap_t));
    }

    //打印参数
    //printf_global_device_info(&_globalDeviceManager->_globalDevInfo);
    
    //查询是否存在全部通道信息
    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_globalDevInfo.product.id,0,
                                    0, //1*8+j
                                    &_globalDeviceManager->_globalPowerManger);
    //未查询到信息 则插入
    if(ret==-1)
    {
        _globalDeviceManager->_globalPowerManger.product_id = _globalDeviceManager->_globalDevInfo.product.id;
        _globalDeviceManager->_globalPowerManger.product_saddr = 0 ;
        _globalDeviceManager->_globalPowerManger.product_ch_id = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_addr = 0;
        sprintf( _globalDeviceManager->_globalPowerManger.product_ch_name,"ALL_CH");//,_globalDeviceManager->_globalPowerManger.product_ch_id);
        _globalDeviceManager->_globalPowerManger.product_ch_type = type;
        _globalDeviceManager->_globalPowerManger.product_ch_status = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_NF_status = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_start_delay = 1000;     
        _globalDeviceManager->_globalPowerManger.product_ch_stop_delay = 1000;
        _globalDeviceManager->_globalPowerManger.global_over_manager.product_cur_over_upper_threshold_ctrl =ALARM_CTRL_ALARM_ONLY;//默认超限只报警
        _globalDeviceManager->_globalPowerManger.global_over_manager.product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager.product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_over_lower_threshold_ctrl= ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager.product_vol_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;

        if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_globalDevInfo.product.id,
                                    0,
                                    &_globalDeviceManager->_globalPowerManger)!=0)
        {
            log_e("all chn data inserted error.\n");
            return 0;
        }
        else
        {
            log_i("all chn data inserted ok.\n");
        }        
    } 
    
    if (_globalDeviceManager->_globalDevInfo.product.pwr_type==SmartPDU_Tree_AC_Tree
    ||_globalDeviceManager->_globalDevInfo.product.pwr_type==SmartPDU_Tree_AC_One
    ||_globalDeviceManager->_globalDevInfo.product.pwr_type== SmartPDU_Tree_AC_Two 
    ||_globalDeviceManager->_globalDevInfo.product.pwr_type==SmartPDU_Tree_AC_One_B
    )
    {
        __globalDeviceManage.nTreeACLshow=0;
        _globalDeviceManager->useSlaveCount++;
        _globalDeviceManager->pCtrlBoard[0].product_saddr = 0;
        _globalDeviceManager->pCtrlBoard[0].product_number = -1;
        _globalDeviceManager->pCtrlBoard[0].product_type = -1;
        
        // 填充三相表
        for (size_t TreeACindex = 0; TreeACindex < 3; TreeACindex++)
        {
            GlobalTreeACManager *_globalTACManager = NULL;
            _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
            if (_globalTACManager == NULL)
            {
                log_e("_globalTACManager malloc error.\n");
                return -1;
            }
            memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
            
            ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                 _globalDeviceManager->_globalDevInfo.product.id, 0,0,
                                                 TreeACindex, // 1*8+j
                                                 _globalTACManager);
            _globalTACManager->product_ch_addr = TreeACindex + 1;
            // 未查询到信息 则插入
            if (ret == -1)
            {
                _globalTACManager->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                _globalTACManager->product_saddr = 0;
                _globalTACManager->product_ch_id = chn;
                _globalTACManager->product_ch_addr = TreeACindex + 1;
                _globalTACManager->product_ph_id = nTac_chn;
                _globalTACManager->product_ph_type = (TreeACindex + 3) % 3;
                if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                      _globalDeviceManager->_globalDevInfo.product.id,
                                                      _globalTACManager->product_ch_id,
                                                      _globalTACManager) != 0)
                {
                    log_e("address %d ph_chn %d data inserted error.\n", 0, nTac_chn);
                    return 0;
                }
            }

            list_add_tail(&_globalTACManager->list_Tree_AC, &_globalDeviceManager->_globalPowerManger.list_Tree_AC);
            nTac_chn += 1;
        }
    }
    log_i("get all chn data ok.\n");

    // 初始化modbus,搜寻子设备
    ret = g_modbus_init(&_globalDeviceManager->_globalRelaySampManger,
                        INTERL_MODBUS_PORT,
                        INTERL_MODBUS_BAUD,
                        MASTER_MODE,
                        0,
                        "relay",1,500);

    if(ret!=0)
    {
        switch (ret)
        {
        case -2:
            log_w("Relay modbus: modbus_rtu_set_serial_mode :MODBUS_RTU_RS485(1)");
            break;
        case -3:
            log_w("Relay modbus: modbus_rtu_set_rts: MODBUS_RTU_RTS_NONE(0)");
            break;
        case -4:
            log_w("Relay modbus: pthread_mutex_init");
            break;
        case -5:
            log_w("Relay modbus: modbus_connect");
            break;
        default:
            break;
        }
        log_w("Relay modbus Error:%s\n",modbus_strerror(errno));
        return -1 ;
    }
    log_i("Relay modbus init ok.\n");



    //first scannner breaker borad;
    unsigned short value;
    breaker_scanner_t *breaker = get_breaker_scanner();
    memset(breaker, 0, sizeof(breaker_scanner_t));
    for (int i = 0; i < BREAKER_BOARD_MAX; i++)
    {
        ret = breaker_485_get_chn_status((void *)&_globalDeviceManager->_globalRelaySampManger,
                                         BREADER_485_ADDR + i, BREADER_485_ADDR_CHN_REG, &value);
        log_d("ret:%d breaker id:%d .\n", ret, BREADER_485_ADDR + i);
        if (ret == 0)
        {
            breaker->breaker_flag[i] = 1;
        }
        else
        {
            breaker->breaker_flag[i] = 0;
        }
    }

    //init power manage
    //搜索子地址
    chn = 1 ;
    nTac_chn=3;

    char strLog[200]={"MODBUS"};
    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],strLog);
    log_d("GCPDU init begin!");

    paras_PhListInit();
    ResetChmData(0);

    ///todo:此信息需要和数据库更新以后在关联
    ret = dev_get_sensor_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_globalDevInfo.product.id,
                                    &_globalDeviceManager->_globalSensorManger);
    if(ret!=0)
    {
        log_e("not find sensor info.");
    }
    else
        log_d("get sensor info ok.");

    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"sensor");
    ret =dev_get_breaker_manage_info(_globalDeviceManager->db,_globalDeviceManager->_globalDevInfo.product.id,
                &_globalDeviceManager->g_new_global_breaker);

    if(ret!=0)
    {
        log_e("not find breaker info.");
    }
    else
        log_d("get breaker info ok.");

    _globalDeviceManager->dev_samp_flag = true;

    cellular_init();

    thread_start(THREAD_ID_POWER,  power_thread,  _globalDeviceManager);
    thread_start(THREAD_ID_SENSOR, sensor_thread, _globalDeviceManager);

#ifndef USE_UI
    thread_start(THREAD_ID_SHMW,   shm_thread,    _globalDeviceManager);

    _globalDeviceManager->_MSG_args.needInit = true;

    thread_start(THREAD_ID_RECV_MESSAGE_QUEUE, recv_handler, _globalDeviceManager);
#endif

    thread_start(THREAD_ID_BREAKER_SCANNER, breaker_scanner_thread, _globalDeviceManager);
    thread_start(THREAD_ID_BREAKER, breaker_thread, _globalDeviceManager);
    
#if (CHIP_TYPE != CHIP_T113s)
    wifi_init();
#endif

#ifndef USE_NETSWITCH
    thread_start(THREAD_ID_SNMP, snmp_thread, _globalDeviceManager);
#endif

    ntp_init();
    cascade_init();
    netswitch_init();
    mail_init();
    mqtt_init();
#endif

    websocket_init();
    appweb_init();

    upg_init();
    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"Server Thread");
    
    return 0;
}