SmartPDCode/f407/applications/datadef.h

#ifndef __DATADEF_Hx__
#define __DATADEF_Hx__

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


#define CH_MAX          12
#define BRD_MAX         32
#define SLAVE_CH_MAX    64

enum{
    A_P = 0,
    B_P = 1,
    C_P = 2,
};


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

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

enum {
    BOARD_TYPE_DC=0,
    BOARD_TYPE_AC,
    BOARD_TYPE_AC3,
};

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

enum {
    ALARM_V_UPPER     = (1<<2),
    ALARM_V_LOWER     = (1<<4),
    ALARM_C_UPPER     = (1<<6), 
    ALARM_W_UPPER     = (1<<8),
    ALARM_P_UPPER     = (1<<10),
};

enum {
    THRESHOLD_V_UPPER = (1<<0), //电压超上限
    THRESHOLD_V_LOWER = (1<<1), //电压超下限
    THRESHOLD_C_UPPER = (1<<2), //电流超上限
    THRESHOLD_P_UPPER = (1<<3), //功率超上限
    THRESHOLD_W_UPPER = (1<<4), //电能/耗电量超上限
};

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
{
    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     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;                   //通道延时
}product_data_t;

typedef struct {
    uint8_t             watchdog;
    int32_t             flip_time;
    uint8_t             led;
    uint8_t             beep;
    uint8_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 {
    modbus_data_t       cas;
    misc_data_t         misc;
    product_data_t      prod;
    service_data_t      serv;
    network_data_t      netwk;
}paras_data_t;

typedef struct {
    uint8_t             lang;
}sys_data_t;


typedef struct power_data{
    float               voltage;                //电压
    float               current;                //电流
    float               power;                  //功率
    float               freq;                   //频率
    float               consump;                //耗电量consumption
    float               factor;                 //功率因素

    uint8_t             status;                 //开关状态     
    uint8_t             nwire;                  //零线状态    
}power_t;

typedef union board_wanning{
    uint8_t             data[3];
}power_wanning_t;

typedef struct {
    uint8_t             en;
    float               val;                    //threashold value
    uint8_t             act;
    uint8_t             para[14];               //14*8=128 channels
}thr_val_t;
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_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;                //缺相
}alarm_t;
typedef struct {
    uint8_t             type;
    uint8_t             addr;
    uint8_t             ch;                      //该通道在全部板上的所排序号,程序始于0，用户始于1
    uint8_t             sch;                     //该通道在其所在的板上的序号,程序始于0，用户始于1
    uint8_t             pid;                     //phase id, 0:L1相 1:L2相 2:L3相
    
    uint16_t            start_delay;
    uint16_t            stop_delay;
}info_t;
typedef struct {
    info_t              info;
    power_t             power[3];                 //电力信息
    thr_t               thr;                      //阈值
    alarm_t             alarm;
    uint32_t            time;
}power_ch_t;

typedef struct {
    uint8_t (*get_elec_data)(power_ch_t *pch);
    uint8_t (*get_waning)(power_ch_t *pch);                          //参数后续补齐
    uint8_t (*open_chn)    (power_ch_t *pch);                        //参数后续补齐
    uint8_t (*close_chn)(power_ch_t *pch);                           //参数后续补齐
    uint8_t (*set_open_delay)(power_ch_t *pch);                      //参数后续补齐
    uint8_t (*set_close_delay)(power_ch_t *pch);                     //参数后续补齐
    uint8_t (*set_meter)(power_ch_t *pch);                           //参数后续补齐
    uint8_t (*over_func)(power_ch_t *pch);
    uint8_t (*reset_consumer)(power_ch_t *pch);

    uint8_t (*get_info)(uint8_t addr);
    uint8_t (*detect)(uint8_t addr);                                 //参数后续补齐
    uint8_t (*open_all)(uint8_t addr);                                
    uint8_t (*close_all)(uint8_t addr);
}board_fn_t;

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

typedef struct {
    uint8_t             chs;                    //所有控制板的总通道数
    power_ch_t          **pch;                  //动态指针
    
    uint8_t             cnt;
    board_data_t        *pbrd[BRD_MAX];
}board_all_t;

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

typedef struct {
    uint8_t             type;
    float               data;
    uint8_t             time;
}sensor_data_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[BRD_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[SLAVE_CH_MAX];
}slave_info_t;


typedef struct cascade_data{
    slave_info_t *c_s[BRD_MAX];                        //从机最多个数
}cascade_data_t;


typedef struct sensor_info{
    uint8_t     type;
    float       v[2];
}sensor_info_t;

typedef struct md_ac_dc{
    uint16_t          dev_cnt;                   //设备类型和通道数
    power_t           power[64];                 //最大64通道
    uint16_t          temp_hum;
    uint16_t          switch_stu[64];
    uint16_t          delay_open[64];
    uint16_t          delay_close[64];
    sensor_info_t     md_s[8];
    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[64];
    chn_phase_info_t    ac_3_chn_p[64][3];
    uint16_t            temp_hum;
    uint16_t            switch_chn[64];
    uint16_t            delay_open[64];
    uint16_t            delay_close[64];
    sensor_info_t       md_s[8];
    uint16_t            dry_node[4];
}md_3_ac_t;
typedef struct {
    sys_data_t          sys;
    
    board_all_t         ball;
    power_total_t       pttl;
}all_data_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                public[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             flag;
}sys_stat_t;

typedef struct {
    uint8_t             flag;
}mesg_data_t;

enum {
    PKT_TYPE_ACK=0,             
    PKT_TYPE_PARAS,             
    PKT_TYPE_POWER_CH,          //all_ch_t
    PKT_TYPE_POWER_TOTAL,       //power_total_t
    PKT_TYPE_SENSOR,
    PKT_TYPE_BREAKER,
    PKT_TYPE_STAT,
    PKT_TYPE_MESG,
    PKT_TYPE_FILE,
    
    PKT_TYPE_MAX
};

#define PKT_MAGIC  0xdeadbeef
typedef struct {
    uint32_t  magic;
    uint32_t  type;
    uint32_t  nack;
    uint32_t  dlen;
    uint8_t   data[0];
}pkt_hdr_t;












#pragma pack ()

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

#define CASCADE_MAX     32

#endif