SmartPDCode/pro/src/cascade.h

#ifndef __CASCADE_Hx__
#define __CASCADE_Hx__

#include <stdint.h>
#include "common.h"
#include "json_handle.h"

#define CASCADE_MAX                     10//32
#define ERR_MAX                         5

#define MAX_READ_REGS                   1000
#define MAX_WRITE_REGS                  1000

#define MAX_READ_REGS2                  50000
#define MAX_WRITE_REGS2                 50000


#define CASCADE_REG_OFFSET              0x10
#define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0x00)
#define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+0x01)

enum {
    CASCADE_CMD_OPEN=0,
    CASCADE_CMD_CLOSE,
    CASCADE_CMD_SAVE,
    CASCADE_CMD_SAVE3,
    CASCADE_CMD_GET_INFO,

    CASCADE_CMD_QUERY_CH,
    CASCADE_CMD_QUERY_VOL,
    CASCADE_CMD_QUERY_CUR,
    CASCADE_CMD_QUERY_PWR,
    CASCADE_CMD_QUERY_PWRQ,
    CASCADE_CMD_QUERY_HIS,
    CASCADE_CMD_QUERY_TOTAL,
    CASCADE_CMD_QUERY_TOTAL_PWR,

    CASCADE_CMD_MAX,
};

#pragma pack (1)

typedef struct {
    int       addr;
    int       err;      //err times
}slave_t;

typedef struct {
    slave_t   *slave;
    int       cnt;
}dev_list_t;

typedef struct {
    uint16_t deveice_type;          //设备类型
    uint16_t slave_addr;            //设备地址
    uint32_t voltage;               //当前电压
    uint32_t current;               //当前电流
    uint32_t power;                 //当前功率
    uint32_t consumption;           //耗电量
    uint32_t freq;                  //频率
    uint32_t factor;                //功率因素
    uint32_t temprature;            //温度值
    uint32_t humidity;              //湿度值
    uint32_t warning;               //告警
    uint16_t power_status;          //供电状态
    uint16_t sensor_status;         //传感器状态

    //uint32_t Warinfo;
    //uint16_t sersor_type;
}sensor_ori_t;

typedef struct {
    int   type;                  //设备类型
    int   addr;

    PowerInfo pwr;

    float temprature;            //温度值
    float humidity;              //湿度值
    float warning;               //告警
    int   power_status;          //供电状态
    int   sensor_status;         //传感器状态
}sensor_data_t;


enum {
    TYPE_CMD=0,
    TYPE_FILE,
};

enum {
    OBJ_OVERALL=0,
    OBJ_CHANNEL,
    OBJ_HISTORY,
    OBJ_SENSOR,
};

typedef struct {
    int             dlen;
    uint8_t         *data;           
}data_t;

typedef struct {
    struct {
        uint8_t     addr;
        uint8_t     ch_addr;
        uint8_t     type;
    }board[128];
    uint8_t         cnt;
}board_info_t;


typedef struct {
    uint8_t        cnt;
    PowerInfo      *info;
}power_info_t;


typedef struct {
    uint8_t         cmd;
    uint8_t         obj;
    uint8_t         chId;
    char            time_s[24];   //start time
    char            time_e[24];   //end time
}cmd_data_t;

typedef struct {
    uint8_t         tp;
    uint16_t        pid;
    uint16_t        dlen;
    uint8_t         *data;
}file_data_t;

typedef struct {
    int8_t          type;
    uint8_t         data[0];
}mb_pkt_t;

typedef struct {
    uint8_t         addr;
    uint8_t         func;
    uint16_t        reg;
    uint16_t        regcnt;
    uint8_t         dlen;
    uint8_t         *data;
}mb_hdr_t;

#pragma pack ()

////////slave define////////////////////
typedef struct mmap_modbus{
    int offset;
    void *addr;             //libmodbus source   addr 
}mmap_modbus_t;
//////////////////////////////////////

typedef struct {
    
    int                 inited;
    pthread_mutex_t     mutex;          //used for list lock     
    
    Modbus_Manger       m;
    int                 addr;
    slave_t             slaves[CASCADE_MAX+1];

    modbus_mapping_t    *map;
    modbus_mapping_t    *map2;

    cmd_data_t          cmd;
    int                 scanAddr;

    board_info_t        info;
    _OverChnPwrAckInfo  chInfo;
    _OverAllPwrAckInfo  allInfo;

    power_info_t        pwrInfo;
}cascade_handle_t;


extern int cur_dev_addr;

int cascade_init(void);
int cascade_reinit(void);
int cascade_request(cmd_data_t *cmd);

int cascade_get_dlist(dev_list_t *dl);
int cascade_free_dlist(dev_list_t *dl);

int cascade_lock(void);
int cascade_unlock(void);

int cascade_slave_map_init(cascade_handle_t *cas);
void cascade_slave_read(cascade_handle_t *cas, uint32_t addr,uint32_t lenth);
void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val);


#endif