SmartPDCode/f407/applications/datadef.h

#ifndef __DATADEF_Hx__
#define __DATADEF_Hx__

#include <stdint.h>
#include "log.h"

#define POWER_CH_MAX                12
#define POWER_BOARD_MAX             32
#define POWER_BOARD_TIMEOUT         200
#define POWER_RETRY_TIMES           3
#define POWER_SLAVE_CH_MAX          32
#define POWER_CASCADE_MAX           32

#define BREAKER_BOARD_MAX           8
#define BREAKER_CH_MAX              6
#define BREAKER_BOARD_ADDR_START    64

enum {
    RW_READ=0,                                 //读
    RW_WRITE                                   //写
};
enum{
	A_P = 0,
	B_P,
	C_P,
};

enum {
    TIME_ABS=0,                                 //绝对时间
    TIME_REL                                    //相对时间
};
enum {
    LOOP_HOUR=0,
    LOOP_DAY,
    LOOP_WEEK,
    LOOP_MONTH,
    LOOP_YEAR,
    
    LOOP_USER
};

enum {
    PDU_AC_I1O1=0,
    PDU_DC_I1O1,
    PDU_AC_I3O3=3,
    PDU_AC_I3O1,
    PDU_AC_I3O1_H,
};

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

enum {
    ALARM_V_UPPER=0,
    ALARM_V_LOWER,
    ALARM_C_UPPER, 
    ALARM_W_UPPER,
    ALARM_P_UPPER,
    ALARM_PH_LOSS,
    
    ALARM_MAX
};

enum {
    ALARM_ACT_CLOSE_CH=1,
    ALARM_ACT_MESG,
    ALARM_ACT_CLOSE_CHALL,
};

enum {
    IP_MODE_DHCP=0,
    IP_MODE_STATIC,
};
enum {
    IP_VER_ERR=0,
    IP_VER_V4,
    IP_VER_V6,
};
enum {
    MODBUS_MASTER=0,
    MODBUS_SLAVE,
};
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
};
enum
{
    SENSOR_TYPE_TEMP_HUMI=0,    //温湿度传感器
    SENSOR_TYPE_SMOKE,          //烟雾传感器
    SENSOR_TYPE_WATER,          //水浸传感器
    SENSOR_TYPE_ACCESS,         //门禁传感器
    SENSOR_TYPE_GAS,            //气体传感器
    SENSOR_TYPE_AIR_PRESS,      //气压传感器
    SENSOR_TYPE_AIR_COND,       //空条传感器
    SENSOR_TYPE_LEAK,           //泄漏传感器
    SENSOR_TYPE_TEMP,           //温度传感器
    SENSOR_TYPE_TEMP_DOUBLE,    //双温度传感器
    SENSOR_TYPE_PRESS,          //压力传感器

    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 {
    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
};
////////////////////////////////////////////////
#pragma pack (1)

typedef struct {
    uint16_t     year;
    uint8_t      mon;
    uint8_t      day;
    uint8_t      hour;
    uint8_t      min;
    uint8_t      sec;
}datetime_t;

typedef struct {
    uint8_t             mode;
    uint8_t             addr;               
    uint32_t            baud;
}modbus_data_t;

typedef struct {
    uint8_t     mode;               //0:DHCP  1:STATIC  
    char        ipaddr[48];         //
    char        mask[48];           //
    char        gateway[48];        //
    char        dns1[48];           //dns1
    char        dns2[48];           //dns2
}network_data_t;

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     count;                      //级联设备数
    uint32_t    samp_time;                  //采集周期 单位ms
    uint32_t    save_time;                  //采集周期 单位ms

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

typedef struct {
    uint8_t             watchdog;
    int32_t             flip_time;
    uint8_t             led;
    uint8_t             beep;
    uint16_t            rotate;
}misc_data_t;

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

typedef struct {
    uint32_t            id[3];
    uint32_t            chs;
    uint32_t            time;
    char                ver[12];
}board_info_t;
typedef struct {
    uint8_t type;
    uint8_t chs;
}board_key_t;

typedef struct {
    char                ver[16];
    char                bldtime[32];
}version_data_t;
typedef struct {
    uint8_t             lang;
    int8_t              tzone;
}system_data_t;


typedef struct {
	uint32_t th_max_1;
	uint32_t th_min_1;
	uint32_t th_max_2;
	uint32_t th_min_2;
}sensor_th_t;


typedef struct {
    system_data_t       sys;
    version_data_t      ver;
    modbus_data_t       cas;
    misc_data_t         misc;
    product_data_t      prod;
    service_data_t      serv;
    network_data_t      netwk;
		sensor_th_t      sensor[3];
}paras_data_t;

typedef struct {
//    float               voltage;                //电压
//    float               current;                //电流
//    float               power;                  //功率(视在)
//    float               freq;                   //频率
//    float               factor;                 //功率因数
//    float               consump;                //耗电量consumption

//    float               active;                 //有功功率
//    float               reactive;               //无功功率
//    uint8_t             ph_out;                 //三相输出时，用于判断该相是否有输出
//    
//    uint8_t             status;                 //开关状态     
//    uint8_t             nwire;                  //零线状态  
			uint16_t 					 voltage;															// 电压			保留1位小数，单位V
			uint16_t           current;															// 电流			保留1位小数，单位A
			uint32_t             power;															// 功率			保留3位小数，单位W,最大值65535W
			uint16_t 							freq;															// 频率			保留1位小数，单位Hz
			uint8_t 						factor;															// 因素			保留2位小数，单位fa
			


			uint32_t           consump;														// 耗电量   保留3位小数，单位kWh	
//			uint8_t             status;
//			uint8_t             nwire;
}power_t;


//designed by liyi
typedef struct
{
	uint16_t freq;																	// 频率			保留1位小数，单位Hz
	uint8_t factor;																// 因素			保留1位小数，单位fa
	uint16_t voltage;															// 电压			保留1位小数，单位V
	uint16_t current;															// 电流			保留1位小数，单位A
	uint32_t power;																// 功率			保留0位小数，单位W,最大值65535W
	uint32_t consumer;														// 耗电量   保留2位小数，单位kWh
}n_power_t;																		  // 16字节   相比于power_t 节约内存，20字节

typedef struct{
	uint16_t v_upper;
	uint16_t v_lower;
	uint16_t c_upper;
	uint32_t p_upper;
	uint32_t w_upper;
}n_thr_t;																	//相对于thr_t节约内存 17字节

typedef struct{
	uint8_t           en;
	n_thr_t 					thr[3];
	uint8_t        		para[14];
}total_thr_t;															//总阈值		


typedef struct{
	uint16_t v_upper				 :			1;						//电压超上限
	uint16_t v_lower    		 :      1;						//电压超下限
	uint16_t c_upper    		 :      1;						//电流超上限
	uint16_t p_upper    		 :      1;						//功率超上限
	uint16_t w_upper    		 :      1;						//耗电量超上限
	uint16_t 								 :			3;						//预留 
	uint16_t ph_1_lose    	 :      1;						//缺相L1用于输入端
	uint16_t ph_2_lose       :    	1;						//缺相L2用于输入端
	uint16_t ph_3_lose       :    	1;						//缺相L3用于输入端
	uint16_t                 :      5;            //预留
}n_alarm_t;																			//告警节约5字节

typedef struct{
	char 								 name[16];									//通道信息数据;
	uint8_t             		type;
  uint8_t             		addr;
  uint8_t             			ch;										//表头id
	uint8_t             		 sch;								  	//在控制板上的通道;
	uint8_t                 ph_id;							    //相信息
	uint8_t                status;
	uint8_t                ph_val;
  uint8_t            open_delay;									//开延时 单位s
  uint8_t           close_delay;									//关延时 单位s
}n_info_t;																				//节约20字节






//designed over by liyi

typedef struct {
	uint8_t    th_sen_max_en  :  1;
	uint8_t    th_sen_min_en  :  1;
	uint8_t    :                 6;
}th_sen_t;






typedef struct {
    th_sen_t             en;
    float               max;                    //threashold max  value
		float               min;										//
    uint8_t             act;
    uint8_t             para[14];               //14*8=128 channels
}thr_val_t;

typedef struct {
	uint16_t       v_upper_en:1;
	uint16_t       v_lower_en:1;
	uint16_t       c_upper_en:1;
	uint16_t       p_upper_en:1;
	uint16_t       w_upper_en:1;
//	uint16_t       :          11; 
}thr_en;


typedef struct {
//    thr_val_t           v_upper;
//    thr_val_t           v_lower;
//    thr_val_t           c_upper;                //current
//    thr_val_t           p_upper;
//    thr_val_t           w_upper;                //power consumption
			thr_en 									 en;
			uint16_t 						v_upper;
			uint16_t 						v_lower;
			uint16_t 						c_upper;
			uint32_t 						p_upper;
			uint32_t 						w_upper;
}thr_t;

typedef struct {
//    uint8_t             v_upper;                //电压超上限
//    uint8_t             v_lower;                //电压超下限
//    uint8_t             c_upper;                //电流超上限
//    uint8_t             p_upper;                //功率超上限
//    uint8_t             w_upper;                //耗电量超上限
//    
//    uint8_t             ph_loss;                //缺相,0,1,2位分别代表L1,L2,L3相，相应位为1则代表缺相，为0则不缺
	uint16_t v_upper				 :			1;						//电压超上限
	uint16_t v_lower    		 :      1;						//电压超下限
	uint16_t c_upper    		 :      1;						//电流超上限
	uint16_t p_upper    		 :      1;						//功率超上限
	uint16_t w_upper    		 :      1;						//耗电量超上限
	uint16_t 								 :			3;						//预留 
	uint16_t ph_1_lose    	 :      1;						//缺相L1用于输入端
	uint16_t ph_2_lose       :    	1;						//缺相L2用于输入端
	uint16_t ph_3_lose       :    	1;						//缺相L3用于输入端
	uint16_t                 :      5;            //预留
}alarm_t;
typedef struct {
    uint8_t             ch;
    alarm_t             alarm;
    uint32_t            time;
}alarm_data_t;

typedef struct {
    char                name[16];
    uint8_t             type;
    uint8_t             addr;
    uint8_t             ch;                      //该通道在全部板上的所排序号,程序始于0，用户始于1
    uint8_t             sch;                     //该通道在其所在的板上的序号,程序始于0，用户始于1
    uint8_t             ph_id;                   //phase id, 0:L1相 1:L2相 2:L3相
    
    uint8_t             ph_val;                  //三相输出设置，0:单相  1:三相
    uint8_t            open_delay;
    uint8_t            close_delay;
}info_t;
typedef struct {
    info_t              info;
    power_t             power[3];                 //电力信息
    thr_t               thr;                      //阈值
    alarm_t             alarm;
		uint8_t             status;
		uint8_t             nwire;
    //uint32_t            time;
    void                *pbrd;
}power_ch_t;

typedef struct {
    char                name[16];
    uint8_t             addr;
}breaker_info_t;
typedef struct {
    uint8_t             id;                     //breaker id
    uint8_t             nid;                    //node id
    uint8_t             sw;
    uint32_t            time;
}breaker_samp_t;
typedef struct {
    breaker_info_t      info;
    breaker_samp_t      samp;
}breaker_data_t;
typedef struct {
    uint8_t             cnt;
    breaker_data_t      *data;
}breaker_all_t;

typedef struct {
    int (*get_power)(power_ch_t *pch);
    int (*get_alarm)(power_ch_t *pch);
    int (*set_ch)(power_ch_t *pch);
    int (*set_open_delay)(power_ch_t *pch);
    int (*set_close_delay)(power_ch_t *pch);
    int (*set_kb_value)(power_ch_t *pch);
    int (*set_threshold)(power_ch_t *pch);
    int (*reset_consump)(power_ch_t *pch);

    int (*detect)(uint8_t addr);
    int (*get_info)(uint8_t addr, board_info_t *info);
    //int (*get_board)(board_data_t *pbrd);
    int (*set_board)(uint8_t addr, uint8_t on);
    int (*set_all)(uint8_t on);
}board_fn_t;

typedef struct {
    board_fn_t          fn;
    uint8_t             type;
    uint8_t             addr;
    uint8_t             chs;
    uint8_t             sw;                     //开关监测状态
    uint8_t             ch0;                    //board ch start
    uint8_t             ph_loss;
    board_info_t        info;
    breaker_data_t      brk[2];
    power_ch_t          *pch;                   //根据实际通道数申请连续内存
}board_data_t;

typedef struct {
    float               voltage;                //电压
    float               current;                //电流
    float               power;                  //视在功率
    float               freq;                   //频率
    float               factor;                 //功率因数
    float               consump;                //耗电量
    
    float               active;                 //有功功率
    float               reactive;               //无功功率
}total_t;
typedef struct {
    uint8_t             type;
    total_t             total[3];
}power_total_t;

typedef struct {
    uint8_t             chs;                    //所有控制板的总通道数
    power_ch_t          *pch;
    power_total_t       ttl;
}power_all_t;

typedef struct {
    char                name[32];
    uint8_t             type;
    uint8_t             addr;
		uint8_t      				num_val;
		uint8_t             status;
		uint8_t             check_count;
}sensor_info_t;

typedef struct {
	uint8_t    max_up : 1;
	uint8_t    min_down  :1;
}sensor_alarm_t;


typedef struct {
    thr_val_t           thr;
		sensor_alarm_t     s_alarm;
    float               value;
}sensor_val_t;




typedef struct {
    sensor_info_t       info;
    sensor_val_t        val[2];
    //uint32_t            time;
}sensor_data_t;
typedef struct {
    uint8_t             cnt;
    uint8_t             max;
    sensor_data_t       *data;
}sensor_all_t;

typedef struct {
    uint8_t             type;
    uint32_t            str_id;
    uint32_t            sep_id;
    uint32_t            time;
}alarm_msg_t;

typedef struct {
    uint32_t            brd[POWER_BOARD_MAX];
    
    uint8_t             time_mode;              //绝对时间/相对时间
    uint32_t            time_s;                 //起始时间, 单位: 秒
    uint32_t            time_inv;               //间隔时间, 单位: 秒
    
    int8_t              loop_mode;              //按日/周/月/年
    int32_t             loop_times;             //循环次数, 负值为无限循环
}schedule_data_t;

typedef struct cascade_saddr{
    uint8_t      addr;
    uint16_t     channels;
    //board_fn_t   *fn;
    power_ch_t   ch[POWER_SLAVE_CH_MAX];
}slave_info_t;


//////////////////////////////
typedef struct 
{
    uint8_t             userID;                 //用户ID
    char                name[32];               //用户名-登录
    char                password[32];           //用户密码
    char                nick[32];               //用户名称
    uint8_t             roleID;                 //角色ID
    uint32_t            time;                   //用户创建时间     
}user_data_t;
typedef struct 
{
    uint8_t             roleID;                 //角色ID
    char                roleName[32];           //角色名称
    uint8_t             roleLevel;              //角色等级
    char                auth[32];               //角色权限
    int                 roleSort;               //显示顺序
    uint32_t            time;                   //创建时间
}role_data_t;

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 {
    uint8_t             mode;
    uint8_t             version;
    char                publics[64];
    uint8_t             trapmode;

    crypt_t             crypt;
    char                nms_ip[64];
}snmp_data_t;

typedef struct
{
    int                 id;
    int                 use;
    char                account[64];
}mail_recv_t;
typedef struct 
{
    uint8_t             id;
    uint8_t             mode;                           //0: open   1: close
    char                account[64];                    //用户账号
    char                password[24];                   //用户密码
    char                server[64];                     //服务器
    char                port[10];                       //端口
    char                auth[16];                       //认证方式  
    char                *ca;                            //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 {
    uint8_t             id;                              //id
    uint8_t             plat;                            //0: emqx   1: aliyun
    uint8_t             mode;                            //0: open   1: close
    char                proto[16];                       //mqtt, mqtts, ws, wss
    char                name[32];                        //server name
    char                server[256];                     //server ip
    char                port[10];                        //server port
    char                cid[64];                         //client ID
    char                user[32];                        //
    char                password[32];
    char                *cert;
    uint8_t             status;
}mqtt_server_t;
typedef struct {
    #define MQTT_SER_MAX   5
    mqtt_server_t       ser[MQTT_SER_MAX];
}mqtt_info_t;

typedef struct {
    uint8_t             type;
    char                *content;
    uint32_t            time;
}log_data_t;
///////////////////////////////////////////////////////////
typedef struct ac_dc_out{
	uint32_t voltage;
	uint32_t current;
	uint32_t power;
	uint32_t freq;
	uint32_t consumer;
	uint32_t factor;
}ac_dc_out_t;

typedef struct ac_dc_in{
	uint32_t all_voltage;
	uint32_t all_current;
	uint32_t all_power;
	uint32_t all_consumer;
}ac_dc_in_t;

typedef struct md_ac_dc{
    uint16_t          dev_cnt;                   //设备类型和通道数
    ac_dc_out_t       power[POWER_SLAVE_CH_MAX];                 //最大64通道
    ac_dc_in_t        power_all;
    uint16_t          temp;
    uint16_t          humity;
    uint16_t          switch_stu[POWER_SLAVE_CH_MAX];
    uint16_t          delay_open[POWER_SLAVE_CH_MAX];
    uint16_t          delay_close[POWER_SLAVE_CH_MAX];
    sensor_info_t     md_s[4];
    //uint16_t          dry_node[4]; 
}md_ac_dc_t;

typedef struct all_info{
    uint32_t voltage;
    uint32_t current;
    uint32_t power;
    uint32_t consumer;
}all_info_t;

typedef struct {
    uint32_t power;
    uint32_t freq;
    uint32_t consumer;
    uint16_t fac;
    uint32_t out_type;
}all_chn_info_t;

typedef struct chn_phase_info{
    uint32_t p_voltage;
    uint32_t p_current;
    uint32_t p_power;
    uint32_t p_consumer;
    uint32_t p_status;
}chn_phase_info_t;

typedef struct md_3_ac{
    uint16_t            dev_cnt;                                        //设备类型和通道数
    all_info_t          ac_3_all_pw[3];
    all_chn_info_t      ac_3_all_chn[POWER_SLAVE_CH_MAX];
    chn_phase_info_t    ac_3_chn_p[POWER_SLAVE_CH_MAX][3];
    uint16_t            temp;
    uint16_t            humity;
    uint16_t            switch_chn[POWER_SLAVE_CH_MAX];
    uint16_t            delay_open[POWER_SLAVE_CH_MAX];
    uint16_t            delay_close[POWER_SLAVE_CH_MAX];
    sensor_info_t       md_s[4];
    //uint16_t            dry_node[4];
}md_3_ac_t;

typedef struct cascade_data{
    uint8_t         chs;                    //从机读取通道数
    power_ch_t      *pch;
}cascade_data_t;
///////////////////////////////////////////////////////////

typedef struct {
    uint8_t             flag;
}sys_stat_t;

typedef struct {
    uint8_t             flag;
}mesg_data_t;

typedef struct {
    uint8_t             cnt;
    uint8_t             addr[POWER_CASCADE_MAX];
}slave_list_t;


enum {
    PKT_TYPE_ACK=0,    
    PKT_TYPE_PARAS,             
    PKT_TYPE_POWER_CH,          //power_ch_t
    PKT_TYPE_POWER_TOTAL,       //power_total_t
    PKT_TYPE_POWER_RESET,
    PKT_TYPE_CH_ALL,
    PKT_TYPE_SCAN,
    PKT_TYPE_FACTORY,
    PKT_TYPE_ALARM,
    PKT_TYPE_SENSOR,
    PKT_TYPE_BREAKER,
    PKT_TYPE_STAT,
    PKT_TYPE_MESG,
    PKT_TYPE_FILE,
    PKT_TYPE_SLAVE_LIST,        //slave addr list
    
    PKT_TYPE_MAX
};

enum {
    SUB_TYPE_POWER_SWITCH=0,            //set relay switch
    SUB_TYPE_POWER_ALARM,
    SUB_TYPE_POWER_THRESHOLD,
    SUB_TYPE_POWER_OPEN_DELAY,
    SUB_TYPE_POWER_CLOSE_DELAY,
    
    SUB_TYPE_PARAS_SYS,
    SUB_TYPE_PARAS_MODBUS,
    SUB_TYPE_PARAS_MISC,
    SUB_TYPE_PARAS_PROD,
    SUB_TYPE_PARAS_SERV,
    SUB_TYPE_PARAS_NETWORK,
    
    SUB_TYPE_MAX
};

#define PKT_MAGIC  0xdead
typedef struct {
    uint16_t  magic;
    uint8_t   addr;
    uint8_t   type;
    uint8_t   subtype;
    uint8_t   nack;
    uint32_t  flag;
    uint32_t  dlen;
    uint8_t   data[0];
}pkt_hdr_t;

#pragma pack ()

#define CONCAT(a,b)     a b
#define SD_DEV          "sd"
#define NOR_DEV         "nor"

#define ROOT_PATH       "/"
#define SD_PATH         CONCAT(ROOT_PATH,SD_DEV)
#define NOR_PATH        CONCAT(ROOT_PATH,NOR_DEV)

#define DB_NAME         "smartPDU"
#define INI_NAME        "smartPDU.ini"
#define INF_NAME        "PDUInfo.txt"

#if 1
#define DB_PATH         SD_PATH
#define CFG_PATH        NOR_PATH
#else
#define DB_PATH         ROOT_PATH
#define CFG_PATH        ROOT_PATH
#endif


#endif