MightyPork
/
TinyFrame
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

beta code, needs testing. Adjustable field sizes, crc16 option, dedicated Type field

Browse Source
pull/9/head
Ondřej Hruška 8 years ago
parent 60a2a90059
commit c83cdf36e2
5 changed files with 600 additions and 368 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 3
      .gitignore
  2. 11
      CMakeLists.txt
  3. 705
      TinyFrame.c
  4. 211
      TinyFrame.h
  5. 38
      test.c

3
.gitignore vendored
Unescape View File

@ -31,3 +31,6 @@
# Debug files
*.dSYM/
*.su
cmake-build-debug/
tf.bin

11
CMakeLists.txt
Unescape View File

@ -0,0 +1,11 @@
cmake_minimum_required(VERSION 3.7)
project(tf)
set(CMAKE_CXX_STANDARD GNU99)
set(SOURCE_FILES
test.c
TinyFrame.c
TinyFrame.h)
add_executable(tf ${SOURCE_FILES})

705
TinyFrame.c
Unescape View File

@ -3,351 +3,502 @@
#include <string.h>
//---------------------------------------------------------------------------
/* Note: payload length determines the Rx buffer size. Max 256 */
#define TF_MAX_PAYLOAD 256
#define TF_SOF_BYTE 0x01
enum TFState {
TFState_SOF = 0, //!< Wait for SOF
TFState_ID, //!< Wait for ID
TFState_NOB, //!< Wait for Number Of Bytes
TFState_PAYLOAD, //!< Receive payload
TFState_CKSUM //!< Wait for Checksum
TFState_SOF = 0, //!< Wait for SOF
TFState_LEN, //!< Wait for Number Of Bytes
TFState_HEAD_CKSUM, //!< Wait for header Checksum
TFState_ID, //!< Wait for ID
TFState_TYPE, //!< Wait for message type
TFState_DATA, //!< Receive payload
TFState_DATA_CKSUM, //!< Wait for Checksum
};
typedef struct _IdListener_struct {
unsigned int id;
TinyFrameListener fn;
unsigned int id;
TF_LISTENER fn;
} IdListener;
typedef struct _TypeListener_struct_ {
unsigned char type;
TinyFrameListener fn;
unsigned char type;
TF_LISTENER fn;
} TypeListener;
typedef struct _GenericListener_struct_ {
TinyFrameListener fn;
TF_LISTENER fn;
} GenericListener;
/**
* Frame parser internal state
*/
static struct TinyFrameStruct {
/* Own state */
bool peer_bit; //!< Own peer bit (unqiue to avoid msg ID clash)
unsigned int next_id; //!< Next frame / frame chain ID
/* Parser state */
enum TFState state;
unsigned int id; //!< Incoming packet ID
unsigned int nob; //!< Payload length
unsigned char pldbuf[TF_MAX_PAYLOAD+1]; //!< Payload byte buffer
unsigned int rxi; //!< Receive counter (for payload or other fields)
unsigned int cksum; //!< Continually updated checksum
/* --- Callbacks --- */
/* Transaction callbacks */
IdListener id_listeners[TF_MAX_ID_LST];
TypeListener type_listeners[TF_MAX_TYPE_LST];
GenericListener generic_listeners[TF_MAX_GEN_LST];
char sendbuf[TF_MAX_PAYLOAD+1];
/* Own state */
TF_PEER peer_bit; //!< Own peer bit (unqiue to avoid msg ID clash)
TF_ID next_id; //!< Next frame / frame chain ID
/* Parser state */
enum TFState state;
int parser_timeout_ticks;
TF_ID id; //!< Incoming packet ID
TF_LEN len; //!< Payload length
uint8_t data[TF_MAX_PAYLOAD]; //!< Data byte buffer
size_t rxi; //!< Byte counter
TF_CKSUM cksum; //!< Checksum calculated of the data stream
TF_CKSUM ref_cksum; //!< Reference checksum read from the message
TF_TYPE type; //!< Collected message type number
/* --- Callbacks --- */
/* Transaction callbacks */
IdListener id_listeners[TF_MAX_ID_LST];
TypeListener type_listeners[TF_MAX_TYPE_LST];
GenericListener generic_listeners[TF_MAX_GEN_LST];
size_t count_id_lst;
size_t count_type_lst;
size_t count_generic_lst;
uint8_t sendbuf[TF_MAX_PAYLOAD + TF_OVERHEAD_BYTES];
} tf;
void TF_Init(bool peer_bit)
{
memset(&tf, 0, sizeof(struct TinyFrameStruct));
tf.peer_bit = peer_bit;
}
//region Optional impls
#if TF_USE_CRC16
// ---- CRC16 checksum impl ----
/** CRC table for the CRC-16. The poly is 0x8005 (x^16 + x^15 + x^2 + 1) */
const uint16_t crc16_table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};
void TF_ResetParser(void)
static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data)
{
tf.state = TFState_SOF;
tf.cksum = 0;
return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
}
int TF_AddIdListener(unsigned int frame_id, TinyFrameListener cb)
{
int i;
#endif
//endregion Optional impls
for (i = 0; i < TF_MAX_ID_LST; i++) {
if (tf.id_listeners[i].fn == NULL) {
tf.id_listeners[i].fn = cb;
tf.id_listeners[i].id = frame_id;
return i;
}
}
// --- macros based on config ---
return TF_ERROR;
}
#define CKSUM_RESET(cksum) do { cksum = 0; } while (0)
#if TF_USE_CRC16
// CRC16 checksum
#define CKSUM_ADD(cksum, byte) do { cksum = crc16_byte(cksum, byte); } while(0)
#else
// XOR checksum
#define CKSUM_ADD(cksum, byte) do { cksum ^= byte; } while(0)
#endif
int TF_AddTypeListener(unsigned char frame_type, TinyFrameListener cb)
{
int i;
for (i = 0; i < TF_MAX_TYPE_LST; i++) {
if (tf.type_listeners[i].fn == NULL) {
tf.type_listeners[i].fn = cb;
tf.type_listeners[i].type = frame_type;
return TF_MAX_ID_LST + i;
}
}
void TF_Init(TF_PEER peer_bit)
{
// Zero it out
memset(&tf, 0, sizeof(struct TinyFrameStruct));
return TF_ERROR;
tf.peer_bit = peer_bit;
}
int TF_AddGenericListener(TinyFrameListener cb)
//region Listeners
bool TF_AddIdListener(TF_ID frame_id, TF_LISTENER cb)
{
int i;
size_t i;
for (i = 0; i < TF_MAX_ID_LST; i++) {
if (tf.id_listeners[i].fn == NULL) {
tf.id_listeners[i].fn = cb;
tf.id_listeners[i].id = frame_id;
if (i >= tf.count_id_lst) {
tf.count_id_lst = i + 1;
}
return true;
}
}
return false;
}
for (i = 0; i < TF_MAX_GEN_LST; i++) {
if (tf.generic_listeners[i].fn == NULL) {
tf.generic_listeners[i].fn = cb;
return TF_MAX_ID_LST + TF_MAX_TYPE_LST + i;
}
}
bool TF_AddTypeListener(unsigned char frame_type, TF_LISTENER cb)
{
size_t i;
for (i = 0; i < TF_MAX_TYPE_LST; i++) {
if (tf.type_listeners[i].fn == NULL) {
tf.type_listeners[i].fn = cb;
tf.type_listeners[i].type = frame_type;
if (i >= tf.count_type_lst) {
tf.count_type_lst = i + 1;
}
return true;
}
}
return false;
}
return TF_ERROR;
bool TF_AddGenericListener(TF_LISTENER cb)
{
size_t i;
for (i = 0; i < TF_MAX_GEN_LST; i++) {
if (tf.generic_listeners[i].fn == NULL) {
tf.generic_listeners[i].fn = cb;
if (i >= tf.count_generic_lst) {
tf.count_generic_lst = i + 1;
}
return true;
}
}
return false;
}
void TF_RemoveListener(unsigned int index)
bool TF_RemoveIdListener(TF_ID frame_id)
{
// all listener arrays share common "address space"
if (index < TF_MAX_ID_LST) {
tf.id_listeners[index].fn = NULL;
}
else if (index < TF_MAX_ID_LST + TF_MAX_TYPE_LST) {
tf.type_listeners[index - TF_MAX_ID_LST].fn = NULL;
}
else if (index < TF_MAX_ID_LST + TF_MAX_TYPE_LST + TF_MAX_GEN_LST) {
tf.generic_listeners[index - TF_MAX_ID_LST - TF_MAX_TYPE_LST].fn = NULL;
}
size_t i;
for (i = 0; i < tf.count_id_lst; i++) {
if (tf.id_listeners[i].fn != NULL
&& tf.id_listeners[i].id == frame_id) {
tf.id_listeners[i].fn = NULL;
if (i == tf.count_id_lst - 1) {
tf.count_id_lst--;
}
return true;
}
}
return false;
}
void TF_RemoveIdListener(unsigned int frame_id)
bool TF_RemoveTypeListener(unsigned char type)
{
int i;
for (i = 0; i < TF_MAX_ID_LST; i++) {
if (tf.id_listeners[i].fn != NULL && tf.id_listeners[i].id == frame_id) {
tf.id_listeners[i].fn = NULL;
}
}
size_t i;
for (i = 0; i < tf.count_type_lst; i++) {
if (tf.type_listeners[i].fn != NULL
&& tf.type_listeners[i].type == type) {
tf.type_listeners[i].fn = NULL;
if (i == tf.count_type_lst - 1) {
tf.count_type_lst--;
}
return true;
}
}
return false;
}
void TF_RemoveTypeListener(unsigned char type)
bool TF_RemoveGenericListener(TF_LISTENER cb)
{
int i;
for (i = 0; i < TF_MAX_TYPE_LST; i++) {
if (tf.type_listeners[i].fn != NULL && tf.type_listeners[i].type == type) {
tf.type_listeners[i].fn = NULL;
}
}
size_t i;
for (i = 0; i < tf.count_generic_lst; i++) {
if (tf.generic_listeners[i].fn == cb) {
tf.generic_listeners[i].fn = NULL;
if (i == tf.count_generic_lst - 1) {
tf.count_generic_lst--;
}
return true;
}
}
return false;
}
void TF_RemoveListenerFn(TinyFrameListener cb)
/** Handle a message that was just collected & verified by the parser */
static void TF_HandleReceivedMessage(TF_ID frame_id, TF_TYPE type, uint8_t *data)
{
int i;
for (i = 0; i < TF_MAX_ID_LST; i++) {
if (tf.id_listeners[i].fn == cb) {
tf.id_listeners[i].fn = NULL;
}
}
for (i = 0; i < TF_MAX_TYPE_LST; i++) {
if (tf.type_listeners[i].fn == cb) {
tf.type_listeners[i].fn = NULL;
}
}
for (i = 0; i < TF_MAX_GEN_LST; i++) {
if (tf.generic_listeners[i].fn == cb) {
tf.generic_listeners[i].fn = NULL;
}
}
size_t i;
// Any listener can consume the message (return true),
// or let someone else handle it.
// The loop upper bounds are the highest currently used slot index
// (or close to it, depending on the order of listener removals)
// ID listeners first
for (i = 0; i < tf.count_id_lst; i++) {
if (tf.id_listeners[i].fn && tf.id_listeners[i].id == tf.id) {
if (tf.id_listeners[i].fn(tf.id, tf.type, tf.data, tf.len)) {
return;
}
}
}
// Type listeners
for (i = 0; i < tf.count_type_lst; i++) {
if (tf.type_listeners[i].fn && tf.type_listeners[i].type == tf.type) {
if (tf.type_listeners[i].fn(tf.id, tf.type, tf.data, tf.len)) {
return;
}
}
}
// Generic listeners
for (i = 0; i < tf.count_generic_lst; i++) {
if (tf.generic_listeners[i].fn) {
if (tf.generic_listeners[i].fn(tf.id, tf.type, tf.data, tf.len)) {
return;
}
}
}
}
void TF_Accept(const unsigned char *buffer, unsigned int count)
//endregion Listeners
void TF_Accept(const uint8_t *buffer, size_t count)
{
unsigned int i;
size_t i;
for (i = 0; i < count; i++) {
TF_AcceptChar(buffer[i]);
}
}
for (i = 0; i < count; i++) {
TF_AcceptChar(buffer[i]);
}
void TF_ResetParser(void)
{
tf.state = TFState_SOF;
}
void TF_AcceptChar(unsigned char c)
{
int i;
bool rv, brk;
switch (tf.state)
{
case TFState_SOF:
if (c == TF_SOF_BYTE) {
tf.cksum = 0;
tf.state = TFState_ID;
}
break;
case TFState_ID:
tf.id = c;
tf.state = TFState_NOB;
break;
case TFState_NOB:
tf.nob = c + 1; // using 0..255 as 1..256
tf.state = TFState_PAYLOAD;
tf.rxi = 0;
break;
case TFState_PAYLOAD:
tf.pldbuf[tf.rxi++] = c;
if (tf.rxi == tf.nob) {
tf.state = TFState_CKSUM;
}
break;
case TFState_CKSUM:
tf.state = TFState_SOF;
if (tf.cksum == (unsigned int)c) {
// Add 0 at the end of the data in the buffer (useful if it was a string)
tf.pldbuf[tf.rxi] = '\0';
brk = false;
// Fire listeners
for (i = 0; i < TF_MAX_ID_LST; i++) {
if (tf.id_listeners[i].fn && tf.id_listeners[i].id == tf.id) {
rv = tf.id_listeners[i].fn(tf.id, tf.pldbuf, tf.nob);
if (rv) {
brk = true;
break;
}
}
}
if (!brk) {
for (i = 0; i < TF_MAX_TYPE_LST; i++) {
if (tf.type_listeners[i].fn &&
tf.type_listeners[i].type == tf.pldbuf[0]) {
rv = tf.type_listeners[i].fn(tf.id, tf.pldbuf, tf.nob);
if (rv) {
brk = true;
break;
}
}
}
}
if (!brk) {
for (i = 0; i < TF_MAX_GEN_LST; i++) {
if (tf.generic_listeners[i].fn) {
rv = tf.generic_listeners[i].fn(tf.id, tf.pldbuf, tf.nob);
if (rv) {
break;
}
}
}
}
} else {
// Fail, return to base state
tf.state = TFState_SOF;
}
break;
}
// Update the checksum
tf.cksum ^= c;
// QUEUE IF PARSER LOCKED
// FIRST PROCESS ALL QUEUED
// Timeout - clear
if (tf.parser_timeout_ticks >= TF_PARSER_TIMEOUT_TICKS) {
TF_ResetParser();
}
tf.parser_timeout_ticks = 0;
// DRY snippet - collect multi-byte number from the input stream
#define COLLECT_NUMBER(dest, type) dest = ((dest) << 8) | c; \
if (++tf.rxi == sizeof(type))
switch (tf.state) {
case TFState_SOF:
if (c == TF_SOF_BYTE) {
// Enter LEN state
tf.state = TFState_LEN;
tf.len = 0;
tf.rxi = 0;
// Reset state vars
CKSUM_RESET(tf.cksum);
}
break;
case TFState_LEN:
CKSUM_ADD(tf.cksum, c);
COLLECT_NUMBER(tf.len, TF_LEN) {
// enter HEAD_CKSUM state
tf.state = TFState_HEAD_CKSUM;
tf.ref_cksum = 0;
tf.rxi = 0;
}
break;
case TFState_HEAD_CKSUM:
COLLECT_NUMBER(tf.ref_cksum, TF_CKSUM){
// Check the header checksum against the computed value
if (tf.cksum != tf.ref_cksum) {
TF_ResetParser();
break;
}
// Enter ID state
tf.state = TFState_ID;
tf.rxi = 0;
tf.cksum = 0; // Start collecting the payload
}
break;
case TFState_ID:
CKSUM_ADD(tf.cksum, c);
COLLECT_NUMBER(tf.id, TF_ID) {
// Enter TYPE state
tf.state = TFState_TYPE;
tf.rxi = 0;
}
break;
case TFState_TYPE:
CKSUM_ADD(tf.cksum, c);
COLLECT_NUMBER(tf.type, TF_TYPE) {
// Enter DATA state
tf.state = TFState_DATA;
tf.rxi = 0;
}
break;
case TFState_DATA:
CKSUM_ADD(tf.cksum, c);
tf.data[tf.rxi++] = c;
if (tf.rxi == tf.len) {
// Enter DATA_CKSUM state
tf.state = TFState_DATA_CKSUM;
tf.rxi = 0;
tf.ref_cksum = 0;
}
break;
case TFState_DATA_CKSUM:
COLLECT_NUMBER(tf.ref_cksum, TF_CKSUM) {
// Check the header checksum against the computed value
if (tf.cksum == tf.ref_cksum) {
// LOCK PARSER
TF_HandleReceivedMessage(tf.id, tf.type, tf.data);
// UNLOCK PARSER
}
TF_ResetParser();
}
break;
}
}
int TF_Compose(unsigned char *outbuff, unsigned int *msgid,
const unsigned char *payload, unsigned int payload_len,
int explicit_id
) {
unsigned int i;
unsigned int id;
int xor;
// sanitize len
if (payload_len > TF_MAX_PAYLOAD) return TF_ERROR;
if (payload_len == 0) payload_len = strlen(payload);
// Gen ID
if (explicit_id == TF_NEXT_ID) {
id = tf.next_id++;
if (tf.peer_bit) {
id |= 0x80;
}
if (tf.next_id > 0x7F) {
tf.next_id = 0;
}
} else {
id = explicit_id;
}
outbuff[0] = TF_SOF_BYTE;
outbuff[1] = id & 0xFF;
outbuff[2] = (payload_len - 1) & 0xFF; // use 0..255 as 1..256
memcpy(outbuff+3, payload, payload_len);
xor = 0;
for (i = 0; i < payload_len + 3; i++) {
xor ^= outbuff[i];
}
outbuff[payload_len + 3] = xor;
if (msgid != NULL) *msgid = id;
return payload_len + 4;
int TF_Compose(uint8_t *outbuff, TF_ID *id_ptr,
TF_TYPE type,
const uint8_t *data, TF_LEN data_len,
TF_ID explicit_id, bool use_expl_id)
{
int i;
uint8_t b;
TF_ID id;
TF_CKSUM cksum;
int pos = 0;
CKSUM_RESET(cksum);
// sanitize len
if (data_len > TF_MAX_PAYLOAD) {
return TF_ERROR;
}
// Gen ID
if (use_expl_id) {
id = explicit_id;
}
else {
id = (TF_ID) ((tf.next_id++) & TF_ID_MASK);
if (tf.peer_bit) {
id |= TF_ID_PEERBIT;
}
}
// DRY helper for writing a multi-byte variable to the buffer
#define WRITENUM_BASE(type, num, xtra) \
for (i = sizeof(type)-1; i>=0; i--) { \
b = (uint8_t)(num >> (i*8) & 0xFF); \
outbuff[pos++] = b; \
xtra; \
}
#define WRITENUM(type, num) WRITENUM_BASE(type, num, )
#define WRITENUM_CKSUM(type, num) WRITENUM_BASE(type, num, CKSUM_ADD(cksum, b))
// --- Start ---
outbuff[pos++] = TF_SOF_BYTE;
cksum = 0;
WRITENUM_CKSUM(TF_LEN, data_len);
WRITENUM(TF_CKSUM, cksum);
// --- payload begin ---
cksum = 0;
WRITENUM_CKSUM(TF_ID, id);
WRITENUM_CKSUM(TF_TYPE, type);
// DATA
for (i = 0; i < data_len; i++) {
b = data[i];
outbuff[pos++] = b;
CKSUM_ADD(cksum, b);
}
WRITENUM(TF_CKSUM, cksum);
if (id_ptr != NULL)
*id_ptr = id;
return pos;
}
int TF_Send(const unsigned char *payload,
unsigned int payload_len,
TinyFrameListener listener,
unsigned int *id_ptr)
bool TF_Send(TF_TYPE type, const uint8_t *payload, TF_LEN payload_len,
TF_LISTENER listener, TF_ID *id_ptr)
{
unsigned int msgid;
int len;
int lstid = TF_ERROR;
len = TF_Compose(tf.sendbuf, &msgid, payload, payload_len, TF_NEXT_ID);
if (listener) lstid = TF_AddIdListener(msgid, listener);
TF_WriteImpl(tf.sendbuf, len);
TF_ID msgid;
int len;
len = TF_Compose(tf.sendbuf, &msgid, type, payload, payload_len, 0, false);
if (len == TF_ERROR) return false;
if (id_ptr) *id_ptr = msgid;
if (listener) TF_AddIdListener(msgid, listener);
if (id_ptr) *id_ptr = msgid;
return lstid;
TF_WriteImpl((const uint8_t *) tf.sendbuf, (TF_LEN)len);
return true;
}
void TF_Respond(const unsigned char *payload,
unsigned int payload_len,
unsigned int frame_id)
bool TF_Respond(TF_TYPE type,
const uint8_t *data, TF_LEN data_len,
TF_ID frame_id)
{
int len;
len = TF_Compose(tf.sendbuf, NULL, payload, payload_len, frame_id);
TF_WriteImpl(tf.sendbuf, len);
}
int len;
len = TF_Compose(tf.sendbuf, NULL, type, data, data_len, frame_id, true);
if (len == TF_ERROR) return false;
TF_WriteImpl(tf.sendbuf, (TF_LEN)len);
return true;
}
int TF_Send1(const unsigned char b0,
TinyFrameListener listener,
unsigned int *id_ptr)
/**
* Like TF_Send(), but with just 1 data byte
*/
bool TF_Send1(TF_TYPE type, uint8_t b1,
TF_LISTENER listener,
TF_ID *id_ptr)
{
unsigned char b[] = {b0};
return TF_Send(b, 1, listener, id_ptr);
unsigned char b[] = {b1};
return TF_Send(type, b, 1, listener, id_ptr);
}
/**
* Like TF_Send(), but with just 2 data bytes
*/
bool TF_Send2(TF_TYPE type, uint8_t b1, uint8_t b2,
TF_LISTENER listener,
TF_ID *id_ptr)
{
unsigned char b[] = {b1, b2};
return TF_Send(type, b, 2, listener, id_ptr);
}
int TF_Send2(const unsigned char b0,
const unsigned char b1,
TinyFrameListener listener,
unsigned int *id_ptr)
void TF_Tick(void)
{
unsigned char b[] = {b0, b1};
return TF_Send(b, 2, listener, id_ptr);
if (tf.parser_timeout_ticks < TF_PARSER_TIMEOUT_TICKS) {
tf.parser_timeout_ticks++;
}
}

211
TinyFrame.h
Unescape View File

@ -1,45 +1,91 @@
#ifndef TinyFrameH
#define TinyFrameH
//---------------------------------------------------------------------------
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h> // for uint8_t etc
#include <stdbool.h> // for bool
#include <stdlib.h> // for NULL
//---------------------------------------------------------------------------
// Frame ID listeners (wait for response / multi-part message)
#ifndef TF_MAX_ID_LST
# define TF_MAX_ID_LST 64
#endif
// A static buffer of this size will be allocated
#define TF_MAX_PAYLOAD 2048
// Frame ID listeners (wait for response / multi-part message)
#define TF_MAX_ID_LST 20
// Frame Type listeners (wait for frame with a specific first payload byte)
#ifndef TF_MAX_TYPE_LST
# define TF_MAX_TYPE_LST 16
#endif
#define TF_MAX_TYPE_LST 20
// Generic listeners (fallback if no other listener catches it)
#ifndef TF_MAX_GEN_LST
# define TF_MAX_GEN_LST 4
#define TF_MAX_GEN_LST 4
// Timeout for receiving & parsing a frame
// ticks = number of calls to TF_Tick()
#define TF_PARSER_TIMEOUT_TICKS 10
#define TF_USE_CRC16 1
//---------------------------------------------------------------------------
// ,-----+-----+-----------+----+------+- - - -+------------,
// | SOF | LEN | LEN_CKSUM | ID | TYPE | DATA | PLD_CKSUM |
// | 1 | 2? | 1? | 1? | 1? | ... | 1? |
// '-----+-----+-----------+----+------+- - - -+------------'
// '----- payload -----'
// The data section is designed thus so the higher levels of TinyFrame
// (message chaining, listeners etc) could be re-used for a different
// framing layer (e.g. sent in UDP packets)
// Fields marked '?' can have their size adjusted by changing the
// typedefs below
// Change those typedefs to adjust the field sizes. BOTH PEERS MUST HAVE THE SAME SIZES!
typedef uint8_t TF_ID; // Message ID. Effectively limits the nr of concurrent request-response sessions.
typedef uint8_t TF_TYPE; // Message type (sent together with the data payload, which can be empty)
typedef uint16_t TF_LEN; // Length of the data payload.
// TF_OVERHEAD_BYTES - added to TF_MAX_PAYLOAD for the send buffer size.
// (TODO - buffer-less sending)
#if TF_USE_CRC16
typedef uint16_t TF_CKSUM;
#define TF_OVERHEAD_BYTES 9
#else
typedef uint8_t TF_CKSUM;
#define TF_OVERHEAD_BYTES 7
#endif
#define TF_NEXT_ID -1
//---------------------------------------------------------------------------
#define TF_SOF_BYTE 0x01
#define TF_ERROR -1
// Type-dependent masks for bit manipulation in the ID field
#define TF_ID_MASK ((1 << (sizeof(TF_ID)*8 - 1)) - 1)
#define TF_ID_PEERBIT (1 << (sizeof(TF_ID)*8) - 1)
typedef enum {
TF_SLAVE = 0,
TF_MASTER = 1,
} TF_PEER;
//---------------------------------------------------------------------------
/**
* TinyFrame receive callback type.
* TinyFrame Type Listener callback
* @param frame_id - ID of the received frame
* @param buff - byte buffer with the payload
* @param data - byte buffer with the application data
* @param len - number of bytes in the buffer
* @return true if the frame was consumed
*/
typedef bool (*TinyFrameListener)(unsigned int frame_id,
const unsigned char *buff,
unsigned int len);
typedef bool (*TF_LISTENER)(TF_ID frame_id,
TF_TYPE type,
const uint8_t *data, TF_LEN len);
/**
* Initialize the TinyFrame engine.
* This can also be used to completely reset it (removing all listeners etc)
* @param peer_bit - peer bit to use for self
*/
void TF_Init(bool peer_bit);
void TF_Init(TF_PEER peer_bit);
/**
* Reset the frame parser state machine.
@ -51,13 +97,13 @@ void TF_ResetParser(void);
* @param buffer - byte buffer to process
* @param count - nr of bytes in the buffer
*/
void TF_Accept(const unsigned char *buffer, unsigned int count);
void TF_Accept(const uint8_t *buffer, size_t count);
/**
* Accept a single incoming byte
* @param c - a received char
*/
void TF_AcceptChar(unsigned char c);
void TF_AcceptChar(uint8_t c);
/**
* Register a frame type listener.
@ -65,103 +111,118 @@ void TF_AcceptChar(unsigned char c);
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
int TF_AddIdListener(unsigned int frame_id, TinyFrameListener cb);
bool TF_AddIdListener(TF_ID frame_id, TF_LISTENER cb);
/**
* Register a frame type listener.
* @param frame_type - frame type to listen for
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
* Remove a listener by the message ID it's registered for
* @param frame_id - the frame we're listening for
*/
int TF_AddTypeListener(unsigned char frame_type, TinyFrameListener cb);
bool TF_RemoveIdListener(TF_ID frame_id);
/**
* Register a generic listener.
* Register a frame type listener.
* @param frame_type - frame type to listen for
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
int TF_AddGenericListener(TinyFrameListener cb);
/**
* Remove any listener by the index received when registering it
* @param index - index in the callbacks table
*/
void TF_RemoveListener(unsigned int index);
bool TF_AddTypeListener(TF_TYPE frame_type, TF_LISTENER cb);
/**
* Remove a listener by the message ID it's registered for
* @param frame_id - the frame we're listening for
* Remove a listener by type.
* @param type - the type it's registered for
*/
void TF_RemoveIdListener(unsigned int frame_id);
bool TF_RemoveTypeListener(TF_TYPE type);
/**
* Remove a listener by type.
* @param type - the type it's registered for
* Register a generic listener.
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
void TF_RemoveTypeListener(unsigned char type);
bool TF_AddGenericListener(TF_LISTENER cb);
/**
* Remove a callback by the function pointer
* Remove a generic listener by function pointer
* @param cb - callback function to remove
*/
void TF_RemoveListenerFn(TinyFrameListener cb); // search all listener types
bool TF_RemoveGenericListener(TF_LISTENER cb);
/**
* Compose a frame
* Compose a frame (used internally by TF_Send and TF_Respond).
* The frame can be sent using TF_WriteImpl(), or received by TF_Accept()
*
* @param outbuff - buffer to store the result in
* @param msgid - message ID is stored here, if not NULL
* @param payload - data buffer
* @param len - payload size in bytes, 0 to use strlen
* @param explicit_id - ID to use, TF_NEXT_ID (-1) to chose next free
* @param type - message type
* @param data - data buffer
* @param len - payload size in bytes
* @param explicit_id - ID to use in the frame (8-bit)
* @param use_expl_id - whether to use the previous param
* @return nr of bytes in outbuff used by the frame, TF_ERROR (-1) on failure
*/
int TF_Compose(unsigned char *outbuff, unsigned int *msgid,
const unsigned char *payload, unsigned int payload_len,
int explicit_id);
int TF_Compose(uint8_t *outbuff,
TF_ID *id_ptr,
TF_TYPE type,
const uint8_t *data, TF_LEN data_len,
TF_ID explicit_id, bool use_expl_id);
/**
* Send a frame, and optionally attach an ID listener for response.
* Send a frame, and optionally attach an ID listener.
*
* @param payload - data to send
* @param payload_len - nr of bytes to send
* @param type - message type
* @param data - data to send (can be NULL if 'data_len' is 0)
* @param data_len - nr of bytes to send
* @param listener - listener waiting for the response
* @param id_ptr - store the ID here, NULL to don't store.
* The ID may be used to unbind the listener after a timeout.
* @return listener ID if listener was attached, else -1 (FT_ERROR).
* If the listener arg was NULL, returned -1 does not indicate an error.
* @return success
*/
int TF_Send(const unsigned char *payload,
unsigned int payload_len,
TinyFrameListener listener, unsigned int *id_ptr);
bool TF_Send(TF_TYPE type, const uint8_t *data, TF_LEN data_len,
TF_LISTENER listener,
TF_ID *id_ptr);
/**
* A shorthand for TF_Send() with just one byte as the payload
* Like TF_Send(), but with just 1 data byte
*/
int TF_Send1(const unsigned char b0,
TinyFrameListener listener, unsigned int *id_ptr);
bool TF_Send1(TF_TYPE type, uint8_t b1,
TF_LISTENER listener,
TF_ID *id_ptr);
/**
* A shorthand for TF_Send() with just 2 bytes as the payload
* Like TF_Send(), but with just 2 data bytes
*/
int TF_Send2(const unsigned char b0,
const unsigned char b1,
TinyFrameListener listener, unsigned int *id_ptr);
bool TF_Send2(TF_TYPE type, uint8_t b1, uint8_t b2,
TF_LISTENER listener,
TF_ID *id_ptr);
/**
* Send a response to a received message.
*
* @param payload - data to send
* @param payload_len - nr of bytes to send
* @param frame_id - ID of the original frame
* @param type - message type. If an ID listener is waiting for this response,
* then 'type' can be used to pass additional information.
* Otherwise, 'type' can be used to handle the message using a TypeListener.
* @param data - data to send
* @param data_len - nr of bytes to send
* @param frame_id - ID of the response frame (re-use ID from the original message)
* @return success
*/
void TF_Respond(const unsigned char *payload,
unsigned int payload_len,
unsigned int frame_id);
bool TF_Respond(TF_TYPE type,
const uint8_t *data, TF_LEN data_len,
TF_ID frame_id);
/**
* Write implementation for TF, to be provided by user code.
* This sends frames composed by TinyFrame to UART
* 'Write bytes' function that sends data to UART
*
* ! Implement this in your application code !
*/
extern void TF_WriteImpl(const uint8_t *buff, TF_LEN len);
/**
* This function must be called periodically.
*
* The time base is used to time-out partial frames in the parser and
* automatically reset it.
*
* (suggestion - call this in a SysTick handler)
*/
extern void TF_WriteImpl(const unsigned char *buff, unsigned int len);
void TF_Tick(void);
#endif

38
test.c
Unescape View File

@ -3,11 +3,17 @@
#include "TinyFrame.h"
// helper func for testing
static void dumpFrame(const unsigned char *buff, unsigned int len)
static void dumpFrame(const uint8_t *buff, TF_LEN len)
{
int i;
for(i = 0; i < len; i++) {
printf("%3u %c\n", buff[i], buff[i]);
printf("%3u \033[34m%02X\033[0m", buff[i], buff[i]);
if (buff[i] >= 0x20 && buff[i] < 127) {
printf(" %c", buff[i]);
} else {
printf(" \033[31m.\033[0m", buff[i]);
}
printf("\n");
}
printf("--- end of frame ---\n");
}
@ -16,36 +22,35 @@ static void dumpFrame(const unsigned char *buff, unsigned int len)
* This function should be defined in the application code.
* It implements the lowest layer - sending bytes to UART (or other)
*/
void TF_WriteImpl(const unsigned char *buff, unsigned int len)
void TF_WriteImpl(const uint8_t *buff, TF_LEN len)
{
printf("\033[32;1mTF_WriteImpl - sending frame:\033[0m\n");
dumpFrame(buff, len);
}
/** An example listener function */
bool myListener(unsigned int frame_id, const unsigned char *buff, unsigned int len)
bool myListener(TF_ID frame_id, TF_TYPE type, const uint8_t *buff, TF_LEN len)
{
printf("\033[33mrx frame %s, len %d, id %d\033[0m\n", buff, len, frame_id);
return false; // Do not unbind
return true;
}
void main()
{
int i;
int msgid;
TF_ID msgid;
int len;
char buff[100];
// Set up the TinyFrame library
TF_Init(1); // 1 = master, 0 = slave
TF_Init(TF_MASTER); // 1 = master, 0 = slave
printf("------ Simulate sending a message --------\n");
// Send a message
// args - payload, length (0 = strlen), listener, id_ptr (for storing the frame ID)
// (see the .h file for details)
TF_Send("Hello TinyFrame", 0, NULL, NULL);
TF_Respond(0xA5, (unsigned char*)"Hello TinyFrame", 16, 0x15);
// This builds the frame in an internal buffer and sends it to
// TF_WriteImpl()
@ -64,19 +69,20 @@ void main()
//TF_AddIdListener(msgID, myIdListener);
// This lets us compose a frame (it's also used internally by TF_Send and TF_Respond)
len = TF_Compose(buff, // Buffer to write the frame to
&msgid, // Int to store the message ID in
"ALPHA BETA", // Payload bytes
5, // Length - this will cut it at "ALPHA" (showing that it works)
len = TF_Compose((unsigned char*)buff, // Buffer to write the frame to
&msgid, // Int to store the message ID in
0xA5,
(unsigned char*)"Hello TinyFrame", // Payload bytes
16, // Length - this will cut it at "ALPHA" (showing that it works)
// For string, we can use "0" to use strlen() internally
TF_NEXT_ID); // Message ID - we could specify a particular ID if we were
0x15, true); // Message ID - we could specify a particular ID if we were
// trying to build a response frame, which has the same ID
// as the request it responds to.
printf("The frame we'll receive is:\n");
dumpFrame(buff, len);
dumpFrame((unsigned char*)buff, (TF_LEN)len);
// Accept the frame
// You will normally call this method in the UART IRQ handler etc
TF_Accept(buff, len);
TF_Accept((unsigned char*)buff, (TF_LEN)len);
}

Write Preview
Loading…
Cancel
Save