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 "thread.h"

#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
static int keep_running;
int get_path(char *path, char *name);
int sys_get_path(char *path, char *name);

RETSIGTYPE stop_server(int __attribute__((unused)) a)
{
    keep_running = 0;
}

/// @brief 电源数据采集线程
/// @param arg 
/// @return 
void* power_thread(void* arg)
{
    int ret = 0 ;
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalPowerInfo _globalPowerInfo ;
    GlobalPowerInfo _globalTotalPowerInfo ; //总电源信息
    GlobalTreeACManager pTreeAPowerInfo;    //三相子电源信息
    GlobalTreeACManager* _pTreeACPowerMangerTemp = NULL ;                
    PowerWarningInfo _globalPowerWarningInfo ;
    struct tm* t ;
    struct timeval tv;
    struct timezone tz ;
    int nSaveIndex =0;
    char strPower[] = "Table_PowerInfo";
    char strTacPower[] = "Table_PhasePowerInfo";
    int nSaveTacIndex = 0;
    thread_handle_t *h=(thread_handle_t*)arg;
    GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)h->arg;
    _PowerDSManage_t* _powerDsManageTemp = NULL ;
    dev_search_last_Index(_globalDeviceManager->db, &nSaveIndex, strPower);       // 查询日志最大点
    dev_search_last_Index(_globalDeviceManager->db, &nSaveTacIndex, strTacPower); // 查询日志最大点
    _globalDeviceManager->_global_alarmLanguage=create_hash_table(18);
    InitHashTable(_globalDeviceManager->_global_alarmLanguage);
    unsigned int samp_time = _globalDeviceManager->_global_device_info->product_samp_time;
    unsigned int usleepTime = samp_time*1000;
    unsigned int sSaveTime = _globalDeviceManager->_global_device_info->product_save_time;
    log_d("samp_time:%dms save_time:%dms\n", samp_time,sSaveTime);
    int nMaxIndex=2000000000;
    int nDeleteNumber=1000/sSaveTime*3600*24*30*10;
    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);
    }
    
    //采集线程
    while (h->quit==0)
    {
        if (_globalDeviceManager->_ReloadChm_flag)
        {
            sleep(1);
            continue;
        }
        if (nSaveIndex>nMaxIndex/2)
        {
            dev_change_last_Index(_globalDeviceManager->db, &nSaveIndex, nDeleteNumber, strPower);
        }
        if (nSaveTacIndex > nMaxIndex / 2)
        {

            dev_change_last_Index(_globalDeviceManager->db, &nSaveIndex, nDeleteNumber, strTacPower);
        }
#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);
                }
            }            
            usleep(usleepTime);
        }
        bool SaveDBFlag=false; //数据库存储记录，只要有通道存，就存一次总通道数据  
        int _chn = 0;
        //数据刷新
        pthread_mutex_lock(&__globalDeviceManage._power_update);
        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->_global_device_info->product_pwr_type == SmartPDU_AC)
            {
                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;
                }
            }else if(_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_DC)
            {
                if (_chn<64)
                {
                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_consumption = _globalPowerInfo._power_info.consumption *1000;
                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_valtage = _globalPowerInfo._power_info.voltage * 1000;
                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_current = _globalPowerInfo._power_info.current * 1000;
                _globalDeviceManager->dc_mmap->o_pw_info[_chn].o_power = _globalPowerInfo._power_info.power *1000;
                }
            }else{

            }
            _chn+=1;
            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->_global_device_info->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->_global_device_info->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,".%03d",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,&nSaveIndex)!=0)
                        {
                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }

                    }
                    
                    //判断阈值状态
                    if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up&&_globalPowerWarningInfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*高电压 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down&&_globalPowerWarningInfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                        /*低电压 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current&&_globalPowerWarningInfo.w_current)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
                    }
                    if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power&&_globalPowerWarningInfo.w_power)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
                    }
                    if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption&&_globalPowerWarningInfo.w_consumption)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
                    }
                    //动作

                }
                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->_global_device_info->product_id;
                    _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
                    _globalTotalPowerInfo.product_status = 0 ;
                    //补全信息
                    _globalPowerInfo.product_id = _globalDeviceManager->_global_device_info->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,".%03d",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,&nSaveIndex)!=0)
                        {
                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }
                    }
                    //插入数据库
                     if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up&&_globalPowerWarningInfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*未知故障 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,-1);
                    }
                    //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));
                    
                    list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
                    {
                        if (__globalDeviceManage._global_device_info->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(&_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;
                        if(_globalPowerInfo._power_info.status==0)
                        {
                            _globalPowerInfo._power_info.status=_pTreeACPowerMangerTemp->_PowerInfo.status;
                    }
                    else
                    {
                            _globalPowerInfo._power_info.status=0;
                        }
                        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, ".%03d", 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, &nSaveTacIndex,_globalPowerInfo.samp_time) != 0)
                            {
                                log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                            }
                        }
                    }
                    _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.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->_global_device_info->product_id;
                    _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
                    _globalTotalPowerInfo.product_status = 0 ;
                    //补全信息
                    _globalPowerInfo.product_id = _globalDeviceManager->_global_device_info->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,".%03d",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,&nSaveIndex)!=0)
                        {

                            log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                        }
                    }
                    //判断阈值状态
                    if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up&&_globalPowerWarningInfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                        /*高电压 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down&&_globalPowerWarningInfo.w_voltage_up)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                        /*低电压 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);
                    }
                    if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current&&_globalPowerWarningInfo.w_current)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
                    }
                    if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power&&_globalPowerWarningInfo.w_power)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
                    }
                    if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption&&_globalPowerWarningInfo.w_consumption)
                    {
                        _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
                    }
                    /*
                    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;
            }
            //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._global_device_info->product_pwr_type == SmartPDU_AC)
        {
            __globalDeviceManage.single_mmap->total_current = _globalTotalPowerInfo._power_info.current;
            __globalDeviceManage.single_mmap->total_power = _globalTotalPowerInfo._power_info.power;
            __globalDeviceManage.single_mmap->total_valtage = _globalTotalPowerInfo._power_info.voltage;
            __globalDeviceManage.single_mmap->dev_chn = __globalDeviceManage._global_device_info->product_pwr_type << 8 | _chn;

        }else if(__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_DC)
        {
            __globalDeviceManage.dc_mmap->i_valtage = _globalTotalPowerInfo._power_info.voltage;
            __globalDeviceManage.dc_mmap->i_power = _globalTotalPowerInfo._power_info.power;
            __globalDeviceManage.dc_mmap->i_current = _globalTotalPowerInfo._power_info.current;
            __globalDeviceManage.dc_mmap->i_consumption = _globalTotalPowerInfo._power_info.consumption;
            __globalDeviceManage.dc_mmap->dev_chn = __globalDeviceManage._global_device_info->product_pwr_type << 8 | _chn;
        }
        //输入数据再处理（三项）
        //memset(_pTreeACPowerMangerTemp,0,sizeof(GlobalTreeACManager));
        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._global_device_info->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.consumption += _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].consumption;
                    _pTreeACPowerMangerTemp->_PowerInfo.factor = _globalDeviceManager->_all_ctrl_board[i]._globalPowerInManger._PowerInfo[nTreeACType].factor;
                }
                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, ".%03d", 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, &nSaveTacIndex, _globalPowerInfo.samp_time) != 0)
                    {
                        log_d("ph_ch%d insert data error.\n", _pTreeACPowerMangerTemp->product_ch_id);
                    }
                }
            }
        }

        //插入总电源信息
        gettimeofday(&tv, &tz);
        t = localtime(&tv.tv_sec);
        sprintf(_globalTotalPowerInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03d",
        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, &nSaveIndex) != 0)
            {
                log_d("ch%d insert data error.\n", _globalTotalPowerInfo.product_ch_id);
            }
        }
        pthread_mutex_unlock(&__globalDeviceManage._power_update);
  
        //判断阈值状态

        //动作

        //1ms
            //sleep(1);
        ///usleep(500*1000);  
        //延时
        usleep(samp_time*1000);
    }
    free_hash_table(_globalDeviceManager->_global_alarmLanguage);
    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 传感器报警函数
 *
 * 根据给定的报警类型和全局传感器管理器，执行相应的传感器报警操作。
 *
 * @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;     //当前值
    if (!_globalSensorMangerTemp)
    {
        return;
    }
    switch (nAlarmType)
    {
    case SENSOR_VAL1_UPPER:
        penable = &_globalSensorMangerTemp->over_manager->sensor_val1_upper_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager->sensor_val1_upper_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val1_upper;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val1;
        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;
        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;
        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;
        break;

    default:
        break;
    }
    if (!(pValthreshold && penable && pValData && pSave))
    {
        return;
    }
    if (nAlarmType == SENSOR_VAL1_UPPER || nAlarmType == SENSOR_VAL2_UPPER)//上限
    {
        if (*penable == 1 && *pValthreshold < *pValData)
        {
            if (!*pSave)
            {
                *pSave = true;
                dev_sensor_Alarm_send_message(&__globalDeviceManage, _globalSensorMangerTemp, nAlarmType);
            }
        }
        else
        {
            *pSave = false;
        }
    }
    else    //下限
    {
        if (*penable == 1 && *pValthreshold > *pValData)
        {
            if (!*pSave)
            {
                *pSave = true;
                dev_sensor_Alarm_send_message(&__globalDeviceManage, _globalSensorMangerTemp, nAlarmType);
            }
        }
        else
        {
            *pSave = false;
        }
    }
}

/// @brief 传感器采集线程
/// @param arg 
/// @return 
void* sensor_thread(void* arg)
{
#if 1
   GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)&__globalDeviceManage;
    unsigned int samp_time = _globalDeviceManager->_global_device_info->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);
        }
        list_for_each_entry(_globalSensorMangerTemp, &_globalDeviceManager->_globalSensorManger.list, list)
        {
            switch (_globalSensorMangerTemp->sensor_type)
            {
            case SENSOR_TYPE_TEMPERATURE: // 温湿度
            {
                // printf("get \n");
                float temperature = 0.0;
                float humidity = 0.0;
                ret = _g_sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &humidity);
                if (ret == -1)
                {
                    _globalSensorMangerTemp->sensor_status = 1;
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                gettimeofday(&tv, &tz);
                t = localtime(&tv.tv_sec);
                sprintf(_globalSensorInfo.samp_time, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
                        t->tm_year + 1900, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
                _globalSensorInfo.product_id = __globalDeviceManage._global_device_info->product_id;
                _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id;
                _globalSensorInfo.val1 = temperature;
                _globalSensorInfo.val2 = humidity;
                _globalSensorInfo.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;;
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
            }
            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);
                    _globalSensorMangerTemp->Cur_sensor_info.val1=nStatus;
                }                
            }
            break;
            case SENSOR_TYPE_GAS: // 气体
            {

            }
            break;
            case SENSOR_TYPE_AIR_PRESS: // 气流
            {

            }
            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, ".%03d", tv.tv_usec / 1000);
            strcat(_globalSensorMangerTemp->Cur_sensor_info.samp_time, buffer);
            if (difftime(now, _globalSensorMangerTemp->Cur_sensor_info.product_log_time) > (30000 / 1000))
            {
                _globalSensorMangerTemp->Cur_sensor_info.product_log_time = now;
                // 插入数据库
                ret = dev_insert_sensor_info(_globalDeviceManager->db, &_globalSensorMangerTemp->Cur_sensor_info, &nSaveIndex);
                if (ret != 0)
                {
                    log_e("sensor_temp_write database error.");
                }
            }
            if (_globalSensorMangerTemp->sensor_status == 0)
            {
                sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL1_UPPER);
                sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL1_LOWER);
                sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL2_UPPER);
                sensor_alarm(_globalSensorMangerTemp, SENSOR_VAL2_LOWER);
            }
        }

        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 / 1000.0;
                        _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity / 1000.0;
                    }
                    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 / 1000.0;
                        _globalDeviceManager->g_shm_Data->fH = _globalDeviceManager->g_modebus_read.humidity / 1000.0;
                    }
                }
                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)
        {
            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);
}



#include <errno.h>
#include <sys/ipc.h> 
#include <sys/msg.h>
#include "upgrade.h"
static key_t upgkey=0;
int upg_send(int evt)
{
    int r,msgid;
    upgrade_msg_t msg={.type=1, .evt=evt};

    msgid = msgget(upgkey, 0666| IPC_CREAT);
    log_e("+++++++++++ key: %d, msgid: %d\n", upgkey, msgid);
    
    r = msgsnd(msgid, &msg, sizeof(msg), IPC_NOWAIT);
    if(r<0) {
        log_e("+++++++++++ msgsnd failed, %d, errno: %d\n", r, errno);
    }
    
    return r;
}
static int upg_init(void)
{
    int r,msgid;
    
    upgkey = ftok(UPG_KEY_PATH, UPG_KEY_SN);
    if(upgkey<0) {
        log_e("ftok %s failed, errno: %d\n", UPG_KEY_PATH, errno);
        return -1;
    }
    upg_send(UPGRADE_EVT_APP_RUNNING);
    
    return 0;
}



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

    //设备管理内存分配
    _globalDeviceManager->_global_device_info = (GlobalDeviceInfo*)malloc(sizeof(GlobalDeviceInfo));
    if(_globalDeviceManager->_global_device_info==NULL)
    {
        log_e("_global_device_info malloc error.!");
        //printf("_global_device_info malloc error.\n");
        return -1 ;       
    }
    log_i("device memory init ok.\n");
    //使用的通道
    _globalDeviceManager->useSlaveCount = 0 ;
    
    _globalDeviceManager->dc_mmap = (cascade_dc_mmap_t*)malloc(sizeof(cascade_dc_mmap_t));
    if(_globalDeviceManager->dc_mmap==NULL)
    {
        log_e("_global_device_info malloc error.!");
        //printf("_global_device_info malloc error.\n");
        return -1 ;       
    }
    memset(_globalDeviceManager->dc_mmap, 0, sizeof(cascade_dc_mmap_t));

    _globalDeviceManager->single_mmap =(cascade_single_mmap_t*)malloc(sizeof(cascade_single_mmap_t));
    if(_globalDeviceManager->single_mmap==NULL)
    {
        log_e("_global_device_info malloc error.!");
        //printf("_global_device_info malloc error.\n");
        return -1 ;       
    }  
    memset(_globalDeviceManager->dc_mmap, 0, sizeof(cascade_single_mmap_t));

    //链接数据库获取配置信息
    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(dev_get_device_info(_globalDeviceManager->db,_globalDeviceManager->_global_device_info)!=0)
    {
        log_e("get device info error.\n");
        return -1 ;
    }
    log_i("get device info ok.\n");

    //打印参数
    //printf_global_device_info(_globalDeviceManager->_global_device_info);

    //电源管理表初始化
    memset(&_globalDeviceManager->_globalPowerManger,0,sizeof(GlobalPowerManger));

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

    //查询是否存在全部通道信息
    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_global_device_info->product_id,0,
                                    0, //1*8+j
                                    &_globalDeviceManager->_globalPowerManger);
    //未查询到信息 则插入
    if(ret==-1)
    {
        _globalDeviceManager->_globalPowerManger.product_id = _globalDeviceManager->_global_device_info->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_start_delay = 1000;     
        _globalDeviceManager->_globalPowerManger.product_ch_stop_delay = 1000;       
        if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_global_device_info->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->_global_device_info->product_pwr_type==SmartPDU_Tree_AC_Tree||_globalDeviceManager->_global_device_info->product_pwr_type==SmartPDU_Tree_AC_One)
    {
        __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;
        INIT_LIST_HEAD(&_globalDeviceManager->_globalPowerManger.list_Tree_AC);
        // 填充三相表
        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->_global_device_info->product_id, 0,TreeACindex + 1,
                                                 TreeACindex, // 1*8+j
                                                 _globalTACManager);
            _globalTACManager->product_ch_addr = TreeACindex + 1;
            // 未查询到信息 则插入
            if (ret == -1)
            {
                _globalTACManager->product_id = _globalDeviceManager->_global_device_info->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->_global_device_info->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");

    INIT_LIST_HEAD(&_globalDeviceManager->_globalPowerManger.list);
    // 初始化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");
    //搜索子地址
    chn = 1 ;
    nTac_chn=3;

    int nGroups=8;

    log_d("GCPDU init begin!");
    memset(&_globalDeviceManager->_all_ctrl_board, 0, sizeof(_globalDeviceManager->_all_ctrl_board));
    for (size_t i = 1; i < MAX_CHN_COUNT; i++)
    {
        type = 0 ;
        int nMaxChn=0;
        ret = g_switch_get_type(&_globalDeviceManager->_globalRelaySampManger,
                          i,
                          &type,
                          &nMaxChn,
                          _globalDeviceManager->_global_device_info->product_pwr_type);
        log_d("ret:%d saddr:%d type:%d ch_num:%d.\n",ret,i,type,nMaxChn);
        //int i =1 ;
        //type = AC_SINGLE_S_TYPE ;
        //chn = i ;

        if(ret==0)
        {
            //有效地址记录
            _globalDeviceManager->useSlaveCount ++ ;
            _globalDeviceManager->_all_ctrl_board[i].product_saddr=i;
            _globalDeviceManager->_all_ctrl_board[i].product_number=nMaxChn;
            _globalDeviceManager->_all_ctrl_board[i].product_type=type;
            switch (type)
            {
                case AC_SINGLE_S_TYPE://AC单相小电流 8路继电器
                case AC_SINGLE_B_TYPE:
                {
                    log_i("Address=%d AC_SINGLE_S_TYPE!\n",i);
                    for (size_t j = 0; j < nMaxChn; j++)
                    {
                        GlobalPowerManger* _globalPowerMangerTemp = (GlobalPowerManger*)malloc(sizeof(GlobalPowerManger));
                        if(_globalPowerMangerTemp==NULL)
                        {
                            //log_e("_globalPowerManger malloc error.\n");
                            return -1 ;       
                        }  
                        memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                        _globalPowerMangerTemp->global_over_manager = (GlobalOverManager*)malloc(sizeof(GlobalOverManager));
                        if(_globalPowerMangerTemp->global_over_manager==NULL)
                        {
                            //log_e("_globalPowerManger->global_over_manager malloc error.\n");
                            return -1 ;       
                        } 
                        memset(_globalPowerMangerTemp->global_over_manager,0,sizeof(GlobalOverManager));
                        //查询是否由通道信息
                        ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,
                                                        i,
                                                        j+1, //1*8+j
                                                        _globalPowerMangerTemp);
                        //未查询到信息 则插入
                        if(ret==-1)
                        {
                            _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->product_id;
                            _globalPowerMangerTemp->product_saddr = i ;
                            _globalPowerMangerTemp->product_ch_id = chn;
                            _globalPowerMangerTemp->product_ch_addr = j+1;
                            sprintf(_globalPowerMangerTemp->product_ch_name,"CH%d",_globalPowerMangerTemp->product_ch_id);
                            _globalPowerMangerTemp->product_ch_type = type;
                            _globalPowerMangerTemp->product_ch_status = 0;
 
                            _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
                            _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
 

                            if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,
                                                        _globalPowerMangerTemp->product_ch_id,
                                                        _globalPowerMangerTemp)!=0)
                            {
                                log_e("address %d chn %d data inserted error.\n",i,chn);
                                return 0;
                            }
                            /*
                            else
                            {
                                log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                            }
                            */
                        }   
                        _globalPowerMangerTemp->product_saddr = i ;
                        //添加到队尾
                        list_add_tail(&_globalPowerMangerTemp->list,&_globalDeviceManager->_globalPowerManger.list);
                        chn+=1;
                    }
                }
                break;
                case AC_MULTI_S_TYPE://预留
                {

                }
                break;
                case AC_MULTI_B_TYPE://预留
                {

                }
                break;
                case DC_OUT_TYPE:   //DC输出继电器 1路
                {

                }
                break;
                case DC_IN_TYPE:    // DC采集
                {
                    log_i("Address=%d DC_IN_TYPE!\n",i);
                    for (size_t j = 0; j < nMaxChn; j++)//AC与DC长度一致
                    {
                        GlobalPowerManger* _globalPowerMangerTemp = (GlobalPowerManger*)malloc(sizeof(GlobalPowerManger));
                        if(_globalPowerMangerTemp==NULL)
                        {
                            //log_e("_globalPowerManger malloc error.\n");
                            return -1 ;       
                        }  
                        memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                        _globalPowerMangerTemp->global_over_manager = (GlobalOverManager*)malloc(sizeof(GlobalOverManager));
                        if(_globalPowerMangerTemp->global_over_manager==NULL)
                        {
                            //log_e("_globalPowerManger->global_over_manager malloc error.\n");
                            return -1 ;       
                        } 
                        memset(_globalPowerMangerTemp->global_over_manager,0,sizeof(GlobalOverManager));
                        //查询是否由通道信息
                        ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,i,
                                                        j+1, //1*8+j
                                                        _globalPowerMangerTemp);
                        //未查询到信息 则插入
                        if(ret==-1)
                        {
                            _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->product_id;
                            _globalPowerMangerTemp->product_saddr = i ;
                            _globalPowerMangerTemp->product_ch_id = chn;
                            _globalPowerMangerTemp->product_ch_addr = j+1;
                            sprintf(_globalPowerMangerTemp->product_ch_name,"CH%d",_globalPowerMangerTemp->product_ch_id);
                            _globalPowerMangerTemp->product_ch_type = type;
                            _globalPowerMangerTemp->product_ch_status = 0;
                            _globalPowerMangerTemp->product_ch_start_delay = 1000;
                            _globalPowerMangerTemp->product_ch_stop_delay = 1000;
                            if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,
                                                        _globalPowerMangerTemp->product_ch_id,
                                                        _globalPowerMangerTemp)!=0)
                            {
                                log_e("address %d chn %d data inserted error.\n",i,chn);
                                return 0;
                            }
                            /*
                            else
                            {
                                log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                            }
                            */
                        }
                        _globalPowerMangerTemp->product_saddr = i ;
                        //添加到队尾
                        list_add_tail(&_globalPowerMangerTemp->list,&_globalDeviceManager->_globalPowerManger.list);
                        chn+=1;
                    }

                }
                break;
                case DCPDU_TYPE:    // DCPDU
                {
                    log_i("DCPDU_TYPE!\n");
                    //unsigned int start_delay[8], stop_delay[8];
                    //g_switch_get_dcpdu_start_time_delay(&_globalDeviceManager->_globalRelaySampManger,i, start_delay);
                    //g_switch_get_dcpdu_stop_time_delay(&_globalDeviceManager->_globalRelaySampManger,i, stop_delay);
                    for (size_t j = 0; j < nMaxChn; j++)
                    {
                        GlobalPowerManger* _globalPowerMangerTemp = (GlobalPowerManger*)malloc(sizeof(GlobalPowerManger));
                        if(_globalPowerMangerTemp==NULL)
                        {
                            //log_e("_globalPowerManger malloc error.\n");
                            return -1 ;       
                        }  
                        memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                        _globalPowerMangerTemp->global_over_manager = (GlobalOverManager*)malloc(sizeof(GlobalOverManager));
                        if(_globalPowerMangerTemp->global_over_manager==NULL)
                        {
                            //log_e("_globalPowerManger->global_over_manager malloc error.\n");
                            return -1 ;       
                        } 
    
                        memset(_globalPowerMangerTemp->global_over_manager,0,sizeof(GlobalOverManager));
                        //查询是否由通道信息
                        ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,i,
                                                        j+1, //1*8+j
                                                        _globalPowerMangerTemp);
                        _globalPowerMangerTemp->product_ch_addr = j+1;
                        //未查询到信息 则插入
                        if(ret==-1)
                        {
                            _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->product_id;
                            _globalPowerMangerTemp->product_saddr = i ;
                            _globalPowerMangerTemp->product_ch_id = chn;
                            _globalPowerMangerTemp->product_ch_addr = j+1;
                            sprintf(_globalPowerMangerTemp->product_ch_name,"CH%d",_globalPowerMangerTemp->product_ch_id);
                            _globalPowerMangerTemp->product_ch_type = type;
                            _globalPowerMangerTemp->product_ch_status = 0;

                            _globalPowerMangerTemp->product_ch_start_delay =1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
                            _globalPowerMangerTemp->product_ch_stop_delay =1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
                        

                            if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_global_device_info->product_id,
                                                        _globalPowerMangerTemp->product_ch_id,
                                                        _globalPowerMangerTemp)!=0)
                            {
                                log_e("address %d chn %d data inserted error.\n",i,chn);
                                return 0;
                            }
                            /*
                            else
                            {
                                log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                            }
                            */
                        }
                        _globalPowerMangerTemp->product_saddr = i ;
                        _globalPowerMangerTemp->product_ch_type = type;
                        if (dev_update_power_manage_genera_info(__globalDeviceManage.db,_globalDeviceManager->_global_device_info->product_id,chn,_globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                        //添加到队尾
                        list_add_tail(&_globalPowerMangerTemp->list,&_globalDeviceManager->_globalPowerManger.list);
                        chn+=1;
                    }
                }
                break;
                case TREE_AC_TYPE:    // 三相供电
                {
                    log_i("TreeAC_TYPE!\n");
                    GlobalPowerManger *_globalPowerMangerTemp=NULL;                 
                    for (size_t j = 0; j < nMaxChn; j++)
                    {
                        if (_globalDeviceManager->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
                        {
                            log_i("TreeAC_TYPE_3-1!\n");
                            _globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                            if (_globalPowerMangerTemp == NULL)
                            {
                                log_e("_globalPowerManger malloc error.\n");
                                return -1;
                            }
                            memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                            INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                            _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                            if (_globalPowerMangerTemp->global_over_manager == NULL)
                            {
                                log_e("_globalPowerManger->global_over_manager malloc error.\n");
                                return -1;
                            }
                            memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                            // 查询是否由通道信息
                            ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                            _globalDeviceManager->_global_device_info->product_id, i,
                                                            j + 1, // 1*8+j
                                                            _globalPowerMangerTemp);
                            _globalPowerMangerTemp->product_ch_addr = j + 1;
                            // 未查询到信息 则插入
                            if (ret == -1)
                            {
                                _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->product_id;
                                _globalPowerMangerTemp->product_saddr = i;
                                _globalPowerMangerTemp->product_ch_id = chn;
                                _globalPowerMangerTemp->product_ch_addr = j + 1;
                                sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                                _globalPowerMangerTemp->product_ch_type = type;
                                _globalPowerMangerTemp->product_ch_status = 0;

                                _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
                                _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);

                                if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                                 _globalDeviceManager->_global_device_info->product_id,
                                                                 _globalPowerMangerTemp->product_ch_id,
                                                                 _globalPowerMangerTemp) != 0)
                                {
                                    log_e("address %d chn %d data inserted error.\n", i, chn);
                                    return 0;
                                }
                            }
                            _globalPowerMangerTemp->product_saddr = i;
                            _globalPowerMangerTemp->product_ch_type = type;
                            if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalDeviceManager->_global_device_info->product_id, chn, _globalPowerMangerTemp) != 0)
                            {
                                log_e("update pwr general data err.");
                            }
                            // 添加到队尾
                            list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                            chn += 1;
                            // 初始化三相子通道三进1出
                            GlobalTreeACManager *_globalTACManager = NULL;
                            for (size_t indexT = 0; indexT < 3; indexT++)
                            {
                                _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                                memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
                                if (_globalTACManager == NULL)
                                {
                                    log_e("_globalTACManager malloc error.\n");
                                    return -1;
                                }
                                _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                                memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
                                if (_globalTACManager->global_over_manager == NULL)
                                {
                                    log_e("_globalTACManager->global_over_manager malloc error.\n");
                                    return -1;
                                }
                                ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                     _globalDeviceManager->_global_device_info->product_id, i,
                                                                     j + 1, // 1*8+j
                                                                     nTac_chn,
                                                                     _globalTACManager);
                                _globalTACManager->product_ch_addr = j + 1;
                                // 未查询到信息 则插入
                                if (ret == -1)
                                {
                                    _globalTACManager->product_id = _globalDeviceManager->_global_device_info->product_id;
                                    _globalTACManager->product_saddr = i;
                                    _globalTACManager->product_ch_id = _globalPowerMangerTemp->product_ch_id;
                                    _globalTACManager->product_ch_addr = j + 1;
                                    _globalTACManager->product_ph_id = nTac_chn;
                                    _globalTACManager->product_ph_type = indexT;
                                    _globalTACManager->product_ph_outputType = 2; // 1三相2单相
                                    if (indexT == (j + 3) % 3)
                                    {
                                        _globalTACManager->product_ph_outputStatus = 1; // 1输出2不输出
                                    }
                                    else
                                    {
                                        _globalTACManager->product_ph_outputStatus = 2; // 1输出2不输出
                                    }

                                    if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                          _globalDeviceManager->_global_device_info->product_id,
                                                                          _globalTACManager->product_ch_id,
                                                                          _globalTACManager) != 0)
                                    {
                                        log_e("address %d ph_chn %d data inserted error.\n", i, nTac_chn);
                                        return 0;
                                    }
                                }
                                // 绑定到三项通道
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ph_type = indexT;
                                if (_globalPowerMangerTemp)
                                {
                                    list_add_tail(&_globalTACManager->list_Tree_AC, &_globalPowerMangerTemp->list_Tree_AC);
                                }
                                nTac_chn += 1;
                            }
                        }
                        else
                        {
                            log_i("TreeAC_TYPE_3-3!\n");
                            if ((j + 3) % 3 == 0) // 线路段初始化
                            {
                                _globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                                if (_globalPowerMangerTemp == NULL)
                                {
                                    log_e("_globalPowerManger malloc error.\n");
                                    return -1;
                                }
                                memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                                INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                                _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                                if (_globalPowerMangerTemp->global_over_manager == NULL)
                                {
                                    log_e("_globalPowerManger->global_over_manager malloc error.\n");
                                    return -1;
                                }
                                memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                                // 查询是否由通道信息
                                ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                                _globalDeviceManager->_global_device_info->product_id, i,
                                                                j / 3 + 1, // 1*8+j
                                                                _globalPowerMangerTemp);
                                _globalPowerMangerTemp->product_ch_addr = j / 3 + 1;
                                // 未查询到信息 则插入
                                if (ret == -1)
                                {
                                    _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->product_id;
                                    _globalPowerMangerTemp->product_saddr = i;
                                    _globalPowerMangerTemp->product_ch_id = chn;
                                    _globalPowerMangerTemp->product_ch_addr = j / 3 + 1;
                                    sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                                    _globalPowerMangerTemp->product_ch_type = type;
                                    _globalPowerMangerTemp->product_ch_status = 0;

                                    _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);
                                    _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn%nGroups!=0?chn%nGroups:nGroups);

                                    if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                                     _globalDeviceManager->_global_device_info->product_id,
                                                                     _globalPowerMangerTemp->product_ch_id,
                                                                     _globalPowerMangerTemp) != 0)
                                    {
                                        log_e("address %d chn %d data inserted error.\n", i, chn);
                                        return 0;
                                    }
                                }
                                _globalPowerMangerTemp->product_saddr = i;
                                _globalPowerMangerTemp->product_ch_type = type;
                                if (dev_update_power_manage_genera_info(__globalDeviceManage.db, _globalDeviceManager->_global_device_info->product_id, chn, _globalPowerMangerTemp) != 0)
                                {
                                    log_e("update pwr general data err.");
                                }
                                // 添加到队尾
                                list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                                chn += 1;
                            }
                            // 初始化三相子通道三进三出
                            GlobalTreeACManager *_globalTACManager = NULL;
                            _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                            memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
                            if (_globalTACManager == NULL)
                            {
                                log_e("_globalTACManager malloc error.\n");
                                return -1;
                            }
                            _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                            memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
                            if (_globalTACManager->global_over_manager == NULL)
                            {
                                log_e("_globalTACManager->global_over_manager malloc error.\n");
                                return -1;
                            }
                            ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                 _globalDeviceManager->_global_device_info->product_id, i,
                                                                 j + 1, // 1*8+j
                                                                 nTac_chn,
                                                                 _globalTACManager);
                            _globalTACManager->product_ch_addr = j + 1;
                            // 未查询到信息 则插入
                            if (ret == -1)
                            {
                                _globalTACManager->product_id = _globalDeviceManager->_global_device_info->product_id;
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ch_id = _globalPowerMangerTemp->product_ch_id;
                                _globalTACManager->product_ch_addr = j + 1;
                                _globalTACManager->product_ph_id = nTac_chn;
                                _globalTACManager->product_ph_type = (j + 3) % 3;
                                _globalTACManager->product_ph_outputType = 1;   // 1三相2单相
                                _globalTACManager->product_ph_outputStatus = 1; // 1输出
                                if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                      _globalDeviceManager->_global_device_info->product_id,
                                                                      _globalTACManager->product_ch_id,
                                                                      _globalTACManager) != 0)
                                {
                                    log_e("address %d ph_chn %d data inserted error.\n", i, nTac_chn);
                                    return 0;
                                }
                            }
                            // 绑定到三项通道
                            _globalTACManager->product_saddr = i;
                            _globalTACManager->product_ph_type = (j + 3) % 3;
                            if (_globalPowerMangerTemp)
                            {
                                list_add_tail(&_globalTACManager->list_Tree_AC, &_globalPowerMangerTemp->list_Tree_AC);
                            }
                            nTac_chn += 1;
                        }
                    }
                }
            }
        }
    }
    //获取数据库中的定时数据
    ret=dev_get_power_ds(_globalDeviceManager->db,&_globalDeviceManager->_globalPowerManger,NULL);

    //初始化传感器列表
    INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);
    //获取传感器管理信息 
    /////////////////////////////////////////
    ///todo:此信息需要和数据库更新以后在关联
    ret = dev_get_sensor_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_global_device_info->product_id,
                                    &_globalDeviceManager->_globalSensorManger);
    if(ret!=0)
    {
        log_e("not find sensor info.");
    }
    else
        log_d("get sensor info ok.");

    //查询数据库获取传感器信息 

    //保存配置
    paras_save();    

    //创建modbus采集线程 继电器控制线程
    #if(OS_HANDWARE==1)
    _globalDeviceManager->dev_samp_flag = true;
    thread_start(THREAD_ID_POWER, power_thread, _globalDeviceManager, 20*MB, 0);
    thread_start(THREAD_ID_SENSOR, sensor_thread, _globalDeviceManager, 10*MB, 0);
    thread_start(THREAD_ID_SHMW, shm_thread, _globalDeviceManager, 10*MB, 0);
   #endif
    //创建传感器采集控制线程

    _globalNTPManager.ntpaddress = malloc(128);
    _globalNTPManager.ntpName = malloc(128);
    _globalNTPManager.time = malloc(22);
    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->_global_device_info->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, ntp_thread, NULL, 10*MB, 0);
    thread_start(THREAD_ID_SNMP, snmp_thread, _globalDeviceManager, 10*MB, 0);
    
    //初始化webapp
    websocket_init();
    appweb_init();

    cascade_init();
    //通知upgd，app已经运行起来
    //upg_init();
    
    while(1)
    {
        sleep(1);
    }
    return 0;
}