/********************************************************************************************************* * ------------------------------------------------------------------------------------------------------ * file description * ------------------------------------------------------------------------------------------------------ * \file slup.h * \unit slup * \brief This is a simple serial link universal protocol for C language * \author Lamdonn * \version v0.1.0 * \license GPL-2.0 * \copyright Copyright (C) 2023 Lamdonn. ********************************************************************************************************/ #ifndef __slup_H #define __slup_H #include #include #include #include /* Version infomation */ #define SLUP_V_MAJOR 0 #define SLUP_V_MINOR 1 #define SLUP_V_PATCH 0 // Maximum size of the head part in the SLUP structure, set to 4 bytes. #define SLUP_HEAD_MAX 4 // Maximum size of the tail part in the SLUP structure, set to 4 bytes. #define SLUP_TAIL_MAX 4 // Maximum size of the check code part in the SLUP structure, set to 4 bytes. #define SLUP_CHECK_MAX 4 // Maximum size of the sequence number (SN) part in the SLUP structure, set to 4 bytes. #define SLUP_SN_MAX 4 // Maximum size of the frame in the SLUP structure, set to 4095 bytes. #define SLUP_FRAME_MAX 4095 // Size of the receive queue in the SLUP structure, set to 1024 bytes. #define SLUP_RXQUE_SIZE 1024 // Success code, indicating that an operation has been completed successfully. #define SLUP_E_OK 0 // Error code, indicating that the 'slup' pointer is invalid. #define SLUP_E_INVALID 1 // Error code, indicating that the 'data' pointer is invalid. #define SLUP_E_DATA 2 // Error code, indicating that the length value is invalid. #define SLUP_E_LEN 3 // Error code, indicating that the SLUP load testing has not started. #define SLUP_E_NTEST 4 // Error code, indicating that the SLUP load exceeds the defined range. #define SLUP_E_OVER 5 // Error code, indicating that the 'link' pointer is invalid. #define SLUP_E_LINK 6 // Error code, indicating that the 'rate' pointer is invalid. #define SLUP_E_RATE 7 // Link status value representing the link is in the down state. #define SLUP_LINK_DOWN 0x00 // Link status value representing the link is in the transmit (TX) state. #define SLUP_LINK_TX 0x01 // Link status value representing the link is in the receive (RX) state. #define SLUP_LINK_RX 0x02 // Link status value representing the link is in the up state. #define SLUP_LINK_UP 0x03 // Function pointer type for a function that writes a character. // It takes a character 'c' as an argument and returns an 'int'. typedef int (*slup_putc_t)(char c); // Function pointer type for a function that checks data. // It takes a pointer to an array of 'uint8_t' data and its length (in 'uint16_t') as arguments // and returns a 'uint32_t'. typedef uint32_t (*slup_check_t)(uint8_t *data, uint16_t length); // Function pointer type for a function that receives data. // It takes a pointer to an array of 'uint8_t' data and its length (in 'uint16_t') as arguments // and returns an 'int'. typedef int (*slup_receive_t)(uint8_t *data, uint16_t length); // Structure definition for SLUP configuration. typedef struct { // Array to store the head mask, with a maximum size defined by SLUP_HEAD_MAX. uint8_t head[SLUP_HEAD_MAX]; /**< head mask */ // Array to store the tail mask, with a maximum size defined by SLUP_TAIL_MAX. uint8_t tail[SLUP_TAIL_MAX]; /**< tail mask */ // Size of the head part, stored in 4 bits. uint8_t hsize : 4; /**< head size */ // Size of the tail part, stored in 4 bits. uint8_t tsize : 4; /**< tail size */ // Size of the check code part, stored in 4 bits. uint8_t csize : 4; /**< check code size */ // Size of the sequence number (sn) part, stored in 4 bits. uint8_t ssize : 4; /**< sn size */ } SLUP_CFG; /* queue type define */ // Structure definition for an SLUP queue. typedef struct { // Array that serves as the base address for the data in the queue, // with a size defined by SLUP_RXQUE_SIZE. char base[SLUP_RXQUE_SIZE]; /* base address of data */ // Total size of the queue. uint32_t size; /* size of queue */ // Index of the queue head. uint32_t head; /* index of queue head */ // Index of the queue tail. uint32_t tail; /* index of queue tail */ } SLUP_QUEUE; // Structure definition for an SLUP parser. typedef struct { // Current state of the parser. uint8_t state; // Index related to the head part, stored in 4 bits. uint8_t hindex : 4; // Index related to the tail part, stored in 4 bits. uint8_t tindex : 4; // Index related to the check code part, stored in 4 bits. uint8_t cindex : 4; // Index related to the sequence number (sn) part, stored in 4 bits. uint8_t sindex : 4; // Index related to the length part, stored in 2 bits. uint8_t lindex : 2; // Flag indicating the frame status. uint8_t frame; // Length of the data being processed. uint16_t length; // Index within the data. uint16_t dindex; // Check value for the data. uint32_t check; // Sequence number. uint32_t sn; } SLUP_PARSER; // Structure definition for an SLUP dummy data structure. typedef struct { // Compression factor, represented as a floating-point number. float compression; // Rate value, represented as a floating-point number. float rate; // Target value, represented as a 32-bit unsigned integer. uint32_t target; // Base value for the gap, represented as a 32-bit unsigned integer. uint32_t gapbase; // Count value for the gap, represented as a 32-bit unsigned integer. uint32_t gapcount; // Array to store data, with a size of 64 bytes. uint8_t data[64]; } SLUP_DUMMY; // Structure definition for the main SLUP structure that combines multiple components. typedef struct { // SLUP configuration structure. SLUP_CFG cfg; // SLUP queue structure. SLUP_QUEUE queue; // SLUP parser structure. SLUP_PARSER parser; // SLUP dummy data structure. SLUP_DUMMY dummy; // Buffer to store data, with a maximum size defined by SLUP_FRAME_MAX. uint8_t buffer[SLUP_FRAME_MAX]; // Size of the buffer. uint32_t bsize; // Sequence number. uint32_t sn; // Link status flag. uint8_t link; // Silent status flag. uint8_t silent; // Period value, represented as a 16-bit unsigned integer. uint16_t period; // Timestamp value, represented as a 32-bit unsigned integer. uint32_t timestamp; // Number of bits for the up direction, represented as a 32-bit unsigned integer. uint32_t upbits; // Number of bits for the down direction, represented as a 32-bit unsigned integer. uint32_t downbits; // Rate value for the up direction, represented as a 32-bit unsigned integer. uint32_t uprate; // Rate value for the down direction, represented as a 32-bit unsigned integer. uint32_t downrate; // Function pointer of type 'slup_putc_t' for writing a character. slup_putc_t putc; // Function pointer of type 'slup_check_t' for checking data. slup_check_t check; // Function pointer of type 'slup_receive_t' for receiving data. slup_receive_t receive; } SLUP; int slup_init(SLUP *slup); int slup_send(SLUP *slup, uint8_t *data, uint16_t length); int slup_link_status(SLUP *slup, uint8_t *link); int slup_upload_rate(SLUP *slup, uint32_t *rate); int slup_download_rate(SLUP *slup, uint32_t *rate); int slup_set_dummy(SLUP *slup, uint32_t rate); void slup_getc(SLUP *slup, char c); void slup_task(SLUP *slup); #endif