serparser

Used for serial format input/output. It has an internal buffer that holds the interpreted binary series. On input, the series is stored in the internal buffer one byte at a time according to the read format, and becomes complete when the interpretation of the series is complete. Conversely, on output, the buffer is output from the internal buffer according to the specified output format.

Three class names are defined according to the memory buffer handling method (alloc).

// serparser_attach : Use existing buffers
serparser_attach

// serparser : Allocate N bytes of buffer internally
serparser_local<N>

// serparser_heap : Allocate buffers in the heap area
serparser_heap

constants (format type)

The type of format to pass in the initialization parameter of begin(). There are two types here: ASCII format and binary format.

About format

ASCII format

The ASCII format is a way to represent a sequence of data in binary as a string.

For example, 00A01301FF123456 in ASCII format is expressed as follows. The beginning is :, B1 is the checksum, and the end is [CR:0x0d][LF:0x0a].

:00A01301FF123456B1[CR][LF]

You can omit the terminating checksum. Replace the CRLF series from the checksum with X. This is useful when you want to send data for experiments, etc., although it is less vulnerable to wrong data series due to garbled characters.

:00A01301FF123456X

Definition.

Binary Format

Binary format is a method of sending a sequence of data consisting of binary data with a header and a checksum.

For example, 00A01301FF123456 is expressed in binary format as follows.

0xA5 0x5A 0x80 0x08 0x00 0xA0 0x13 0x01 0xFF 0x12 0x34 0x56 0x3D

Definition.

Methods

declaration, begin()

// serparser_attach : use existing buffer
serparser_attach p1;

uint8_t buff[128];
p1.begin(ARSER::ASCII, buff, 0, 128);


// serparser : allocate N bytes buffer inside
serparser p2<128>;
p2.begin(PARSER::ASCII);


// serparser_heap : allocate buffer in heap area
serparser_heap p3;
p3.begin(PARSER::ASCII, 128);

The declaration specifies the memory allocation class. Since this specification is complicated, an alias definition is used as described above.

Calls the begin() method according to the memory allocation class.

serparser_attach

void begin(uint8_t ty, uint8_t *p, uint16_t siz, uint16_t max_siz)

The buffer specified by p is used in the [format] (ser_parser.md#nitsuite) specified by ty. The maximum length of the buffer is specified by max_siz and the effective data length of the buffer by siz.

This definition is used especially when you want to format output data columns (see >> operator).

serparser_local<N> - Allocate internal buffer

void begin(uint8_t ty)

Initialize with the format specified by ty.

serparser_heap - Allocated to heap

void begin(uint8_t ty, uint16_t siz)

Initialize the heap by allocating the size specified by siz to the heap in the format specified by ty.

get_buf()

BUFTYPE& get_buf()

Returns an internal buffer. The buffer will be of type smplbuf<uint8_t, alloc>.

parse()

inline bool parse(uint8_t b)

Processes input characters. Receives a single byte of input string of formatted input and interprets it according to the format. For example, in ASCII format, it receives a series like :00112233X as input. X, one byte at a time, and when the last X` is entered, the interpretation of the format is completed and reported as done.

The parameter to parse() is the input byte, and the return value is true if the interpretation is complete.

例

while (Serial.available()) {
    int c = Serial.read();
    
    if (SerialParser.parse(c)) {
        // Format interpretation complete, data sequence obtained in b (smplbuf<uint8_t>)
        auto&& b = SerialParser.get_buf();
        
        // The following is the processing of the resulting data sequence
        if (b[0] == 0xcc) {
          // ...
        }
    }
}

operator bool()

operator bool() 

If true, reading is completed by parse(); if false, interpretation is in progress.

Example (parse() example can be rewritten as follows)

while (Serial.available()) {
    int c = Serial.read();
    
    SerialParser.parse(c);
    
    if(SerialParser) {
        // Format interpretation complete, data sequence obtained in b (smplbuf<uint8_t>)
        auto&& b = SerialParser.get_buf();
        // ...
    }
}

<< operator

Outputs the internal buffer to the stream (Serial) in a formatted format.

Example

uint8_t u8buf[] = { 0x11, 0x22, 0x33, 0xaa, 0xbb, 0xcc };

ser_parser pout;
pout.begin(ARSER::ASCII, u8buf, 6, 6); // Specify 6 bytes of u8buf

Serial << pout;// Format output to Serial -> :112233AABBCC??[CR][LF]