SmartPDCode/pro/src/common.h

#ifndef __COMMON_H_
#define __COMMON_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include "sqlite3.h"
#include "pthread.h"
#include "list.h"
#include "modbus_handle.h"
#include "elog.h"
#include "mongoose.h"
#include "ntpclient.h"
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>

#include "pduMIB_form.h"
#include "pduMIB_scalar.h"
#include "pduMIB_trap.h"
#include "language_hashmap.h"
#include "hlw8110_habdle.h"
#include "language_common.h"
#include <sys/shm.h>
#include "cfg.h"


#define MAX_RELAY_CHN       100

//是否在OS环境下运行
#define OS_HANDWARE 1

#define WEB_ROOT            "../web"
#define PARAS_FILE          "pduParas"

#define DATABASE_NAME       "pdu_dat.db"
#define DATABASE_BAK_NAME   "pdu_dat_bak.db"
#define SNMP_MIB_NAME       "pduMIB"
#define INI_FILE_NAME       "smartPDU.ini"
#define INI_FILE_BAK_NAME   "smartPDU_bak.ini"
#define CHANGES_NAME        "changes.txt"

#define SERV_CFG_NAME       "service.ini"
#define SENSOR_CFG_NAME     "sensor.ini"
#define ALARM_CFG_NAME      "alarm.ini"

#define INFO_FILE_PATH      "/usr/share/PDUInfo.txt"


#if (CHIP_TYPE == CHIP_T113s)

//控制板通信串口
#define INTERL_MODBUS_PORT          "/dev/ttyS4"
#define INTERL_MODBUS_BAUD          115200
//表头级联通讯串口
#define CASCADE_MODBUS_PORT         "/dev/ttyS5"
#define CASCADE_MODBUS_BAUD         115200
//传感器通信串口
#define INTERL_SENSOR_MODBUS_PORT   "/dev/ttyS1"
#define INTERL_SENSOR_MODBUS_BAUD   9600

#else

//高配表头串口定义-----------------------------------------------
//控制板通信串口
#define INTERL_MODBUS_PORT "/dev/ttyAS5"
#define INTERL_MODBUS_BAUD 115200
//表头级联通讯串口
#define CASCADE_MODBUS_PORT     "/dev/ttyAS4"
#ifdef NORTH_USER_SPECILS
#define CASCADE_MODBUS_BAUD     9600
#else
#define CASCADE_MODBUS_BAUD     115200
#endif
//传感器通信串口
#define INTERL_SENSOR_MODBUS_PORT "/dev/ttyAS2"
#define INTERL_SENSOR_MODBUS_BAUD 9600

#endif





#define IMAGE_FOLDER        "image"
#define LOGO_FILE           "logo.png"
#define QRCODE_FILE         "qrcode.png"
#define CERT_FILE           "ca.cert"


#define AC_SINGLE_S_CUR_CHN_NUM 8
#define AC_SINGLE_B_CUR_CHN_NUM 4

#define AC_SINGLE_S_MAX_CHN_NUM 10  	//单个控制板最大数量
#define AC_SINGLE_S_MAX_ADDRESS_NUM 16  //控制板最大数量

#define AC_MAX_VOLTAGE_VAL 500
#define AC_MAX_CURRENT_VAL 100
#define AC_MAX_POWER_VAL 100

enum{
    BREAKER_DIO = 0,
    BREAKER_RS485
};


enum
{
	TOTAL_VOLTAGE_TYPE 			= 0,//统计电压类型
	TOTAL_CURRENT_TYPE 			= 1,//统计电流类型
	TOTAL_POWER_TYPE 			= 2,//统计功率类型
	TOTAL_POWER_CONS_TYPE 		= 3 //统计耗电量类型
};

enum
{
	POWER_MERITORIOUS_TYPE 			= 0,//有功功率类型
	POWER_REACTIVE_TYPE 			= 1,//无功功率类型
	POWER_APPARENT_TYPE 			= 2 //视在功率类型
};

enum
{
    SENSOR_TYPE_TEMP_HUMI   = 0 , //温湿度传感器
    SENSOR_TYPE_SMOKE       = 1 , //烟雾传感器
    SENSOR_TYPE_WATER       = 2 , //水浸传感器
    SENSOR_TYPE_ACCESS      = 3 , //门禁传感器
    SENSOR_TYPE_GAS         = 4 , //气体传感器
    SENSOR_TYPE_AIR_PRESS   = 5 , //气压传感器
    SENSOR_TYPE_AIR_COND    = 6,  //空条传感器
    SENSOR_TYPE_LEAK        = 7,  //泄漏传感器
    SENSOR_TYPE_TEMP        = 8,  //温度传感器
    SENSOR_TYPE_TEMP_DOUBLE = 9,  //双温度传感器
    SENSOR_TYPE_PRESS       = 10, //压力传感器

    SENSOR_TYPE_MAX,
};

enum {
    SENSOR_TYPE_TEMP_HUMI_RSWSN01PVC=0,
    SENSOR_TYPE_TEMP_HUMI_HKSHT301T1H536VRS485,

    SENSOR_TYPE_TEMP_HUMI_MAX
};
enum {
    SENSOR_TYPE_TEMP_DOUBLE_DL10BM485V24D2=0,

    SENSOR_TYPE_TEMP_DOUBLE_MAX
};
enum {
    SENSOR_TYPE_TEMP_BTG50H8EL3200=0,

    SENSOR_TYPE_TEMP_MAX
};
enum {
    SENSOR_TYPE_LEAK_XWDC01A=0,

    SENSOR_TYPE_LEAK_MAX
};


enum
{
    SENSOR_VAL1_UPPER = 0,
    SENSOR_VAL1_LOWER,
    SENSOR_VAL2_UPPER,
    SENSOR_VAL2_LOWER,

};
enum
{
    SENSOR_TYPE_VALUE = 0 , //传感器类型0、4、5
    SENSOR_TYPE_LIST        //传感器类型1、2、3
};


/// @brief 板子类型
enum MODBUS_BOARD_TYPE
{
    AC_SINGLE_S_TYPE=1,
    AC_SINGLE_B_TYPE,
    AC_MULTI_S_TYPE,
    AC_MULTI_B_TYPE,
    DC_OUT_TYPE,
    DC_IN_TYPE,
    DCPDU_TYPE,
    TREE_AC_TYPE,   //三相进三项出
};

enum AppProductType
{
    SmartPDU_AC=0,
    SmartPDU_DC=1,
    SmartPDU_Tree_AC_Tree=3,
    SmartPDU_Tree_AC_One=4,
    SmartPDU_Tree_AC_One_B=5,    
};

/// @brief 三相网页数据
static char* g_product_t_ac_type_str[3] = {
    "L1",
    "L2",
    "L3",
};
/// @brief 按位标记
enum BIT_CTRL
{
    BIT_00 = 1 ,
    BIT_01 = 2 ,
    BIT_02 = 4 ,
    BIT_03 = 8 ,
    BIT_04 = 16,
    BIT_05 = 32,
    BIT_06 = 64,
    BIT_07 = 128,
    BIT_08 = 256,
    BIT_09 = 512,
    BIT_10 = 1024,
    BIT_11 = 2048,
    BIT_12 = 4096,
    BIT_13 = 8192,
    BIT_14 = 16384,
    BIT_15 = 32768,
};
/// @brief 使能位
enum ENABLE_BIT_CTRL
{
    ENABLE_V_UP     = 2 ,
    ENABLE_V_DOWN   = 8 ,
    ENABLE_A_UP     = 32,
    ENABLE_W_UP     = 128,
    ENABLE_P_UP     = 512,
    ENABLE_ALL_UP   = BIT_11,
    ENABLE_ALL_DOWN = BIT_12,
};
/// @brief 使能位三项
enum ENABLE_TreeAC_CTRL
{
    ENABLE_TAC_V_UP     = BIT_01,
    ENABLE_TAC_V_DOWN   = BIT_02,
    ENABLE_TAC_A_UP     = BIT_03,
    ENABLE_TAC_W_UP     = BIT_04,
    ENABLE_TAC_P_UP     = BIT_05,
    ENABLE_TAC_STIME    = BIT_06,
    ENABLE_TAC_ETIME    = BIT_07,
};
/// @brief 报警位
enum WARNING_BIT_CTRL
{
    WARNING_V_UP     = 4 ,
    WARNING_V_DOWN   = 16 ,
    WARNING_A_UP     = 64, 
    WARNING_W_UP     = 256,
    WARNING_P_UP     = 1024,
};


enum {
    ALARM_TYPE_POWER=0,
    ALARM_TYPE_SENSOR,
    ALARM_TYPE_NETWORK,
    ALARM_TYPE_OPRATION,
    ALARM_TYPE_RUNNING,
};


enum {
    NETWORK_MAC_CHANGED=0,
    NETWORK_IP_CHANGED,
};


/// @brief 报警动作
enum ALARM_CTRL
{
    ALARM_CTRL_CLOSE_CH     = 1 ,
    ALARM_CTRL_ALARM_ONLY     = 2 ,
    ALARM_CTRL_CLOSE_ALLCH     = 3 ,
};


enum {
    MODBUS_MASTER=0,
    MODBUS_SLAVE,
};

enum {
    LANG_ID_CHINESE=0,
    LANG_ID_ENGLISH,
    LANG_ID_RUSSIAN,
    LANG_ID_SPANISH,
    LANG_ID_PORTYGYESE,
    LANG_ID_GERMAN,
    LANG_ID_FRENCH,
    LANG_ID_ITALIAN,
    LANG_ID_JAPANESE,

    LANG_ID_MAX
};


///////////////////////////////////////////////////////////////////////////////////
typedef struct {
    int             id;
    int             up;
    char            ip[48];
    char            mac[24];
    char            desc[64];
}port_info_t;
typedef struct {
    #define SW_PORT_MAX 28
    port_info_t     port[SW_PORT_MAX];
}netswitch_info_t;

///////////////////////////////////////////////////////////////////////////////////
//modbus信息管理
typedef struct
{
    bool            mode ;          //0: master   1slave
    unsigned char   addr;
    unsigned int    baudrate ;      //波特率
    char            path[32] ;      //device path
}ModbusInfo_t;

typedef struct
{
    int           mode;    						//0:dhcp  1:static  
    char          ip_address[64] ; 				//ip地址
    char          mask[64]; 					//子网掩码
    char          gateway[64]; 					//网关
    char          dns1[64];    					//dns1
    char          dns2[64];    					//dns2
}NetworkInfo_t;


/// @brief 用户登录
typedef struct
{
    char user_name[64];
    char user_password[64];
    char user_uuid[64];
    char user_token[64];
    struct list_head list;
}_User_Log;

typedef struct {
    uint32_t    id;                     //产品ID   
    char        pname[32];         //产品名称
    char        pnumber[32];         //产品编号    
    char        status[32];             //产品状态
    
    char        name[32];               //设备名称
    char        number[32];             //设备编号    
    char        date[32];           //设备生产日期
    char        batch[32];        //设备生产批次

    uint8_t     type;                   //产品类型
    uint8_t     pwr_type;               //电源类型
    char        version[8];             //软件版本
    uint8_t     language;               //多国语言
    uint8_t     count;                  //级联设备数
    uint32_t    samp_time;              //采集周期 单位ms
    uint32_t    save_time;              //采集周期 单位ms

    uint16_t    ph_group;               //三组相数
    uint16_t    ch_delay;               //通道延时
}ProductInfo_t;

typedef struct {
    int         monway;                  //1:总检测 2:分监分控 3:分监不控
    int         netsw;
    int         nwire;
    int         ipv4;
    int         ipv6;
}WebcfgInfo_t;

typedef struct {
    int         watchdog;
    int         flip_time;
    int         led;
    int         beep;
    int         rotate;
}MiscInfo_t;


typedef struct {
    char        name[256];
    char        site[256];
    char        mail[256];
    char        addr[256];
    char        tele[32];
}ServiceInfo_t;

typedef struct
{
    int          voltage;
    int          current;
    int          power;
    int          brdMax;
}PowerTotal_t; 

// WIFI信息
typedef struct
{
    int mode;         // WIFI模块启用状态
    bool Link_status; // wifi网络连接状态
    char WIFI_ip[64]; // wifi ip address
    char WIFI_name[64];// WIFI网络SSID名称
    char WIFI_code[64];// WIFI密码
} WIFIManager;

typedef struct
{
    ModbusInfo_t    relay;              //继电器控制端口
    NetworkInfo_t   network;            //网络信息
    ModbusInfo_t    cascade;            //级联端口  
    ProductInfo_t   product;            //产品信息
    PowerTotal_t    ptotal;
    WebcfgInfo_t    webcfg;
    ServiceInfo_t   service;            //服务信息
    MiscInfo_t      misc;

    int             cell;
    WIFIManager     wifi;
}GlobalDeviceInfo;
///////////////////////////////////////////////////////////////////////////////////
//自定义共享内存类
typedef struct
{
    //电源数据
    int bPDUSet;
    int nSelectPowerCH;
    int nMaxCh;
    float fV;
    float fA;
    float fW;
    float fF;
    float fS;
    int nStatus;
    //传感器数据
    int nSelectSensor;
    float fT;//温度
    float fH;//湿度
    //三项数据
    int bT_ACType;//三相类型
    int nSelectPh;//当前通道的三相ph参数:0：A相 1：B相 2：C相 -1通道总计
} smartPDU_shm_data;

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//超限管理表
typedef struct
{
    int             product_vol_upper_enable                   ;//电压上限使能
    float           product_vol_upper_threshold                ;//电压上限值
    int             product_vol_over_upper_threshold_ctrl      ;//电压超限动作
    int             product_vol_over_upper_threshold_ctrl_para ;//电压超限关联参数
    int             product_vol_lower_enable                   ;//电压下限使能
    float           product_vol_lower_threshold                ;//电压下限值
    int             product_vol_over_lower_threshold_ctrl      ;//电压超限动作 
    int             product_vol_over_lower_threshold_ctrl_para ;//电压超限动作   
    int             product_cur_upper_enable                   ;//电流下限使能
    float           product_cur_upper_threshold                ;//电流下限值
    float           product_cur_lower_threshold;                //
    int             product_cur_over_upper_threshold_ctrl      ;//电流超限动作 
    int             product_cur_over_upper_threshold_ctrl_para ;//电流超限动作   
    int             product_pwr_upper_enable                   ;//功率上限使能
    float           product_pwr_upper_threshold                ;//功率上限值
    int             product_pwr_over_upper_threshold_ctrl      ;//功率超限动作 
    int             product_pwr_over_upper_threshold_ctrl_para ;//功率超限动作      
    int             product_pwrcon_upper_enable                ;//耗电量上限使能
    float           product_pwrcon_upper_threshold             ;//耗电量上限值
    int             product_pwrcon_over_upper_threshold_ctrl   ;//耗电量超限动作   
    int             product_pwrcon_over_upper_threshold_ctrl_para   ;//耗电量超限动作   
}GlobalOverManager;


/// @brief 定时管理
typedef struct
{
    char                set_date[16]; //设置日期
    char                ds_date[16]; //设置时间
    char                ds_time[16]; //设置时间
    int                 set_stats;    //状态
    int                 ds_is_triggered;   //是否已触发
    struct list_head    list;   
}_PowerDSManage_t;


typedef struct
{
    int                 firingSortno;   //启动序号
    int                 closeSortno;    //关闭序号 
}_PowerSXManage_t;

typedef struct
{
    int                 product_id;
    int                 mode;
    char                ntpName[64];
    char                ntpaddress[64];
    int                 port;
    char                time[64];
    int                 weekday;
    int                 tzone;
}NTPManager;



enum {
    SNMP_AUTH_NONE=0,
    SNMP_AUTH_MD5,
    SNMP_AUTH_SHA,

    SNMP_AUTH_MAX
};
enum {
    SNMP_ENCYPT_NONE=0,
    SNMP_ENCYPT_DES,
    SNMP_ENCYPT_AES,

    SNMP_ENCYPT_MAX
};

typedef struct {
    char                alg[12];
    char                passwd[64];
}crypt_data_t;
typedef struct {
    char                user[32];
    crypt_data_t        auth;
    crypt_data_t        priv;
}crypt_t;
typedef struct
{
    int                 product_id;
    int                 mode;
    int                 version;
    char                public[64];
    int                 trapmode;

    crypt_t             crypt;
    char                nmsIP[64];
}SNMPManager;


//分组管理
typedef struct
{
    int                 product_id;
    int                 GroupID;
    char                GroupName[64];
    char                GroupChList[512];
    struct list_head    list;  
}GroupInfo;

// 4G网络及GPS信息
typedef struct
{
    int mode;         // 4G模块启用状态
    bool Link_status; // 4G网络连接状态
    bool RS_status; // 4G模组串口访问状态
    int RS_fd; // 4G模组串口访问状态
    float Signal_strength; // 信号强度
    char Cellular_name[64];// 4G网络名称
    char Cellular_APN[64];// APN接入点名称
    char Cellular_Num[64];// 电话号码
	
	bool GPS_status; // GPS功能启用
    char GPS_utc[64];// UTC时间
    float GPS_latitude;// 纬度，范围-89.99999~89.99999
    float GPS_longitude;// 精度，范围-179.99999~179.99999
    float GPS_altitude;// 海拔高度，单位m
    float GPS_speed;//地面速率，单位km/h
    int GPS_nsat;//卫星数量

    bool SMS_status; // 短信功能启用

} CellularManager;

//电源部分
typedef struct 
{
    float           voltage                                     ;//电压
    float           current                                     ;//电流
    float           power                                       ;//功率
    float           freq                                        ;//频率
    float           consumption                                 ;//耗电量
    float           factor                                      ;//功率因素    
    unsigned short  status                                      ;//开关状态     
    unsigned short  NF_status                                   ;//零线状态
    
    port_info_t     port;                                       //
}PowerInfo;

//电源部分报警信息
typedef struct 
{
    bool           w_voltage_up                                  ;//电压上限报警
    bool           w_voltage_down                                ;//电压下限报警
    bool           w_current                                     ;//电流上限报警
    bool           w_power                                       ;//功率
    bool           w_consumption                                 ;//耗电量
    bool w_phase_lossA;                                           // 缺相报警
    bool w_phase_lossB;                                           // 缺相报警
    bool w_phase_lossC;                                           // 缺相报警
}PowerWarningInfo;

//三项数据
typedef struct
{
    int product_id;
    int product_ch_id;
    int product_ph_id;
    int product_ph_type;//0:A相 1:B相 2:C相                
    int product_saddr;
    int product_ch_addr;
    int product_ph_outputType;//三相控制方式1,三项2单项
    int product_ph_outputStatus;//该相是否输出，1输出2不输出

    char                samp_time[64];                           //采集时间
    PowerInfo           _PowerInfo;                              //存储最新的数据(兼容三项输入)
    GlobalOverManager   global_over_manager;                     //超限管理
    PowerWarningInfo    _PowerWarninginfo;                       //存储报警数据(兼容三项输入)  
    time_t              product_log_time;                           //存储最新时间   
    struct list_head    list_Tree_AC;                              //存储三项数据指针    
}GlobalTreeACManager;
//电源通道管理总表(输出)
typedef struct 
{
    int                 product_id                                 ;//产品ID
    //20240225 add
    int                 product_saddr                              ;//modbus地址记录                       
    int                 product_ch_id                              ;//通道号
    int                 product_ch_addr                            ;//通道号实际地址
    char                product_ch_name[32]                        ;//通道名称
    int                 product_ch_type                            ;//通道类型
    int                 product_ch_status                          ;//通道状态
    int                 product_ch_NF_status                       ;//通道零线状态（三相）
    int                 product_ch_start_delay                     ;//通道延时 
    int                 product_ch_stop_delay                      ;//通道延时

    GlobalOverManager   global_over_manager                        ;//超限管理
    struct list_head    list_DS;                                    //定时设置      
    _PowerSXManage_t*   _PowerSXManage;                             //时序管理      
    PowerInfo           _PowerInfo;                                 //存储最新的数据     
    PowerWarningInfo    _PowerWarninginfo ;                         //存储报警数据     
    time_t              product_log_time;                           //存储最新时间     
    struct list_head    list_Tree_AC;                              //存储三项数据指针
    struct list_head    list;  
}   GlobalPowerManger;

//电源通道管理总表(输入)
typedef struct 
{
    int                 product_id                                 ;//产品ID
    //20240225 add
    char                product_saddr                              ;//modbus地址记录                       
    char                product_saddr_name[32]                     ;//输入名称
    char                product_saddr_type                         ;//输入类型
    GlobalOverManager   global_over_manager                        ;//超限管理
    PowerInfo           _PowerInfo[3];                              //存储最新的数据(兼容三项输入)
    PowerWarningInfo    _PowerWarninginfo[3];                       //存储报警数据(兼容三项输入)    
    time_t              product_log_time;                           //存储最新时间 
    int                 product_MissingPH[3];                       //缺相报警                                       
}GlobalPowerInManger;

//电源控制板计数
typedef struct 
{
    char                product_saddr                              ;//modbus地址记录                       
    int                 product_number;                             //数量
    int                 product_type;                               //类型
    PowerInfo           _PowerInfo[AC_SINGLE_S_MAX_CHN_NUM];        //存储最新的数据     
    PowerWarningInfo    _PowerWarninginfo[AC_SINGLE_S_MAX_CHN_NUM] ;//存储报警数据     
    struct list_head    list;  //存储具有的通道指针
    GlobalPowerInManger _globalPowerInManger;                       //总输入数据
}GlobalPowerCtrlBoard;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

//电源信息统计
typedef struct
{
	float ydata[60];    //value
    char  xAxis[60][32];//时间点
}GetTotalInfo;

//系统总数信息
typedef struct
{
    int channel_total  ;//通道总数
    int warn_total     ;//告警总数
    int sensor_total   ;//传感器总数
    int log_total      ;//运行日志总数
}SystemTotalInfo;

//功率趋势接口
typedef struct
{
    float  ydata[3][60]     ;//0：有功功率；1：无功功率；2：视在功率；
    char   xAxis[60][32]    ;//时间点      
}PowerTrendInfo;

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//电源监控
typedef struct 
{
    int             product_id                                  ;//产品ID
    char            product_ch_id                               ;//电源通道
    unsigned short  product_status                              ;//当前状态
    PowerInfo       _power_info                                 ;//采集值
    char            samp_time[64]                               ;//采集时间
    GetTotalInfo	_total_voltage								;//统计电压
	GetTotalInfo	_total_current								;//统计电流
	GetTotalInfo	_total_power								;//统计功率
	GetTotalInfo	_total_consumption							;//统计耗电量
    SystemTotalInfo _system_total_info                          ;//系统总数信息
    PowerTrendInfo  _power_trend_info                           ;//功率趋势图
    struct list_head list;
}GlobalPowerInfo;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//传感器值
typedef struct
{
    char            samp_time[64]                               ;//采集时间
    int             product_id                                  ;//产品ID
    char            sensor_id                                   ;//传感器ID
    float           val1                                        ;//值1
    float           val2                                        ;//值2
    time_t          product_log_time;                           //存储最新时间     
    struct list_head list;
}GlobalSensorInfo;

typedef struct
{
    int                 sensor_val1_upper_enabled ;//
    float               sensor_val1_upper_threshold;
    int                 sensor_val1_upper_threshold_ctrl;
    char                sensor_val1_upper_threshold_ctrl_para[512];
    int                 sensor_val1_lower_enabled ;//
    float               sensor_val1_lower_threshold;
    int                 sensor_val1_lower_threshold_ctrl;
    char                sensor_val1_lower_threshold_ctrl_para[512];
    int                 sensor_val2_upper_enabled ;//
    float               sensor_val2_upper_threshold;
    int                 sensor_val2_upper_threshold_ctrl;
    char                sensor_val2_upper_threshold_ctrl_para[512];
    int                 sensor_val2_lower_enabled ;//
    float               sensor_val2_lower_threshold;
    int                 sensor_val2_lower_threshold_ctrl;
    char                sensor_val2_lower_threshold_ctrl_para[512];
}GlobalSensorOverManage;

//传感器报警状态表
typedef struct
{   
    int                 sensor_val1_upper;
    int                 sensor_val1_lower;
    int                 sensor_val2_upper;
    int                 sensor_val2_lower;
}GlobalSensorOverInfo;
//传感器管理总表
typedef struct 
{
    int                 product_id                                 ;//产品ID    
    int                 sensor_id                                  ;//传感器ID
    int                 sensor_type                                ;//传感器类型
    int                 sensor_interface_type;                     //接口类型
    char                sensor_name[64]                            ;//传感器名称
    char                sensor_port_name[32]                       ;//传感器端口号
    int                 sensor_baud                                ;//波特率
    int                 sensor_addr                                ;//modbus地址
    int                 sensor_status                              ;//传感器状态
    int                 sensor_val_count                           ;//传感器值个数
    int                 sensor_node_number                         ;//节点号
    GlobalSensorInfo Cur_sensor_info ;
    GlobalSensorOverManage over_manager                            ;//超限管理   
    GlobalSensorOverInfo warning_status;//报警状态
    struct list_head    list;   
}GlobalSensorManger;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////



///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///温湿度数据信息管理
typedef struct
{
    float  temperature;
    float   humidity;
}SenorTempVal;


//采集KB值
typedef struct 
{
    float   voltage_k;//电压K
    float   voltage_b;//电压B
    float   current_k;//电流K
    float   current_b;//电流B
}SwitchKbVal;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

//MAIL管理
typedef struct
{
    int                 id;
    int                 use;
    char                account[64];
}mail_recv_t;
typedef struct 
{
    int                 id;
    int                 mode;    				        //0: open   1: close
    char                account[64];                    //用户账号
    char                password[24]; 		            //用户密码
    char                server[64]; 			        //服务器
    char                port[10];    		            //端口
    char                auth[16];    			        //认证方式  
    char                ca[8196];                       //ca cert
}mail_send_t;
typedef struct
{
    mail_send_t         send;

    #define MAIL_RECV_MAX  10
    mail_recv_t         recv[MAIL_RECV_MAX];      //接收账号列表
}mail_info_t;

enum {
    MQTT_PLAT_EMQX=0,
    MQTT_PLAT_ALIYUN,
    
    MQTT_PLAT_MAX
};

typedef struct {
    int                 id;    		                    //id
    int                 plat;                           //0: emqx   1: aliyun
    int                 mode;    				        //0: open   1: close
    char                proto[16];                      //mqtt, mqtts, ws, wss
    char                name[32];                       //server name
    char                server[512]; 		            //server ip
    char                port[10]; 			            //server port
    char                cid[64];    		            //client ID
    char                user[64];    			        //
    char                password[64];
    char                cert[8200];
    int                 status;
}mqtt_server_t;
typedef struct {
    #define MQTT_SER_MAX   5
    mqtt_server_t       ser[MQTT_SER_MAX];
}mqtt_info_t;

typedef struct 
{
    int                 product_id;
    int                 userID;    				//用户ID
    char                userName[32];           //用户名-登录
    char                userPW[32]; 		    //用户密码
    char                nickName[32]; 			//用户名称
    int                 roleID;    		        //角色ID
    char                createTime[32];         //用户创建时间     
    struct list_head    list;

}UserInfo;

typedef struct 
{
    int                 product_id;
    int                 roleID;    				//角色ID
    char                roleName[32];           //角色名称
    int                 roleLevel; 		        //角色等级
    char                roleAuthority[32]; 		//角色权限
    int                 roleSort;    		    //显示顺序
    char                createTime[32];         //创建时间     
    struct list_head    list;

}RoleInfo;

typedef struct MenuAuthority{
    bool PowerEnabled;
    bool SensorEnabled;
    bool AlarmEnabled;
    bool LogEnabled;
    bool UserInfoEnabled;
    bool CommEnabled;
    bool ServiceEnabled;
    bool MaintenanceEnabled;

    //1、电源监控菜单
    bool MonitorallEnabled;
    bool ChannelstatusEnabled;
    bool SwitchtatusEnabled;
    bool MonitorhistoryEnabled;
    //2、传感器管理菜单
    bool SensorStatusEnabled;
    bool SensorHistorylEnabled;
    //3、告警管理菜单
    bool XtjgEnabled;
    bool YzszEnabled;
    //4、日志信息菜单
    bool CzrzEnabled;
    bool YxrzEnabled;
    //5、用户管理菜单
    bool UserEnabled;
    bool RoleEnabled;
    bool MenuEnabled;
    //6、通信管理菜单
    bool WkszEnabled;
    bool RsszEnabled;
    bool CellularEnabled;
    bool WifiEnabled;
    //7、服务管理菜单
    bool SmtpszEnabled;
    bool SnmpszEnabled;
    bool MqszEnabled;
    bool NtpszEnabled;
    bool DsszEnabled;
    bool SxszEnabled;
    bool FzszEnabled;
     //8、设备维护菜单
    bool SbcqEnabled;
    bool GjsjEnabled;
    bool KzbsjEnabled;
    bool HhccszEnabled;
    bool PzdrdcEnabled;
    bool ShfwEnabled;
    bool GysbEnabled;
}MenuAuthority;


typedef struct CascadeDevices{
    int                 product_id;     //级联设备ID modbus地址
    int                 type;           //
    char                device_name[20];    //接连设备名;
    float               valtage;            //485
    float               current;
    float               power;
    float               factor;
    float               freq;
    float               consumption;
}CascadeDevices;

struct modbus_slave_read_reg{
    uint16_t deveice_type;              //设备类型
    uint16_t slave_addr;                //设备地址
    uint32_t voltage;                   //当前电压
    uint32_t current;                   //当前电流
    uint32_t power;                     //当前功率
    uint32_t consumption_cur;           //耗电量
    uint32_t freq;                      //频率
    uint32_t factor;                    //功率因素
    uint32_t temprature;                //温度值
    uint32_t humidity;                  //湿度值
    uint32_t warning;                   //告警
    uint16_t power_supplay_status;      //供电状态
    uint16_t sencor_status;             //传感器状态
    uint32_t temprature2;                //温度值2
//    uint32_t Warinfo;
//    uint16_t sercor_type;
};



typedef struct cascade_pw_info{
    uint32_t           voltage                                     ;//电压
    uint32_t           current                                     ;//电流
    uint32_t           power                                       ;//功率
    uint32_t           freq                                        ;//频率
    uint32_t           consumption                                 ;//耗电量
    uint32_t           factor                                      ;//功率因素 
}cascade_single_chn_info;     //siggle hell 

typedef struct temp_hum{
    uint16_t temperature;
    uint16_t humidity;
}temp_hum_t;

typedef uint32_t  sensor_t;
typedef uint16_t  dry_node_t;

typedef struct cascade_sensor{
    sensor_t s_1;
    sensor_t s_2;
}cascade_sensor_t;

#pragma pack (1)
typedef struct cascade_single_mmap{
    uint16_t dev_chn;
    cascade_single_chn_info all_ch[128];
    uint32_t total_valtage;
    uint32_t total_current;
    uint32_t total_power;
    uint32_t total_consumer;
    temp_hum_t total_temp;

    uint16_t chn_status[64];
    uint16_t open_delay[64];
    uint16_t close_delay[64];
    //uint16_t reservers[29];
    cascade_sensor_t cas_sensor[4];
    dry_node_t       d_node[4];
    uint16_t reservers[9];
    uint16_t set_chn_open_delay[64];
    uint16_t set_chn_close_delay[64];
    uint16_t set_chn_switch_status[64];
    uint16_t set_chn_all_switch_status;
}cascade_single_mmap_t;


#ifdef NORTH_USER_SPECILS


typedef struct cascade_north_user{
    uint32_t total_elec_energy;
    uint16_t frequency;
    uint16_t wire_voltage[3];
    uint16_t wire_current[3];
    uint16_t total_power;
    uint16_t status_1_16;
    uint16_t status_17_32;
    uint16_t status_33_48;
    uint16_t status_49_64;
    uint16_t total_wanning;
    uint16_t current_wanning;
    uint16_t fault_1_16;
    uint16_t fault_17_32;
    uint16_t fault_33_48;
    uint16_t fault_49_64;
    uint16_t set_1_16;
    uint16_t set_17_32;
    uint16_t set_33_48;
    uint16_t set_49_64;
}cascade_north_user_t;




#endif



#pragma pack ()


#pragma pack (1)


#define MAX_CHN  64

typedef struct cascade_triphasic_pw_out{
    uint32_t o_voltage;
    uint32_t o_current;
    uint32_t o_power;
    uint32_t o_consumption;
    uint32_t o_status;
}cascade_triphasic_pw_out_t;


typedef struct cascade_triphasic_pw_o_chn{
    cascade_triphasic_pw_out_t chn[3];        // A B C
}cascade_triphasic_pw_o_chn_t;


typedef struct cascade_triphasic_pw_in{
    uint32_t i_total_voltage;
    uint32_t i_total_current;
    uint32_t i_total_power;
    uint32_t i_total_consumption;
}cascade_triphasic_pw_in_t;

typedef struct cascade_triphasic_pw_i_total{
    cascade_triphasic_pw_in_t pw_i_total[3];   // A  B  C
}cascade_triphasic_pw_i_total_t;

typedef struct cascade_triphasic_chn_info{
    uint32_t chn_power;
    uint32_t chn_freq;
    uint32_t chn_consumption;
    uint32_t chn_factor;
    uint32_t chn_type;
}cascade_triphasic_chn_info_t;


typedef struct cascade_triphasic_mmap{
    uint16_t dev_chn;
    cascade_triphasic_pw_i_total_t i_total;
    cascade_triphasic_chn_info_t chn_info[MAX_CHN];
    cascade_triphasic_pw_o_chn_t pw_o_chn[MAX_CHN];
    uint16_t temperature;
    uint16_t humidity;
    uint16_t chn_status[MAX_CHN];
    uint16_t open_delay[MAX_CHN];
    uint16_t close_delay[MAX_CHN];
    cascade_sensor_t cas_sensor[4];
    dry_node_t       d_node[4];
    uint16_t set_chn_open_delay[MAX_CHN];
    uint16_t set_chn_close_delay[MAX_CHN];
    uint16_t set_chn_switch_status[MAX_CHN];
    uint16_t set_chn_all_switch_status;
}cascade_triphasic_mmap_t;


typedef struct
{
    modbus_t *ctx;
    char ip[64];
    uint16_t port;
    uint8_t slave_id;
    uint8_t power_type;
    modbus_mapping_t *map;
    int connection;
    //pthread_mutex_t mutex;
}Modbus_Manger_Tcp;



#pragma pack ()

struct modbus_slave_write_reg{
    uint16_t      voltage_high_enable:1;           //电压高阈值检测使能
    uint16_t       voltage_low_enable:1;            //电压低阈值检测使能
    uint16_t           current_enable:1;            //电流阈值使能
    uint16_t             power_enable:1;            //功率阈值使能
    uint16_t   consumption_cur_enable:1;            //功耗阈值使能
    uint32_t    voltage_upper_threshold;            //
    uint32_t    voltage_lower_threshold;
    uint32_t    current_upper_threshold;
    uint32_t      power_upper_threshold;
    uint32_t      consumption_threshold;
};
enum 
{
    DI,
    RS485
};

enum{
    SWITCH_CONNETCTED,
    SWITCH_DISCONNETCTED,
    SWITCH_OFFLINE
};


#define SWITCH_CHN_1_SET        (1<<0)
#define SWITCH_CHN_2_SET        (1<<1)
#define SWITCH_CHN_3_SET        (1<<2)
#define SWITCH_CHN_4_SET        (1<<3)
#define SWITCH_CHN_5_SET        (1<<4)
#define SWITCH_CHN_6_SET        (1<<5)
#define SWITCH_CHN_DI_1_SET     (1<<6)
#define SWITCH_CHN_DI_2_SET     (1<<7)


typedef struct {
    int     id;
    int     type;
    char    date[32];
    char    content[128];
}alarm_data_t;

typedef struct {
    int     ch;
    char    date[16];
    char    time[16];
    int     status;
    int     triggered;
}timer_data_t;

typedef struct {
    int  addr;
    char name[32];
    char ver[32];
    char date[32];
    int  dev_id;
    int  brd_id;
    int  channels;
    int  status;
}board_info_t;

typedef struct breaker_switch_sta{     
    uint16_t status;
    uint16_t gather;
    char com[30];
    uint8_t product_name[256];
}breaker_switch_sta_t;

typedef struct GlobalBreakerManger{
    uint32_t all_count;
    uint32_t online_count;
    uint32_t mask;
    uint8_t saddr;
    void *manager;
    breaker_switch_sta_t sta[8];        // 6 + 2
    pthread_mutex_t b_mutex;
}GlobalBreakerManger;


typedef struct GlobalBreakerManager{
    uint32_t        product_id;
    uint32_t        breaker_id;
    uint32_t        breaker_chn;
    uint32_t        breaker_status;
    uint32_t        breaker_gather_addr;
    char            breaker_switch_name[128];
    char            breaker_com[64];
    char            breaker_gather_type[64];
    char            breaker_chns_name[128];
    struct  list_head  list;
}GlobalBreakerManager;

//设备总体管理
typedef struct
{
    sqlite3*            db;             //数据库接口
    pthread_mutex_t     dbThreadlock;        //写入线程锁 
    pthread_t           appweb_thread;  //appweb线程
    pthread_t           dev_samp_thread;//电源采集与控制线程
    pthread_t           dev_update_thread;//电源采集与控制线程

    pthread_t           io_thread;  //IO采集线程
    pthread_t           sensor_thread; //传感器采集现成
    bool                dev_samp_flag ; //电源采集线程标志
    GlobalDeviceInfo    _globalDevInfo;    //设备管理信息
    GlobalPowerManger   _globalPowerManger;      //电源管理表
    GlobalSensorManger  _globalSensorManger;     //传感器管理表  
    Modbus_Manger       sensor_modbus_manager;  //通信接口管理
    unsigned int        useSlaveCount ;         //有效地址
    Modbus_Manger       _globalRelaySampManger; //内部继电器使用
    
    unsigned char       uart_init_flag[6] ; //

    bool                 ws_isok; //ws准备好
    struct mg_connection *ws_client;   //websocket管理信息
    HashTable*           alarmTab; //全局的报警映射
    int                 nTreeACLshow; //三项总数据显示L1=0,L2=1,L3=2
    pthread_t           snmp_agent_thread;//SNMP代理线程
    bool                _ReloadChm_flag; //重新加载端口数据
    int                  brdMax;
    GlobalPowerCtrlBoard *pCtrlBoard; //所有控制板
    LowConf*            _RS485LowConfData;//485Data
      //传感器
    struct modbus_slave_read_reg g_modebus_read;
    struct modbus_slave_write_reg g_modebus_write;
    smartPDU_shm_data* g_shm_Data;
    pthread_mutex_t     _power_ds;        //定时器锁 
    pthread_mutex_t     _power_update;        //数据刷新锁
    pthread_mutex_t     _sensor_update;        //传感器刷新锁
	pthread_mutex_t     _breaker_mutex;         // breaker info
    cascade_single_mmap_t *single_mmap;
    cascade_triphasic_mmap_t *triphasic_mmap;	
	GlobalBreakerManager g_new_global_breaker;

    mail_info_t          mailInfo;
    mqtt_info_t          mqttInfo;
    Modbus_Manger_Tcp *md_tcp;
#ifdef NORTH_USER_SPECILS
    cascade_north_user_t north_user;
#endif
}GlobalDeviceManager;

extern GlobalDeviceManager __globalDeviceManage;
extern GlobalDeviceManager __globalDeviceManage2;

extern int ntp_sync_flag;
extern unsigned long __globalSxIdx;

extern _User_Log _GlobalUserLoginInfo;//全局用户登录信息
extern UserInfo _GlobalUserInfoNew;////最近登录的信息
extern char _GlobalUserToken[64];////最近登录的信息
extern MenuAuthority _GlobalMenuAuthority;////角色菜单权限
extern NTPManager _globalNTPManager;
extern SNMPManager _globalSNMPManager;

extern CellularManager  _globalCellularManager;
extern WIFIManager _globalWIFIManager;


void initLogger(void);

//打印设备信息结构
void printf_global_device_info(GlobalDeviceInfo* _globalDeviceInfo);
//打印设备超限电源管理
void printf_global_power_manage_info(GlobalPowerManger* _globalPowerManger);
//打印设备超限电源通道管理
//void printf_global_power_chn_manage_info(GlobalPowerChnManger* _globalPowerChnManger);

void printf_power_info(GlobalPowerInfo* _globalPowerInfo);


int getTotalMemorySize(unsigned int* totalSize);
char* getLocalIpAddress(char* dev);
char* get_mac_address(const char *iface_name) ;
void get_disk_occupy(char ** reused);

int get_tzone(void);
int set_tzone(int tzone);
int set_time(struct tm *t, int tzone);
int set_utctime(time_t t);
int set_time_zone(struct tm *t, int tzone);
int set_utctime_zone(time_t t, int tzone);

time_t mktime0(void);
time_t mktime2(struct tm *t, int tzone);
int get_time_str(char *s, int len, time_t t);
int get_time_str2(char *s, int len, time_t t);
int get_curtime_str(char *s, int len);
int get_curtime_str2(char *s, int len);
int get_bldtime(char *buf, int len);
int get_bldtime2(char *dst, char *ori);
void print_time(char *s, struct tm *tm);
void print_utc(char *s, time_t t);

char* getUserNamebyToken(char* Token);
int is_process_running(const char *process_name);
bool CheckLoginStatus(char* Token);

// 辅助函数：判断是否是闰年  
int is_leap_year(int year);  
// 辅助函数：获取某月的天数  
int days_in_month(int year, int month);
// 函数：增加一天到日期  
void add_day_to_date(char *date_str, int *year, int *month, int *day);

void SetMenuAuthority(int RoleID);
void InitCellularManager();

#endif