SmartPDCode/485/src/app.c

#include "app.h"
#include "common.h"
#include "switch_ctrl.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 "modbus.h"

#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "cascade.h"
#include "errno.h"
#include "hlw8110_handle.h"

int get_path(char *path, char *name);
int sys_get_path(char *path, char *name);


/// @brief 电源数据采集线程
/// @param arg 
/// @return 


#if 1
void * _global_power_samp_func(void* arg)
{
    GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)arg;
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    GlobalPowerInfo _globalPowerInfo ;
    GlobalPowerInfo _globalTotalPowerInfo ; //总电源信息
    PowerWarningInfo _globalPowerWarningInfo ;
    //采集线程
    log_d("Start ch Thread");
    float consumer = _globalDeviceManager->_global_device_info->consumer;
    while (_globalDeviceManager->dev_samp_flag)
    {
        // if (_globalDeviceManager->_ReloadChm_flag)
        // {
        //     sleep(1);
        //     continue;
        // }
        // if (nSaveIndex>nMaxIndex)
        // {
        //     dev_change_last_Index(_globalDeviceManager->db,&nSaveIndex,nDeleteNumber,strPower);
        // }        
#if(1)
        memset(&_globalTotalPowerInfo,0,sizeof(GlobalPowerInfo));
        memset(&_globalPowerWarningInfo,0,sizeof(PowerWarningInfo));
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].current = hlw8110_read_IA(_globalDeviceManager->_RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].voltage = hlw8110_read_UV(_globalDeviceManager->_RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].power =   hwl8110_read_PA(_globalDeviceManager->_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(_globalDeviceManager->_RS485LowConfData);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq =   hwl8110_read_LineFreq(_globalDeviceManager->_RS485LowConfData);
        if(_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq > 100)
            _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].freq  = 0;
        

        _globalDeviceManager->_global_device_info->consumer += hwl8110_read_EA(_globalDeviceManager->_RS485LowConfData);

        //printf("consumer =  %0.4f\n",_globalDeviceManager->_global_device_info->consumer);

        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].consumption =   _globalDeviceManager->_global_device_info->consumer;
        _globalDeviceManager->for85_data.consumer = (_globalDeviceManager->_global_device_info->consumer * 1000);
        int val = 0;
        hlw8110_read_Status(_globalDeviceManager->_RS485LowConfData,&val);
        _globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0].status = val;
        _globalDeviceManager->for85_data.angle = (hlw8110_read_Angle(_globalDeviceManager->_RS485LowConfData)*1000);

        
        //log_d("ReadOnceEnd,StartSet");
        list_for_each_entry(_globalPowerMangerTemp, &_globalDeviceManager->_globalPowerManger.list, list)
        {
            #if(1)
            //获取通道类型
            memcpy(&_globalPowerInfo._power_info,&_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0],sizeof(PowerInfo));

            _globalPowerMangerTemp->_PowerInfo.voltage = _globalPowerInfo._power_info.voltage;
            _globalPowerMangerTemp->_PowerInfo.current = _globalPowerInfo._power_info.current;
            _globalPowerMangerTemp->_PowerInfo.power = _globalPowerInfo._power_info.power;
            _globalPowerMangerTemp->_PowerInfo.freq = _globalPowerInfo._power_info.freq;
            _globalPowerMangerTemp->_PowerInfo.consumption = _globalPowerInfo._power_info.consumption;
            _globalPowerMangerTemp->_PowerInfo.factor = _globalPowerInfo._power_info.factor;

            switch (_globalPowerMangerTemp->product_ch_type)
            {            
                case RS485_Type:
                {
                    _globalPowerMangerTemp->_PowerInfo.voltage = _globalPowerInfo._power_info.voltage;
                    _globalPowerMangerTemp->_PowerInfo.current = _globalPowerInfo._power_info.current;
                    _globalPowerMangerTemp->_PowerInfo.power = _globalPowerInfo._power_info.power;
                    _globalPowerMangerTemp->_PowerInfo.freq = _globalPowerInfo._power_info.freq;
                    _globalPowerMangerTemp->_PowerInfo.consumption = _globalPowerInfo._power_info.consumption;
                    _globalPowerMangerTemp->_PowerInfo.factor = _globalPowerInfo._power_info.factor;

                    _globalDeviceManager->_globalPowerManger._PowerInfo.voltage = _globalPowerInfo._power_info.voltage ;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.current = _globalPowerInfo._power_info.current ;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.power = _globalPowerInfo._power_info.power ;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.freq = _globalPowerInfo._power_info.freq;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.consumption = _globalPowerInfo._power_info.consumption ;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.factor = _globalPowerInfo._power_info.factor ;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.status = _globalPowerInfo._power_info.status;
                    _globalDeviceManager->_globalPowerManger._PowerInfo.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 ;
                    _globalTotalPowerInfo._power_info.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=1;
                    _globalPowerInfo.product_ch_id=1;

                }
                break;
            }     

            #endif
            //全局记录一份数据
            // if (!isErrorBreak)
            {
                memcpy(&_globalPowerMangerTemp->_PowerInfo,&_globalPowerInfo._power_info,sizeof(PowerInfo)); 
                memcpy(&_globalPowerMangerTemp->_PowerWarninginfo,&_globalPowerWarningInfo,sizeof(PowerWarningInfo)); 
            }
           // isErrorBreak=false;

        }
       // log_d("all_Ch_Data_set");
        if (_globalDeviceManager->_global_device_info->product_type==2)
        {
            memcpy(&_globalPowerInfo._power_info,
                   &_globalDeviceManager->_all_ctrl_board[0]._PowerInfo[0],
                   sizeof(PowerInfo));
            _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;
            _globalTotalPowerInfo._power_info.status = _globalPowerInfo._power_info.status;

            // 作为从机将数据要放入mmpae
        }
        //log_d("all_Ch_Data_cpy_to_modbusMapping");
        if(_globalDeviceManager->_global_device_info->product_type==2 &&
            _globalDeviceManager->_global_device_info->product_pwr_type == 2)
        {
                _globalDeviceManager->g_modebus_read.voltage = _globalTotalPowerInfo._power_info.voltage*1000;
                _globalDeviceManager->g_modebus_read.current = _globalTotalPowerInfo._power_info.current*1000;
                _globalDeviceManager->g_modebus_read.power = _globalTotalPowerInfo._power_info.power*1000;
                _globalDeviceManager->g_modebus_read.freq = _globalTotalPowerInfo._power_info.freq*1000;
                _globalDeviceManager->g_modebus_read.consumption_cur = _globalTotalPowerInfo._power_info.consumption*1000;
                _globalDeviceManager->g_modebus_read.factor = _globalTotalPowerInfo._power_info.factor*1000;
                _globalDeviceManager->g_modebus_read.power_supplay_status = _globalTotalPowerInfo._power_info.status;
                _globalDeviceManager->g_modebus_read.warning = val;

                _globalDeviceManager->for85_data.voltage = _globalTotalPowerInfo._power_info.voltage*1000;
                _globalDeviceManager->for85_data.current = _globalTotalPowerInfo._power_info.current*1000;
                _globalDeviceManager->for85_data.power = _globalTotalPowerInfo._power_info.power*1000;
                _globalDeviceManager->for85_data.freq = _globalTotalPowerInfo._power_info.freq*1000;
                _globalDeviceManager->for85_data.consumer = _globalTotalPowerInfo._power_info.consumption*1000;
                _globalDeviceManager->for85_data.factor = _globalTotalPowerInfo._power_info.factor*1000;
                _globalDeviceManager->for85_data.breaker_status = _globalTotalPowerInfo._power_info.status;
        }

        dev_update_485_consumer(_globalDeviceManager->db,_globalDeviceManager->_global_device_info->consumer,_globalDeviceManager->_global_device_info);

#endif
    sleep(3);
    }
    log_e("Error!!!!!!!!!!!!!!Thread End");
    pthread_exit(NULL);
}
#endif


/// @brief 传感器硬件接口初始化
/// @param _globalDeviceManager 
/// @return 

#if 1
int dev_sensor_init(GlobalDeviceManager* _globalDeviceManager)
{
    int ret = 0 ;

    //初始化modbus,搜寻子设备

    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");


    if(ret!=0)
    {
        printf("sensor modbus init error.\n");
    }

    return 0 ;
}

#endif

/// @brief 传感器采集线程
/// @param arg 
/// @return 
#if 1
void* _global_sensor_samp_func(void* arg)
{

    GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)arg;
    //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";
    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");
    //采集线程
    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 0: //温湿度
                {   
                   // printf("get \n");
                    float temperature =0.0;
                    float humidity =0.0;
                    ret = _g_sensor_get_temperature_value((void*)&_globalDeviceManager->sensor_modbus_manager,
                                            _globalSensorMangerTemp->sensor_addr,
                                            &temperature,
                                            &humidity
                    );
                    if(ret==-1)
                    {
                        _globalSensorMangerTemp->sensor_status = 1 ;
                    }else
                    {
                        _globalSensorMangerTemp->sensor_status = 0;
                    }
                    //log_d("sensor val:%0.2f %0.2f\n",temperature,humidity);
                    //printf("get temperature=%f   humidity=%f\n",temperature,humidity);
                    gettimeofday(&tv, &tz);
                    t = localtime(&tv.tv_sec);
                    sprintf(_globalSensorInfo.samp_time,"%04d-%02d-%02d %02d:%02d:%02d.%03ld",
                    t->tm_year+1900,t->tm_mon,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,tv.tv_usec/1000);
                    _globalSensorInfo.product_id = __globalDeviceManage._global_device_info->product_id;
                    _globalSensorInfo.sensor_id = _globalSensorMangerTemp->sensor_id ;
                    _globalSensorInfo.val1 = temperature;
                    _globalSensorInfo.val2 = humidity ;

                    if(_globalDeviceManager->_global_device_info->product_type==2 &&
                        _globalDeviceManager->_global_device_info->product_pwr_type == 2)
                    {
                        //modbus_mapping_t *mb_mapping = _globalDeviceManager->_global_Slave_Modbus.mmp;
                        // *(uint32_t *)(&(mb_mapping->tab_registers[14])) = _globalSensorInfo.val1*1000;
                        // *(uint32_t *)(&(mb_mapping->tab_registers[16])) = _globalSensorInfo.val2*1000;
                        _globalDeviceManager->g_modebus_read.temprature = _globalSensorInfo.val1*1000;
                        _globalDeviceManager->g_modebus_read.humidity = _globalSensorInfo.val2*1000;
                        _globalDeviceManager->g_modebus_read.sencor_status = _globalSensorMangerTemp->sensor_status;
                        _globalDeviceManager->for85_data.temprature = _globalSensorInfo.val1*100;
                        _globalDeviceManager->for85_data.humnate = _globalSensorInfo.val2*100;
                        _globalDeviceManager->for85_data.sensor_status = _globalSensorMangerTemp->sensor_status;
                    }
                    //写入数据库
                    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(_globalSensorInfo.samp_time,0,sizeof(_globalSensorInfo.samp_time));
                    strftime(_globalSensorInfo.samp_time, sizeof(_globalSensorInfo.samp_time), "%Y-%m-%d %H:%M:%S", t);
                    sprintf(buffer,".%03ld",tv.tv_usec/1000);
                    strcat(_globalSensorInfo.samp_time,buffer);

                    // if (difftime(now, _globalSensorInfo.product_log_time) > (10000 / 1000))
                    // {
                    //     _globalSensorInfo.product_log_time = now;
                    //     // 插入数据库
                    //     ret = dev_insert_sensor_info(_globalDeviceManager->db, &_globalSensorInfo, &nSaveIndex);
                    //     if (ret != 0)
                    //     {
                    //         log_e("sensor_temp_write database error.");
                    //     }
                    // }
                }break;
                case 1://烟雾
                {
                    
                }break;
                case 2://水浸
                {

                }break;
                case 3://门禁 IO信号
                {

                }break;
                case 4://气体
                {

                }break;
                case 5://气流
                {

                }break;
            }
        }
        sleep(3);
    }

    pthread_exit(NULL);
}
#endif
//刷新共享内存功能


void * _global_shm_data_func(void *arg)
{
    int fd = 0;
    GlobalDeviceManager *_globalDeviceManager = (GlobalDeviceManager *)arg;
    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->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;
                   // printf("tttttttttttttttttttttttttt %d   hellooos\n",_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;
                    // printf("%d  %d   %0.2f  %0.2f\n",_globalDeviceManager->g_modebus_read.temprature
                    //                                 ,_globalDeviceManager->g_modebus_read.humidity
                    //                                 ,_globalDeviceManager->g_shm_Data->fT
                    //                                 ,_globalDeviceManager->g_shm_Data->fH);
                }
                else if (_globalDeviceManager->g_shm_Data->bPDUSet == 0)
                { // 等于于0则更新pdu数据
                    //int  nIndex=1;                    
                    //pShmData.nMaxCh = 1;
                    //pShmData.bPDUSet = 1;
                    //memcpy(_globalDeviceManager->g_shm_Data,&pShmData,sizeof(smartPDU_shm_data));
                    //memcpy(_globalDeviceManager->g_shm_Data->nMaxCh,&nIndex,sizeof(int));
                    //memcpy(_globalDeviceManager->g_shm_Data->bPDUSet,&nIndex,sizeof(int));
                    _globalDeviceManager->g_shm_Data->nMaxCh=1;              
                    _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(1);
        }
        
    }
    if (_globalDeviceManager->g_shm_Data)
    {
        munmap(_globalDeviceManager->g_shm_Data, sizeof(smartPDU_shm_data));
        close(fd);
    }
    return NULL;
}


void* gloable_operate_master_func(void* arg)
{
    GlobalDeviceManager* _globalDeviceManager = (GlobalDeviceManager*)arg;
    
    int ret = 0;
    unsigned char buff[MODBUS_TCP_MAX_ADU_LENGTH] = {0};

    modbus_mapping_t *mb_mapping =_globalDeviceManager->_global_Slave_Modbus.mmp;
    while(_globalDeviceManager->dev_samp_flag)
    {
        printf("run!!!\n");
    
        ret = modbus_receive(_globalDeviceManager->_global_Slave_Modbus.mb,buff);
        
        if(ret > 0)
        {
            printf("len=%02d: ", ret);
            for (int idx = 0; idx < ret; idx++)
            {
                printf(" %02x", buff[idx]);
            }
            printf("\n");

            //解析写入阈值或寄存器


            modbus_reply(_globalDeviceManager->_global_Slave_Modbus.mb,buff,ret,mb_mapping);
        }else if(ret == -1)
        {
            printf("receive errror !!!! %s\n",modbus_strerror(errno));
            // break;
        }

        // usleep(1000000);
    }
    // modbus_mapping_free(mb_mapping);
    // mb_mapping = NULL;
    pthread_exit(NULL);
}



int get_path(char *path, char *name)
{
    char tmp[PATH_MAX];

    pid_t pid = getpid();
    snprintf(tmp, sizeof(tmp), "/proc/%d/exe", pid); 
    readlink(tmp, path, sizeof(tmp));
    char *p = strrchr(path, '/');
    if(p && strlen(path)>1) {
        *p = 0;
        strcat(path, "/");
        strcat(path, name);
    }
    
    return 0;
}



int sys_get_path(char *path, char *name)
{
    char tmp[500];

    pid_t pid = getpid();
    snprintf(tmp, sizeof(tmp), "/proc/%d/exe", pid); 
    readlink(tmp, path, sizeof(tmp));
    char *p = strrchr(path, '/');
    if(p && strlen(path)>1) {
        *p = 0;
        if(name && strlen(name)>0) {
            strcat(path, "/");
            strcat(path, name);
        }
    }
    
    return 0;
}


/// @brief 全局结构体初始化
/// @param _globalDeviceManager 
/// @return 


#if 1
int _global_device_manage_init(GlobalDeviceManager* _globalDeviceManager)
{
    int ret = 0 ;
    int type = 0 ;
    
    char path[PATH_MAX];
    //wdog_init();
    pthread_t pthread_wg = 0;
    //pthread_create(&pthread_wg, NULL, _global_feed_dog, NULL);


    //初始化用户登录列表
    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 ;

    //链接数据库获取配置信息
    sys_get_path(path, DATABASE_NAME);
    ret = sqlite_init(&_globalDeviceManager->db, path);
    if(ret<0)
    {
        log_e("open database error.\n");
        return -1 ;
    }
    log_i("database init ok.\n");

    //查询设备总体参数
    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_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");
        }
    }
    log_i("get all chn data ok.\n");
    INIT_LIST_HEAD(&_globalDeviceManager->_globalPowerManger.list);

    log_d("485Type init begin!");
    _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 = RS485_Type;
    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)
    {
        return -1;
    }
    memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
        // 查询是否由通道信息
    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                        _globalDeviceManager->_global_device_info->product_id,
                                        0,
                                        1, // 1*8+j
                                        _globalPowerMangerTemp);
        // 未查询到信息 则插入
    if (ret == -1)
    {
        _globalPowerMangerTemp->product_id = _globalDeviceManager->_global_device_info->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 = RS485_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", 0, 1);
                return 0;
            }
    }
        // 添加到队尾
    list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
    log_d("485Type init success!");
    
    //初始化传感器列表
    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.");

    //查询数据库获取传感器信息 
    //存储设备类型
    _globalDeviceManager->for85_data.addr = _globalDeviceManager->_global_device_info->_modbus_info.product_modbus_addr;
    _globalDeviceManager->for85_data.dev_cnt = 1;
    //创建modbus采集线程 继电器控制线程
    _globalDeviceManager->dev_samp_flag = true;
    pthread_create(&_globalDeviceManager->dev_samp_thread, NULL, _global_power_samp_func, _globalDeviceManager);
    // 传感器采用485 modebus
    // 创建传感器采集控制线程
    pthread_create(&_globalDeviceManager->sensor_thread, NULL, _global_sensor_samp_func, _globalDeviceManager);
    
    pthread_create(&_globalDeviceManager->shm_thread, NULL, _global_shm_data_func, _globalDeviceManager);

    // 485 从机
    if (_globalDeviceManager->_global_device_info->product_type == 2 && _globalDeviceManager->_global_device_info->product_pwr_type == 2)
    {
        cascade_init();
    }

    //等待
    pthread_join(_globalDeviceManager->dev_samp_thread,NULL);
    pthread_join(pthread_wg,NULL);

    while(1)
    {
     //   wdog_feed();
        sleep(1);
    }
    return 0;
}




#endif