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 "smtp.h"
#include "mqtt.h"
#include "netswitch.h"
#include "breaker_detection.h"
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>


static void get_time(char *ts)
{
    struct timeval tv;
    struct tm      *tm;

    gettimeofday(&tv, NULL);
    tm = localtime(&tv.tv_sec);
    sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d.%03ld", tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, tv.tv_usec/1000);
}
static void db_ow_test(sqlite3 *db, int *index, int *index3)
{
    int i,ow_flag=0;
    GlobalPowerInfo info;
    GlobalTreeACManager info3;
    int idx=1;
    char temp[100];

    dev_sql_set_overwrite(0);
    for(i=0; i<200; i++) {
        get_time(info.samp_time);
        dev_insert_power_info(db, &info, index);
        dev_insert_t_ac_power_info(db, &info3, index3, info.samp_time);

        sprintf(temp, "alarm %d", idx++);
        dev_insert_alarm_info(db, 0, ALARM_TYPE_POWER, info.samp_time, temp);
    }
    dev_sql_set_overwrite(1);

    for(i=0; i<10; i++) {
        get_time(info.samp_time);

        dev_insert_power_info(db, &info, index);
        dev_insert_t_ac_power_info(db, &info3, index3, info.samp_time);

        sprintf(temp, "alarm %d", idx++);
        dev_insert_alarm_info(db, 0, ALARM_TYPE_POWER, info.samp_time, temp);
    }
}


void* power_thread(void* arg)
{
    int ret = 0 ;
    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 ;
    dev_search_last_Index(_globalDeviceManager->db, &lastIndex, tabPower);       // 查询日志最大点
    dev_search_last_Index(_globalDeviceManager->db, &lastIndex3, tabPower3);      // 查询日志最大点
    InitHashTable(_globalDeviceManager);
    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;
    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);
    }

    //db_ow_test(_globalDeviceManager->db, &lastIndex, &lastIndex3);
    //采集线程
    while (h->quit==0)
    {
        if (_globalDeviceManager->_ReloadChm_flag)
        {
            sleep(1);
            continue;
        }
        
#if (1)
        memset(&_globalTotalPowerInfo, 0, sizeof(GlobalPowerInfo));
        memset(&_globalPowerWarningInfo, 0, sizeof(PowerWarningInfo));
        for (size_t i = 0; i < MAX_CHN_COUNT; i++)
        {
            if (_globalDeviceManager->_all_ctrl_board[i].product_saddr == 0)
            {
                continue;
            }
            ret=g_switch_get_all_out_info(&_globalDeviceManager->_globalRelaySampManger,
                                        _globalDeviceManager->_all_ctrl_board[i].product_type,
                                        _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                        _globalDeviceManager->_all_ctrl_board[i].product_number,
                                        _globalDeviceManager->_all_ctrl_board[i]._PowerInfo,
                                            _globalDeviceManager->_all_ctrl_board[i]._PowerWarninginfo);
            if (ret<0)
            {
                usleep(usleepTime);
                ret = g_switch_get_all_out_info(&_globalDeviceManager->_globalRelaySampManger,
                                                _globalDeviceManager->_all_ctrl_board[i].product_type,
                                                _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                                _globalDeviceManager->_all_ctrl_board[i].product_number,
                                                _globalDeviceManager->_all_ctrl_board[i]._PowerInfo,
                                                _globalDeviceManager->_all_ctrl_board[i]._PowerWarninginfo);
            }
            // 输入总信息(三相)(后续应同步所有类型)
            if (_globalDeviceManager->_all_ctrl_board[i].product_saddr != 0 && _globalDeviceManager->_all_ctrl_board[i].product_type == TREE_AC_TYPE)
            {
                usleep(usleepTime);
                ret = g_switch_get_t_ac_in_info(&_globalDeviceManager->_globalRelaySampManger,
                                                _globalDeviceManager->_all_ctrl_board[i].product_saddr, // saadr
                                                _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo,
                                                _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerWarninginfo);
                if (ret < 0)
                {
                    usleep(usleepTime);
                    ret = g_switch_get_t_ac_in_info(&_globalDeviceManager->_globalRelaySampManger,
                                                    _globalDeviceManager->_all_ctrl_board[i].product_saddr, // saadr
                                                    _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo,
                                                    _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerWarninginfo);
                }
                ret = g_switch_set_t_ac_alarm_missing_ph(&_globalDeviceManager->_globalRelaySampManger,
                                                         _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                                         _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger.product_MissingPH);
                if (ret < 0)
                {
                    usleep(usleepTime);
                    ret = g_switch_set_t_ac_alarm_missing_ph(&_globalDeviceManager->_globalRelaySampManger,
                                                             _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                                             _globalDeviceManager->_all_ctrl_board[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 (!(_globalPowerMangerTemp->product_saddr < MAX_CHN_COUNT && _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->_all_ctrl_board[(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->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[(int)_globalPowerMangerTemp->product_ch_addr-1],
            sizeof(PowerInfo));
            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->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._PowerInfo[_pTreeACPowerMangerTemp->product_ch_addr - 1], sizeof(PowerInfo));
                            memcpy(&_pTreeACPowerMangerTemp->_PowerWarninginfo, &_globalDeviceManager->_all_ctrl_board[_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 */
                                // 插入数据库
                                if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3, _globalPowerInfo.samp_time) != 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);
                        }
                    }
                    
                #ifndef PRJ_INSPUR
                    //插入数据库
                     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);
                    }
                #endif

                    //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:
                {     
                    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&&_pTreeACPowerMangerTemp->product_ph_outputStatus==2)
                        {
                            continue;
                        }                        
                        memcpy(&_pTreeACPowerMangerTemp->_PowerInfo,&_globalDeviceManager->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._PowerInfo[_pTreeACPowerMangerTemp->product_ch_addr - 1],sizeof(PowerInfo)); 
                        memcpy(&_globalTACWarningInfo,&_globalDeviceManager->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._PowerWarninginfo[_pTreeACPowerMangerTemp->product_ch_addr - 1],sizeof(PowerWarningInfo));
                        gettimeofday(&tv, NULL);
                        // t = localtime(&tv.tv_sec);
                         _globalDeviceManager->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq=_globalDeviceManager->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq> _pTreeACPowerMangerTemp->_PowerInfo.freq?_globalDeviceManager->_all_ctrl_board[_pTreeACPowerMangerTemp->product_saddr]._globalPowerInManger._PowerInfo[k].freq:_pTreeACPowerMangerTemp->_PowerInfo.freq;
                        //计算总三项总数据
                        _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;
                        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;
                        }

                        _globalPowerInfo._power_info.NF_status=_pTreeACPowerMangerTemp->_PowerInfo.NF_status;

                        k=k+1;
                        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 */
                            // 插入数据库
                            if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3,_globalPowerInfo.samp_time) != 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);
                        }

                    }

                    _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 = _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 ;
                    _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 ;

                    // tong dao zong ti xin xi
                     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;
                     }

                    //累加总电源信息
                    _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->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._globalPowerInManger.product_MissingPH,sizeof(nMissPH));   
                    nMissPH=_globalDeviceManager->_all_ctrl_board[(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->_all_ctrl_board[(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->_all_ctrl_board[(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);
            #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);
                    }
                }                
            }
        }

        //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;

        }
        //输入数据再处理（三项）
        //memset(_pTreeACPowerMangerTemp,0,sizeof(GlobalTreeACManager));
        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One)
        {
            _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(&_pTreeACPowerMangerTemp->_PowerInfo, 0, sizeof(_globalPowerInfo._power_info));
                for (size_t i = 0; i < MAX_CHN_COUNT; i++)
                {
                    if (_globalDeviceManager->_all_ctrl_board[i].product_saddr == 0 || _globalDeviceManager->_all_ctrl_board[i].product_type != TREE_AC_TYPE)
                    {
                        continue;
                    }
                    // 如果存在电压则置位如果都没有电压则保持0
                    if (_globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].voltage != 0)
                    {
                        _pTreeACPowerMangerTemp->_PowerInfo.voltage = _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].voltage;
                    }
                    _pTreeACPowerMangerTemp->_PowerInfo.current += _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].current;
                    _pTreeACPowerMangerTemp->_PowerInfo.power += _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].power;
                   // if (_globalTotalPowerInfo._power_info.freq != 0)
                  //  {
                     //   _pTreeACPowerMangerTemp->_PowerInfo.freq = _globalTotalPowerInfo._power_info.freq;
                   // }
                     _pTreeACPowerMangerTemp->_PowerInfo.freq =  _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].freq> _pTreeACPowerMangerTemp->_PowerInfo.freq? _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].freq: _pTreeACPowerMangerTemp->_PowerInfo.freq;
                    _pTreeACPowerMangerTemp->_PowerInfo.consumption += _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].consumption;
                    _pTreeACPowerMangerTemp->_PowerInfo.factor = _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].factor;
                }
                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;
                }
                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 */
                    // 插入数据库
                    if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3, _globalPowerInfo.samp_time) != 0)
                    {
                        log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                    }
                }
            }
            if (__globalDeviceManage.triphasic_mmap)
            {
                __globalDeviceManage.triphasic_mmap->dev_chn = __globalDeviceManage._globalDevInfo.product.pwr_type << 8 | _chn;
            }
        }
        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;
                }

                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 */
                    // 插入数据库
                    if (dev_insert_t_ac_power_info(_globalDeviceManager->db, _pTreeACPowerMangerTemp, &lastIndex3, _globalPowerInfo.samp_time) != 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);
        //更新总电源信息

        _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);
            }
        }
        lock_s_release(LOCK_ID_POWER_UPDATE);
  
        //判断阈值状态

        //动作

        //1ms
            //sleep(1);
        ///usleep(500*1000);  
        //延时
        //usleep(samp_time*1000);
    }
    free_hash_table(_globalDeviceManager->alarmTab);
    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);

    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);
            dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_SENSOR, buff);
            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 |$关闭$|$所有$|$通道$");
        dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,ALARM_TYPE_SENSOR,buff);
}
/**
 * @brief 传感器报警函数
 *
 * 根据给定的报警类型和全局传感器管理器，执行相应的传感器报警操作。
 *
 * @param _globalSensorMangerTemp 全局传感器管理器指针
 * @param nAlarmType 报警类型（如SENSOR_VAL1_UPPER、SENSOR_VAL1_LOWER等）
 */
void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType)
{
    bool *penable = NULL;   //使能
    bool *pSave = NULL;     //是否已报警
    float *pValthreshold = NULL;//阈值
    float *pValData = NULL;     //当前值
    char  *nCtrlType = NULL; //报警方式
    char  *nCtrlValue= NULL; //控制通道
    char strCtrlValue[512]={0};
    if (!_globalSensorMangerTemp|| !_globalSensorMangerTemp->over_manager)
    {
        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;
        }
    }
}

void* breaker_thread(void *arg)
{
    int r;
    int ret=0;
    unsigned int usleepTime = 30000;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    GlobalBreakerManager *temp = NULL;
    uint16_t value = 0;
    breaker_scanner_t* breaker_scann = get_breaker_scanner(); 
    while (_globalDeviceManager->dev_samp_flag)
    {
        lock_s_hold(LOCK_ID_BREAKER);
        list_for_each_entry(temp, &_globalDeviceManager->g_new_global_breaker.list,list)
        {
            // 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];
                    }
                }else
                {
                    temp->breaker_status = 0;
                }
            }

            if (temp->breaker_gather_addr>0&&temp->breaker_gather_addr<=MAX_CHN_COUNT)
            {
                for (size_t i = 0; i < MAX_CHN_COUNT; i++)
                {
                    if (_globalDeviceManager->_all_ctrl_board[i].product_saddr != temp->breaker_gather_addr)
                    {
                        continue;
                    }
                    ret = g_switch_get_breaker_info(&_globalDeviceManager->_globalRelaySampManger,
                                                    _globalDeviceManager->_all_ctrl_board[i].product_type,
                                                    _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                                    temp);
                    if (ret < 0)
                    {
                        usleep(usleepTime);
                        ret = g_switch_get_breaker_info(&_globalDeviceManager->_globalRelaySampManger,
                                                        _globalDeviceManager->_all_ctrl_board[i].product_type,
                                                        _globalDeviceManager->_all_ctrl_board[i].product_saddr,
                                                        temp);
                    }
                    break;
                }
            }
        }
        lock_s_release(LOCK_ID_BREAKER);
        sleep(1);
    }
    pthread_exit(NULL);
}

/// @brief 传感器采集线程
/// @param arg 
/// @return 
void* sensor_thread(void* arg)
{
#if 1
   GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    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;
    //  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 (_globalDeviceManager->dev_samp_flag)
    {

        if (nSaveIndex > nMaxIndex)
        {
            dev_change_last_Index(_globalDeviceManager->db, &nSaveIndex, nDeleteNumber, strTable);
        }
        
        lock_s_hold(LOCK_ID_SENSOR);
        list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
        {
            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_TEMPERATURE: // 温湿度
            {
                // printf("get \n");
                float temperature = 0.0;
                float humidity = 0.0;
#ifdef PRJ_ANDERSON
                ret = _g_sensor_get_temperature_value_ANDERSON((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                               _globalSensorMangerTemp->sensor_addr,
                                                               &temperature,
                                                               &humidity);
#else
                ret = _g_sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &humidity);
#endif
                if (ret == -1)
                {
                    _globalSensorMangerTemp->sensor_status = 1;
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);

                _globalSensorInfo.val1 = temperature;
                _globalSensorInfo.val2 = 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;
                _globalDeviceManager->g_modebus_read.temprature=temperature;
                _globalDeviceManager->g_modebus_read.humidity=humidity;
            }
            break;
            case SENSOR_TYPE_SMOKE: // 烟雾
            case SENSOR_TYPE_WATER: // 水浸
            case SENSOR_TYPE_DOOR: // 门禁 IO信号
            {
                if (_globalSensorMangerTemp->sensor_interface_type==2)//干节点传感器
                {
                    int nStatus=0;
                    g_switch_get_gpio_status(_globalSensorMangerTemp->sensor_addr+GPIO_PD11,&nStatus);
                    _globalSensorInfo.val1=nStatus;
                    _globalSensorInfo.val2=-1;
                    _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                }                
            }
            break;
            case SENSOR_TYPE_GAS: // 气体
            {
                    _globalSensorInfo.val1=0;
                    _globalSensorInfo.val2=0;
                    _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
            }
            break;
            case SENSOR_TYPE_AIR_PRESS: // 气流
            {
                    _globalSensorInfo.val1=0;
                    _globalSensorInfo.val2=0;
                    _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
            }
            break;
            case SENSOR_TYPE_AIR_Conditioner: // 空调
            {
                _globalSensorInfo.val1 = 0;
                _globalSensorInfo.val2 =0;
                _globalSensorMangerTemp->Cur_sensor_info = _globalSensorInfo;
            }
            break;
            case SENSOR_TYPE_DoubleT://双头传感器
            {
                float temperature = 0.0;
                float temperature2 = 0.0;
                ret = _g_sensor_get_D_temperature_value_ANDERSON((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &temperature2);

                if (ret == -1)
                {
                    //log_w("Relay modbus Error:%s\n", modbus_strerror(errno));
                    _globalSensorMangerTemp->sensor_status = 1;
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                _globalSensorInfo.val1 = temperature;
                _globalSensorInfo.val2 = temperature2;
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                _globalDeviceManager->g_modebus_read.temprature=temperature;
                _globalDeviceManager->g_modebus_read.temprature2=temperature2;
            }
            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);
            }
        }
        lock_s_release(LOCK_ID_SENSOR);
        sleep(1);
    }
#endif
    pthread_exit(NULL);
}
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)
        {
            printf("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)
        {
            printf("mmap failed!\n");
            close(fd);
            sleep(5); // 延时5秒后再次创建
            continue;
        }
        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) // 已更新
                {
                    int nselect=_globalDeviceManager->g_shm_Data->nSelectPowerCH;
                    int nIndex=0;
                    if (nselect==0)
                    {
                        //_globalDeviceManager->_globalPowerManger;
                        _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;
                        _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity;
                    }
                    else
                    {
                        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
                        {
                            nIndex += 1;
                            if (nselect <= nIndex)
                            break;
                        }
                        // GlobalPowerInfo _globalPowerInfo;
                        // memset(&_globalPowerInfo._power_info, 0, sizeof(PowerInfo));
                        // memcpy(&_globalPowerInfo._power_info,
                        //        &_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0],
                        //        sizeof(PowerInfo));
                        _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;
                        _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity;
                    }
                }
                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;
                     _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);
}

void* ntp_thread(void *arg)
{
    time_t start_t, end_t;
    thread_handle_t *h=(thread_handle_t*)arg;

    start_t = time(NULL);
    while(h->quit==0)
    {
        if (end_t - start_t >= 1 && _globalNTPManager.mode == true)
        {
            if(globalNTPclient==NULL) {
                globalNTPclient = createNTPClient(_globalNTPManager.ntpaddress, _globalNTPManager.port);
            }

            if (globalNTPclient ==NULL)
            {
                log_e("Failed to Connect the NTP server.");
                sleep(600);
                continue;
            }
            
            time_t current_time;  
            if (getCurrentTimeFromNTP(globalNTPclient, &current_time) < 0)
            {
                log_e("Failed to get time from NTP server.");
                sleep(600);
                continue;
            }
            time_t t = time(NULL);
            struct tm *ptm = localtime(&t);
            struct tm *pCurrenttm = gmtime(&current_time);
            if (abs(t - current_time) >= 5)
                set_local_timeandzone(pCurrenttm, _globalNTPManager.tzone);
            end_t = start_t;
        }
        end_t = time(NULL);

        sleep(600); // 十分钟同步一次
    }
    destroyNTPClient(globalNTPclient);

    pthread_exit(NULL);
}

void* snmp_thread(void *arg)
{
    //int ret = 0 ;
    thread_handle_t *h=(thread_handle_t*)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);
    int reconfig=0;
    while(h->quit==0)
    {
        if (reconfig) {  
        free_config();  
        read_configs();  
        reconfig = 0;  
        }  
        agent_check_and_process(1);/* block every 1 second */
    }
    /* at shutdown time */
    snmp_shutdown(path);
    
    /* deinitialize your mib code here */    
    /* shutdown the agent library */
    shutdown_agent();

    pthread_exit(NULL);
}


/// @brief 全局结构体初始化
/// @param _globalDeviceManager 
/// @return 
int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
{
    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;
    
    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 ;
    
    //链接数据库获取配置信息
    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);

    _globalDeviceManager->_globalPowerManger.global_over_manager = (GlobalOverManager*)malloc(sizeof(GlobalOverManager));
    if(_globalDeviceManager->_globalPowerManger.global_over_manager==NULL)
    {
        log_e("_globalPowerManger->global_over_manager malloc error.\n");
        return -1 ;       
    } 
    memset(_globalDeviceManager->_globalPowerManger.global_over_manager, 0, sizeof(GlobalOverManager));
    //查询是否存在全部通道信息
    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_One_B
    )
    {
        __globalDeviceManage.nTreeACLshow=0;
        _globalDeviceManager->useSlaveCount++;
        _globalDeviceManager->_all_ctrl_board[0].product_saddr = 0;
        _globalDeviceManager->_all_ctrl_board[0].product_number = -1;
        _globalDeviceManager->_all_ctrl_board[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));
            _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
            if (_globalTACManager->global_over_manager == NULL)
            {
                log_e("_globalTACManager->global_over_manager malloc error.\n");
                return -1;
            }
            memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
            ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                 _globalDeviceManager->_globalDevInfo.product.id, 0,TreeACindex + 1,
                                                 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);

    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!");
    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;
    thread_start(THREAD_ID_POWER, _globalDeviceManager);
    thread_start(THREAD_ID_SENSOR, _globalDeviceManager);
    thread_start(THREAD_ID_SHMW, _globalDeviceManager);

    thread_start(THREAD_ID_BREAKER_SCANNER,_globalDeviceManager);
    thread_start(THREAD_ID_BREAKER, _globalDeviceManager);

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

    ret = dev_get_ntp_info(_globalDeviceManager->db,  &_globalNTPManager);
    if (ret == -1)
    {
        log_e("get ntp info from database failed");
    }
    else if (ret == -2)
    {
        _globalNTPManager.mode = 1;
        strcpy(_globalNTPManager.ntpaddress, "119.28.183.184");
        strcpy(_globalNTPManager.ntpName, "百度NTP");
        _globalNTPManager.port = 123;
        _globalNTPManager.product_id = _globalDeviceManager->_globalDevInfo.product.id;
        time_t t = time(NULL);
        struct tm* ptm = localtime(&t);
        sprintf(_globalNTPManager.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);
        _globalNTPManager.tzone = 8;//ptm_gm->tm_hour - ptm->tm_hour;
        _globalNTPManager.weekday = (ptm->tm_wday == 0) ? 7 : ptm->tm_wday;
        if (dev_insert_ntp_info(_globalDeviceManager->db,  &_globalNTPManager))
        {
            log_e("insert npt info failed");
        }
    }
    else
    {
        log_d("get ntp info from database succeeded");
    }

    thread_start(THREAD_ID_NTP, NULL);
    dev_Alarm_Run_message(_globalDeviceManager, language_alarm_Init_Success[0], "NTP");

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

    dev_Alarm_Run_message(_globalDeviceManager, language_alarm_Init_Success[0], "SNMP");

    cascade_init();
    netswitch_init();
    smtp_init();
#endif

    mqtt_init();

    websocket_init();
    appweb_init();

    //通知smartUPG，app已经运行起来
    upg_init();
    
    return 0;
}