gex/gex-core
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Installed new TinyFrame

Browse Source
This commit is contained in:
MightyPork
2018-01-26 17:23:05 +01:00
parent 3784a46951
commit 255f96c754
6 changed files with 734 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TinyFrame/TF_Config.h
+2 -32
View File
@@ -7,48 +7,18 @@
#include "platform.h" #include "platform.h"
#include <stdint.h> #include <stdint.h>
//#include <esp8266.h> // when using with esphttpd
//----------------------------- FRAME FORMAT ---------------------------------
// The format can be adjusted to fit your particular application needs
// If the connection is reliable, you can disable the SOF byte and checksums.
// That can save up to 9 bytes of overhead.
// ,-----+----+-----+------+------------+- - - -+------------,
// | SOF | ID | LEN | TYPE | HEAD_CKSUM | DATA | PLD_CKSUM |
// | 1 | ? | ? | ? | ? | ... | ? | <- size (bytes)
// '-----+----+-----+------+------------+- - - -+------------'
// !!! BOTH SIDES MUST USE THE SAME SETTINGS !!!
// Adjust sizes as desired (1,2,4)
#define TF_ID_BYTES 2 #define TF_ID_BYTES 2
#define TF_LEN_BYTES 2 #define TF_LEN_BYTES 2
#define TF_TYPE_BYTES 1 #define TF_TYPE_BYTES 1
// Checksum type
//#define TF_CKSUM_TYPE TF_CKSUM_NONE
#define TF_CKSUM_TYPE TF_CKSUM_XOR #define TF_CKSUM_TYPE TF_CKSUM_XOR
//#define TF_CKSUM_TYPE TF_CKSUM_CRC16
//#define TF_CKSUM_TYPE TF_CKSUM_CRC32
// Use a SOF byte to mark the start of a frame
#define TF_USE_SOF_BYTE 1 #define TF_USE_SOF_BYTE 1
// Value of the SOF byte (if TF_USE_SOF_BYTE == 1)
#define TF_SOF_BYTE 0x01 #define TF_SOF_BYTE 0x01
//----------------------- PLATFORM COMPATIBILITY ----------------------------
// used for timeout tick counters - should be large enough for all used timeouts
typedef uint16_t TF_TICKS; typedef uint16_t TF_TICKS;
// used in loops iterating over listeners
typedef uint8_t TF_COUNT; typedef uint8_t TF_COUNT;
#define TF_USE_MUTEX 1
//----------------------------- PARAMETERS ---------------------------------- // buffer sizes and listener counts are in plat_compat.h
// buffers, counts and timeout are defined in plat_compat.h
#define TF_Error(format, ...) dbg("[TF] " format, ##__VA_ARGS__) #define TF_Error(format, ...) dbg("[TF] " format, ##__VA_ARGS__)
TinyFrame/TF_Integration.c
+4 -2
View File
@@ -14,7 +14,7 @@
extern osSemaphoreId semVcomTxReadyHandle; extern osSemaphoreId semVcomTxReadyHandle;
extern osMutexId mutTinyFrameTxHandle; extern osMutexId mutTinyFrameTxHandle;
void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len) void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
{ {
(void) tf; (void) tf;
#define CHUNK 64 // same as TF_SENDBUF_LEN, so we should always have only one run of the loop #define CHUNK 64 // same as TF_SENDBUF_LEN, so we should always have only one run of the loop
@@ -30,13 +30,15 @@ void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len)
} }
/** Claim the TX interface before composing and sending a frame */ /** Claim the TX interface before composing and sending a frame */
void TF_ClaimTx(TinyFrame *tf) bool TF_ClaimTx(TinyFrame *tf)
{ {
(void) tf; (void) tf;
assert_param(osThreadGetId() != tskMainHandle); assert_param(osThreadGetId() != tskMainHandle);
assert_param(!inIRQ()); assert_param(!inIRQ());
assert_param(osOK == osMutexWait(mutTinyFrameTxHandle, 5000)); assert_param(osOK == osMutexWait(mutTinyFrameTxHandle, 5000));
return true;
} }
/** Free the TX interface after composing and sending a frame */ /** Free the TX interface after composing and sending a frame */
TinyFrame/TinyFrame.c
+288 -129
View File
@@ -1,6 +1,6 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "TinyFrame.h" #include "TinyFrame.h"
#include <malloc.h> #include <stdlib.h> // - for malloc() if dynamic constructor is used
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Compatibility with ESP8266 SDK // Compatibility with ESP8266 SDK
@@ -10,35 +10,94 @@
#define _TF_FN #define _TF_FN
#endif #endif
// Helper macros
#define TF_MAX(a, b) ((a)>(b)?(a):(b))
#define TF_MIN(a, b) ((a)<(b)?(a):(b))
// TODO It would be nice to have per-instance configurable checksum types, but that would // Helper macros
// mandate configurable field sizes unless we use u32 everywhere (and possibly shorten #define TF_MIN(a, b) ((a)<(b)?(a):(b))
// it when encoding to the buffer). I don't really like this idea so much. -MP #define TF_TRY(func) do { if(!(func)) return false; } while (0)
// Type-dependent masks for bit manipulation in the ID field
#define TF_ID_MASK (TF_ID)(((TF_ID)1 << (sizeof(TF_ID)*8 - 1)) - 1)
#define TF_ID_PEERBIT (TF_ID)((TF_ID)1 << ((sizeof(TF_ID)*8) - 1))
#if !TF_USE_MUTEX
// Not thread safe lock implementation, used if user did not provide a better one.
// This is less reliable than a real mutex, but will catch most bugs caused by
// inappropriate use fo the API.
/** Claim the TX interface before composing and sending a frame */
static bool TF_ClaimTx(TinyFrame *tf) {
if (tf->soft_lock) {
TF_Error("TF already locked for tx!");
return false;
}
tf->soft_lock = true;
return true;
}
/** Free the TX interface after composing and sending a frame */
static void TF_ReleaseTx(TinyFrame *tf)
{
tf->soft_lock = false;
}
#endif
//region Checksums //region Checksums
#if TF_CKSUM_TYPE == TF_CKSUM_NONE #if TF_CKSUM_TYPE == TF_CKSUM_NONE
// NONE static TF_CKSUM TF_CksumStart(void)
#define CKSUM_RESET(cksum) { return 0; }
#define CKSUM_ADD(cksum, byte)
#define CKSUM_FINALIZE(cksum) static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
{ return cksum; }
static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
{ return cksum; }
#elif TF_CKSUM_TYPE == TF_CKSUM_XOR #elif TF_CKSUM_TYPE == TF_CKSUM_XOR
// ~XOR static TF_CKSUM TF_CksumStart(void)
#define CKSUM_RESET(cksum) do { (cksum) = 0; } while (0) { return 0; }
#define CKSUM_ADD(cksum, byte) do { (cksum) ^= (byte); } while(0)
#define CKSUM_FINALIZE(cksum) do { (cksum) = (TF_CKSUM)~cksum; } while(0) static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
{ return cksum ^ byte; }
static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
{ return (TF_CKSUM) ~cksum; }
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC8
static inline uint8_t crc8_bits(uint8_t data)
{
uint8_t crc = 0;
if(data & 1) crc ^= 0x5e;
if(data & 2) crc ^= 0xbc;
if(data & 4) crc ^= 0x61;
if(data & 8) crc ^= 0xc2;
if(data & 0x10) crc ^= 0x9d;
if(data & 0x20) crc ^= 0x23;
if(data & 0x40) crc ^= 0x46;
if(data & 0x80) crc ^= 0x8c;
return crc;
}
static TF_CKSUM TF_CksumStart(void)
{ return 0; }
static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
{ return crc8_bits(byte ^ cksum); }
static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
{ return cksum; }
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC16 #elif TF_CKSUM_TYPE == TF_CKSUM_CRC16
// TODO try to replace with an algorithm // TODO try to replace with an algorithm
/** CRC table for the CRC-16. The poly is 0x8005 (x^16 + x^15 + x^2 + 1) */ /** CRC table for the CRC-16. The poly is 0x8005 (x^16 + x^15 + x^2 + 1) */
static const uint16_t crc16_table[256] = { static const uint16_t crc16_table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
@@ -71,21 +130,21 @@ static const uint16_t crc16_table[256] = {
0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
}; };
static inline uint16_t crc16_byte(uint16_t cksum, const uint8_t byte) static TF_CKSUM TF_CksumStart(void)
{ { return 0; }
return (cksum >> 8) ^ crc16_table[(cksum ^ byte) & 0xff];
}
#define CKSUM_RESET(cksum) do { (cksum) = 0; } while (0) static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
#define CKSUM_ADD(cksum, byte) do { (cksum) = crc16_byte((cksum), (byte)); } while(0) { return (cksum >> 8) ^ crc16_table[(cksum ^ byte) & 0xff]; }
#define CKSUM_FINALIZE(cksum)
static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
{ return cksum; }
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC32 #elif TF_CKSUM_TYPE == TF_CKSUM_CRC32
// TODO try to replace with an algorithm // TODO try to replace with an algorithm
static const uint32_t crc32_table[] = { /* CRC polynomial 0xedb88320 */ static const uint32_t crc32_table[] = { /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
@@ -129,25 +188,35 @@ static const uint32_t crc32_table[] = { /* CRC polynomial 0xedb88320 */
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
}; };
static inline uint32_t crc32_byte(uint32_t cksum, const uint8_t byte) static TF_CKSUM TF_CksumStart(void)
{ { return (TF_CKSUM)0xFFFFFFFF; }
return (crc32_table[((cksum) ^ ((uint8_t)byte)) & 0xff] ^ ((cksum) >> 8));
}
#define CKSUM_RESET(cksum) do { (cksum) = (TF_CKSUM)0xFFFFFFFF; } while (0) static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
#define CKSUM_ADD(cksum, byte) do { (cksum) = crc32_byte(cksum, byte); } while(0) { return crc32_table[((cksum) ^ ((uint8_t)byte)) & 0xff] ^ ((cksum) >> 8); }
#define CKSUM_FINALIZE(cksum) do { (cksum) = (TF_CKSUM)~(cksum); } while(0)
static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
{ return (TF_CKSUM) ~cksum; }
#endif #endif
#define CKSUM_RESET(cksum) do { (cksum) = TF_CksumStart(); } while (0)
#define CKSUM_ADD(cksum, byte) do { (cksum) = TF_CksumAdd((cksum), (byte)); } while (0)
#define CKSUM_FINALIZE(cksum) do { (cksum) = TF_CksumEnd((cksum)); } while (0)
//endregion //endregion
//region Init
/** Init with a user-allocated buffer */ /** Init with a user-allocated buffer */
void _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit) bool _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit)
{ {
if (tf == NULL) return; if (tf == NULL) {
TF_Error("TF_InitStatic() failed, tf is null.");
return false;
}
// Zero it out, keeping user config // Zero it out, keeping user config
uint32_t usertag = tf->usertag; uint32_t usertag = tf->usertag;
@@ -159,12 +228,18 @@ void _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit)
tf->userdata = userdata; tf->userdata = userdata;
tf->peer_bit = peer_bit; tf->peer_bit = peer_bit;
return true;
} }
/** Init with malloc */ /** Init with malloc */
TinyFrame * _TF_FN TF_Init(TF_Peer peer_bit) TinyFrame * _TF_FN TF_Init(TF_Peer peer_bit)
{ {
TinyFrame *tf = malloc(sizeof(TinyFrame)); TinyFrame *tf = malloc(sizeof(TinyFrame));
if (!tf) {
TF_Error("TF_Init() failed, out of memory.");
return NULL;
}
TF_InitStatic(tf, peer_bit); TF_InitStatic(tf, peer_bit);
return tf; return tf;
} }
@@ -176,6 +251,9 @@ void TF_DeInit(TinyFrame *tf)
free(tf); free(tf);
} }
//endregion Init
//region Listeners //region Listeners
/** Reset ID listener's timeout to the original value */ /** Reset ID listener's timeout to the original value */
@@ -191,7 +269,7 @@ static void _TF_FN cleanup_id_listener(TinyFrame *tf, TF_COUNT i, struct TF_IdLi
if (lst->fn == NULL) return; if (lst->fn == NULL) return;
// Make user clean up their data - only if not NULL // Make user clean up their data - only if not NULL
if (lst->userdata != NULL) { if (lst->userdata != NULL || lst->userdata2 != NULL) {
msg.userdata = lst->userdata; msg.userdata = lst->userdata;
msg.userdata2 = lst->userdata2; msg.userdata2 = lst->userdata2;
msg.data = NULL; // this is a signal that the listener should clean up msg.data = NULL; // this is a signal that the listener should clean up
@@ -444,12 +522,33 @@ static void _TF_FN TF_HandleReceivedMessage(TinyFrame *tf)
TF_Error("Unhandled message, type %d", (int)msg.type); TF_Error("Unhandled message, type %d", (int)msg.type);
} }
/** Externally renew an ID listener */
bool _TF_FN TF_RenewIdListener(TinyFrame *tf, TF_ID id)
{
TF_COUNT i;
struct TF_IdListener_ *lst;
for (i = 0; i < tf->count_id_lst; i++) {
lst = &tf->id_listeners[i];
// test if live & matching
if (lst->fn != NULL && lst->id == id) {
renew_id_listener(lst);
return true;
}
}
TF_Error("Renew listener: not found (id %d)", (int)id);
return false;
}
//endregion Listeners //endregion Listeners
//region Parser
/** Handle a received byte buffer */ /** Handle a received byte buffer */
void _TF_FN TF_Accept(TinyFrame *tf, const uint8_t *buffer, size_t count) void _TF_FN TF_Accept(TinyFrame *tf, const uint8_t *buffer, uint32_t count)
{ {
size_t i; uint32_t i;
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
TF_AcceptChar(tf, buffer[i]); TF_AcceptChar(tf, buffer[i]);
} }
@@ -586,8 +685,8 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
if (tf->rxi == tf->len) { if (tf->rxi == tf->len) {
#if TF_CKSUM_TYPE == TF_CKSUM_NONE #if TF_CKSUM_TYPE == TF_CKSUM_NONE
// All done // All done
TF_HandleReceivedMessage(); TF_HandleReceivedMessage(tf);
TF_ResetParser(); TF_ResetParser(tf);
#else #else
// Enter DATA_CKSUM state // Enter DATA_CKSUM state
tf->state = TFState_DATA_CKSUM; tf->state = TFState_DATA_CKSUM;
@@ -614,18 +713,17 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
break; break;
} }
//@formatter:on //@formatter:on
// we get here after finishing HEAD, if no data are to be received - handle and clear
// TODO verify - this seems unreachable under normal circumstances
if (tf->len == 0 && tf->state == TFState_DATA) {
TF_HandleReceivedMessage(tf);
TF_ResetParser(tf);
}
} }
//endregion Parser
//region Compose and send
// Helper macros for the Compose functions // Helper macros for the Compose functions
// use variables: si - signed int, b - byte, outbuff - target buffer, pos - count of bytes in buffer // use variables: si - signed int, b - byte, outbuff - target buffer, pos - count of bytes in buffer
/** /**
* Write a number to the output buffer. * Write a number to the output buffer.
* *
@@ -669,15 +767,15 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
* @param msg - message written to the buffer * @param msg - message written to the buffer
* @return nr of bytes in outbuff used by the frame, 0 on failure * @return nr of bytes in outbuff used by the frame, 0 on failure
*/ */
static inline size_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_Msg *msg) static inline uint32_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_Msg *msg)
{ {
int8_t si = 0; // signed small int int8_t si = 0; // signed small int
uint8_t b = 0; uint8_t b = 0;
TF_ID id = 0; TF_ID id = 0;
TF_CKSUM cksum = 0; TF_CKSUM cksum = 0;
size_t pos = 0; // can be needed to grow larger than TF_LEN uint32_t pos = 0;
(void)cksum; (void)cksum; // suppress "unused" warning if checksums are disabled
CKSUM_RESET(cksum); CKSUM_RESET(cksum);
@@ -724,13 +822,13 @@ static inline size_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_M
* @param cksum - checksum variable, used for all calls to TF_ComposeBody. Must be reset before first use! (CKSUM_RESET(cksum);) * @param cksum - checksum variable, used for all calls to TF_ComposeBody. Must be reset before first use! (CKSUM_RESET(cksum);)
* @return nr of bytes in outbuff used * @return nr of bytes in outbuff used
*/ */
static size_t _TF_FN TF_ComposeBody(uint8_t *outbuff, static inline uint32_t _TF_FN TF_ComposeBody(uint8_t *outbuff,
const uint8_t *data, TF_LEN data_len, const uint8_t *data, TF_LEN data_len,
TF_CKSUM *cksum) TF_CKSUM *cksum)
{ {
TF_LEN i = 0; TF_LEN i = 0;
uint8_t b = 0; uint8_t b = 0;
size_t pos = 0; uint32_t pos = 0;
for (i = 0; i < data_len; i++) { for (i = 0; i < data_len; i++) {
b = data[i]; b = data[i];
@@ -748,11 +846,11 @@ static size_t _TF_FN TF_ComposeBody(uint8_t *outbuff,
* @param cksum - checksum variable used for the body * @param cksum - checksum variable used for the body
* @return nr of bytes in outbuff used * @return nr of bytes in outbuff used
*/ */
static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum) static inline uint32_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
{ {
int8_t si = 0; // signed small int int8_t si = 0; // signed small int
uint8_t b = 0; uint8_t b = 0;
size_t pos = 0; uint32_t pos = 0;
#if TF_CKSUM_TYPE != TF_CKSUM_NONE #if TF_CKSUM_TYPE != TF_CKSUM_NONE
CKSUM_FINALIZE(*cksum); CKSUM_FINALIZE(*cksum);
@@ -761,6 +859,83 @@ static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
return pos; return pos;
} }
/**
* Begin building and sending a frame
*
* @param tf - instance
* @param msg - message to send
* @param listener - response listener or NULL
* @param timeout - listener timeout ticks, 0 = indefinite
* @return success (mutex claimed and listener added, if any)
*/
static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{
TF_TRY(TF_ClaimTx(tf));
tf->tx_pos = (uint32_t) TF_ComposeHead(tf, tf->sendbuf, msg); // frame ID is incremented here if it's not a response
tf->tx_len = msg->len;
if (listener) {
TF_TRY(TF_AddIdListener(tf, msg, listener, timeout));
}
CKSUM_RESET(tf->tx_cksum);
return true;
}
/**
* Build and send a part (or all) of a frame body.
* Caution: this does not check the total length against the length specified in the frame head
*
* @param tf - instance
* @param buff - bytes to write
* @param length - count
*/
static void _TF_FN TF_SendFrame_Chunk(TinyFrame *tf, const uint8_t *buff, uint32_t length)
{
uint32_t remain;
uint32_t chunk;
uint32_t sent = 0;
remain = length;
while (remain > 0) {
// Write what can fit in the tx buffer
chunk = TF_MIN(TF_SENDBUF_LEN - tf->tx_pos, remain);
tf->tx_pos += TF_ComposeBody(tf->sendbuf+tf->tx_pos, buff+sent, (TF_LEN) chunk, &tf->tx_cksum);
remain -= chunk;
sent += chunk;
// Flush if the buffer is full
if (tf->tx_pos == TF_SENDBUF_LEN) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
tf->tx_pos = 0;
}
}
}
/**
* End a multi-part frame. This sends the checksum and releases mutex.
*
* @param tf - instance
*/
static void _TF_FN TF_SendFrame_End(TinyFrame *tf)
{
// Checksum only if message had a body
if (tf->tx_len > 0) {
// Flush if checksum wouldn't fit in the buffer
if (TF_SENDBUF_LEN - tf->tx_pos < sizeof(TF_CKSUM)) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
tf->tx_pos = 0;
}
// Add checksum, flush what remains to be sent
tf->tx_pos += TF_ComposeTail(tf->sendbuf + tf->tx_pos, &tf->tx_cksum);
}
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
TF_ReleaseTx(tf);
}
/** /**
* Send a message * Send a message
* *
@@ -772,50 +947,22 @@ static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
*/ */
static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout) static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{ {
size_t len = 0; TF_TRY(TF_SendFrame_Begin(tf, msg, listener, timeout));
size_t remain = 0; if (msg->len == 0 || msg->data != NULL) {
size_t sent = 0; // Send the payload and checksum only if we're not starting a multi-part frame.
TF_CKSUM cksum = 0; // A multi-part frame is identified by passing NULL to the data field and setting the length.
// User then needs to call those functions manually
TF_ClaimTx(tf); TF_SendFrame_Chunk(tf, msg->data, msg->len);
TF_SendFrame_End(tf);
len = TF_ComposeHead(tf, tf->sendbuf, msg);
if (listener) TF_AddIdListener(tf, msg, listener, timeout);
CKSUM_RESET(cksum);
remain = msg->len;
while (remain > 0) {
size_t chunk = TF_MIN(TF_SENDBUF_LEN - len, remain);
len += TF_ComposeBody(tf->sendbuf+len, msg->data+sent, (TF_LEN) chunk, &cksum);
remain -= chunk;
sent += chunk;
// Flush if the buffer is full and we have more to send
if (remain > 0 && len == TF_SENDBUF_LEN) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
len = 0;
} }
}
// Checksum only if message had a body
if (msg->len > 0) {
// Flush if checksum wouldn't fit in the buffer
if (TF_SENDBUF_LEN - len < sizeof(TF_CKSUM)) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
len = 0;
}
// Add checksum, flush what remains to be sent
len += TF_ComposeTail(tf->sendbuf + len, &cksum);
}
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
TF_ReleaseTx(tf);
return true; return true;
} }
//endregion Compose and send
//region Sending API funcs
/** send without listener */ /** send without listener */
bool _TF_FN TF_Send(TinyFrame *tf, TF_Msg *msg) bool _TF_FN TF_Send(TinyFrame *tf, TF_Msg *msg)
{ {
@@ -857,28 +1004,56 @@ bool _TF_FN TF_Respond(TinyFrame *tf, TF_Msg *msg)
return TF_Send(tf, msg); return TF_Send(tf, msg);
} }
/** Externally renew an ID listener */ //endregion Sending API funcs
bool _TF_FN TF_RenewIdListener(TinyFrame *tf, TF_ID id)
{
TF_COUNT i;
struct TF_IdListener_ *lst;
for (i = 0; i < tf->count_id_lst; i++) {
lst = &tf->id_listeners[i];
// test if live & matching
if (lst->fn != NULL && lst->id == id) {
renew_id_listener(lst);
return true;
}
}
TF_Error("Renew listener: not found (id %d)", (int)id);
return false; //region Sending API funcs - multipart
bool _TF_FN TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg)
{
msg->data = NULL;
return TF_Send(tf, msg);
} }
bool _TF_FN TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len)
{
return TF_SendSimple(tf, type, NULL, len);
}
bool _TF_FN TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout)
{
return TF_QuerySimple(tf, type, NULL, len, listener, timeout);
}
bool _TF_FN TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{
msg->data = NULL;
return TF_Query(tf, msg, listener, timeout);
}
void _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg)
{
msg->data = NULL;
TF_Respond(tf, msg);
}
void _TF_FN TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length)
{
TF_SendFrame_Chunk(tf, buff, length);
}
void _TF_FN TF_Multipart_Close(TinyFrame *tf)
{
TF_SendFrame_End(tf);
}
//endregion Sending API funcs - multipart
/** Timebase hook - for timeouts */ /** Timebase hook - for timeouts */
void _TF_FN TF_Tick(TinyFrame *tf) void _TF_FN TF_Tick(TinyFrame *tf)
{ {
TF_COUNT i = 0; TF_COUNT i;
struct TF_IdListener_ *lst; struct TF_IdListener_ *lst;
// increment parser timeout (timeout is handled when receiving next byte) // increment parser timeout (timeout is handled when receiving next byte)
@@ -898,19 +1073,3 @@ void _TF_FN TF_Tick(TinyFrame *tf)
} }
} }
} }
/** Default impl for claiming write mutex; can be specific to the instance */
void __attribute__((weak)) TF_ClaimTx(TinyFrame *tf)
{
(void) tf;
// do nothing
}
/** Default impl for releasing write mutex; can be specific to the instance */
void __attribute__((weak)) TF_ReleaseTx(TinyFrame *tf)
{
(void) tf;
// do nothing
}
TinyFrame/TinyFrame.h
+357 -215
View File
@@ -4,13 +4,13 @@
/** /**
* TinyFrame protocol library * TinyFrame protocol library
* *
* (c) Ondřej Hruška 2017, MIT License * (c) Ondřej Hruška 2017-2018, MIT License
* no liability/warranty, free for any use, must retain this notice & license * no liability/warranty, free for any use, must retain this notice & license
* *
* Upstream URL: https://github.com/MightyPork/TinyFrame * Upstream URL: https://github.com/MightyPork/TinyFrame
*/ */
#define TF_VERSION "2.1.0" #define TF_VERSION "2.3.0"
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include <stdint.h> // for uint8_t etc #include <stdint.h> // for uint8_t etc
@@ -19,78 +19,77 @@
#include <string.h> // for memset() #include <string.h> // for memset()
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Select checksum type (0 = none, 8 = ~XOR, 16 = CRC16 0x8005, 32 = CRC32) // Checksum type (0 = none, 8 = ~XOR, 16 = CRC16 0x8005, 32 = CRC32)
#define TF_CKSUM_NONE 0 #define TF_CKSUM_NONE 0 // no checksums
#define TF_CKSUM_XOR 8 #define TF_CKSUM_XOR 8 // inverted xor of all payload bytes
#define TF_CKSUM_CRC16 16 #define TF_CKSUM_CRC8 9 // Dallas/Maxim CRC8 (1-wire)
#define TF_CKSUM_CRC32 32 #define TF_CKSUM_CRC16 16 // CRC16 with the polynomial 0x8005 (x^16 + x^15 + x^2 + 1)
#define TF_CKSUM_CRC32 32 // CRC32 with the polynomial 0xedb88320
#define TF_CKSUM_CUSTOM8 1 // Custom 8-bit checksum
#define TF_CKSUM_CUSTOM16 2 // Custom 16-bit checksum
#define TF_CKSUM_CUSTOM32 3 // Custom 32-bit checksum
#include "TF_Config.h" #include "TF_Config.h"
//region Resolve data types //region Resolve data types
#if TF_LEN_BYTES == 1 #if TF_LEN_BYTES == 1
typedef uint8_t TF_LEN; typedef uint8_t TF_LEN;
#elif TF_LEN_BYTES == 2 #elif TF_LEN_BYTES == 2
typedef uint16_t TF_LEN; typedef uint16_t TF_LEN;
#elif TF_LEN_BYTES == 4 #elif TF_LEN_BYTES == 4
typedef uint32_t TF_LEN; typedef uint32_t TF_LEN;
#else #else
#error Bad value of TF_LEN_BYTES, must be 1, 2 or 4 #error Bad value of TF_LEN_BYTES, must be 1, 2 or 4
#endif #endif
#if TF_TYPE_BYTES == 1 #if TF_TYPE_BYTES == 1
typedef uint8_t TF_TYPE; typedef uint8_t TF_TYPE;
#elif TF_TYPE_BYTES == 2 #elif TF_TYPE_BYTES == 2
typedef uint16_t TF_TYPE; typedef uint16_t TF_TYPE;
#elif TF_TYPE_BYTES == 4 #elif TF_TYPE_BYTES == 4
typedef uint32_t TF_TYPE; typedef uint32_t TF_TYPE;
#else #else
#error Bad value of TF_TYPE_BYTES, must be 1, 2 or 4 #error Bad value of TF_TYPE_BYTES, must be 1, 2 or 4
#endif #endif
#if TF_ID_BYTES == 1 #if TF_ID_BYTES == 1
typedef uint8_t TF_ID; typedef uint8_t TF_ID;
#elif TF_ID_BYTES == 2 #elif TF_ID_BYTES == 2
typedef uint16_t TF_ID; typedef uint16_t TF_ID;
#elif TF_ID_BYTES == 4 #elif TF_ID_BYTES == 4
typedef uint32_t TF_ID; typedef uint32_t TF_ID;
#else #else
#error Bad value of TF_ID_BYTES, must be 1, 2 or 4 #error Bad value of TF_ID_BYTES, must be 1, 2 or 4
#endif #endif
#if TF_CKSUM_TYPE == TF_CKSUM_XOR || TF_CKSUM_TYPE == TF_CKSUM_NONE #if (TF_CKSUM_TYPE == TF_CKSUM_XOR) || (TF_CKSUM_TYPE == TF_CKSUM_NONE) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM8) || (TF_CKSUM_TYPE == TF_CKSUM_CRC8)
// ~XOR (if 0, still use 1 byte - it won't be used) // ~XOR (if 0, still use 1 byte - it won't be used)
typedef uint8_t TF_CKSUM; typedef uint8_t TF_CKSUM;
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC16 #elif (TF_CKSUM_TYPE == TF_CKSUM_CRC16) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM16)
// CRC16 // CRC16
typedef uint16_t TF_CKSUM; typedef uint16_t TF_CKSUM;
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC32 #elif (TF_CKSUM_TYPE == TF_CKSUM_CRC32) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM32)
// CRC32 // CRC32
typedef uint32_t TF_CKSUM; typedef uint32_t TF_CKSUM;
#else #else
#error Bad value for TF_CKSUM_TYPE, must be 8, 16 or 32 #error Bad value for TF_CKSUM_TYPE
#endif #endif
//endregion //endregion
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Type-dependent masks for bit manipulation in the ID field
#define TF_ID_MASK (TF_ID)(((TF_ID)1 << (sizeof(TF_ID)*8 - 1)) - 1)
#define TF_ID_PEERBIT (TF_ID)((TF_ID)1 << ((sizeof(TF_ID)*8) - 1))
//---------------------------------------------------------------------------
/** Peer bit enum (used for init) */ /** Peer bit enum (used for init) */
typedef enum { typedef enum {
TF_SLAVE = 0, TF_SLAVE = 0,
TF_MASTER = 1, TF_MASTER = 1,
} TF_Peer; } TF_Peer;
/** Response from listeners */ /** Response from listeners */
typedef enum { typedef enum {
TF_NEXT = 0, //!< Not handled, let other listeners handle it TF_NEXT = 0, //!< Not handled, let other listeners handle it
@@ -99,43 +98,301 @@ typedef enum {
TF_CLOSE = 3, //!< Handled, remove self TF_CLOSE = 3, //!< Handled, remove self
} TF_Result; } TF_Result;
/** Data structure for sending / receiving messages */ /** Data structure for sending / receiving messages */
typedef struct _TF_MSG_STRUCT_ { typedef struct TF_Msg_ {
TF_ID frame_id; //!< message ID TF_ID frame_id; //!< message ID
bool is_response; //!< internal flag, set when using the Respond function. frame_id is then kept unchanged. bool is_response; //!< internal flag, set when using the Respond function. frame_id is then kept unchanged.
TF_TYPE type; //!< received or sent message type TF_TYPE type; //!< received or sent message type
const uint8_t *data; //!< buffer of received data or data to send. NULL = listener timed out, free userdata!
TF_LEN len; //!< length of the buffer /**
void *userdata; //!< here's a place for custom data; this data will be stored with the listener * Buffer of received data, or data to send.
*
* - If (data == NULL) in an ID listener, that means the listener timed out and
* the user should free any userdata and take other appropriate actions.
*
* - If (data == NULL) and length is not zero when sending a frame, that starts a multi-part frame.
* This call then must be followed by sending the payload and closing the frame.
*/
const uint8_t *data;
TF_LEN len; //!< length of the payload
/**
* Custom user data for the ID listener.
*
* This data will be stored in the listener slot and passed to the ID callback
* via those same fields on the received message.
*/
void *userdata;
void *userdata2; void *userdata2;
} TF_Msg; } TF_Msg;
/** /**
* Clear message struct * Clear message struct
*
* @param msg - message to clear in-place
*/ */
static inline void TF_ClearMsg(TF_Msg *msg) static inline void TF_ClearMsg(TF_Msg *msg)
{ {
memset(msg, 0, sizeof(TF_Msg)); memset(msg, 0, sizeof(TF_Msg));
} }
/** TinyFrame struct typedef */
typedef struct TinyFrame_ TinyFrame; typedef struct TinyFrame_ TinyFrame;
/** /**
* TinyFrame Type Listener callback * TinyFrame Type Listener callback
* *
* @param frame_id - ID of the received frame * @param tf - instance
* @param type - type field from the message * @param msg - the received message, userdata is populated inside the object
* @param data - byte buffer with the application data
* @param len - number of bytes in the buffer
* @return listener result * @return listener result
*/ */
typedef TF_Result (*TF_Listener)(TinyFrame *tf, TF_Msg *msg); typedef TF_Result (*TF_Listener)(TinyFrame *tf, TF_Msg *msg);
// -------------------------------------------------------------------
// region Internal // ---------------------------------- INIT ------------------------------
enum TFState_ { /**
* Initialize the TinyFrame engine.
* This can also be used to completely reset it (removing all listeners etc).
*
* The field .userdata (or .usertag) can be used to identify different instances
* in the TF_WriteImpl() function etc. Set this field after the init.
*
* This function is a wrapper around TF_InitStatic that calls malloc() to obtain
* the instance.
*
* @param tf - instance
* @param peer_bit - peer bit to use for self
* @return TF instance or NULL
*/
TinyFrame *TF_Init(TF_Peer peer_bit);
/**
* Initialize the TinyFrame engine using a statically allocated instance struct.
*
* The .userdata / .usertag field is preserved when TF_InitStatic is called.
*
* @param tf - instance
* @param peer_bit - peer bit to use for self
* @return success
*/
bool TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit);
/**
* De-init the dynamically allocated TF instance
*
* @param tf - instance
*/
void TF_DeInit(TinyFrame *tf);
// ---------------------------------- API CALLS --------------------------------------
/**
* Accept incoming bytes & parse frames
*
* @param tf - instance
* @param buffer - byte buffer to process
* @param count - nr of bytes in the buffer
*/
void TF_Accept(TinyFrame *tf, const uint8_t *buffer, uint32_t count);
/**
* Accept a single incoming byte
*
* @param tf - instance
* @param c - a received char
*/
void TF_AcceptChar(TinyFrame *tf, uint8_t c);
/**
* This function should be called periodically.
* The time base is used to time-out partial frames in the parser and
* automatically reset it.
* It's also used to expire ID listeners if a timeout is set when registering them.
*
* A common place to call this from is the SysTick handler.
*
* @param tf - instance
*/
void TF_Tick(TinyFrame *tf);
/**
* Reset the frame parser state machine.
* This does not affect registered listeners.
*
* @param tf - instance
*/
void TF_ResetParser(TinyFrame *tf);
// ---------------------------- MESSAGE LISTENERS -------------------------------
/**
* Register a frame type listener.
*
* @param tf - instance
* @param msg - message (contains frame_id and userdata)
* @param cb - callback
* @param timeout - timeout in ticks to auto-remove the listener (0 = keep forever)
* @return slot index (for removing), or TF_ERROR (-1)
*/
bool TF_AddIdListener(TinyFrame *tf, TF_Msg *msg, TF_Listener cb, TF_TICKS timeout);
/**
* Remove a listener by the message ID it's registered for
*
* @param tf - instance
* @param frame_id - the frame we're listening for
*/
bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
/**
* Register a frame type listener.
*
* @param tf - instance
* @param frame_type - frame type to listen for
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
bool TF_AddTypeListener(TinyFrame *tf, TF_TYPE frame_type, TF_Listener cb);
/**
* Remove a listener by type.
*
* @param tf - instance
* @param type - the type it's registered for
*/
bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
/**
* Register a generic listener.
*
* @param tf - instance
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
bool TF_AddGenericListener(TinyFrame *tf, TF_Listener cb);
/**
* Remove a generic listener by function pointer
*
* @param tf - instance
* @param cb - callback function to remove
*/
bool TF_RemoveGenericListener(TinyFrame *tf, TF_Listener cb);
/**
* Renew an ID listener timeout externally (as opposed to by returning TF_RENEW from the ID listener)
*
* @param tf - instance
* @param id - listener ID to renew
* @return true if listener was found and renewed
*/
bool TF_RenewIdListener(TinyFrame *tf, TF_ID id);
// ---------------------------- FRAME TX FUNCTIONS ------------------------------
/**
* Send a frame, no listener
*
* @param tf - instance
* @param msg - message struct. ID is stored in the frame_id field
* @return success
*/
bool TF_Send(TinyFrame *tf, TF_Msg *msg);
/**
* Like TF_Send, but without the struct
*/
bool TF_SendSimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len);
/**
* Send a frame, and optionally attach an ID listener.
*
* @param tf - instance
* @param msg - message struct. ID is stored in the frame_id field
* @param listener - listener waiting for the response (can be NULL)
* @param timeout - listener expiry time in ticks
* @return success
*/
bool TF_Query(TinyFrame *tf, TF_Msg *msg,
TF_Listener listener, TF_TICKS timeout);
/**
* Like TF_Query(), but without the struct
*/
bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type,
const uint8_t *data, TF_LEN len,
TF_Listener listener, TF_TICKS timeout);
/**
* Send a response to a received message.
*
* @param tf - instance
* @param msg - message struct. ID is read from frame_id. set ->renew to reset listener timeout
* @return success
*/
bool TF_Respond(TinyFrame *tf, TF_Msg *msg);
// ------------------------ MULTIPART FRAME TX FUNCTIONS -----------------------------
// Those routines are used to send long frames without having all the data available
// at once (e.g. capturing it from a peripheral or reading from a large memory buffer)
/**
* TF_Send() with multipart payload.
* msg.data is ignored and set to NULL
*/
bool TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg);
/**
* TF_SendSimple() with multipart payload.
*/
bool TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len);
/**
* TF_QuerySimple() with multipart payload.
*/
bool TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout);
/**
* TF_Query() with multipart payload.
* msg.data is ignored and set to NULL
*/
bool TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout);
/**
* TF_Respond() with multipart payload.
* msg.data is ignored and set to NULL
*/
void TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg);
/**
* Send the payload for a started multipart frame. This can be called multiple times
* if needed, until the full length is transmitted.
*
* @param tf - instance
* @param buff - buffer to send bytes from
* @param length - number of bytes to send
*/
void TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length);
/**
* Close the multipart message, generating chekcsum and releasing the Tx lock.
*
* @param tf - instance
*/
void TF_Multipart_Close(TinyFrame *tf);
// ---------------------------------- INTERNAL ----------------------------------
// This is publicly visible only to allow static init.
enum TF_State_ {
TFState_SOF = 0, //!< Wait for SOF TFState_SOF = 0, //!< Wait for SOF
TFState_LEN, //!< Wait for Number Of Bytes TFState_LEN, //!< Wait for Number Of Bytes
TFState_HEAD_CKSUM, //!< Wait for header Checksum TFState_HEAD_CKSUM, //!< Wait for header Checksum
@@ -149,7 +406,7 @@ struct TF_IdListener_ {
TF_ID id; TF_ID id;
TF_Listener fn; TF_Listener fn;
TF_TICKS timeout; // nr of ticks remaining to disable this listener TF_TICKS timeout; // nr of ticks remaining to disable this listener
TF_TICKS timeout_max; // the original timeout is stored here TF_TICKS timeout_max; // the original timeout is stored here (0 = no timeout)
void *userdata; void *userdata;
void *userdata2; void *userdata2;
}; };
@@ -178,7 +435,7 @@ struct TinyFrame_ {
TF_ID next_id; //!< Next frame / frame chain ID TF_ID next_id; //!< Next frame / frame chain ID
/* Parser state */ /* Parser state */
enum TFState_ state; enum TF_State_ state;
TF_TICKS parser_timeout_ticks; TF_TICKS parser_timeout_ticks;
TF_ID id; //!< Incoming packet ID TF_ID id; //!< Incoming packet ID
TF_LEN len; //!< Payload length TF_LEN len; //!< Payload length
@@ -189,6 +446,18 @@ struct TinyFrame_ {
TF_TYPE type; //!< Collected message type number TF_TYPE type; //!< Collected message type number
bool discard_data; //!< Set if (len > TF_MAX_PAYLOAD) to read the frame, but ignore the data. bool discard_data; //!< Set if (len > TF_MAX_PAYLOAD) to read the frame, but ignore the data.
/* Tx state */
// Buffer for building frames
uint8_t sendbuf[TF_SENDBUF_LEN]; //!< Transmit temporary buffer
uint32_t tx_pos; //!< Next write position in the Tx buffer (used for multipart)
uint32_t tx_len; //!< Total expected Tx length
TF_CKSUM tx_cksum; //!< Transmit checksum accumulator
#if !TF_USE_MUTEX
bool soft_lock; //!< Tx lock flag used if the mutex feature is not enabled.
#endif
/* --- Callbacks --- */ /* --- Callbacks --- */
/* Transaction callbacks */ /* Transaction callbacks */
@@ -202,183 +471,56 @@ struct TinyFrame_ {
TF_COUNT count_id_lst; TF_COUNT count_id_lst;
TF_COUNT count_type_lst; TF_COUNT count_type_lst;
TF_COUNT count_generic_lst; TF_COUNT count_generic_lst;
// Buffer for building frames
uint8_t sendbuf[TF_SENDBUF_LEN];
}; };
// endregion
// ------------------------------------------------------------------- // ------------------------ TO BE IMPLEMENTED BY USER ------------------------
/**
* Initialize the TinyFrame engine.
* This can also be used to completely reset it (removing all listeners etc).
*
* The field .userdata (or .usertag) can be used to identify different instances
* in the TF_WriteImpl() function etc. Set this field after the init.
*
* This function is a wrapper around TF_InitStatic that calls malloc() to obtain
* the instance.
*
* @param peer_bit - peer bit to use for self
*/
TinyFrame *TF_Init(TF_Peer peer_bit);
/**
* Initialize the TinyFrame engine using a statically allocated instance struct.
*
* The .userdata / .usertag field is preserved when TF_InitStatic is called.
*
* @param peer_bit - peer bit to use for self
*/
void TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit);
/**
* De-init the dynamically allocated TF instance
*
* @param tf
*/
void TF_DeInit(TinyFrame *tf);
/**
* Reset the frame parser state machine.
* This does not affect registered listeners.
*/
void TF_ResetParser(TinyFrame *tf);
/**
* Register a frame type listener.
*
* @param msg - message (contains frame_id and userdata)
* @param cb - callback
* @param timeout - timeout in ticks to auto-remove the listener (0 = keep forever)
* @return slot index (for removing), or TF_ERROR (-1)
*/
bool TF_AddIdListener(TinyFrame *tf, TF_Msg *msg, TF_Listener cb, TF_TICKS timeout);
/**
* Remove a listener by the message ID it's registered for
*
* @param frame_id - the frame we're listening for
*/
bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
/**
* 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)
*/
bool TF_AddTypeListener(TinyFrame *tf, TF_TYPE frame_type, TF_Listener cb);
/**
* Remove a listener by type.
*
* @param type - the type it's registered for
*/
bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
/**
* Register a generic listener.
*
* @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1)
*/
bool TF_AddGenericListener(TinyFrame *tf, TF_Listener cb);
/**
* Remove a generic listener by function pointer
*
* @param cb - callback function to remove
*/
bool TF_RemoveGenericListener(TinyFrame *tf, TF_Listener cb);
/**
* Send a frame, no listener
*
* @param msg - message struct. ID is stored in the frame_id field
* @return success
*/
bool TF_Send(TinyFrame *tf, TF_Msg *msg);
/**
* Like TF_Send, but without the struct
*/
bool TF_SendSimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len);
/**
* Send a frame, and optionally attach an ID listener.
*
* @param msg - message struct. ID is stored in the frame_id field
* @param listener - listener waiting for the response (can be NULL)
* @param timeout - listener expiry time in ticks
* @return success
*/
bool TF_Query(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout);
/**
* Like TF_Query, but without the struct
*/
bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len,
TF_Listener listener, TF_TICKS timeout);
/**
* Send a response to a received message.
*
* @param msg - message struct. ID is read from frame_id. set ->renew to reset listener timeout
* @return success
*/
bool TF_Respond(TinyFrame *tf, TF_Msg *msg);
/**
* Renew an ID listener timeout externally (as opposed to by returning TF_RENEW from the ID listener)
*
* @param id - listener ID to renew
* @return true if listener was found and renewed
*/
bool TF_RenewIdListener(TinyFrame *tf, TF_ID id);
/**
* Accept incoming bytes & parse frames
*
* @param buffer - byte buffer to process
* @param count - nr of bytes in the buffer
*/
void TF_Accept(TinyFrame *tf, const uint8_t *buffer, size_t count);
/**
* Accept a single incoming byte
*
* @param c - a received char
*/
void TF_AcceptChar(TinyFrame *tf, uint8_t c);
/**
* This function should 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)
*/
void TF_Tick(TinyFrame *tf);
// --- TO BE IMPLEMENTED BY USER ---
/** /**
* 'Write bytes' function that sends data to UART * 'Write bytes' function that sends data to UART
* *
* ! Implement this in your application code ! * ! Implement this in your application code !
*/ */
extern void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len); extern void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len);
/** Claim the TX interface before composing and sending a frame */ // Mutex functions
extern void TF_ClaimTx(TinyFrame *tf); #if TF_USE_MUTEX
/** Free the TX interface after composing and sending a frame */ /** Claim the TX interface before composing and sending a frame */
extern void TF_ReleaseTx(TinyFrame *tf); extern bool TF_ClaimTx(TinyFrame *tf);
/** Free the TX interface after composing and sending a frame */
extern void TF_ReleaseTx(TinyFrame *tf);
#endif
// Custom checksum functions
#if (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM8) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM16) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM32)
/**
* Initialize a checksum
*
* @return initial checksum value
*/
extern TF_CKSUM TF_CksumStart(void);
/**
* Update a checksum with a byte
*
* @param cksum - previous checksum value
* @param byte - byte to add
* @return updated checksum value
*/
extern TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte);
/**
* Finalize the checksum calculation
*
* @param cksum - previous checksum value
* @return final checksum value
*/
extern TF_CKSUM TF_CksumEnd(TF_CKSUM cksum);
#endif
#endif #endif
platform/irq_dispatcher.c
+6 -1
View File
@@ -146,7 +146,10 @@ static struct cbslot *get_slot_for_periph(void *periph)
void irqd_attach(void *periph, IrqCallback callback, void *arg) void irqd_attach(void *periph, IrqCallback callback, void *arg)
{ {
struct cbslot *slot = get_slot_for_periph(periph); struct cbslot *slot = get_slot_for_periph(periph);
assert_param(slot->callback == NULL); if (slot->callback != NULL) {
trap("Attach IRQ %p() to %p but %p() already bound", callback, periph, slot->callback);
}
slot->callback = callback; slot->callback = callback;
slot->arg = arg; slot->arg = arg;
} }
@@ -157,6 +160,8 @@ void irqd_detach(void *periph, IrqCallback callback)
if (slot->callback == callback) { if (slot->callback == callback) {
slot->callback = NULL; slot->callback = NULL;
slot->arg = NULL; slot->arg = NULL;
} else {
trap("Detach IRQ %p() from %p but %p() bound instead", callback, periph, slot->callback);
} }
} }
units/usart/_dmas.c
+2 -2
View File
@@ -433,8 +433,8 @@ void UUSART_DeInitDMAs(Unit *unit)
struct priv *priv = unit->data; struct priv *priv = unit->data;
assert_param(priv); assert_param(priv);
irqd_detach(priv->dma_tx, UUSART_DMA_RxHandler); irqd_detach(priv->dma_tx, UUSART_DMA_TxHandler);
irqd_detach(priv->dma_rx, UUSART_DMA_TxHandler); irqd_detach(priv->dma_rx, UUSART_DMA_RxHandler);
LL_DMA_DeInit(priv->dma, priv->dma_rx_chnum); LL_DMA_DeInit(priv->dma, priv->dma_rx_chnum);
LL_DMA_DeInit(priv->dma, priv->dma_tx_chnum); LL_DMA_DeInit(priv->dma, priv->dma_tx_chnum);