SmartPDCode/ip/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_handle.h"
#include "language_common.h"
#include <sys/shm.h>
#include "cfg.h"


#define MAX_RELAY_CHN       100

#define  SURPPORT_OLD485                0

//是否在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 INTERL_MODBUS_PORT "/dev/ttyAS5"
#define INTERL_MODBUS_BAUD 115200
//表头级联通讯串口

// #define CASCADE_MODBUS_PORT     "/dev/ttyAS4"
// #define CASCADE_MODBUS_BAUD     115200
//传感器通信串口
// #define INTERL_SENSOR_MODBUS_PORT "/dev/ttyAS2"
// #define INTERL_SENSOR_MODBUS_BAUD 9600

//表头级联通讯串口

#define CASCADE_MODBUS_PORT     "/dev/ttyS5"
#define CASCADE_MODBUS_BAUD     115200
//传感器通信串口
#define INTERL_SENSOR_MODBUS_PORT "/dev/ttyS1"
#define INTERL_SENSOR_MODBUS_BAUD 9600

#define IMAGE_PATH          "image"
#define LOGO_FILE           "logo.png"
#define QRCODE_FILE         "qrcode.png"


#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 400
#define AC_MAX_CURRENT_VAL 100
#define AC_MAX_POWER_VAL 100

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_TEMPERATURE = 0 , //温度传感器
    SENSOR_TYPE_SMOKE       = 1 , //烟雾传感器
    SENSOR_TYPE_WATER       = 2 , //水浸传感器
    SENSOR_TYPE_DOOR        = 3 , //门禁传感器
    SENSOR_TYPE_GAS         = 4 , //气体传感器
    SENSOR_TYPE_AIR_PRESS   = 5 ,  //气体、气压传感器
    SENSOR_TYPE_DoubleT     = 7   //双头温度
};
enum
{
    SENSOR_VAL1_UPPER = 0,
    SENSOR_VAL1_LOWER = 1,
    SENSOR_VAL2_UPPER = 2,
    SENSOR_VAL2_LOWER = 3,

};

enum
{
    SENSOR_TYPE_VALUE = 0 , //传感器类型0、4、5
    SENSOR_TYPE_LIST =1     //传感器类型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 {
    WARNING_IP_V_UP         = 1,
    WARNING_IP_V_DOWN       = 2,
    WARNING_IP_I_UP         = 4,
    WARNING_IP_P_UP         = 8,
    WARNING_IP_C_UP         = 16,
};


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


///////////////////////////////////////////////////////////////////////////////////
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            product_modbus_type ;       //modbus模式
    unsigned int    product_modbus_baud ;       //波特率
    unsigned char   product_modbus_addr         ;//从Modbus地址信息
    char            product_relay_ctrl_port[32] ;//继电器modbus控制端口
}ModbusInfo_t;

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

typedef struct {
    int         watchdog;
    int         flip_time;
    int         led;
    int         beep;
    int         rotate;
}MiscInfo_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
{
    int             product_id                  ;//产品ID 
    char            product_number[16]          ;//产品编号    
    char            product_name[32]            ;//产品名称
    char            product_status[32]          ;//产品状态
    unsigned char   product_type                ;//产品类型
    unsigned char   product_pwr_type            ;//电源类型
    char            product_version[8]          ;//软件版本
    unsigned char   product_language            ;//多国语言
    unsigned char   product_count               ;//级联设备数
    unsigned short  product_samp_time           ;//采集周期 单位ms
    unsigned short  product_save_time           ;//采集周期 单位ms
    ModbusInfo_t    _modbus_info                ;//继电器控制端口
    NetworkInfo_t   _network_info ;             ;//网络信息
    ModbusInfo_t    _gmodbus_info               ;//级联端口    
    float           consumer                    ;  
    MiscInfo_t      misc;
}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;//湿度
} smartPDU_shm_data;

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//超限管理表
typedef struct
{
    char            product_vol_upper_enable                   ;//电压上限使能
    float           product_vol_upper_threshold                ;//电压上限值
    char            product_vol_over_upper_threshold_ctrl      ;//电压超限动作
    char            product_vol_over_upper_threshold_ctrl_para ;//电压超限关联参数
    char            product_vol_lower_enable                   ;//电压下限使能
    float           product_vol_lower_threshold                ;//电压下限值
    char            product_vol_over_lower_threshold_ctrl      ;//电压超限动作 
    char            product_vol_over_lower_threshold_ctrl_para ;//电压超限动作   
    char            product_cur_upper_enable                   ;//电流下限使能
    float           product_cur_upper_threshold                ;//电流下限值
    float           product_cur_lower_threshold;                //
    char            product_cur_over_upper_threshold_ctrl      ;//电流超限动作 
    char            product_cur_over_upper_threshold_ctrl_para ;//电流超限动作   
    char            product_pwr_upper_enable                   ;//功率上限使能
    float           product_pwr_upper_threshold                ;//功率上限值
    char            product_pwr_over_upper_threshold_ctrl      ;//功率超限动作 
    char            product_pwr_over_upper_threshold_ctrl_para ;//功率超限动作      
    char            product_pwrcon_upper_enable                ;//耗电量上限使能
    float           product_pwrcon_upper_threshold             ;//耗电量上限值
    char            product_pwrcon_over_upper_threshold_ctrl   ;//耗电量超限动作   
    char            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;
NTPManager _globalNTPManager;

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;
SNMPManager _globalSNMPManager;

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


//电源部分
typedef struct 
{
    float           voltage                                     ;//电压
    float           current                                     ;//电流
    float           power                                       ;//功率
    float           freq                                        ;//频率
    float           consumption                                 ;//耗电量
    float           factor                                      ;//功率因素    
    unsigned short  status                                      ;//开关状态     
    unsigned short  NF_status                                   ;//零线状态
    float           tempratue                                   ;
    float           humidity                                    ;
    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不输出
    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
    char                product_saddr                              ;//modbus地址记录                       
    char                product_ch_id                              ;//通道号
    char                product_ch_addr                            ;//通道号实际地址
    char                product_ch_name[32]                        ;//通道名称
    char                product_ch_type                            ;//通道类型
    char                product_ch_status                          ;//通道状态
    char                product_ch_NF_status                          ;//通道零线状态（三相）
    unsigned short      product_ch_start_delay                     ;//通道延时 
    unsigned short      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
{
    bool                sensor_val1_upper_enabled ;//
    float               sensor_val1_upper_threshold;
    char                sensor_val1_upper_threshold_ctrl;
    char                sensor_val1_upper_threshold_ctrl_para[512];
    bool                sensor_val1_lower_enabled ;//
    float               sensor_val1_lower_threshold;
    char                sensor_val1_lower_threshold_ctrl;
    char                sensor_val1_lower_threshold_ctrl_para[512];
    bool                sensor_val2_upper_enabled ;//
    float               sensor_val2_upper_threshold;
    char                sensor_val2_upper_threshold_ctrl;
    char                sensor_val2_upper_threshold_ctrl_para[512];
    bool                sensor_val2_lower_enabled ;//
    float               sensor_val2_lower_threshold;
    char                sensor_val2_lower_threshold_ctrl;
    char                sensor_val2_lower_threshold_ctrl_para[512];
}GlobalSensorOverManage;

//传感器报警状态表
typedef struct
{   
    bool                sensor_val1_upper;
    bool                sensor_val1_lower;
    bool                sensor_val2_upper;
    bool                sensor_val2_lower;
}GlobalSensorOverInfo;
//传感器管理总表
typedef struct 
{
    int                 product_id                                 ;//产品ID    
    char                sensor_id                                  ;//传感器ID
    char                sensor_type                                ;//传感器类型
    char                sensor_interface_type;                     //接口类型
    char                sensor_name[64]                            ;//传感器名称
    char                sensor_port_name[32]                       ;//传感器端口号
    int                 sensor_baud                                ;//波特率
    char                sensor_addr                                ;//modbus地址
    int                sensor_status                              ;//传感器状态
    char                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;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

//SMTP管理
typedef struct
{
    int                 idx;
    int                 use;
    char                account[64];
}smtp_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];    			        //认证方式  
}smtp_send_t;
typedef struct
{
    smtp_send_t         send;

    #define SMTP_RECV_MAX  10
    smtp_recv_t         recv[SMTP_RECV_MAX];      //接收账号列表
}smtp_info_t;

typedef struct {
    int                 id;    		                    //id
    int                 mode;    				        //0: open   1: close
    char                server[512];                    //server
    char                ip[48]; 		                //server ip
    char                port[10]; 			            //server port
    char                cid[32];    		            //client ID
    char                user[32];    			        //认证方式  
    char                password[32];
}mqtt_server_t;
typedef struct {
    #define MQTT_SERV_MAX   10
    mqtt_server_t       serv[MQTT_SERV_MAX];
}mqtt_info_t;

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

}UserInfo;

typedef struct 
{
    int                 product_id;
    int                 roleID;    				//角色ID
    char*               roleName;               //角色名称
    int                 roleLevel; 		        //角色等级
    char*               roleAuthority; 			//角色权限
    int                 roleSort;    		    //显示顺序
    char*               createTime;             //创建时间     
    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;
    //7、服务管理菜单
    bool SmtpszEnabled;
    bool SnmpszEnabled;
    bool MqszEnabled;
    bool NtpszEnabled;
    bool DsszEnabled;
    bool SxszEnabled;
    bool FzszEnabled;
     //8、设备维护菜单
    bool SbcqEnabled;
    bool GjsjEnabled;
    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;

#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];
    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;

#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];
    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 case_ip_485_data{
    uint16_t saddr;
    uint16_t status;
    uint16_t temprature;
    uint16_t humidity;
    uint16_t temprature_status;
    uint32_t voltage;
    uint32_t current;
    uint32_t power;
    uint32_t consumer;
    uint32_t factor;
    uint32_t freq;
    //uint32_t angle;
    
}case_ip_485_data_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;

typedef struct {
    uint16_t waning;
}case_ip_wanning_t;

typedef struct cascade_ip_mmap{
    uint16_t dev_chn;
    uint16_t mac[6];
    case_ip_485_data_t data[32];
    case_ip_wanning_t  waning[32];
}cascade_ip_mmap_t;


#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 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; //重新加载端口数据
    GlobalPowerCtrlBoard _all_ctrl_board[MAX_CHN_COUNT]; //所有控制板
    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;
    cascade_ip_mmap_t * mmp;
    smtp_info_t          smtpInfo;
    mqtt_info_t          mqttInfo;
    Modbus_Manger_Tcp *md_tcp;
}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;

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 set_zone(int zone);
int set_time(struct tm *t, int zone);
int set_utctime(time_t t);
int set_time_zone(struct tm *t, int zone);
int set_utctime_zone(time_t t, int zone);

time_t mktime0(void);
time_t mktime2(struct tm *t, int zone);
int get_time_str(char *s, int len, time_t t);
int get_time_str2(char *s, int len, time_t t);
int get_bldtime(char *buf, int len);
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);

#endif