SmartPDCode/ip/src/app.c

#include "app.h"
#include "common.h"
#include "switch_ctrl.h"
#include "appweb_handle.h"
#include "modbus_handle.h"
#include "sqlite_handle.h"
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include "elog.h"
#include "sensor_handle.h"
#include "websocket_handle.h"
#include "paras.h"
#include "thread.h"
#include "cascade.h"
#include "upg.h"
#include "sys.h"
#include "cfg.h"
#include "lock.h"
#include "smtp.h"
#include "netswitch.h"
#include "breaker_detection.h"
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "hlw8110_handle.h"
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>

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


void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType);


/// @brief 电源数据采集线程
/// @param arg 
/// @return 
static uint8_t channel[32] = {0};

void* power_thread(void* arg)
{
    int ret = 0 ;
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalPowerInfo _globalPowerInfo ;
    GlobalPowerInfo _globalTotalPowerInfo ; //总电源信息
    GlobalTreeACManager* pTreeAPowerInfo;    //三相子电源信息
    GlobalTreeACManager* _pTreeACPowerMangerTemp = NULL ;                
    PowerWarningInfo _globalPowerWarningInfo ;
    PowerWarningInfo _globalTACWarningInfo;
    float Vavg[3]={0.0,0.0,0.0};
    int VavgTimes[3]={0,0,0};
    struct tm* t ;
    struct timeval tv;
    struct timezone tz ;
    int nSaveIndex =0;
    int sensor_nSaveIndex = 0;
    char strPower[] = "Table_PowerInfo";
    char strTacPower[] = "Table_PhasePowerInfo";
    char strTable[] = "Table_SensorInfo";
    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); // 查询日志最大点

    dev_search_last_Index(_globalDeviceManager->db, &sensor_nSaveIndex,strTable);

    
    InitHashTable(_globalDeviceManager);
    unsigned int samp_time = _globalDeviceManager->_globalDevInfo.product_samp_time;
    unsigned int usleepTime = samp_time*1000;
    unsigned int sSaveTime = _globalDeviceManager->_globalDevInfo.product_save_time;
    log_d("samp_time:%dms save_time:%dms\n", samp_time,sSaveTime);
    int nMaxIndex=2000000000;
    int nDeleteNumber=1000/sSaveTime*3600*24*30*10;
    bool isErrorBreak=false;
    _globalDeviceManager->_ReloadChm_flag=false;


    GlobalDeviceInfo *devInfo = &_globalDeviceManager->_globalDevInfo;



    int nsensor_DeleteNumber = 1000 / 120000 * 3600 * 24 * 30 * 10; 



    //channel[0] = 1;
    dev_get_all_profuct_chid_from_power_mgr(_globalDeviceManager->db,channel);

    //int cnt = 1;

    //采集线程
    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(_globalDeviceManager->_RS485LowConfData->opreation == 0)
        {
            sleep(1);
            continue;
        }
        if (sensor_nSaveIndex > nMaxIndex)
        {
            dev_change_last_Index(_globalDeviceManager->db, &sensor_nSaveIndex, nsensor_DeleteNumber, strTable);
        }
#if (1)

        memset(&_globalTotalPowerInfo, 0, sizeof(GlobalPowerInfo));
        memset(&_globalPowerWarningInfo, 0, sizeof(PowerWarningInfo));
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].current = hlw8110_read_IA(__globalDeviceManage._RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].voltage = hlw8110_read_UV(__globalDeviceManage._RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].power = hwl8110_read_PA(__globalDeviceManage._RS485LowConfData);
        if(_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].voltage < 1)
            _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].voltage = 0;
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].factor = hwl8110_read_PF(__globalDeviceManage._RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq = hwl8110_read_LineFreq(__globalDeviceManage._RS485LowConfData);
        if(_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq > 100)
            _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq  = 0;
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].consumption = hwl8110_read_EA(__globalDeviceManage._RS485LowConfData);
        int val = 0;
        hlw8110_read_Status(__globalDeviceManage._RS485LowConfData,&val);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].status = val;

        _globalDeviceManager->mmp->data[0].current = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].current * 1000;
        _globalDeviceManager->mmp->data[0].voltage = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].voltage * 1000;
        _globalDeviceManager->mmp->data[0].power = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].power * 1000;
        _globalDeviceManager->mmp->data[0].factor = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].factor * 1000;
        _globalDeviceManager->mmp->data[0].freq = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq * 1000;
        _globalDeviceManager->mmp->data[0].consumer = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].consumption * 1000;
        _globalDeviceManager->mmp->data[0].status = _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].status ;
        _globalDeviceManager->mmp->data[0].saddr = 0;
        _globalDeviceManager->mmp->data[0].temprature = _globalDeviceManager->g_modebus_read.temprature *100;
        _globalDeviceManager->mmp->data[0].humidity = _globalDeviceManager->g_modebus_read.humidity *100;

        dev_list_t dl;
        cascade_get_dlist(&dl);

        int flag = 0;


        //shanchu


        //add
        for(int i = 1;i < dl.cnt;i++)
        {
            flag = 0;
            list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list) 
            {
                int k = dl.slave[i].addr;
                int p = _globalPowerMangerTemp->product_saddr;
                if(_globalPowerMangerTemp->product_saddr == dl.slave[i].addr)
                {
                    //cunzai
                    flag = 1;
                    break;
                }
            }
            if(flag)
            {

            }else
            {
                //add 
                //cnt++;
                int k = 0;
                for( ;k < 32;k++)
                {
                    if(!channel[k])
                    {
                        break;
                    }
                }
                GlobalPowerManger *Temp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                if (Temp == NULL)
                {
                    log_e("_globalPowerManger malloc error.\n");
                    return NULL;
                }
                memset(Temp, 0, sizeof(GlobalPowerManger));
                Temp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                if (Temp->global_over_manager == NULL)
                {
                    log_e("_globalPowerManger->global_over_manager malloc error.\n");
                    return NULL;
                }
                memset(Temp->global_over_manager, 0, sizeof(GlobalOverManager));
                //add a temprature and humunite

                ret = dev_get_power_manage_info(_globalDeviceManager->db,dl.slave[i].addr,dl.slave[i].addr,1,Temp);
                if(ret < 0)
                {
                    Temp->product_id = dl.slave[i].addr;
                    Temp->product_saddr   = dl.slave[i].addr;
                    Temp->product_ch_id   = k;
                    channel[k] = 1;
                    sprintf(Temp->product_ch_name, "CH%d", k);
                    Temp->product_ch_addr = 1;
                     if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                          Temp->product_id,
                                                          Temp->product_ch_id,
                                                          Temp) != 0)
                     {
                         log_e("address %d chn %d data inserted error.\n", i, k);
                         free(Temp->global_over_manager);
                         free(Temp);
                         //return NULL;
                     }else
                     {
                        list_add_tail(&Temp->list, &_globalDeviceManager->_globalPowerManger.list);
                     }
                }else
                    list_add_tail(&Temp->list, &_globalDeviceManager->_globalPowerManger.list);

                
                GlobalSensorManger* sensor_temp = (GlobalSensorManger *)malloc(sizeof(GlobalSensorManger));
                if(!sensor_temp)
                {
                    return NULL;
                }
                ret = dev_get_sensor_info (_globalDeviceManager->db,dl.slave[i].addr,dl.slave[i].addr,sensor_temp);
                if(ret < 0)
                {
                    sensor_temp->over_manager = (GlobalSensorOverManage*)malloc(sizeof(GlobalSensorOverManage));
                    
                    if(sensor_temp->over_manager==NULL)
                        return NULL ;
                    memset(sensor_temp->over_manager,0,sizeof(GlobalSensorOverManage));
                    sensor_temp->product_id                     = dl.slave[i].addr;
                    sensor_temp->sensor_id                      = dl.slave[i].addr;
                    sensor_temp->sensor_type                    = 0;
                    sensor_temp->sensor_interface_type          = 0;    
                    strcpy(sensor_temp->sensor_name,"温湿度传感器");
                    strcpy(sensor_temp->sensor_port_name,"COM2"); 
                    if( sensor_temp->sensor_interface_type==1)
                    {
                        sensor_temp->sensor_baud =  9600;
                        sensor_temp->sensor_addr =  1;
                    } else {
                        sensor_temp->sensor_baud = 0 ;
                        sensor_temp->sensor_addr = 1;
                        
                    }
                    sensor_temp->sensor_status = 1;
                    if(dev_insert_sensor_genera_manage(_globalDeviceManager->db,sensor_temp))
                    {
                        log_e("sensor inserted failed error.\n");
                        free(sensor_temp->over_manager);
                        free(sensor_temp);
                    }else
                    {
                        list_add_tail(&sensor_temp->list, &_globalDeviceManager->_globalSensorManger.list);
                    }
                    
                }else
                    list_add_tail(&sensor_temp->list, &_globalDeviceManager->_globalSensorManger.list);
                
            }
        }
        GlobalPowerManger *tmp,*pos;
        list_for_each_entry_safe(tmp,pos,&_globalDeviceManager->_globalPowerManger.list,list)
        {
            if(tmp->product_saddr == 0 || tmp == NULL)
                continue;
            flag = 0;
            for(int i = 1 ; i < dl.cnt; i++)
            {
                if(tmp->product_saddr == dl.slave[i].addr)
                {
                    flag = 1;
                    break;
                }

            }
            if(!flag)
            {
                    //delete sensor
                pthread_mutex_lock(&__globalDeviceManage._sensor_update);
                GlobalSensorManger *sensor_temp,*sensor_pos;
                list_for_each_entry_safe(sensor_temp,sensor_pos,&_globalDeviceManager->_globalSensorManger.list,list)
                {
                    if(tmp->product_saddr == 0 || sensor_temp == NULL)
                        continue;
                    if(sensor_temp->product_id == tmp->product_saddr && sensor_temp->sensor_id == tmp->product_saddr)
                    {
                        free(sensor_temp->over_manager);
                        list_del(&sensor_temp->list);
                        free(sensor_temp);

                        break;
                    }
                }
                pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
                //delete power_thead
                free(tmp->global_over_manager);
                list_del(&tmp->list);
                //cnt --;
                free(tmp);
            }
        }

        cmd_data_t cmd;
        cmd.cmd = CASCADE_CMD_GET_INFO;
        cmd.obj = OBJ_OVERALL;

        for(int i = 1;i < dl.cnt;i++)
        {
            cascade_request_saddr(&cmd,dl.slave[i].addr,i);
            usleep(10000);
        }
        _globalDeviceManager->mmp->dev_chn = dl.cnt;
        cmd.cmd = CASCADE_CMD_QUERY_CH;
        cascade_free_dlist(&dl);

        for(int i = 1; i < _globalDeviceManager->mmp->dev_chn;i++)
        {
            int board = _globalDeviceManager->mmp->data[i].saddr;   
            _globalDeviceManager->_all_ctrl_board[board].product_type = 0;
            _globalDeviceManager->_all_ctrl_board[board].product_saddr = _globalDeviceManager->mmp->data[i].saddr;
            _globalDeviceManager->_all_ctrl_board[board].product_number = 1;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->consumption = _globalDeviceManager->mmp->data[i].consumer/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->current     = _globalDeviceManager->mmp->data[i].current/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->factor      = _globalDeviceManager->mmp->data[i].factor/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->freq        = _globalDeviceManager->mmp->data[i].freq/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->voltage     = _globalDeviceManager->mmp->data[i].voltage/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->power       = _globalDeviceManager->mmp->data[i].power/1000.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->status      = _globalDeviceManager->mmp->data[i].status;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->tempratue   = _globalDeviceManager->mmp->data[i].temprature / 100.0;
            _globalDeviceManager->_all_ctrl_board[board]._PowerInfo->humidity    = _globalDeviceManager->mmp->data[i].humidity /100.0;
        }

        struct tm *t;
        struct timeval tv;
        struct timezone tz;

        //warnning 
        //cascade sensor thread!!!!
        GlobalSensorManger *_sensor_temp = NULL;
        GlobalSensorInfo _globalSensorInfo;
        pthread_mutex_lock(&__globalDeviceManage._sensor_update);
        list_for_each_entry(_sensor_temp, &_globalDeviceManager->_globalSensorManger.list, list)
        {

            switch (_sensor_temp->sensor_type)
            {
                case SENSOR_TYPE_TEMPERATURE:
                {
                    gettimeofday(&tv, &tz);
                    t = localtime(&tv.tv_sec);
                    sprintf(_globalSensorInfo.samp_time, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
                            t->tm_year + 1900, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
                    _globalSensorInfo.product_id = _sensor_temp->product_id;
                    _globalSensorInfo.sensor_id = _sensor_temp->sensor_id;
                    if(devInfo->_gmodbus_info.product_modbus_type == 0 && _sensor_temp->product_id == 0)
                    {
                        float temperature = 0.0;
                        float humidity = 0.0;
                        ret = _g_sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                                _sensor_temp->sensor_addr,
                                                                &temperature,
                                                                &humidity);

                        if (ret == -1)
                        {
                            _sensor_temp->sensor_status = 1;
                        }else{
                            _sensor_temp->sensor_status = 0;
                        }
                        _globalSensorInfo.val1 = temperature;
                        _globalSensorInfo.val2 = humidity;
                        _globalDeviceManager->g_modebus_read.temprature=temperature *1000;
                         _globalDeviceManager->g_modebus_read.humidity=humidity *1000;
                    }else{
                        _globalSensorInfo.val1 = _globalDeviceManager->_all_ctrl_board[(int)_sensor_temp->sensor_id]._PowerInfo->tempratue;
                        _globalSensorInfo.val2 = _globalDeviceManager->_all_ctrl_board[(int)_sensor_temp->sensor_id]._PowerInfo->humidity;
                        _sensor_temp->sensor_status = 0;
                    }

                    _globalSensorInfo.product_log_time=_sensor_temp->Cur_sensor_info.product_log_time;
                    _sensor_temp->Cur_sensor_info=_globalSensorInfo;
                }
                break;
                default:
                break;
            }
            
            gettimeofday(&tv, NULL);
            time_t now;
            time(&now);
            t = localtime(&now);
            char buffer[80];
            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
            memset(_sensor_temp->Cur_sensor_info.samp_time, 0, sizeof(_sensor_temp->Cur_sensor_info.samp_time));
            strftime(_sensor_temp->Cur_sensor_info.samp_time, sizeof(_sensor_temp->Cur_sensor_info.samp_time), "%Y-%m-%d %H:%M:%S", t);
            sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
            strcat(_sensor_temp->Cur_sensor_info.samp_time, buffer);
            if (difftime(now, _sensor_temp->Cur_sensor_info.product_log_time) > (30000 / 1000))
            {
                _sensor_temp->Cur_sensor_info.product_log_time = now;
                // 插入数据库
                 ret = dev_insert_sensor_info(_globalDeviceManager->db, &_sensor_temp->Cur_sensor_info, &sensor_nSaveIndex);
                 if (ret != 0)
                 {
                     log_e("sensor_temp_write database error.");
                 }
            }
            if (_sensor_temp->sensor_status == 0)
            {
                sensor_alarm(_sensor_temp, SENSOR_VAL1_UPPER);
                sensor_alarm(_sensor_temp, SENSOR_VAL1_LOWER);
                sensor_alarm(_sensor_temp, SENSOR_VAL2_UPPER);
                sensor_alarm(_sensor_temp, SENSOR_VAL2_LOWER);
            }
            
        }
        pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
        



        bool SaveDBFlag=false; //数据库存储记录，只要有通道存，就存一次总通道数据  
        int _chn = 0;
        memset(Vavg,0.0,sizeof(Vavg));
        memset(VavgTimes,0,sizeof(VavgTimes));
        //数据刷新
        pthread_mutex_lock(&__globalDeviceManage._power_update);
        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list) 
        {
            memcpy(&_globalPowerInfo._power_info,&_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0],sizeof(PowerInfo));
                   
            _globalTotalPowerInfo.product_id = _globalDeviceManager->_globalDevInfo.product_id;
            _globalTotalPowerInfo.product_ch_id = 0 ; //总电源通道信息为0
            _globalTotalPowerInfo.product_status = 0 ;
            _globalTotalPowerInfo._power_info.voltage =  _globalTotalPowerInfo._power_info.voltage > _globalPowerInfo._power_info.voltage ? _globalTotalPowerInfo._power_info.voltage : _globalPowerInfo._power_info.voltage;
            _globalTotalPowerInfo._power_info.current += _globalPowerInfo._power_info.current ;
            _globalTotalPowerInfo._power_info.power += _globalPowerInfo._power_info.power ;
            _globalTotalPowerInfo._power_info.freq =  _globalTotalPowerInfo._power_info.freq > _globalPowerInfo._power_info.freq ? _globalTotalPowerInfo._power_info.freq : _globalPowerInfo._power_info.freq;
            _globalTotalPowerInfo._power_info.consumption += _globalPowerInfo._power_info.consumption ;
            _globalTotalPowerInfo._power_info.factor = _globalTotalPowerInfo._power_info.factor > _globalPowerInfo._power_info.factor ? _globalTotalPowerInfo._power_info.factor : _globalPowerInfo._power_info.factor;
            _globalTotalPowerInfo._power_info.status = _globalPowerInfo._power_info.status;
            //补全信息
            _globalPowerInfo.product_id = _globalPowerMangerTemp->product_id;
            _globalPowerInfo.product_ch_id = _globalPowerMangerTemp->product_ch_id ;
            _globalPowerInfo.product_status = _globalPowerInfo._power_info.status ;

                    //voltage
        if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable)
        {
            if(_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0].voltage > 
                                _globalPowerMangerTemp->global_over_manager->product_vol_upper_threshold)
            {
                 _globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0].w_voltage_up = 1;
            }
        }
        if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable)
        {
            if(_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0].voltage < 
                                _globalPowerMangerTemp->global_over_manager->product_vol_lower_threshold)
            {
                 _globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0].w_voltage_down = 1;
            }
        }
        //current
        if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable)
        {
            if(_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0].current >
                                _globalPowerMangerTemp->global_over_manager->product_cur_upper_threshold)
            {
                _globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0].w_current = 1;
            }
               
        }
        //power
        if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable)
        {
            if(_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0].power >
                                _globalPowerMangerTemp->global_over_manager->product_pwr_upper_threshold)
            {
                _globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0].w_power = 1;
            }
        }
        //constmer
        if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable)
        {
            if(_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerInfo[0].consumption >
                                _globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_threshold)
            {
                _globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0].w_consumption = 1;
            }
        }

            memcpy(&_globalPowerWarningInfo,
            &_globalDeviceManager->_all_ctrl_board[(int)_globalPowerMangerTemp->product_saddr]._PowerWarninginfo[0],
            sizeof(PowerWarningInfo));

            time_t now;
            time(&now);
            t = localtime(&now);
            char buffer[80];
            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
            memset(_globalPowerInfo.samp_time,0,sizeof(_globalPowerInfo.samp_time));
            strftime(_globalPowerInfo.samp_time, sizeof(_globalPowerInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
            sprintf(buffer,".%03ld",tv.tv_usec/1000);
            strcat(_globalPowerInfo.samp_time,buffer);
            if (difftime(now,_globalPowerMangerTemp->product_log_time)>(sSaveTime/1000))
            {
                _globalPowerMangerTemp->product_log_time=now;
                SaveDBFlag=true;
                        /* code */
                        //插入数据库
                if(dev_insert_power_info(_globalDeviceManager->db,&_globalPowerInfo,&nSaveIndex)!=0)
                {
                    log_d("ch%d insert data error.\n",_globalPowerMangerTemp->product_ch_id);
                }
            }
            
                        
            //判断阈值状态
            if (_globalPowerWarningInfo.w_voltage_up!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up)
            {
                _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_up=_globalPowerWarningInfo.w_voltage_up;
                /*高电压 */
                if (_globalPowerWarningInfo.w_voltage_up) 
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_UP);       
            }
            if (_globalPowerWarningInfo.w_voltage_down!=_globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down)
            {
                _globalPowerMangerTemp->_PowerWarninginfo.w_voltage_down=_globalPowerWarningInfo.w_voltage_down;
                /*低电压 */
               if(_globalPowerWarningInfo.w_voltage_down) 
                        dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_V_DOWN);
            }
            if (_globalPowerWarningInfo.w_current!=_globalPowerMangerTemp->_PowerWarninginfo.w_current)
            {
                _globalPowerMangerTemp->_PowerWarninginfo.w_current=_globalPowerWarningInfo.w_current;
                        /*高电流 */
                if(_globalPowerWarningInfo.w_current) 
                    dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_A_UP);
            }
            if (_globalPowerWarningInfo.w_power!=_globalPowerMangerTemp->_PowerWarninginfo.w_power)
            {
                _globalPowerMangerTemp->_PowerWarninginfo.w_power=_globalPowerWarningInfo.w_power;
                        /*高功率 */
                if(_globalPowerWarningInfo.w_power) 
                    dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_W_UP);
            }
            if (_globalPowerWarningInfo.w_consumption!=_globalPowerMangerTemp->_PowerWarninginfo.w_consumption)
            {
                _globalPowerMangerTemp->_PowerWarninginfo.w_consumption=_globalPowerWarningInfo.w_consumption;
                        /*高耗电 */
                if(_globalPowerWarningInfo.w_consumption)
                    dev_Alarm_send_message(_globalDeviceManager,_globalPowerMangerTemp,WARNING_P_UP);
            }


            //nanosleep(&reqSleep, NULL); 
            //usleep(usleepTime);
#endif

            //全局记录一份数据
            if (!isErrorBreak)
            {
                memcpy(&_globalPowerMangerTemp->_PowerInfo,&_globalPowerInfo._power_info,sizeof(PowerInfo)); 
                memcpy(&_globalPowerMangerTemp->_PowerWarninginfo,&_globalPowerWarningInfo,sizeof(PowerWarningInfo)); 
            }
            isErrorBreak=false;
            //判断是否存在定时需要触发
        }
        //插入总电源信息
        gettimeofday(&tv, &tz);
        t = localtime(&tv.tv_sec);
        sprintf(_globalTotalPowerInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03ld",
        t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,tv.tv_usec/1000);
        

        //更新总电源信息

        _globalDeviceManager->_globalPowerManger._PowerInfo  = _globalTotalPowerInfo._power_info;

        //插入数据库
        if (SaveDBFlag)
        {
            if (dev_insert_power_info(_globalDeviceManager->db, &_globalTotalPowerInfo, &nSaveIndex) != 0)
            {
                log_d("ch%d insert data error.\n", _globalTotalPowerInfo.product_ch_id);
            }
        }
        pthread_mutex_unlock(&__globalDeviceManage._power_update);
        sleep(2);

    }
    free_hash_table(_globalDeviceManager->alarmTab);
    log_e("Error!!!!!!!!!!!!!!Thread End");
    pthread_exit(NULL);
}


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

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

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

    return 0;
}

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

            sprintf(buff, "$开启$|$通道$|%d", _globalPowerMangerTemp->product_ch_id);
            dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, 2, buff);
            break;
        }
    }
}
void AlarmCtrlAll(int nCtrl)
{
        //总关
        int nSendAddr=0;
        char buff[256];
        log_d("AlarmCtrlAll:Ctrl=%d",nCtrl);
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue;
            nSendAddr=_globalPowerMangerTemp->product_saddr;
            log_i("Close All address Start");
            int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,nCtrl);
            if(rec<0)log_i("Close All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno));
        }      
        sprintf(buff,"$关闭$|$所有$|$通道$");
        dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,2,buff);
}
/**
 * @brief 传感器报警函数
 *
 * 根据给定的报警类型和全局传感器管理器，执行相应的传感器报警操作。
 *
 * @param _globalSensorMangerTemp 全局传感器管理器指针
 * @param nAlarmType 报警类型（如SENSOR_VAL1_UPPER、SENSOR_VAL1_LOWER等）
 */
void sensor_alarm(GlobalSensorManger *_globalSensorMangerTemp, int nAlarmType)
{
    bool *penable = NULL;   //使能
    bool *pSave = NULL;     //是否已报警
    float *pValthreshold = NULL;//阈值
    float *pValData = NULL;     //当前值
    char  *nCtrlType = NULL; //报警方式
    char  *nCtrlValue= NULL; //控制通道
    if (!_globalSensorMangerTemp|| !_globalSensorMangerTemp->over_manager)
    {
        return;
    }
    switch (nAlarmType)
    {
    case SENSOR_VAL1_UPPER:
        penable = &_globalSensorMangerTemp->over_manager->sensor_val1_upper_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager->sensor_val1_upper_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val1_upper;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val1;
        nCtrlType = &_globalSensorMangerTemp->over_manager->sensor_val1_upper_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager->sensor_val1_upper_threshold_ctrl_para;
        break;
    case SENSOR_VAL1_LOWER:
        penable = &_globalSensorMangerTemp->over_manager->sensor_val1_lower_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager->sensor_val1_lower_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val1_lower;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val1;
        nCtrlType = &_globalSensorMangerTemp->over_manager->sensor_val1_lower_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager->sensor_val1_lower_threshold_ctrl_para;
        break;
    case SENSOR_VAL2_UPPER:
        penable = &_globalSensorMangerTemp->over_manager->sensor_val2_upper_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager->sensor_val2_upper_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val2_upper;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val2;
        nCtrlType = &_globalSensorMangerTemp->over_manager->sensor_val2_upper_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager->sensor_val2_upper_threshold_ctrl_para;
        break;
    case SENSOR_VAL2_LOWER:
        penable = &_globalSensorMangerTemp->over_manager->sensor_val2_lower_enabled;
        pValthreshold = &_globalSensorMangerTemp->over_manager->sensor_val2_lower_threshold;
        pSave = &_globalSensorMangerTemp->warning_status.sensor_val2_lower;
        pValData = &_globalSensorMangerTemp->Cur_sensor_info.val2;
        nCtrlType = &_globalSensorMangerTemp->over_manager->sensor_val2_lower_threshold_ctrl;
        nCtrlValue = _globalSensorMangerTemp->over_manager->sensor_val2_lower_threshold_ctrl_para;
        break;

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




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

    pthread_mutex_init(&__globalDeviceManage._sensor_update,NULL);
    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);
        }
        pthread_mutex_lock(&__globalDeviceManage._sensor_update);
        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;
#ifdef CUST_ANDERSON
                ret = _g_sensor_get_temperature_value_ANDERSON((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &humidity);
#else
                ret = _g_sensor_get_temperature_value((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &humidity);
#endif
                if (ret == -1)
                {
                    _globalSensorMangerTemp->sensor_status = 1;
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                gettimeofday(&tv, &tz);
                t = localtime(&tv.tv_sec);
                sprintf(_globalSensorInfo.samp_time, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
                        t->tm_year + 1900, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
                _globalSensorInfo.product_id = __globalDeviceManage._globalDevInfo.product_id;
                _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id;
                _globalSensorInfo.val1 = temperature;
                _globalSensorInfo.val2 = humidity;

                _globalSensorInfo.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                _globalDeviceManager->g_modebus_read.temprature=temperature *1000;
                _globalDeviceManager->g_modebus_read.humidity=humidity *1000;
            }
            break;
            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;
            case SENSOR_TYPE_DoubleT://双头传感器
            {
                float temperature = 0.0;
                float temperature2 = 0.0;
                ret = _g_sensor_get_D_temperature_value_ANDERSON((void *)&_globalDeviceManager->sensor_modbus_manager,
                                                      _globalSensorMangerTemp->sensor_addr,
                                                      &temperature,
                                                      &temperature2);

                if (ret == -1)
                {
                    //log_w("Relay modbus Error:%s\n", modbus_strerror(errno));
                    _globalSensorMangerTemp->sensor_status = 1;
                }
                else
                {
                    _globalSensorMangerTemp->sensor_status = 0;
                }
                // log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                // printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                gettimeofday(&tv, &tz);
                t = localtime(&tv.tv_sec);
                sprintf(_globalSensorInfo.samp_time, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
                        t->tm_year + 1900, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
                _globalSensorInfo.product_id = __globalDeviceManage._globalDevInfo.product_id;
                _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id;
                _globalSensorInfo.val1 = temperature;
                _globalSensorInfo.val2 = temperature2;
                _globalSensorInfo.product_log_time=_globalSensorMangerTemp->Cur_sensor_info.product_log_time;;
                _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                _globalDeviceManager->g_modebus_read.temprature=temperature;
                _globalDeviceManager->g_modebus_read.temprature2=temperature2;
            }
            break;
            }
            // 通用功能
            //  写入数据库
            gettimeofday(&tv, NULL);
            time_t now;
            time(&now);
            t = localtime(&now);
            char buffer[80];
            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
            memset(_globalSensorMangerTemp->Cur_sensor_info.samp_time, 0, sizeof(_globalSensorMangerTemp->Cur_sensor_info.samp_time));
            strftime(_globalSensorMangerTemp->Cur_sensor_info.samp_time, sizeof(_globalSensorMangerTemp->Cur_sensor_info.samp_time), "%Y-%m-%d %H:%M:%S", t);
            sprintf(buffer, ".%03ld", tv.tv_usec / 1000);
            strcat(_globalSensorMangerTemp->Cur_sensor_info.samp_time, buffer);
            if (difftime(now, _globalSensorMangerTemp->Cur_sensor_info.product_log_time) > (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);
            }
        }
        pthread_mutex_unlock(&__globalDeviceManage._sensor_update);
        sleep(3);
    }
#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) // 已更新
                {
                   
                    GlobalPowerInfo _globalPowerInfo;
                    memset(&_globalPowerInfo._power_info, 0, sizeof(PowerInfo));
                    memcpy(&_globalPowerInfo._power_info,
                           &_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0],
                           sizeof(PowerInfo));
                   
                        //_globalDeviceManager->_globalPowerManger;
                    _globalDeviceManager->g_shm_Data->fV = _globalPowerInfo._power_info.voltage;
                    _globalDeviceManager->g_shm_Data->fA = _globalPowerInfo._power_info.current;
                    _globalDeviceManager->g_shm_Data->fW = _globalPowerInfo._power_info.power;
                    _globalDeviceManager->g_shm_Data->fF = _globalPowerInfo._power_info.factor;
                    _globalDeviceManager->g_shm_Data->fS = _globalPowerInfo._power_info.consumption;
                    _globalDeviceManager->g_shm_Data->nStatus = _globalPowerInfo._power_info.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;
                }
            }
            sleep(5);
        }
    }
    if (_globalDeviceManager->g_shm_Data)
    {
        munmap(_globalDeviceManager->g_shm_Data, sizeof(smartPDU_shm_data));
        close(fd);
    }
	
	pthread_exit(NULL);
}

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

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

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

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

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

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

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

    ntp_config(pntp);
#ifndef USE_NTPD
    thread_start(THREAD_ID_NTP, ntp_thread, NULL, 10 * MB, 0);
#endif

    return 0;
}


void* snmp_thread(void *arg)
{
    //int ret = 0 ;
    thread_handle_t *h = (thread_handle_t *)arg;
    GlobalDeviceManager *dm = (GlobalDeviceManager *)h->arg;

    /* we are a subagent */
    char path[PATH_MAX];
    /* we are a subagent */
    
    netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE, 1);
    
    /* initialize the agent library */
    sys_get_path(path, SNMP_MIB_NAME);
    init_agent(path);
    
    /* initialize your mib code here */
    init_pduMIB_form();
    init_pduMIB_scalar();
    
    /* pduMIB will be used to read pduMIB.conf files. */
    init_snmp(path);
    init_snmp_alarm();

    dev_get_snmp_info(dm->db, &_globalSNMPManager);
    dev_Alarm_Run_message(dm, language_alarm_Init_Success[0], "SNMP");


    int reconfig=0;
    while(h->quit==0)
    {
        if (reconfig) {  
        free_config();  
        read_configs();  
        reconfig = 0;  
        }  
        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);
}


static void get_mac(cascade_ip_mmap_t *mmp)
{
    struct ifreq ifreq;
    int sock;
    char *net = "eth0";

    if((sock = socket(AF_INET,SOCK_STREAM,0))<0)
    {
        perror("socket");
        return;
    }
    strcpy(ifreq.ifr_name,net);
    if(ioctl(sock,SIOCGIFHWADDR,&ifreq)<0)
    {
            perror("ioctl");
            return;
    }
    close(sock);
    mmp->mac[0]=ifreq.ifr_hwaddr.sa_data[0];
    mmp->mac[1]=ifreq.ifr_hwaddr.sa_data[1];
    mmp->mac[2]=ifreq.ifr_hwaddr.sa_data[2];
    mmp->mac[3]=ifreq.ifr_hwaddr.sa_data[3];
    mmp->mac[4]=ifreq.ifr_hwaddr.sa_data[4];
    mmp->mac[5]=ifreq.ifr_hwaddr.sa_data[5];
}

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


    //paras_load(&_globalDeviceManager->_globalDevInfo);

    //初始化用户登录列表
    INIT_LIST_HEAD(&_GlobalUserLoginInfo.list);

    //使用的通道
    _globalDeviceManager->useSlaveCount = 0 ;
    
    //链接数据库获取配置信息
    sys_get_path(path, DATABASE_NAME);
    log_i("database: %s\n", path);
    ret = sqlite_init(&_globalDeviceManager->db,&_globalDeviceManager->dbThreadlock, path);
    if(ret<0)
    {
        log_e("database %s open error.\n", path);
        return -1 ;
    }
    log_i("database %s open ok.\n", path);
    
    //查询设备总体参数
    if(dev_get_device_info(_globalDeviceManager->db,&_globalDeviceManager->_globalDevInfo)!=0)
    {
        log_e("get device info error.\n");
        return -1 ;
    }
    log_i("get device info ok.\n");

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

    _globalDeviceManager->_globalPowerManger.global_over_manager = (GlobalOverManager*)malloc(sizeof(GlobalOverManager));
    if(_globalDeviceManager->_globalPowerManger.global_over_manager==NULL)
    {
        log_e("_globalPowerManger->global_over_manager malloc error.\n");
        return -1 ;       
    } 
    memset(_globalDeviceManager->_globalPowerManger.global_over_manager, 0, sizeof(GlobalOverManager));
    //查询是否存在全部通道信息
    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_globalDevInfo.product_id,0,
                                    0, //1*8+j
                                    &_globalDeviceManager->_globalPowerManger);
    //未查询到信息 则插入
    if(ret==-1)
    {
        _globalDeviceManager->_globalPowerManger.product_id = _globalDeviceManager->_globalDevInfo.product_id;
        _globalDeviceManager->_globalPowerManger.product_saddr = 0 ;
        _globalDeviceManager->_globalPowerManger.product_ch_id = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_addr = 0;
        sprintf( _globalDeviceManager->_globalPowerManger.product_ch_name,"ALL_CH");//,_globalDeviceManager->_globalPowerManger.product_ch_id);
        _globalDeviceManager->_globalPowerManger.product_ch_type = type;
        _globalDeviceManager->_globalPowerManger.product_ch_status = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_NF_status = 0;
        _globalDeviceManager->_globalPowerManger.product_ch_start_delay = 1000;     
        _globalDeviceManager->_globalPowerManger.product_ch_stop_delay = 1000;
        _globalDeviceManager->_globalPowerManger.global_over_manager->product_cur_over_upper_threshold_ctrl =ALARM_CTRL_ALARM_ONLY;//默认超限只报警
        _globalDeviceManager->_globalPowerManger.global_over_manager->product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager->product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager->product_vol_over_lower_threshold_ctrl= ALARM_CTRL_ALARM_ONLY;
        _globalDeviceManager->_globalPowerManger.global_over_manager->product_vol_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY;

        if(dev_insert_power_manage_info(_globalDeviceManager->db,
                                    _globalDeviceManager->_globalDevInfo.product_id,
                                    0,
                                    &_globalDeviceManager->_globalPowerManger)!=0)
        {
            log_e("all chn data inserted error.\n");
            return 0;
        }
        else
        {
            log_i("all chn data inserted ok.\n");
        }        
    }
    _globalDeviceManager->mmp = (cascade_ip_mmap_t *)malloc(sizeof(cascade_ip_mmap_t));
    if(_globalDeviceManager->mmp == NULL)
    {
        log_e("mmp malloc error!!!!!\n");
        return 0;        
    }
    get_mac(_globalDeviceManager->mmp);

    _globalDeviceManager->_RS485LowConfData = hlw8110_init();
    _globalDeviceManager->useSlaveCount++;
    _globalDeviceManager->_all_ctrl_board[0].product_saddr = 1;
    _globalDeviceManager->_all_ctrl_board[0].product_number = 1;
    _globalDeviceManager->_all_ctrl_board[0].product_type = 0;

    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->_globalDevInfo.product_id,
                                        0,
                                        1, // 1*8+j
                                        _globalPowerMangerTemp);

    
    if(ret == -1)
    {
        _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product_id;
        _globalPowerMangerTemp->product_saddr = 0;
        _globalPowerMangerTemp->product_ch_id = 1;
        _globalPowerMangerTemp->product_ch_addr = 1;            
        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
        _globalPowerMangerTemp->product_ch_type = 9;
        _globalPowerMangerTemp->product_ch_status = 0;
        _globalPowerMangerTemp->product_ch_start_delay = 0;
        _globalPowerMangerTemp->product_ch_stop_delay = 0;
        if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                             _globalDeviceManager->_globalDevInfo.product_id,
                                             _globalPowerMangerTemp->product_ch_id,
                                             _globalPowerMangerTemp) != 0)
        {
            log_e("address %d chn %d data inserted error.\n", 0, 1);
            return 0;
        }

    }

    list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
    
    int nGroups=CHANNEL_DELAY_SEC;
    char strLog[200]={"MODBUS"};
    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],strLog);
    log_d("GCPDU init begin!");
    ResetChmData(0);

#if 1
    //初始化传感器列表
    INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);

    


    INIT_LIST_HEAD(&_globalDeviceManager->_globalSensorManger.list);
    // ret = dev_get_sensor_manage_info(_globalDeviceManager->db,
    //                                 _globalDeviceManager->_globalDevInfo.product_id,
    //                                 &_globalDeviceManager->_globalSensorManger);
                
    

    
    
    //创建modbus采集线程 继电器控制线程
#if(OS_HANDWARE==1)
    _globalDeviceManager->dev_samp_flag = true;
    sensor_or_cascade_init();
    cascade_init();
    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"sensor");


    thread_start(THREAD_ID_POWER, power_thread, _globalDeviceManager, 10*MB, 0);
    //thread_start(THREAD_ID_SENSOR, ip_cascade_thread, _globalDeviceManager, 5*MB, 0);
    thread_start(THREAD_ID_SHMW, shm_thread, _globalDeviceManager, 5*MB, 0);

    //thread_start(THREAD_ID_BREAKER_SCANNER,breaker_scanner_thread,_globalDeviceManager,1*MB,0);
    //thread_start(THREAD_ID_BREAKER, breaker_thread, _globalDeviceManager, 5*MB, 0);

    dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"Server Thread");
#endif
    //创建传感器采集控制线程


     ntp_init();
    dev_Alarm_Run_message(_globalDeviceManager, language_alarm_Init_Success[0], "NTP");

#ifndef USE_NETSWITCH
    thread_start(THREAD_ID_SNMP, snmp_thread, _globalDeviceManager, 10 * MB, 0);
#endif

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

    // 初始化web
    websocket_init();
    appweb_init();

    

    
    

    //netswitch_init();
    
    smtp_init();

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


int snmp_config(SNMPManager *m)
{
    char path[200];
    char *conf="/snmp/conf/snmpd.conf";
    char user[100],pass[200],cmd[400],trapinfo[200];
    sys_get_path(path, conf);

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

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

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

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

            sprintf(cmd, "sed -e \"$ a %s\" -e \"$ a %s\" -i %s", pass, user, path);
            system(cmd);
        }
    }

    system("killall snmpd");
    sleep(1);
    char *snmpdorder="/snmp/bin/snmpd";
    char snmpdpath[200];
    sys_get_path(snmpdpath, snmpdorder);
    sprintf(cmd, "%s -Cc %s -Lo", snmpdpath,path);
    system(cmd);
    //exit(0);
    //thread_restart(THREAD_ID_SNMP);

    return 0;
}