frame.h

Go to the documentation of this file.

 
#ifndef ARES_SERIAL_FRAME_H
#define ARES_SERIAL_FRAME_H
 
#include <zephyr/kernel.h>

#define ARES_FRAME_HEADER '^'

#define ARES_FRAME_FOOTER '@'

#define ARES_FRAME_HEADER_OVERHEAD UINT32_C(1)

#define ARES_FRAME_TYPE_OVERHEAD UINT32_C(1)

#define ARES_FRAME_LEN_OVERHEAD UINT32_C(2)

#define ARES_FRAME_FOOTER_OVERHEAD UINT32_C(1)

#define ARES_FRAME_OVERHEAD                                                    \
    (uint64_t)(ARES_FRAME_HEADER_OVERHEAD + ARES_FRAME_TYPE_OVERHEAD +         \
               ARES_FRAME_LEN_OVERHEAD + ARES_FRAME_FOOTER_OVERHEAD)

enum ares_frame_error {
    ARES_FRAME_ERROR_BAD_FRAME = 0, 
    ARES_FRAME_ERROR_BAD_TYPE = 1,  
    ARES_FRAME_ERROR_NOT_IMPLEMENTED = 2, 
};

enum ares_frame_type {
    ARES_FRAME_SETTING,       
    ARES_FRAME_START,         
    ARES_FRAME_LORA_CONFIG,   
    ARES_FRAME_LED,           
    ARES_FRAME_HEARTBEAT,     
    ARES_FRAME_CLAIM,         
    ARES_FRAME_LOG,           
    ARES_FRAME_LOG_ACK,       
    ARES_FRAME_VERSION,       
    ARES_FRAME_ACK,           
    ARES_FRAME_FRAMING_ERROR, 
    ARES_FRAME_DBG,           
    ARES_FRAME_PKT_RX,        
    ARES_FRAME_PKT_TX,        
 
    ARES_FRAME_TYPE_INVALID, 
};

struct ares_frame {
    enum ares_frame_type type;

    union {
        struct {
            uint16_t setting;
            uint32_t value;
            bool set;
        } SETTING; 
 
        struct {
            int64_t sec;
            uint64_t ns;
            uint16_t id;
            uint16_t packet_id;
            bool broadcast;
            uint8_t seq_cnt;
        } START; 
 
        struct {
            uint32_t freq_hz;
            uint16_t preamble_len;
            uint8_t bandwidth;
            uint8_t data_rate;
            uint8_t coding_rate;
            int8_t tx_pow_dbm;
            uint8_t cad_mode;
            uint8_t cad_symbol_num;
            uint8_t cad_detection_peak;
            uint8_t cad_detection_min;
        } LORA_CONFIG; 
 
        struct {
            struct {
                uint8_t ready : 1;
                uint8_t broadcast : 1;
                uint8_t padding : 6;
            } flags;
            uint8_t tx_count;
            uint16_t id;
        } HEARTBEAT; 
 
        struct {
            uint8_t led;
            uint8_t state;
        } LED; 
 
        uint16_t CLAIM; 
 
        struct {
            bool broadcast;
            uint8_t tx_cnt;
            uint8_t part;
            uint8_t num_parts;
            uint16_t id;
            uint16_t log_id;
            size_t msg_len;
            const char *msg; // This must remain valid for
                             // the lifetime of the frame.
        } LOG;               
 
        struct {
            uint8_t part;
            uint8_t num_parts;
            uint16_t id;
            uint16_t log_id;
        } LOG_ACK; 
 
        struct {
            uint32_t app;
            uint32_t ncs;
            uint32_t kernel;
        } VERSION; 
 
        int ACK; 
 
        enum ares_frame_error FRAMING_ERROR; 
 
        int DBG; 
 
        struct {
            uint16_t packet_id;
            uint16_t src_id;
            uint8_t seq_cnt;
        } PKT_RX; 
 
        uint32_t PKT_TX; 
    } payload;
};

struct ares_frame_info {
    int start_index;

    int frame_size;

    int bytes_left;
};

int ares_serialize_frame(uint8_t *buf, size_t len,
                         const struct ares_frame *frame);

int ares_deserialize_frame(struct ares_frame *frame, const uint8_t *buf,
                           size_t len);

int ares_serial_frame_present(const uint8_t *buf, size_t len,
                              struct ares_frame_info *info);

bool ares_check_if_frame(const uint8_t *buf, size_t len);
 
#endif // ARES_SERIAL_FRAME_H