parent
bb386fcbbc
commit
5f14fdf1e9
@ -1,3 +0,0 @@ |
||||
[submodule "libesphttpd"] |
||||
path = libesphttpd |
||||
url = http://git.spritesserver.nl/libesphttpd.git/ |
||||
@ -0,0 +1,110 @@ |
||||
SBMP library, v1.3 |
||||
================== |
||||
|
||||
This is a reference implementation of SBMP, which should be usable in embedded |
||||
environment. |
||||
|
||||
The library cosists of a **Framing layer**, **Datagram middleware** and a **Session layer**. |
||||
|
||||
How to use |
||||
---------- |
||||
|
||||
The framing layer is isolated in the `sbmp_frame` module, and can be used on it's own, |
||||
if sessions are not needed. That gives you reliable data transfer with error detection. |
||||
|
||||
If you want to *get the most out of SBMP*, use the session layer. Session layer functions are |
||||
namespaced `sbmp_ep_` ("ep" stands for endpoint). |
||||
|
||||
All header files are included in `sbmp.h`, which is the only file you should |
||||
`#include` in your application. |
||||
|
||||
Read comments in the examples to see how to use the library. |
||||
|
||||
Configuration & porting |
||||
----------------------- |
||||
|
||||
You can customize a lot of aspects of SBMP in `sbmp_config.h`. |
||||
|
||||
If you included the library as a submodule, and want to avoid manual edits, you can set |
||||
the options using compiler flags (eg. to disable CRC32: `-DSBMP_HAS_CRC32=0`). |
||||
|
||||
**What to change for Arduino** |
||||
|
||||
Basically disable all you can in the config file. |
||||
|
||||
- You don't want `malloc()` |
||||
- Logging is useless if there's only one USART anyway |
||||
- CRC32 can be replaced with XOR if you don't care about reliability that much. |
||||
|
||||
This gains you a huge size reduction, and the whole library will take only around |
||||
2.5 kB flash and 150 B ram (of course, not including your Rx buffer). |
||||
|
||||
It works really well for ATmega328P - the usual Arduino chip. |
||||
|
||||
Example for AVR |
||||
--------------- |
||||
|
||||
This example uses the [AVR C boilerplate](https://github.com/MightyPork/avr-c-boilerplate). |
||||
|
||||
It's here just to show how to set up SBMP in your AVR application. |
||||
|
||||
**NOTE:** This example uses static allocation of the struct and buffer. |
||||
|
||||
If you pass NULLs to the init function, it will `malloc()` it for you |
||||
and return a pointer to the Endpoint. |
||||
|
||||
```c |
||||
#include <avr/io.h> // register definitions |
||||
#include <avr/interrupt.h> // interrupt vectors |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
|
||||
// AVR C boilerplate libs |
||||
#include "lib/iopins.h" |
||||
#include "lib/usart.h" |
||||
|
||||
// SBMP |
||||
#include "sbmp/sbmp.h" |
||||
|
||||
// SBMP globals |
||||
#define RXBUF_LEN 128 |
||||
static uint8_t rxbuf[RXBUF_LEN]; |
||||
static SBMP_Endpoint ep; |
||||
|
||||
/** USART receive handler */ |
||||
ISR(USART_RX_vect) |
||||
{ |
||||
// Get the byte and pass it to SBMP |
||||
uint8_t b = usart_rx(); |
||||
sbmp_ep_receive(&ep, b); // WARN: This can fail. Should check retval. |
||||
} |
||||
|
||||
/** Message received from SBMP */ |
||||
void message_received(SBMP_Datagram *dg) |
||||
{ |
||||
// ... |
||||
} |
||||
|
||||
int main() |
||||
{ |
||||
usart_init(BAUD_115200); |
||||
usart_isr_rx_enable(true); // enable the interrupt |
||||
|
||||
// init SBMP |
||||
sbmp_ep_init(&ep, rxbuf, RXBUF_LEN, message_received, usart_tx); |
||||
|
||||
// ...additional SBMP configuration if needed... |
||||
|
||||
// enable rx, tx |
||||
sbmp_ep_enable(&ep, true); |
||||
|
||||
// globally enable interrupts (for the USART_RX handler) |
||||
sei(); |
||||
|
||||
while (1) { |
||||
// ... do stuff |
||||
} |
||||
} |
||||
``` |
||||
|
||||
@ -0,0 +1,144 @@ |
||||
#include "esp8266.h" |
||||
|
||||
#include "crc32.h" |
||||
#include "sbmp_config.h" |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
|
||||
// This file was downloaded from some forum, and modified a bit.
|
||||
|
||||
/**********************************************************************\
|
||||
|* Demonstration program to compute the 32-bit CRC used as the frame *| |
||||
|* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *| |
||||
|* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *| |
||||
|* protocol). The 32-bit FCS was added via the Federal Register, *| |
||||
|* 1 June 1982, p.23798. I presume but don't know for certain that *| |
||||
|* this polynomial is or will be included in CCITT V.41, which *| |
||||
|* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *| |
||||
|* PUB 78 says that the 32-bit FCS reduces otherwise undetected *| |
||||
|* errors by a factor of 10^-5 over 16-bit FCS. *| |
||||
\**********************************************************************/ |
||||
|
||||
|
||||
/* Copyright (C) 1986 Gary S. Brown. You may use this program, or
|
||||
code or tables extracted from it, as desired without restriction.*/ |
||||
|
||||
/* First, the polynomial itself and its table of feedback terms. The */ |
||||
/* polynomial is */ |
||||
/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */ |
||||
/* Note that we take it "backwards" and put the highest-order term in */ |
||||
/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */ |
||||
/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */ |
||||
/* the MSB being 1. */ |
||||
|
||||
/* Note that the usual hardware shift register implementation, which */ |
||||
/* is what we're using (we're merely optimizing it by doing eight-bit */ |
||||
/* chunks at a time) shifts bits into the lowest-order term. In our */ |
||||
/* implementation, that means shifting towards the right. Why do we */ |
||||
/* do it this way? Because the calculated CRC must be transmitted in */ |
||||
/* order from highest-order term to lowest-order term. UARTs transmit */ |
||||
/* characters in order from LSB to MSB. By storing the CRC this way, */ |
||||
/* we hand it to the UART in the order low-byte to high-byte; the UART */ |
||||
/* sends each low-bit to hight-bit; and the result is transmission bit */ |
||||
/* by bit from highest- to lowest-order term without requiring any bit */ |
||||
/* shuffling on our part. Reception works similarly. */ |
||||
|
||||
/* The feedback terms table consists of 256, 32-bit entries. Notes: */ |
||||
/* */ |
||||
/* 1. The table can be generated at runtime if desired; code to do so */ |
||||
/* is shown later. It might not be obvious, but the feedback */ |
||||
/* terms simply represent the results of eight shift/xor opera- */ |
||||
/* tions for all combinations of data and CRC register values. */ |
||||
/* */ |
||||
/* 2. The CRC accumulation logic is the same for all CRC polynomials, */ |
||||
/* be they sixteen or thirty-two bits wide. You simply choose the */ |
||||
/* appropriate table. Alternatively, because the table can be */ |
||||
/* generated at runtime, you can start by generating the table for */ |
||||
/* the polynomial in question and use exactly the same "updcrc", */ |
||||
/* if your application needn't simultaneously handle two CRC */ |
||||
/* polynomials. (Note, however, that XMODEM is strange.) */ |
||||
/* */ |
||||
/* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */ |
||||
/* of course, 32-bit entries work OK if the high 16 bits are zero. */ |
||||
/* */ |
||||
/* 4. The values must be right-shifted by eight bits by the "updcrc" */ |
||||
/* logic; the shift must be unsigned (bring in zeroes). On some */ |
||||
/* hardware you could probably optimize the shift in assembler by */ |
||||
/* using byte-swap instructions. */ |
||||
|
||||
static uint32_t ICACHE_RODATA_ATTR STORE_ATTR crc_32_tab[] = { /* CRC polynomial 0xedb88320 */ |
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, |
||||
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, |
||||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, |
||||
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, |
||||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, |
||||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, |
||||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, |
||||
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, |
||||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, |
||||
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, |
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, |
||||
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, |
||||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, |
||||
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, |
||||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, |
||||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, |
||||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, |
||||
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, |
||||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, |
||||
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, |
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, |
||||
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, |
||||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, |
||||
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, |
||||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, |
||||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, |
||||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, |
||||
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, |
||||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, |
||||
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, |
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, |
||||
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, |
||||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, |
||||
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, |
||||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, |
||||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, |
||||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, |
||||
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, |
||||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, |
||||
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, |
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, |
||||
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, |
||||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d |
||||
}; |
||||
|
||||
|
||||
#define UPDC32(octet, crc) (crc_32_tab[((crc) ^ ((uint8_t)octet)) & 0xff] ^ ((crc) >> 8)) |
||||
|
||||
uint32_t crc32_begin(void) |
||||
{ |
||||
return 0xFFFFFFFF; |
||||
} |
||||
|
||||
uint32_t crc32_update(uint32_t crc_scratch, uint8_t ch) |
||||
{ |
||||
return UPDC32(ch, crc_scratch); |
||||
} |
||||
|
||||
uint32_t crc32_end(uint32_t crc_scratch) |
||||
{ |
||||
return ~crc_scratch; |
||||
} |
||||
|
||||
uint32_t crc32buf(uint8_t *buf, size_t len) |
||||
{ |
||||
uint32_t scratch = crc32_begin(); |
||||
|
||||
for (; len; --len, ++buf) { |
||||
scratch = crc32_update(scratch, *buf); |
||||
} |
||||
|
||||
return crc32_end(scratch); |
||||
} |
||||
|
||||
#endif /* SBMP_HAS_CRC32 */ |
||||
@ -0,0 +1,51 @@ |
||||
#ifndef CRC32_H |
||||
#define CRC32_H |
||||
|
||||
#include "sbmp_config.h" |
||||
#if SBMP_HAS_CRC32 |
||||
|
||||
/**
|
||||
* This module is used by the framing layer to calculate CRC32. |
||||
* |
||||
* If your hardware provides a hardware checksum calculator, |
||||
* you can modify the .c file to use that instead of |
||||
* doing it in software. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <stddef.h> |
||||
|
||||
/**
|
||||
* @brief Calculate CRC32 of a buffer. |
||||
* @param buf : buffer to checksum |
||||
* @param len : buffer size |
||||
* @return the CRC32 checksum |
||||
*/ |
||||
uint32_t crc32buf(uint8_t *buf, size_t len); |
||||
|
||||
/**
|
||||
* @brief Start calculating a checksum of a block of data. |
||||
* @return the scratch value, for use in the update and end functions. |
||||
*/ |
||||
uint32_t crc32_begin(void); |
||||
|
||||
/**
|
||||
* @brief Update the CRC32 scratch value with a byte of the data block. |
||||
* @param crc_scratch : old scratch value pointer. |
||||
* @param b : received byte |
||||
* @return updated scratch |
||||
*/ |
||||
uint32_t crc32_update(uint32_t crc_scratch, uint8_t b); |
||||
|
||||
/**
|
||||
* @brief Finish the CRC calculation. |
||||
* @param crc_scratch : your scratch buffer. |
||||
* @return the final CRC32 value. |
||||
*/ |
||||
uint32_t crc32_end(uint32_t crc_scratch); |
||||
|
||||
|
||||
#endif /* SBMP_HAS_CRC32 */ |
||||
|
||||
#endif /* CRC32_H */ |
||||
@ -0,0 +1,23 @@ |
||||
#ifndef SBMP_H |
||||
#define SBMP_H |
||||
|
||||
/**
|
||||
* This is the main SBMP header file. |
||||
* |
||||
* This is the only header file you should need to |
||||
* #include in your application code. |
||||
*/ |
||||
|
||||
#include "sbmp_config.h" |
||||
|
||||
// Common utils & the frame parser
|
||||
#include "sbmp_logging.h" |
||||
#include "sbmp_checksum.h" |
||||
|
||||
#include "sbmp_frame.h" |
||||
|
||||
// Datagram & session layer
|
||||
#include "sbmp_datagram.h" |
||||
#include "sbmp_session.h" |
||||
|
||||
#endif /* SBMP_H */ |
||||
@ -0,0 +1,105 @@ |
||||
#include "esp8266.h" |
||||
|
||||
#include <stdbool.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_checksum.h" |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
#include "crc32.h" |
||||
#endif |
||||
|
||||
|
||||
/** Get nr of bytes in a checksum */ |
||||
uint8_t chksum_length(SBMP_CksumType cksum_type) |
||||
{ |
||||
switch (cksum_type) { |
||||
case SBMP_CKSUM_CRC32: return 4; |
||||
case SBMP_CKSUM_XOR: return 1; |
||||
case SBMP_CKSUM_NONE: return 0; |
||||
default: |
||||
return 4; // assume all unknown checksums are 4 bytes long
|
||||
} |
||||
} |
||||
|
||||
/** Start calculating a checksum */ |
||||
void cksum_begin(SBMP_CksumType type, uint32_t *scratch) |
||||
{ |
||||
switch (type) { |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
case SBMP_CKSUM_CRC32: |
||||
*scratch = crc32_begin(); |
||||
break; |
||||
#endif |
||||
case SBMP_CKSUM_XOR: |
||||
*scratch = 0; |
||||
break; |
||||
|
||||
case SBMP_CKSUM_NONE: // fall-through
|
||||
default: |
||||
; |
||||
} |
||||
} |
||||
|
||||
/** Update the checksum calculation with an incoming byte */ |
||||
void cksum_update(SBMP_CksumType type, uint32_t *scratch, uint8_t byte) |
||||
{ |
||||
switch (type) { |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
case SBMP_CKSUM_CRC32: |
||||
*scratch = crc32_update(*scratch, byte); |
||||
break; |
||||
#endif |
||||
case SBMP_CKSUM_XOR: |
||||
*scratch ^= byte; |
||||
break; |
||||
|
||||
case SBMP_CKSUM_NONE: // fall-through
|
||||
default: |
||||
; |
||||
} |
||||
} |
||||
|
||||
/** Stop the checksum calculation, get the result */ |
||||
void cksum_end(SBMP_CksumType type, uint32_t *scratch) |
||||
{ |
||||
switch (type) { |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
case SBMP_CKSUM_CRC32: |
||||
*scratch = crc32_end(*scratch); |
||||
#endif |
||||
case SBMP_CKSUM_XOR: |
||||
// scratch already contains the checksum
|
||||
break; |
||||
|
||||
case SBMP_CKSUM_NONE: // fall-through
|
||||
default: |
||||
*scratch = 0; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/** Check if the calculated checksum matches the received one */ |
||||
bool cksum_verify(SBMP_CksumType type, uint32_t *scratch, uint32_t received_cksum) |
||||
{ |
||||
cksum_end(type, scratch); |
||||
|
||||
// scratch now contains the checksum
|
||||
|
||||
switch (type) { |
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
case SBMP_CKSUM_CRC32: // fall-through
|
||||
#endif |
||||
case SBMP_CKSUM_XOR: |
||||
return (*scratch == received_cksum); |
||||
|
||||
case SBMP_CKSUM_NONE: // fall-through
|
||||
default: |
||||
// unknown checksum type
|
||||
return true; // assume it's OK
|
||||
} |
||||
} |
||||
@ -0,0 +1,39 @@ |
||||
#ifndef SBMP_CHECKSUM_H |
||||
#define SBMP_CHECKSUM_H |
||||
|
||||
/**
|
||||
* Checksum functions for the SBMP framing layer. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
|
||||
|
||||
/** Checksum types */ |
||||
typedef enum { |
||||
SBMP_CKSUM_NONE = 0, /*!< No checksum */ |
||||
SBMP_CKSUM_CRC32 = 32, /*!< ISO CRC-32 */ |
||||
SBMP_CKSUM_XOR = 1, /*!< Simple XOR check, good for small micros (Arduino) */ |
||||
|
||||
} SBMP_CksumType; |
||||
|
||||
|
||||
/** Get nr of bytes in a checksum */ |
||||
uint8_t chksum_length(SBMP_CksumType cksum_type); |
||||
|
||||
/** Start calculating a checksum. Updates scratch. */ |
||||
void cksum_begin(SBMP_CksumType type, uint32_t *scratch); |
||||
|
||||
/** Update the checksum calculation with an incoming byte. Updates scratch. */ |
||||
void cksum_update(SBMP_CksumType type, uint32_t *scratch, uint8_t byte); |
||||
|
||||
/** Stop the checksum calculation, get the result */ |
||||
void cksum_end(SBMP_CksumType type, uint32_t *scratch); |
||||
|
||||
/** Check if the calculated checksum matches the received one */ |
||||
bool cksum_verify(SBMP_CksumType type, uint32_t *scratch, uint32_t received_cksum); |
||||
|
||||
|
||||
#endif /* SBMP_CHECKSUM_H */ |
||||
@ -0,0 +1,53 @@ |
||||
#ifndef SBMP_CONFIG_H |
||||
#define SBMP_CONFIG_H |
||||
|
||||
/* --- Configuration ------------------- */ |
||||
|
||||
|
||||
#ifndef SBMP_LOGGING |
||||
/**
|
||||
* @brief Enable logging. |
||||
* |
||||
* Logging functions are WEAK stubs in sbmp_logging. |
||||
* |
||||
* Disable logging to free up memory taken by the messages. |
||||
*/ |
||||
#define SBMP_LOGGING 1 |
||||
#endif |
||||
|
||||
|
||||
#ifndef SBMP_MALLOC |
||||
/**
|
||||
* @brief Enable malloc if NULL is passed. |
||||
* |
||||
* This lets you malloc() the struct / buffer if you pass NULL |
||||
* to the init functions. |
||||
* |
||||
* Disable malloc to free up memory taken by the malloc routine. |
||||
* If disabled, init funcs will return NULL if NULL is passed |
||||
* as argument. |
||||
*/ |
||||
#define SBMP_MALLOC 1 |
||||
#endif |
||||
|
||||
|
||||
#ifndef SBMP_HAS_CRC32 |
||||
/**
|
||||
* @brief Add support for CRC32 |
||||
* |
||||
* Disabling CRC32 will reduce program size (for small micros). |
||||
* If CRC32 is disabled, XOR will be used as the preferred checksum |
||||
* method. |
||||
* |
||||
* Received CRC32'd messages will be accepted without checking. |
||||
* |
||||
* If handshake is used, the peer will detect that CRC32 is not |
||||
* supported here, and should start using XOR. |
||||
*/ |
||||
#define SBMP_HAS_CRC32 0 |
||||
#endif |
||||
|
||||
/* ------------------------------------- */ |
||||
|
||||
|
||||
#endif // SBMP_CONFIG_H
|
||||
@ -0,0 +1,69 @@ |
||||
#include "esp8266.h" |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_logging.h" |
||||
#include "sbmp_datagram.h" |
||||
|
||||
SBMP_Datagram *sbmp_dg_parse(SBMP_Datagram *dg, const uint8_t *payload, uint16_t length) |
||||
{ |
||||
if (length < 3) { |
||||
sbmp_error("Can't parse datagram, payload too short."); |
||||
return NULL; // shorter than the minimal no-payload datagram
|
||||
} |
||||
|
||||
// S.N. (2 B) | Dg Type (1 B) | Payload
|
||||
|
||||
#if SBMP_MALLOC |
||||
if (dg == NULL) { |
||||
// request to allocate
|
||||
dg = malloc(sizeof(SBMP_Datagram)); |
||||
} |
||||
#else |
||||
if (dg == NULL) { |
||||
return NULL; // fail
|
||||
} |
||||
#endif |
||||
|
||||
dg->session = (uint16_t)((payload[0]) | (payload[1] << 8)); |
||||
dg->type = payload[2]; |
||||
dg->length = length - 3; |
||||
dg->payload = payload + 3; // pointer arith
|
||||
|
||||
return dg; |
||||
} |
||||
|
||||
|
||||
/** Start a datagram transmission */ |
||||
bool sbmp_dg_start(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, uint16_t session, SBMP_DgType type, uint16_t length) |
||||
{ |
||||
if (length > (0xFFFF - 3)) { |
||||
sbmp_error("Can't send a datagram, payload too long."); |
||||
return false; |
||||
} |
||||
|
||||
if (frm->tx_status != FRM_STATE_IDLE) { |
||||
sbmp_error("Can't state datagram, SBMP tx not IDLE."); |
||||
return false; |
||||
} |
||||
|
||||
if (! sbmp_frm_start(frm, cksum_type, length + 3)) return false; |
||||
|
||||
sbmp_frm_send_byte(frm, session & 0xFF); |
||||
sbmp_frm_send_byte(frm, (session >> 8) & 0xFF); |
||||
sbmp_frm_send_byte(frm, type); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
|
||||
/** Send a whole datagram in one go */ |
||||
bool sbmp_dg_send(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, SBMP_Datagram *dg) |
||||
{ |
||||
if (! sbmp_dg_start(frm, cksum_type, dg->session, dg->type, dg->length)) { |
||||
sbmp_error("Failed to start datagram."); |
||||
return false; |
||||
} |
||||
|
||||
size_t n = sbmp_frm_send_buffer(frm, dg->payload, dg->length); |
||||
return (n == dg->length); |
||||
} |
||||
@ -0,0 +1,71 @@ |
||||
#ifndef SBMP_DATAGRAM_H |
||||
#define SBMP_DATAGRAM_H |
||||
|
||||
/**
|
||||
* SBMP datagram layer |
||||
* |
||||
* This layer is coupled to the framing layer, and |
||||
* builds a datagram abstraction on top of it. |
||||
* |
||||
* This layer sits right under the session layer, |
||||
* and is not very useful on it's own. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_frame.h" |
||||
|
||||
typedef uint8_t SBMP_DgType; |
||||
#define SBMP_DG_HSK_START 0x00 |
||||
#define SBMP_DG_HSK_ACCEPT 0x01 |
||||
#define SBMP_DG_HSK_CONFLICT 0x02 |
||||
|
||||
/**
|
||||
* SBMP datagram object. |
||||
*/ |
||||
typedef struct { |
||||
const uint8_t *payload; /*!< Datagram payload */ |
||||
SBMP_DgType type; /*!< Datagram type ID */ |
||||
uint16_t length; /*!< Datagram length (bytes) */ |
||||
uint16_t session; /*!< Datagram session number */ |
||||
} SBMP_Datagram; |
||||
|
||||
|
||||
/**
|
||||
* @brief Convert a received buffer payload to a datagram. |
||||
* |
||||
* If the payload is < 3 bytes long, datagram can't be createdn and NULL |
||||
* is returned instead. The caller should then free the payload buffer. |
||||
* |
||||
* @param dg : datagram variable to populate, or NULL to allocate |
||||
* @param frame_payload : frame payload to parse |
||||
* @param length : frame payload length |
||||
* @return datagram (allocated if dg was NULL), or NULL if parsing failed. |
||||
*/ |
||||
SBMP_Datagram *sbmp_dg_parse(SBMP_Datagram *dg_or_null, const uint8_t *frame_payload, uint16_t length); |
||||
|
||||
/**
|
||||
* @brief Start a datagram (and the frame) |
||||
* |
||||
* @param state : SBMP state struct |
||||
* @param cksum_type : Checksum type to use for the frame; 0 - none, 32 - CRC32 |
||||
* @param session : session number |
||||
* @param type : Datagram type ID |
||||
* @param length : Datagram payload length (bytes) |
||||
* @return success |
||||
*/ |
||||
bool sbmp_dg_start(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, uint16_t session, SBMP_DgType type, uint16_t length); |
||||
|
||||
/**
|
||||
* @brief Send a complete prepared datagram, also starts the frame. |
||||
* |
||||
* @param state : SBMP state struct |
||||
* @param cksum_type : Checksum type to use for the frame; 0 - none, 32 - CRC32 |
||||
* @param dg : Datagram struct containing DG settings and the payload. |
||||
* @return success |
||||
*/ |
||||
bool sbmp_dg_send(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, SBMP_Datagram *dg); |
||||
|
||||
|
||||
#endif /* SBMP_DATAGRAM_H */ |
||||
@ -0,0 +1,442 @@ |
||||
#include "esp8266.h" |
||||
|
||||
#include <stdarg.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_logging.h" |
||||
#include "sbmp_checksum.h" |
||||
#include "sbmp_frame.h" |
||||
|
||||
// protos
|
||||
static void call_frame_rx_callback(SBMP_FrmInst *frm); |
||||
|
||||
|
||||
/** Allocate the state struct & init all fields */ |
||||
SBMP_FrmInst *sbmp_frm_init( |
||||
SBMP_FrmInst *frm, |
||||
uint8_t *buffer, |
||||
uint16_t buffer_size, |
||||
void (*rx_handler)(uint8_t *, uint16_t, void *), |
||||
void (*tx_func)(uint8_t)) |
||||
{ |
||||
|
||||
#if SBMP_MALLOC |
||||
|
||||
if (frm == NULL) { |
||||
// caller wants us to allocate it
|
||||
frm = malloc(sizeof(SBMP_FrmInst)); |
||||
} |
||||
|
||||
if (buffer == NULL) { |
||||
// caller wants us to allocate it
|
||||
buffer = malloc(buffer_size); |
||||
} |
||||
|
||||
#else |
||||
|
||||
if (frm == NULL || buffer == NULL) { |
||||
return NULL; // malloc not enabled, fail
|
||||
} |
||||
|
||||
#endif |
||||
|
||||
frm->rx_handler = rx_handler; |
||||
|
||||
frm->rx_buffer = buffer; |
||||
frm->rx_buffer_cap = buffer_size; |
||||
|
||||
frm->user_token = NULL; // NULL if not set
|
||||
|
||||
frm->tx_func = tx_func; |
||||
|
||||
frm->rx_enabled = false; |
||||
frm->tx_enabled = false; |
||||
|
||||
sbmp_frm_reset(frm); |
||||
|
||||
return frm; |
||||
} |
||||
|
||||
/** Reset the internal state */ |
||||
void sbmp_frm_reset(SBMP_FrmInst *frm) |
||||
{ |
||||
sbmp_frm_reset_rx(frm); |
||||
sbmp_frm_reset_tx(frm); |
||||
} |
||||
|
||||
/** Enable or disable Rx */ |
||||
void sbmp_frm_enable_rx(SBMP_FrmInst *frm, bool enable) |
||||
{ |
||||
frm->rx_enabled = enable; |
||||
} |
||||
|
||||
/** Enable or disable Tx */ |
||||
void sbmp_frm_enable_tx(SBMP_FrmInst *frm, bool enable) |
||||
{ |
||||
frm->tx_enabled = enable; |
||||
} |
||||
|
||||
/** Enable or disable both Rx and Tx */ |
||||
void sbmp_frm_enable(SBMP_FrmInst *frm, bool enable) |
||||
{ |
||||
sbmp_frm_enable_rx(frm, enable); |
||||
sbmp_frm_enable_tx(frm, enable); |
||||
} |
||||
|
||||
/** Set user token */ |
||||
void sbmp_frm_set_user_token(SBMP_FrmInst *frm, void *token) |
||||
{ |
||||
frm->user_token = token; |
||||
} |
||||
|
||||
/** Reset the receiver state */ |
||||
void sbmp_frm_reset_rx(SBMP_FrmInst *frm) |
||||
{ |
||||
frm->rx_buffer_i = 0; |
||||
frm->rx_length = 0; |
||||
frm->mb_buf = 0; |
||||
frm->mb_cnt = 0; |
||||
frm->rx_hdr_xor = 0; |
||||
frm->rx_cksum_scratch = 0; |
||||
frm->rx_cksum_type = SBMP_CKSUM_NONE; |
||||
frm->rx_status = FRM_STATE_IDLE; |
||||
// printf("---- RX RESET STATE ----\n");
|
||||
} |
||||
|
||||
/** Reset the transmitter state */ |
||||
void sbmp_frm_reset_tx(SBMP_FrmInst *frm) |
||||
{ |
||||
frm->tx_status = FRM_STATE_IDLE; |
||||
frm->tx_remain = 0; |
||||
frm->tx_cksum_scratch = 0; |
||||
frm->tx_cksum_type = SBMP_CKSUM_NONE; |
||||
// printf("---- TX RESET STATE ----\n");
|
||||
} |
||||
|
||||
/** Update a header XOR */ |
||||
static inline |
||||
void hdrxor_update(SBMP_FrmInst *frm, uint8_t rxbyte) |
||||
{ |
||||
frm->rx_hdr_xor ^= rxbyte; |
||||
} |
||||
|
||||
/** Check header xor against received value */ |
||||
static inline |
||||
bool hdrxor_verify(SBMP_FrmInst *frm, uint8_t rx_xor) |
||||
{ |
||||
return frm->rx_hdr_xor == rx_xor; |
||||
} |
||||
|
||||
/** Append a byte to the rx buffer */ |
||||
static inline |
||||
void append_rx_byte(SBMP_FrmInst *frm, uint8_t b) |
||||
{ |
||||
frm->rx_buffer[frm->rx_buffer_i++] = b; |
||||
} |
||||
|
||||
/** Set n-th byte (0 = LSM) to a value */ |
||||
static inline |
||||
void set_byte(uint32_t *acc, uint8_t pos, uint8_t byte) |
||||
{ |
||||
*acc |= (uint32_t)(byte << (pos * 8)); |
||||
} |
||||
|
||||
/**
|
||||
* Call the message handler with the payload. |
||||
* |
||||
*/ |
||||
static void call_frame_rx_callback(SBMP_FrmInst *frm) |
||||
{ |
||||
if (frm->rx_handler == NULL) { |
||||
sbmp_error("frame_handler is null!"); |
||||
return; |
||||
} |
||||
|
||||
frm->rx_status = FRM_STATE_WAIT_HANDLER; |
||||
frm->rx_handler(frm->rx_buffer, frm->rx_length, frm->user_token); |
||||
} |
||||
|
||||
/**
|
||||
* @brief Receive a byte |
||||
* |
||||
* SOF 8 | CKSUM_TYPE 8 | LEN 16 | PAYLOAD | CKSUM 0/4 |
||||
* |
||||
* @param state |
||||
* @param rxbyte |
||||
* @return status |
||||
*/ |
||||
SBMP_RxStatus sbmp_frm_receive(SBMP_FrmInst *frm, uint8_t rxbyte) |
||||
{ |
||||
if (! frm->rx_enabled) { |
||||
return SBMP_RX_DISABLED; |
||||
} |
||||
|
||||
SBMP_RxStatus retval = SBMP_RX_OK; |
||||
|
||||
switch (frm->rx_status) { |
||||
case FRM_STATE_WAIT_HANDLER: |
||||
retval = SBMP_RX_BUSY; |
||||
break; |
||||
|
||||
case FRM_STATE_IDLE: |
||||
// can be first byte of a packet
|
||||
|
||||
if (rxbyte == 0x01) { // start byte
|
||||
|
||||
hdrxor_update(frm, rxbyte); |
||||
|
||||
frm->rx_status = FRM_STATE_CKSUM_TYPE; |
||||
} else { |
||||
// bad char
|
||||
retval = SBMP_RX_INVALID; |
||||
} |
||||
break; |
||||
|
||||
case FRM_STATE_CKSUM_TYPE: |
||||
frm->rx_cksum_type = rxbyte; // checksum type received
|
||||
|
||||
hdrxor_update(frm, rxbyte); |
||||
|
||||
// next will be length
|
||||
frm->rx_status = FRM_STATE_LENGTH; |
||||
// clear MB for 2-byte length
|
||||
frm->mb_buf = 0; |
||||
frm->mb_cnt = 0; |
||||
break; |
||||
|
||||
case FRM_STATE_LENGTH: |
||||
// append to the multi-byte buffer
|
||||
set_byte(&frm->mb_buf, frm->mb_cnt++, rxbyte); |
||||
|
||||
hdrxor_update(frm, rxbyte); |
||||
|
||||
// if last of the MB field
|
||||
if (frm->mb_cnt == 2) { |
||||
|
||||
// next will be the payload
|
||||
uint16_t len = (uint16_t) frm->mb_buf; |
||||
frm->rx_length = len; |
||||
|
||||
if (len == 0) { |
||||
sbmp_error("Rx packet with no payload!"); |
||||
sbmp_frm_reset_rx(frm); // abort
|
||||
break; |
||||
} |
||||
|
||||
frm->rx_status = FRM_STATE_HDRXOR; |
||||
} |
||||
break; |
||||
|
||||
case FRM_STATE_HDRXOR: |
||||
if (! hdrxor_verify(frm, rxbyte)) { |
||||
sbmp_error("Header XOR mismatch!"); |
||||
sbmp_frm_reset_rx(frm); // abort
|
||||
break; |
||||
} |
||||
|
||||
// Check if not too long
|
||||
if (frm->rx_length > frm->rx_buffer_cap) { |
||||
sbmp_error("Rx packet too long - %d!", (uint16_t)frm->rx_length); |
||||
// discard the rest + checksum
|
||||
frm->rx_status = FRM_STATE_DISCARD; |
||||
frm->rx_length += chksum_length(frm->rx_cksum_type); |
||||
break; |
||||
} |
||||
|
||||
frm->rx_status = FRM_STATE_PAYLOAD; |
||||
cksum_begin(frm->rx_cksum_type, &frm->rx_cksum_scratch); |
||||
break; |
||||
|
||||
case FRM_STATE_DISCARD: |
||||
frm->rx_buffer_i++; |
||||
if (frm->rx_buffer_i == frm->rx_length) { |
||||
// done
|
||||
sbmp_frm_reset_rx(frm); // go IDLE
|
||||
} |
||||
break; |
||||
|
||||
case FRM_STATE_PAYLOAD: |
||||
append_rx_byte(frm, rxbyte); |
||||
cksum_update(frm->rx_cksum_type, &frm->rx_cksum_scratch, rxbyte); |
||||
|
||||
if (frm->rx_buffer_i == frm->rx_length) { |
||||
// payload rx complete
|
||||
|
||||
if (frm->rx_cksum_type != SBMP_CKSUM_NONE) { |
||||
// receive the checksum
|
||||
frm->rx_status = FRM_STATE_CKSUM; |
||||
|
||||
// clear MB for the 4-byte length
|
||||
frm->mb_buf = 0; |
||||
frm->mb_cnt = 0; |
||||
} else { |
||||
// no checksum
|
||||
// fire the callback
|
||||
call_frame_rx_callback(frm); |
||||
|
||||
// clear
|
||||
sbmp_frm_reset_rx(frm); |
||||
} |
||||
} |
||||
break; |
||||
|
||||
case FRM_STATE_CKSUM: |
||||
// append to the multi-byte buffer
|
||||
set_byte(&frm->mb_buf, frm->mb_cnt++, rxbyte); |
||||
|
||||
// if last of the MB field
|
||||
if (frm->mb_cnt == chksum_length(frm->rx_cksum_type)) { |
||||
|
||||
if (cksum_verify(frm->rx_cksum_type, &frm->rx_cksum_scratch, frm->mb_buf)) { |
||||
call_frame_rx_callback(frm); |
||||
} else { |
||||
sbmp_error("Rx checksum mismatch!"); |
||||
} |
||||
|
||||
// clear, enter IDLE
|
||||
sbmp_frm_reset_rx(frm); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
return retval; |
||||
} |
||||
|
||||
/** Send a frame header */ |
||||
bool sbmp_frm_start(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, uint16_t length) |
||||
{ |
||||
if (! frm->tx_enabled) { |
||||
sbmp_error("Can't tx, not enabled."); |
||||
return false; |
||||
} |
||||
|
||||
if (frm->tx_status != FRM_STATE_IDLE) { |
||||
sbmp_error("Can't tx, busy."); |
||||
return false; |
||||
} |
||||
|
||||
if (frm->tx_func == NULL) { |
||||
sbmp_error("Can't tx, no tx func!"); |
||||
return false; |
||||
} |
||||
|
||||
if (cksum_type == SBMP_CKSUM_CRC32 && !SBMP_HAS_CRC32) { |
||||
sbmp_error("CRC32 disabled, using XOR for Tx."); |
||||
cksum_type = SBMP_CKSUM_XOR; |
||||
} |
||||
|
||||
sbmp_frm_reset_tx(frm); |
||||
|
||||
frm->tx_cksum_type = cksum_type; |
||||
frm->tx_remain = length; |
||||
frm->tx_status = FRM_STATE_PAYLOAD; |
||||
|
||||
// Send the header
|
||||
|
||||
uint16_t len = (uint16_t) length; |
||||
|
||||
uint8_t hdr[4] = { |
||||
0x01, |
||||
cksum_type, |
||||
len & 0xFF, |
||||
(len >> 8) & 0xFF |
||||
}; |
||||
|
||||
uint8_t hdr_xor = 0; |
||||
for (int i = 0; i < 4; i++) { |
||||
hdr_xor ^= hdr[i]; |
||||
frm->tx_func(hdr[i]); |
||||
} |
||||
|
||||
frm->tx_func(hdr_xor); |
||||
|
||||
cksum_begin(frm->tx_cksum_type, &frm->tx_cksum_scratch); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
/** End frame and enter idle mode */ |
||||
static void end_frame(SBMP_FrmInst *frm) |
||||
{ |
||||
if (!frm->tx_enabled) { |
||||
sbmp_error("Can't tx, not enabled."); |
||||
return; |
||||
} |
||||
|
||||
cksum_end(frm->tx_cksum_type, &frm->tx_cksum_scratch); |
||||
|
||||
uint32_t cksum = frm->tx_cksum_scratch; |
||||
|
||||
switch (frm->tx_cksum_type) { |
||||
case SBMP_CKSUM_NONE: |
||||
break; // do nothing
|
||||
|
||||
case SBMP_CKSUM_XOR: |
||||
// 1-byte checksum
|
||||
frm->tx_func(cksum & 0xFF); |
||||
break; |
||||
|
||||
case SBMP_CKSUM_CRC32: |
||||
frm->tx_func(cksum & 0xFF); |
||||
frm->tx_func((cksum >> 8) & 0xFF); |
||||
frm->tx_func((cksum >> 16) & 0xFF); |
||||
frm->tx_func((cksum >> 24) & 0xFF); |
||||
} |
||||
|
||||
frm->tx_status = FRM_STATE_IDLE; // tx done
|
||||
} |
||||
|
||||
/** Send a byte in the currently open frame */ |
||||
bool sbmp_frm_send_byte(SBMP_FrmInst *frm, uint8_t byte) |
||||
{ |
||||
if (!frm->tx_enabled) { |
||||
sbmp_error("Can't tx, not enabled."); |
||||
return false; |
||||
} |
||||
|
||||
if (frm->tx_remain == 0 || frm->tx_status != FRM_STATE_PAYLOAD) { |
||||
return false; |
||||
} |
||||
|
||||
frm->tx_func(byte); |
||||
cksum_update(frm->tx_cksum_type, &frm->tx_cksum_scratch, byte); |
||||
frm->tx_remain--; |
||||
|
||||
if (frm->tx_remain == 0) { |
||||
end_frame(frm); // checksum & go idle
|
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
/** Send a buffer in the currently open frame */ |
||||
uint16_t sbmp_frm_send_buffer(SBMP_FrmInst *frm, const uint8_t *buffer, uint16_t length) |
||||
{ |
||||
if (! frm->tx_enabled) { |
||||
sbmp_error("Can't tx, not enabled."); |
||||
return false; |
||||
} |
||||
|
||||
if (frm->tx_status != FRM_STATE_PAYLOAD) { |
||||
return false; // invalid call
|
||||
} |
||||
|
||||
if (length == 0) { |
||||
end_frame(frm); // checksum & go idle
|
||||
return 0; |
||||
} |
||||
|
||||
if (frm->tx_remain == 0) { |
||||
return false; // write past EOF (this shouldn't happen)
|
||||
} |
||||
|
||||
uint16_t remain = length; |
||||
while (frm->tx_status == FRM_STATE_PAYLOAD && remain-- > 0) { |
||||
if (! sbmp_frm_send_byte(frm, *buffer++)) { |
||||
remain++; // "push back"
|
||||
break; |
||||
} |
||||
} |
||||
|
||||
return (length - remain); |
||||
} |
||||
@ -0,0 +1,205 @@ |
||||
#ifndef SBMP_FRAME_H |
||||
#define SBMP_FRAME_H |
||||
|
||||
/**
|
||||
* SBMP Frame parser. |
||||
* |
||||
* This is the lowest level of the SBMP stack. |
||||
* |
||||
* You can use the frame parser on it's own, if you don't the higher layers. |
||||
* You will still get checksums and other benefits. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <stddef.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_checksum.h" |
||||
|
||||
/**
|
||||
* Status returned from the byte rx function. |
||||
*/ |
||||
typedef enum { |
||||
SBMP_RX_OK = 0, /*!< Byte received */ |
||||
SBMP_RX_BUSY, /*!< SBMP busy with the last packet, try again */ |
||||
SBMP_RX_INVALID, /*!< The byte was rejected - can be ASCII debug, or just garbage. */ |
||||
SBMP_RX_DISABLED, /*!< The byte was rejected, because the frame parser is not enabled yet. */ |
||||
} SBMP_RxStatus; |
||||
|
||||
/** SBMP internal state (context). Allows having multiple SBMP interfaces. */ |
||||
typedef struct SBMP_FrmInstance_struct SBMP_FrmInst; |
||||
|
||||
|
||||
/**
|
||||
* @brief Initialize the SBMP internal state struct |
||||
* |
||||
* @param frm : Pointer to the state struct to populate. NULL to allocate. |
||||
* @param buffer : Buffer for Rx. NULL to allocate. |
||||
* @param buffer_size : size of the Rx buffer (or how many bytes to allocate) |
||||
* @param rx_handler : callback when frame is received |
||||
* @param tx_func : function for sending bytes (USART Tx) |
||||
* @return pointer to the state struct (passed or allocated) |
||||
*/ |
||||
SBMP_FrmInst *sbmp_frm_init( |
||||
SBMP_FrmInst *frm_or_null, |
||||
uint8_t *buffer_or_null, |
||||
uint16_t buffer_size, |
||||
void (*rx_handler)(uint8_t *payload, uint16_t length, void *user_token), |
||||
void (*tx_func)(uint8_t byte) |
||||
); |
||||
|
||||
/**
|
||||
* @brief Set the user token value. |
||||
* |
||||
* The token will be passed to the Frame Rx callback. |
||||
* Can be used to identify higher level layer instance. |
||||
* |
||||
* If the token is not set, NULL will be used in the callback. |
||||
* |
||||
* @param frm : Framing layer instance |
||||
* @param token : pointer to arbitrary object. |
||||
*/ |
||||
void sbmp_frm_set_user_token(SBMP_FrmInst *frm, void *token); |
||||
|
||||
/**
|
||||
* @brief Reset the SBMP frm state, discard partial messages (both rx and tx). |
||||
* @param frm : Framing layer instance |
||||
*/ |
||||
void sbmp_frm_reset(SBMP_FrmInst *frm); |
||||
|
||||
/** Reset the receiver state only */ |
||||
void sbmp_frm_reset_rx(SBMP_FrmInst *frm); |
||||
|
||||
/** Reset the transmitter state only */ |
||||
void sbmp_frm_reset_tx(SBMP_FrmInst *frm); |
||||
|
||||
/**
|
||||
* @brief Enable or disable both Rx and Tx |
||||
* @param frm : Framing layer instance |
||||
* @param enable : true - enable, false - disable |
||||
*/ |
||||
void sbmp_frm_enable(SBMP_FrmInst *frm, bool enable); |
||||
|
||||
/**
|
||||
* @brief Enable or disable Rx & the frame parser |
||||
* @param frm : Framing layer instance |
||||
* @param enable_rx : true - enable, false - disable |
||||
*/ |
||||
void sbmp_frm_enable_rx(SBMP_FrmInst *frm, bool enable_rx); |
||||
|
||||
/**
|
||||
* @brief Enable or disable the frame builder & Tx |
||||
* @param frm : Framing layer instance |
||||
* @param enable_tx : true - enable, false - disable |
||||
*/ |
||||
void sbmp_frm_enable_tx(SBMP_FrmInst *frm, bool enable_tx); |
||||
|
||||
/**
|
||||
* @brief Handle an incoming byte |
||||
* |
||||
* @param frm : Framing layer instance |
||||
* @param rxbyte : byte received |
||||
* @return status |
||||
*/ |
||||
SBMP_RxStatus sbmp_frm_receive(SBMP_FrmInst *frm, uint8_t rxbyte); |
||||
|
||||
/**
|
||||
* @brief Start a frame transmission |
||||
* |
||||
* @param frm : Framing layer instance |
||||
* @param cksum_type : checksum to use (0, 32) |
||||
* @param length : payload length |
||||
* @return true if frame was started. |
||||
*/ |
||||
bool sbmp_frm_start(SBMP_FrmInst *frm, SBMP_CksumType cksum_type, uint16_t length); |
||||
|
||||
/**
|
||||
* @brief Send one byte in the open frame. |
||||
* |
||||
* If the payload was completed, checksum is be added and |
||||
* the frame is closed. |
||||
* |
||||
* @param frm : Framing layer instance |
||||
* @param byte : byte to send |
||||
* @return true on success (value did fit in a frame) |
||||
*/ |
||||
bool sbmp_frm_send_byte(SBMP_FrmInst *frm, uint8_t byte); |
||||
|
||||
/**
|
||||
* @brief Send a data buffer (or a part). |
||||
* |
||||
* If the payload was completed, checksum is be added and |
||||
* the frame is closed. |
||||
* |
||||
* @param frm : Framing layer instance |
||||
* @param buffer : buffer of bytes to send |
||||
* @param length : buffer length (byte count) |
||||
* @return actual sent length (until payload is full) |
||||
*/ |
||||
uint16_t sbmp_frm_send_buffer(SBMP_FrmInst *frm, const uint8_t *buffer, uint16_t length); |
||||
|
||||
|
||||
|
||||
// ---- Internal frame struct ------------------------
|
||||
|
||||
/** SBMP framing layer Rx / Tx state */ |
||||
enum SBMP_FrmStatus { |
||||
FRM_STATE_IDLE, /*!< Ready to start/accept a frame */ |
||||
FRM_STATE_CKSUM_TYPE, /*!< Rx, waiting for checksum type (1 byte) */ |
||||
FRM_STATE_LENGTH, /*!< Rx, waiting for payload length (2 bytes) */ |
||||
FRM_STATE_HDRXOR, /*!< Rx, waiting for header XOR (1 byte) */ |
||||
FRM_STATE_PAYLOAD, /*!< Rx or Tx, payload rx/tx in progress. */ |
||||
FRM_STATE_DISCARD, /*!< Discard rx_length worth of bytes, then end */ |
||||
FRM_STATE_CKSUM, /*!< Rx, waiting for checksum (4 bytes) */ |
||||
FRM_STATE_WAIT_HANDLER, /*!< Rx, waiting for rx callback to process the payload */ |
||||
}; |
||||
|
||||
/**
|
||||
* Internal state of the SBMP node |
||||
* Placed in the header to allow static allocation. |
||||
*/ |
||||
struct SBMP_FrmInstance_struct { |
||||
|
||||
// --- reception ---
|
||||
|
||||
uint32_t mb_buf; /*!< Multi-byte value buffer */ |
||||
uint8_t mb_cnt; |
||||
|
||||
uint8_t rx_hdr_xor; /*!< Header xor scratch field */ |
||||
|
||||
enum SBMP_FrmStatus rx_status; |
||||
|
||||
bool rx_enabled; /*!< Enable Rx. Disabled -> reject incoming bytes. */ |
||||
bool tx_enabled; /*!< Enable Rx. Disabled -> reject incoming bytes. */ |
||||
|
||||
uint8_t *rx_buffer; /*!< Incoming packet buffer */ |
||||
uint16_t rx_buffer_i; /*!< Buffer cursor */ |
||||
uint16_t rx_buffer_cap; /*!< Buffer capacity */ |
||||
|
||||
uint16_t rx_length; /*!< Total payload length */ |
||||
|
||||
SBMP_CksumType rx_cksum_type; /*!< Current packet's checksum type */ |
||||
uint32_t rx_cksum_scratch; /*!< crc aggregation field for received data */ |
||||
|
||||
void (*rx_handler)(uint8_t *payload, uint16_t length, void *user_token); /*!< Message received handler */ |
||||
|
||||
void *user_token; /*!< Arbitrary pointer set by the user. Passed to callbacks.
|
||||
Can be used to identify instance of a higher layer. */ |
||||
|
||||
// --- transmission ---
|
||||
|
||||
uint16_t tx_remain; /*!< Number of remaining bytes to transmit */ |
||||
SBMP_CksumType tx_cksum_type; |
||||
uint32_t tx_cksum_scratch; /*!< crc aggregation field for transmit */ |
||||
|
||||
enum SBMP_FrmStatus tx_status; |
||||
|
||||
// output functions. Only tx_func is needed.
|
||||
void (*tx_func)(uint8_t byte); /*!< Function to send one byte */ |
||||
}; |
||||
|
||||
// ------------------------------------
|
||||
|
||||
|
||||
#endif /* SBMP_FRAME_H */ |
||||
@ -0,0 +1,6 @@ |
||||
#include <stdarg.h> |
||||
|
||||
#include "esp8266.h" |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_logging.h" |
||||
@ -0,0 +1,15 @@ |
||||
#ifndef SBMP_COMMON_H |
||||
#define SBMP_COMMON_H |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "esp8266.h" |
||||
|
||||
/**
|
||||
* SBMP logging utils |
||||
*/ |
||||
|
||||
// do-nothing definitions
|
||||
#define sbmp_error(fmt, ...) os_printf("\x1b[31;1mSBMP][E] " #fmt "\x1b[0m\r\n", ##__VA_ARGS__) |
||||
#define sbmp_info(fmt, ...) os_printf("\x1b[32;1m[SBMP][i] " #fmt "\x1b[0m\r\n", ##__VA_ARGS__) |
||||
|
||||
#endif /* SBMP_COMMON_H */ |
||||
@ -0,0 +1,416 @@ |
||||
#include "esp8266.h" |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_logging.h" |
||||
#include "sbmp_session.h" |
||||
|
||||
// protos
|
||||
static void handle_hsk_datagram(SBMP_Endpoint *ep, SBMP_Datagram *dg); |
||||
|
||||
// lsb, msb for uint16_t
|
||||
#define U16_LSB(x) ((x) & 0xFF) |
||||
#define U16_MSB(x) ((x >> 8) & 0xFF) |
||||
|
||||
// length of the payload sent with a handshake packet.
|
||||
#define HSK_PAYLOAD_LEN 3 |
||||
// Datagram header length - 2 B sesn, 1 B type
|
||||
#define DATAGRA_HEADER_LEN 3 |
||||
|
||||
|
||||
/** Rx handler that is assigned to the framing layer */ |
||||
static void ep_rx_handler(uint8_t *buf, uint16_t len, void *token) |
||||
{ |
||||
// endpoint pointer is stored in the user token
|
||||
SBMP_Endpoint *ep = (SBMP_Endpoint *)token; |
||||
|
||||
if (NULL != sbmp_dg_parse(&ep->static_dg, buf, len)) { |
||||
// payload parsed OK
|
||||
|
||||
// check if handshake datagram, else call user callback.
|
||||
handle_hsk_datagram(ep, &ep->static_dg); |
||||
} |
||||
} |
||||
|
||||
/**
|
||||
* @brief Initialize the endpoint. |
||||
* |
||||
* @param ep : Endpoint var pointer, or NULL to allocate one. |
||||
* @param buffer : Rx buffer. NULL to allocate one. |
||||
* @param buffer_size : Rx buffer length |
||||
* @return the endpoint struct pointer (allocated if ep was NULL) |
||||
*/ |
||||
SBMP_Endpoint *sbmp_ep_init( |
||||
SBMP_Endpoint *ep, |
||||
uint8_t *buffer, |
||||
uint16_t buffer_size, |
||||
void (*dg_rx_handler)(SBMP_Datagram *dg), |
||||
void (*tx_func)(uint8_t byte)) |
||||
{ |
||||
if (ep == NULL) { |
||||
// request to allocate it
|
||||
#if SBMP_MALLOC |
||||
ep = malloc(sizeof(SBMP_Endpoint)); |
||||
#else |
||||
return NULL; // fail
|
||||
#endif |
||||
} |
||||
|
||||
// set up the framing layer
|
||||
sbmp_frm_init(&ep->frm, buffer, buffer_size, ep_rx_handler, tx_func); |
||||
|
||||
// set token, so callback knows what EP it's for.
|
||||
sbmp_frm_set_user_token(&ep->frm, (void *) ep); |
||||
|
||||
ep->rx_handler = dg_rx_handler; |
||||
ep->buffer_size = buffer_size; // sent to the peer
|
||||
|
||||
#if SBMP_HAS_CRC32 |
||||
ep->peer_pref_cksum = SBMP_CKSUM_CRC32; |
||||
ep->pref_cksum = SBMP_CKSUM_CRC32; |
||||
#else |
||||
ep->peer_pref_cksum = SBMP_CKSUM_XOR; |
||||
ep->pref_cksum = SBMP_CKSUM_XOR; |
||||
#endif |
||||
|
||||
// reset state information
|
||||
sbmp_ep_reset(ep); |
||||
|
||||
return ep; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Reset an endpoint and it's Framing Layer |
||||
* |
||||
* This discards all state information. |
||||
* |
||||
* @param ep : Endpoint |
||||
*/ |
||||
void sbmp_ep_reset(SBMP_Endpoint *ep) |
||||
{ |
||||
ep->next_session = 0; |
||||
ep->origin = 0; |
||||
|
||||
// init the handshake status
|
||||
ep->hsk_session = 0; |
||||
ep->hsk_state = SBMP_HSK_NOT_STARTED; |
||||
|
||||
ep->peer_buffer_size = 0xFFFF; // max possible buffer
|
||||
|
||||
sbmp_frm_reset(&ep->frm); |
||||
} |
||||
|
||||
|
||||
// --- Customizing settings ---
|
||||
|
||||
/** Set session number (good to randomize before first message) */ |
||||
void sbmp_ep_seed_session(SBMP_Endpoint *ep, uint16_t sesn) |
||||
{ |
||||
ep->next_session = sesn & 0x7FFF; |
||||
} |
||||
|
||||
/** Set the origin bit (bypass handshake) */ |
||||
void sbmp_ep_set_origin(SBMP_Endpoint *endp, bool bit) |
||||
{ |
||||
endp->origin = bit; |
||||
} |
||||
|
||||
/** Set the preferred checksum. */ |
||||
void sbmp_ep_set_preferred_cksum(SBMP_Endpoint *endp, SBMP_CksumType cksum_type) |
||||
{ |
||||
if (cksum_type == SBMP_CKSUM_CRC32 && !SBMP_HAS_CRC32) { |
||||
sbmp_error("CRC32 not avail, using XOR instead."); |
||||
cksum_type = SBMP_CKSUM_XOR; |
||||
} |
||||
|
||||
endp->pref_cksum = cksum_type; |
||||
} |
||||
|
||||
|
||||
/** Enable or disable RX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable_rx(SBMP_Endpoint *ep, bool enable_rx) |
||||
{ |
||||
sbmp_frm_enable_rx(&ep->frm, enable_rx); |
||||
} |
||||
|
||||
/** Enable or disable TX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable_tx(SBMP_Endpoint *ep, bool enable_tx) |
||||
{ |
||||
sbmp_frm_enable_tx(&ep->frm, enable_tx); |
||||
} |
||||
|
||||
/** Enable or disable Rx & TX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable(SBMP_Endpoint *ep, bool enable) |
||||
{ |
||||
sbmp_frm_enable(&ep->frm, enable); |
||||
} |
||||
|
||||
// ---
|
||||
|
||||
/** Get a new session number */ |
||||
static uint16_t next_session(SBMP_Endpoint *ep) |
||||
{ |
||||
uint16_t sesn = ep->next_session; |
||||
|
||||
if (++ep->next_session == 0x8000) { |
||||
// overflow into the origin bit
|
||||
ep->next_session = 0; // start from zero
|
||||
} |
||||
|
||||
return sesn | (uint16_t)(ep->origin << 15); // add the origin bit
|
||||
} |
||||
|
||||
|
||||
// --- Header/body send funcs ---
|
||||
|
||||
/** Start a message as a reply */ |
||||
bool sbmp_ep_start_response(SBMP_Endpoint *ep, SBMP_DgType type, uint16_t length, uint16_t sesn) |
||||
{ |
||||
uint16_t peer_accepts = ep->peer_buffer_size - DATAGRA_HEADER_LEN; |
||||
|
||||
if (length > peer_accepts) { |
||||
sbmp_error("Msg too long (%d B), peer accepts max %d B.", length, peer_accepts); |
||||
return false; |
||||
} |
||||
|
||||
return sbmp_dg_start(&ep->frm, ep->peer_pref_cksum, sesn, type, length); |
||||
} |
||||
|
||||
/** Start a message in a new session */ |
||||
bool sbmp_ep_start_session(SBMP_Endpoint *ep, SBMP_DgType type, uint16_t length, uint16_t *sesn_ptr) |
||||
{ |
||||
uint16_t sn = next_session(ep); |
||||
|
||||
bool suc = sbmp_ep_start_response(ep, type, length, sn); |
||||
if (suc) { |
||||
if (sesn_ptr != NULL) *sesn_ptr = sn; |
||||
} |
||||
|
||||
return suc; |
||||
} |
||||
|
||||
/** Send one byte in the current message */ |
||||
bool sbmp_ep_send_byte(SBMP_Endpoint *ep, uint8_t byte) |
||||
{ |
||||
return sbmp_frm_send_byte(&ep->frm, byte); |
||||
} |
||||
|
||||
/** Send a data buffer (or a part) in the current message */ |
||||
uint16_t sbmp_ep_send_buffer(SBMP_Endpoint *ep, const uint8_t *buffer, uint16_t length) |
||||
{ |
||||
return sbmp_frm_send_buffer(&ep->frm, buffer, length); |
||||
} |
||||
|
||||
/** Rx, pass to framing layer */ |
||||
SBMP_RxStatus sbmp_ep_receive(SBMP_Endpoint *ep, uint8_t byte) |
||||
{ |
||||
return sbmp_frm_receive(&ep->frm, byte); |
||||
} |
||||
|
||||
|
||||
// --- All-in-one send funcs ---
|
||||
|
||||
/** Send a message in a session. */ |
||||
bool sbmp_ep_send_response( |
||||
SBMP_Endpoint *ep, |
||||
SBMP_DgType type, |
||||
const uint8_t *buffer, |
||||
uint16_t length, |
||||
uint16_t sesn, |
||||
uint16_t *sent_bytes_ptr) |
||||
{ |
||||
bool suc = sbmp_ep_start_response(ep, type, length, sesn); |
||||
|
||||
if (suc) { |
||||
uint16_t sent = sbmp_ep_send_buffer(ep, buffer, length); |
||||
|
||||
if (sent_bytes_ptr != NULL) *sent_bytes_ptr = sent; |
||||
} |
||||
|
||||
return suc; |
||||
} |
||||
|
||||
/** Send message in a new session */ |
||||
bool sbmp_ep_send_message( |
||||
SBMP_Endpoint *ep, |
||||
SBMP_DgType type, |
||||
const uint8_t *buffer, |
||||
uint16_t length, |
||||
uint16_t *sesn_ptr, |
||||
uint16_t *sent_bytes_ptr) |
||||
{ |
||||
// This juggling with session nr is because it wouldn't work
|
||||
// without actual hardware delay otherwise.
|
||||
|
||||
uint16_t sn = next_session(ep);; |
||||
|
||||
uint16_t old_sesn = 0; |
||||
if (sesn_ptr != NULL) { |
||||
old_sesn = *sesn_ptr; |
||||
*sesn_ptr = sn; |
||||
} |
||||
|
||||
bool suc = sbmp_ep_send_response(ep, type, buffer, length, sn, sent_bytes_ptr); |
||||
|
||||
if (!suc) { |
||||
if (sesn_ptr != NULL) { |
||||
*sesn_ptr = old_sesn; // restore
|
||||
} |
||||
} |
||||
|
||||
return suc; |
||||
} |
||||
|
||||
|
||||
// --- Handshake ---
|
||||
/**
|
||||
* Prepare a buffer to send to peer during handshake |
||||
* |
||||
* The buffer is long HSK_PAYLOAD_LEN bytes |
||||
*/ |
||||
static void populate_hsk_buf(SBMP_Endpoint *ep, uint8_t* buf) |
||||
{ |
||||
// [ pref_crc 1B | buf_size 2B ]
|
||||
|
||||
buf[0] = ep->pref_cksum; |
||||
buf[1] = U16_LSB(ep->buffer_size); |
||||
buf[2] = U16_MSB(ep->buffer_size); |
||||
} |
||||
|
||||
/** Parse peer info from received handhsake dg payload */ |
||||
static void parse_peer_hsk_buf(SBMP_Endpoint *ep, const uint8_t* buf) |
||||
{ |
||||
ep->peer_pref_cksum = buf[0]; |
||||
ep->peer_buffer_size = (uint16_t)(buf[1] | (buf[2] << 8)); |
||||
|
||||
sbmp_info("HSK success, peer buf %d, pref cksum %d", |
||||
ep->peer_buffer_size, |
||||
ep->peer_pref_cksum); |
||||
|
||||
// check if checksum available
|
||||
if (ep->peer_pref_cksum == SBMP_CKSUM_CRC32 && !SBMP_HAS_CRC32) { |
||||
sbmp_error("CRC32 not avail, using XOR as peer's pref cksum."); |
||||
ep->peer_pref_cksum = SBMP_CKSUM_XOR; |
||||
} |
||||
} |
||||
|
||||
/**
|
||||
* @brief Start a handshake (origin bit arbitration) |
||||
* @param ep : Endpoint state |
||||
*/ |
||||
bool sbmp_ep_start_handshake(SBMP_Endpoint *ep) |
||||
{ |
||||
if (ep->hsk_state == SBMP_HSK_AWAIT_REPLY) { |
||||
// busy now
|
||||
sbmp_error("Can't start HSK, in progress already."); |
||||
return false; |
||||
} |
||||
|
||||
ep->hsk_state = 0; |
||||
|
||||
uint8_t buf[HSK_PAYLOAD_LEN]; |
||||
populate_hsk_buf(ep, buf); |
||||
|
||||
ep->hsk_state = SBMP_HSK_AWAIT_REPLY; |
||||
|
||||
bool suc = sbmp_ep_send_message(ep, SBMP_DG_HSK_START, buf, 3, &ep->hsk_session, NULL); |
||||
|
||||
if (!suc) { |
||||
ep->hsk_state = SBMP_HSK_NOT_STARTED; |
||||
} |
||||
|
||||
return suc; |
||||
} |
||||
|
||||
/** Get hsk state */ |
||||
SBMP_HandshakeStatus sbmp_ep_handshake_status(SBMP_Endpoint *ep) |
||||
{ |
||||
return ep->hsk_state; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Process handshake datagrams & update handshake state accordingly. |
||||
* |
||||
* Non-handshake datagrams are passed on to the user Rx callback. |
||||
* |
||||
* @param ep : endpoint |
||||
* @param dg : datagram |
||||
*/ |
||||
static void handle_hsk_datagram(SBMP_Endpoint *ep, SBMP_Datagram *dg) |
||||
{ |
||||
bool hsk_start = (dg->type == SBMP_DG_HSK_START); |
||||
bool hsk_accept = (dg->type == SBMP_DG_HSK_ACCEPT); |
||||
bool hsk_conflict = (dg->type == SBMP_DG_HSK_CONFLICT); |
||||
|
||||
if (hsk_start || hsk_accept || hsk_conflict) { |
||||
// prepare payload to send in response
|
||||
uint8_t our_info_pld[HSK_PAYLOAD_LEN]; |
||||
populate_hsk_buf(ep, our_info_pld); |
||||
|
||||
//printf("hsk_state = %d, hsk_ses %d, dg_ses %d\n",ep->hsk_state, ep->hsk_session, dg->session);
|
||||
|
||||
if (hsk_start) { |
||||
// peer requests origin
|
||||
sbmp_info("Rx HSK request"); |
||||
|
||||
if (ep->hsk_state == SBMP_HSK_AWAIT_REPLY) { |
||||
// conflict occured - we're already waiting for a reply.
|
||||
sbmp_ep_send_response(ep, SBMP_DG_HSK_CONFLICT, our_info_pld, HSK_PAYLOAD_LEN, dg->session, NULL); |
||||
ep->hsk_state = SBMP_HSK_CONFLICT; |
||||
|
||||
sbmp_error("HSK conflict"); |
||||
} else { |
||||
// we're idle, accept the request.
|
||||
bool peer_origin = (dg->session & 0x8000) >> 15; |
||||
sbmp_ep_set_origin(ep, !peer_origin); |
||||
|
||||
// read peer's info
|
||||
if (dg->length >= HSK_PAYLOAD_LEN) { |
||||
parse_peer_hsk_buf(ep, dg->payload); |
||||
} |
||||
|
||||
ep->hsk_state = SBMP_HSK_SUCCESS; |
||||
|
||||
// Send Accept response
|
||||
sbmp_ep_send_response(ep, SBMP_DG_HSK_ACCEPT, our_info_pld, HSK_PAYLOAD_LEN, dg->session, NULL); |
||||
} |
||||
} else if (hsk_accept) { |
||||
// peer accepted our request
|
||||
sbmp_info("Rx HSK accept"); |
||||
|
||||
if (ep->hsk_state != SBMP_HSK_AWAIT_REPLY || ep->hsk_session != dg->session) { |
||||
// but we didn't send any request
|
||||
sbmp_error("Rx unexpected HSK accept, ignoring."); |
||||
|
||||
} else { |
||||
// OK, we were waiting for this reply
|
||||
|
||||
// read peer's info
|
||||
if (dg->length >= HSK_PAYLOAD_LEN) { |
||||
parse_peer_hsk_buf(ep, dg->payload); |
||||
} |
||||
|
||||
ep->hsk_state = SBMP_HSK_SUCCESS; |
||||
} |
||||
} else if (hsk_conflict) { |
||||
// peer rejected our request due to conflict
|
||||
sbmp_info("Rx HSK conflict"); |
||||
|
||||
if (ep->hsk_state != SBMP_HSK_AWAIT_REPLY || ep->hsk_session != dg->session) { |
||||
// but we didn't send any request
|
||||
sbmp_error("Rx unexpected HSK conflict, ignoring."); |
||||
} else { |
||||
// Acknowledge the conflict
|
||||
|
||||
// reset everything
|
||||
sbmp_frm_reset(&ep->frm); |
||||
|
||||
ep->hsk_state = SBMP_HSK_CONFLICT; |
||||
} |
||||
} |
||||
|
||||
} else { |
||||
// Not a HSK message
|
||||
ep->rx_handler(dg); |
||||
} |
||||
} |
||||
|
||||
@ -0,0 +1,207 @@ |
||||
#ifndef SBMP_SESSION_H |
||||
#define SBMP_SESSION_H |
||||
|
||||
/**
|
||||
* SBMP session layer |
||||
* |
||||
* This layer provides an abstraction over all of SBMP. |
||||
* |
||||
* Start by creating "endpoint" with sbmp_ep_init(), then configure and enable it. |
||||
* |
||||
* Next you should trigger a handshake, which assigns your endpoint the origin bit, |
||||
* and obtains information about your peer (it's buffer size and preferred checksum). |
||||
* |
||||
* You can still interact with the framing layer directly, but it shouldn't be needed. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include "sbmp_config.h" |
||||
#include "sbmp_datagram.h" |
||||
#include "sbmp_frame.h" |
||||
|
||||
typedef enum { |
||||
SBMP_HSK_NOT_STARTED = 0, /*!< Initial state, unconfigured */ |
||||
SBMP_HSK_SUCCESS = 1, /*!< Handshake done, origin assigned. */ |
||||
SBMP_HSK_AWAIT_REPLY = 2, /*!< Request sent, awaiting a reply */ |
||||
SBMP_HSK_CONFLICT = 3, /*!< Conflict occured during HSK */ |
||||
} SBMP_HandshakeStatus; |
||||
|
||||
|
||||
/** SBMP Endpoint (session) structure */ |
||||
typedef struct { |
||||
bool origin; /*!< Local origin bit */ |
||||
uint16_t next_session; /*!< Next session number */ |
||||
|
||||
void (*rx_handler)(SBMP_Datagram *dg); /*!< Datagram receive handler */ |
||||
|
||||
SBMP_FrmInst frm; /*!< Framing layer internal state */ |
||||
|
||||
// Handshake
|
||||
SBMP_HandshakeStatus hsk_state; /*!< Handshake progress */ |
||||
uint16_t hsk_session; /*!< Session number of the handshake request message */ |
||||
uint16_t peer_buffer_size; /*!< Peer's buffer size (obtained during handshake) */ |
||||
SBMP_CksumType peer_pref_cksum; /*!< Peer's preferred checksum type */ |
||||
|
||||
// Our info for the peer
|
||||
uint16_t buffer_size; /*!< Our buffer size */ |
||||
SBMP_CksumType pref_cksum; /*!< Our preferred checksum */ |
||||
|
||||
SBMP_Datagram static_dg; /*!< Static datagram, used when DG is pased to a callback.
|
||||
This way the datagram remains valid until next Frm Rx, |
||||
not only until the callback ends. Disabling the EP in the Rx |
||||
callback lets you preserve the Dg for a longer period - |
||||
i.e. put it in a global var, where a loop retrieves it. */ |
||||
} SBMP_Endpoint; |
||||
|
||||
|
||||
/**
|
||||
* @brief Initialize the endpoint. |
||||
* |
||||
* @note about the Rx handler: |
||||
* The datagram is valid until a new payload byte is received by the Frm. |
||||
* Disable the endpoint (-> thus also Frm) in the callback if you need |
||||
* to keep the Dg longer. Then re-enable it after the Dg is processed. |
||||
* |
||||
* @param ep : Endpoint struct pointer, or NULL to allocate one. |
||||
* @param buffer : Rx buffer. NULL to allocate one. |
||||
* @param buffer_size : Rx buffer length |
||||
* @param dg_rx_handler : Datagram received handler. |
||||
* @param tx_func : Function to send a byte to USART |
||||
* @return the endpoint struct pointer (allocated if ep was NULL) |
||||
*/ |
||||
SBMP_Endpoint *sbmp_ep_init(SBMP_Endpoint *ep, |
||||
uint8_t *buffer, |
||||
uint16_t buffer_size, |
||||
void (*dg_rx_handler)(SBMP_Datagram *dg), |
||||
void (*tx_func)(uint8_t byte)); |
||||
|
||||
/**
|
||||
* @brief Reset an endpoint and it's Framing Layer |
||||
* |
||||
* This discards all state information. |
||||
* |
||||
* @param ep : Endpoint |
||||
*/ |
||||
void sbmp_ep_reset(SBMP_Endpoint *ep); |
||||
|
||||
/** Set session number (good to randomize before starting a handshake) */ |
||||
void sbmp_ep_seed_session(SBMP_Endpoint *ep, uint16_t sesn); |
||||
|
||||
/**
|
||||
* Set the origin bit. |
||||
* This can be used instead of handshake if origins are pre-assigned. |
||||
*/ |
||||
void sbmp_ep_set_origin(SBMP_Endpoint *endp, bool bit); |
||||
|
||||
/** Set the preferred checksum for this peer. */ |
||||
void sbmp_ep_set_preferred_cksum(SBMP_Endpoint *endp, SBMP_CksumType cksum_type); |
||||
|
||||
/**
|
||||
* @brief Start a message as a reply, with CRC32 |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param type : Datagram type ID |
||||
* @param length : Datagram payload length (bytes) |
||||
* @param sesn : Session number of message this is a reply to. |
||||
* @return success |
||||
*/ |
||||
bool sbmp_ep_start_response(SBMP_Endpoint *ep, SBMP_DgType type, uint16_t length, uint16_t sesn); |
||||
|
||||
/**
|
||||
* @brief Start a message in a new session, with CRC32 |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param type : Datagram type ID |
||||
* @param length : Datagram payload length (bytes) |
||||
* @param sesn : Var to store session number, NULL = don't store. |
||||
* @return success |
||||
*/ |
||||
bool sbmp_ep_start_session(SBMP_Endpoint *ep, SBMP_DgType type, uint16_t length, uint16_t *sesn_ptr); |
||||
|
||||
/**
|
||||
* @brief Send one byte in the current message |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param byte : byte to send |
||||
* @return true on success |
||||
*/ |
||||
bool sbmp_ep_send_byte(SBMP_Endpoint *ep, uint8_t byte); |
||||
|
||||
/**
|
||||
* @brief Send a data buffer (or a part) in the current message |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param buffer : buffer of bytes to send |
||||
* @param length : buffer length (byte count) |
||||
* @return actual sent length (until payload is full) |
||||
*/ |
||||
uint16_t sbmp_ep_send_buffer(SBMP_Endpoint *ep, const uint8_t *buffer, uint16_t length); |
||||
|
||||
/**
|
||||
* @brief Send a message in a new session. |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param type : Datagram type ID |
||||
* @param buffer : Buffer with data to send |
||||
* @param length : Datagram payload length (bytes) |
||||
* @param sesn_ptr : Session number |
||||
* @param sent_bytes_ptr : Var to store NR of sent bytes. NULL = don't store. |
||||
* @return success |
||||
*/ |
||||
bool sbmp_ep_send_response( |
||||
SBMP_Endpoint *ep, |
||||
SBMP_DgType type, |
||||
const uint8_t *buffer, |
||||
uint16_t length, |
||||
uint16_t sesn_ptr, |
||||
uint16_t *sent_bytes_ptr); |
||||
|
||||
/**
|
||||
* @brief Send a message in a new session. |
||||
* |
||||
* @param ep : Endpoint struct |
||||
* @param type : Datagram type ID |
||||
* @param buffer : Buffer with data to send |
||||
* @param length : Datagram payload length (bytes) |
||||
* @param sesn_ptr : Var to store session number. NULL = don't store. |
||||
* @param sent_bytes_ptr : Var to store NR of sent bytes. NULL = don't store. |
||||
* @return success |
||||
*/ |
||||
bool sbmp_ep_send_message( |
||||
SBMP_Endpoint *ep, |
||||
SBMP_DgType type, |
||||
const uint8_t *buffer, |
||||
uint16_t length, |
||||
uint16_t *sesn, |
||||
uint16_t *sent_bytes); |
||||
|
||||
/**
|
||||
* @brief Start a handshake (origin bit arbitration) |
||||
* @param ep : Endpoint struct |
||||
*/ |
||||
bool sbmp_ep_start_handshake(SBMP_Endpoint *ep); |
||||
|
||||
/**
|
||||
* @brief Receive a byte from USART (is passed to the framing layer) |
||||
* @param ep : Endpoint struct |
||||
* @param byte : Byte received from USART |
||||
* @return true if byte was consumed |
||||
*/ |
||||
SBMP_RxStatus sbmp_ep_receive(SBMP_Endpoint *ep, uint8_t byte); |
||||
|
||||
/** Get current handshake state */ |
||||
SBMP_HandshakeStatus sbmp_ep_handshake_status(SBMP_Endpoint *ep); |
||||
|
||||
/** Enable or disable both Rx and TX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable(SBMP_Endpoint *ep, bool enable); |
||||
|
||||
/** Enable or disable RX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable_rx(SBMP_Endpoint *ep, bool enable_rx); |
||||
|
||||
/** Enable or disable TX in the FrmInst backing this Endpoint */ |
||||
void sbmp_ep_enable_tx(SBMP_Endpoint *ep, bool enable_tx); |
||||
|
||||
#endif /* SBMP_SESSION_H */ |
||||
@ -0,0 +1,27 @@ |
||||
#include "esp8266.h" |
||||
#include "uart_driver.h" |
||||
#include "sbmp.h" |
||||
|
||||
#include "datalink.h" |
||||
|
||||
/** func used for sending bytes by SBMP */ |
||||
static void u0_putc(uint8_t c) |
||||
{ |
||||
UART_WriteCharCRLF(UART0, c, 0); |
||||
} |
||||
|
||||
|
||||
static void dg_handler(SBMP_Datagram *dg) |
||||
{ |
||||
sbmp_info("Datagram received."); |
||||
} |
||||
|
||||
|
||||
|
||||
static SBMP_Endpoint *ep; |
||||
|
||||
/** Datalink */ |
||||
void datalinkInit(void) |
||||
{ |
||||
ep = sbmp_ep_init(NULL, NULL, 256, dg_handler, u0_putc); |
||||
} |
||||
@ -0,0 +1,6 @@ |
||||
#ifndef DATALINK_H |
||||
#define DATALINK_H |
||||
|
||||
void datalinkInit(void); |
||||
|
||||
#endif // DATALINK_H
|
||||
Loading…
Reference in new issue