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

Installed new TinyFrame

Browse Source
sipo
Ondřej Hruška 6 years ago
parent 3784a46951
commit 255f96c754
Signed by: MightyPork
GPG Key ID: 2C5FD5035250423D
6 changed files with 658 additions and 380 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. 34
      TinyFrame/TF_Config.h
  2. 6
      TinyFrame/TF_Integration.c
  3. 367
      TinyFrame/TinyFrame.c
  4. 402
      TinyFrame/TinyFrame.h
  5. 7
      platform/irq_dispatcher.c
  6. 4
      units/usart/_dmas.c

34
TinyFrame/TF_Config.h
Unescape 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__)

6
TinyFrame/TF_Integration.c
Unescape 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 */

367
TinyFrame/TinyFrame.c
Unescape 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,29 +10,88 @@
#define _TF_FN #define _TF_FN
#endif #endif
// Helper macros // Helper macros
#define TF_MAX(a, b) ((a)>(b)?(a):(b))
#define TF_MIN(a, b) ((a)<(b)?(a):(b)) #define TF_MIN(a, b) ((a)<(b)?(a):(b))
#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;
}
// TODO It would be nice to have per-instance configurable checksum types, but that would /** Free the TX interface after composing and sending a frame */
// mandate configurable field sizes unless we use u32 everywhere (and possibly shorten static void TF_ReleaseTx(TinyFrame *tf)
// it when encoding to the buffer). I don't really like this idea so much. -MP {
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
@ -73,14 +132,14 @@ static const uint16_t crc16_table[256] = {
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];
} static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
{ return (cksum >> 8) ^ crc16_table[(cksum ^ byte) & 0xff]; }
#define CKSUM_RESET(cksum) do { (cksum) = 0; } while (0) static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
#define CKSUM_ADD(cksum, byte) do { (cksum) = crc16_byte((cksum), (byte)); } while(0) { return cksum; }
#define CKSUM_FINALIZE(cksum)
#elif TF_CKSUM_TYPE == TF_CKSUM_CRC32 #elif TF_CKSUM_TYPE == TF_CKSUM_CRC32
@ -131,23 +190,33 @@ static const uint32_t crc32_table[] = { /* CRC polynomial 0xedb88320 */
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);
@ -762,60 +860,109 @@ static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
} }
/** /**
* Send a message * Begin building and sending a frame
* *
* @param tf - instance * @param tf - instance
* @param msg - message object * @param msg - message to send
* @param listener - ID listener, or NULL * @param listener - response listener or NULL
* @param timeout - listener timeout, 0 is none * @param timeout - listener timeout ticks, 0 = indefinite
* @return true if sent * @return success (mutex claimed and listener added, if any)
*/ */
static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout) static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{ {
size_t len = 0; TF_TRY(TF_ClaimTx(tf));
size_t remain = 0;
size_t sent = 0;
TF_CKSUM cksum = 0;
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;
len = TF_ComposeHead(tf, tf->sendbuf, msg); if (listener) {
if (listener) TF_AddIdListener(tf, msg, listener, timeout); TF_TRY(TF_AddIdListener(tf, msg, listener, timeout));
}
CKSUM_RESET(cksum); CKSUM_RESET(tf->tx_cksum);
return true;
}
remain = msg->len; /**
* 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) { while (remain > 0) {
size_t chunk = TF_MIN(TF_SENDBUF_LEN - len, remain); // Write what can fit in the tx buffer
len += TF_ComposeBody(tf->sendbuf+len, msg->data+sent, (TF_LEN) chunk, &cksum); 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; remain -= chunk;
sent += chunk; sent += chunk;
// Flush if the buffer is full and we have more to send // Flush if the buffer is full
if (remain > 0 && len == TF_SENDBUF_LEN) { if (tf->tx_pos == TF_SENDBUF_LEN) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len); TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
len = 0; 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 // Checksum only if message had a body
if (msg->len > 0) { if (tf->tx_len > 0) {
// Flush if checksum wouldn't fit in the buffer // Flush if checksum wouldn't fit in the buffer
if (TF_SENDBUF_LEN - len < sizeof(TF_CKSUM)) { if (TF_SENDBUF_LEN - tf->tx_pos < sizeof(TF_CKSUM)) {
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len); TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
len = 0; tf->tx_pos = 0;
} }
// Add checksum, flush what remains to be sent // Add checksum, flush what remains to be sent
len += TF_ComposeTail(tf->sendbuf + len, &cksum); tf->tx_pos += TF_ComposeTail(tf->sendbuf + tf->tx_pos, &tf->tx_cksum);
} }
TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len); TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
TF_ReleaseTx(tf); TF_ReleaseTx(tf);
}
/**
* Send a message
*
* @param tf - instance
* @param msg - message object
* @param listener - ID listener, or NULL
* @param timeout - listener timeout, 0 is none
* @return true if sent
*/
static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{
TF_TRY(TF_SendFrame_Begin(tf, msg, listener, timeout));
if (msg->len == 0 || msg->data != NULL) {
// Send the payload and checksum only if we're not starting a multi-part frame.
// 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_SendFrame_Chunk(tf, msg->data, msg->len);
TF_SendFrame_End(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)
//region Sending API funcs - multipart
bool _TF_FN TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg)
{ {
TF_COUNT i; msg->data = NULL;
struct TF_IdListener_ *lst; return TF_Send(tf, msg);
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;
} }
bool _TF_FN TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len)
{
return TF_SendSimple(tf, type, NULL, len);
} }
TF_Error("Renew listener: not found (id %d)", (int)id); bool _TF_FN TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout)
return false; {
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
}

402
TinyFrame/TinyFrame.h
Unescape 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,11 +19,15 @@
#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"
@ -62,35 +66,30 @@ typedef uint32_t TF_ID;
#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,117 +98,59 @@ 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
enum TFState_ {
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
};
struct TF_IdListener_ {
TF_ID id;
TF_Listener fn;
TF_TICKS timeout; // nr of ticks remaining to disable this listener
TF_TICKS timeout_max; // the original timeout is stored here
void *userdata;
void *userdata2;
};
struct TF_TypeListener_ {
TF_TYPE type;
TF_Listener fn;
};
struct TF_GenericListener_ {
TF_Listener fn;
};
/**
* Frame parser internal state.
*/
struct TinyFrame_ {
/* Public user data */
void *userdata;
uint32_t usertag;
// --- the rest of the struct is internal, do not access directly ---
/* 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;
TF_TICKS parser_timeout_ticks;
TF_ID id; //!< Incoming packet ID
TF_LEN len; //!< Payload length
uint8_t data[TF_MAX_PAYLOAD_RX]; //!< Data byte buffer
TF_LEN rxi; //!< Field size 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
bool discard_data; //!< Set if (len > TF_MAX_PAYLOAD) to read the frame, but ignore the data.
/* --- Callbacks --- */
/* Transaction callbacks */ // ---------------------------------- INIT ------------------------------
struct TF_IdListener_ id_listeners[TF_MAX_ID_LST];
struct TF_TypeListener_ type_listeners[TF_MAX_TYPE_LST];
struct TF_GenericListener_ generic_listeners[TF_MAX_GEN_LST];
// Those counters are used to optimize look-up times.
// They point to the highest used slot number,
// or close to it, depending on the removal order.
TF_COUNT count_id_lst;
TF_COUNT count_type_lst;
TF_COUNT count_generic_lst;
// Buffer for building frames
uint8_t sendbuf[TF_SENDBUF_LEN];
};
// endregion
// -------------------------------------------------------------------
/** /**
* Initialize the TinyFrame engine. * Initialize the TinyFrame engine.
@ -221,7 +162,9 @@ struct TinyFrame_ {
* This function is a wrapper around TF_InitStatic that calls malloc() to obtain * This function is a wrapper around TF_InitStatic that calls malloc() to obtain
* the instance. * the instance.
* *
* @param tf - instance
* @param peer_bit - peer bit to use for self * @param peer_bit - peer bit to use for self
* @return TF instance or NULL
*/ */
TinyFrame *TF_Init(TF_Peer peer_bit); TinyFrame *TF_Init(TF_Peer peer_bit);
@ -231,26 +174,66 @@ TinyFrame *TF_Init(TF_Peer peer_bit);
* *
* The .userdata / .usertag field is preserved when TF_InitStatic is called. * The .userdata / .usertag field is preserved when TF_InitStatic is called.
* *
* @param tf - instance
* @param peer_bit - peer bit to use for self * @param peer_bit - peer bit to use for self
* @return success
*/ */
void TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit); bool TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit);
/** /**
* De-init the dynamically allocated TF instance * De-init the dynamically allocated TF instance
* *
* @param tf * @param tf - instance
*/ */
void TF_DeInit(TinyFrame *tf); 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. * Reset the frame parser state machine.
* This does not affect registered listeners. * This does not affect registered listeners.
*
* @param tf - instance
*/ */
void TF_ResetParser(TinyFrame *tf); void TF_ResetParser(TinyFrame *tf);
// ---------------------------- MESSAGE LISTENERS -------------------------------
/** /**
* Register a frame type listener. * Register a frame type listener.
* *
* @param tf - instance
* @param msg - message (contains frame_id and userdata) * @param msg - message (contains frame_id and userdata)
* @param cb - callback * @param cb - callback
* @param timeout - timeout in ticks to auto-remove the listener (0 = keep forever) * @param timeout - timeout in ticks to auto-remove the listener (0 = keep forever)
@ -261,6 +244,7 @@ bool TF_AddIdListener(TinyFrame *tf, TF_Msg *msg, TF_Listener cb, TF_TICKS timeo
/** /**
* Remove a listener by the message ID it's registered for * Remove a listener by the message ID it's registered for
* *
* @param tf - instance
* @param frame_id - the frame we're listening for * @param frame_id - the frame we're listening for
*/ */
bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id); bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
@ -268,6 +252,7 @@ bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
/** /**
* Register a frame type listener. * Register a frame type listener.
* *
* @param tf - instance
* @param frame_type - frame type to listen for * @param frame_type - frame type to listen for
* @param cb - callback * @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1) * @return slot index (for removing), or TF_ERROR (-1)
@ -277,6 +262,7 @@ bool TF_AddTypeListener(TinyFrame *tf, TF_TYPE frame_type, TF_Listener cb);
/** /**
* Remove a listener by type. * Remove a listener by type.
* *
* @param tf - instance
* @param type - the type it's registered for * @param type - the type it's registered for
*/ */
bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type); bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
@ -284,6 +270,7 @@ bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
/** /**
* Register a generic listener. * Register a generic listener.
* *
* @param tf - instance
* @param cb - callback * @param cb - callback
* @return slot index (for removing), or TF_ERROR (-1) * @return slot index (for removing), or TF_ERROR (-1)
*/ */
@ -292,13 +279,27 @@ bool TF_AddGenericListener(TinyFrame *tf, TF_Listener cb);
/** /**
* Remove a generic listener by function pointer * Remove a generic listener by function pointer
* *
* @param tf - instance
* @param cb - callback function to remove * @param cb - callback function to remove
*/ */
bool TF_RemoveGenericListener(TinyFrame *tf, TF_Listener cb); 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 * Send a frame, no listener
* *
* @param tf - instance
* @param msg - message struct. ID is stored in the frame_id field * @param msg - message struct. ID is stored in the frame_id field
* @return success * @return success
*/ */
@ -312,73 +313,214 @@ bool TF_SendSimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len)
/** /**
* Send a frame, and optionally attach an ID listener. * 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 msg - message struct. ID is stored in the frame_id field
* @param listener - listener waiting for the response (can be NULL) * @param listener - listener waiting for the response (can be NULL)
* @param timeout - listener expiry time in ticks * @param timeout - listener expiry time in ticks
* @return success * @return success
*/ */
bool TF_Query(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout); bool TF_Query(TinyFrame *tf, TF_Msg *msg,
TF_Listener listener, TF_TICKS timeout);
/** /**
* Like TF_Query, but without the struct * Like TF_Query(), but without the struct
*/ */
bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len, bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type,
const uint8_t *data, TF_LEN len,
TF_Listener listener, TF_TICKS timeout); TF_Listener listener, TF_TICKS timeout);
/** /**
* Send a response to a received message. * 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 * @param msg - message struct. ID is read from frame_id. set ->renew to reset listener timeout
* @return success * @return success
*/ */
bool TF_Respond(TinyFrame *tf, TF_Msg *msg); 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)
/** /**
* Renew an ID listener timeout externally (as opposed to by returning TF_RENEW from the ID listener) * TF_Send() with multipart payload.
* * msg.data is ignored and set to NULL
* @param id - listener ID to renew
* @return true if listener was found and renewed
*/ */
bool TF_RenewIdListener(TinyFrame *tf, TF_ID id); bool TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg);
/** /**
* Accept incoming bytes & parse frames * TF_SendSimple() with multipart payload.
*
* @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); bool TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len);
/** /**
* Accept a single incoming byte * TF_QuerySimple() with multipart payload.
*
* @param c - a received char
*/ */
void TF_AcceptChar(TinyFrame *tf, uint8_t c); bool TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout);
/** /**
* This function should be called periodically. * 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.
* *
* The time base is used to time-out partial frames in the parser and * @param tf - instance
* automatically reset it. * @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.
* *
* (suggestion - call this in a SysTick handler) * @param tf - instance
*/ */
void TF_Tick(TinyFrame *tf); void TF_Multipart_Close(TinyFrame *tf);
// --- TO BE IMPLEMENTED BY USER ---
// ---------------------------------- INTERNAL ----------------------------------
// This is publicly visible only to allow static init.
enum TF_State_ {
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
};
struct TF_IdListener_ {
TF_ID id;
TF_Listener fn;
TF_TICKS timeout; // nr of ticks remaining to disable this listener
TF_TICKS timeout_max; // the original timeout is stored here (0 = no timeout)
void *userdata;
void *userdata2;
};
struct TF_TypeListener_ {
TF_TYPE type;
TF_Listener fn;
};
struct TF_GenericListener_ {
TF_Listener fn;
};
/**
* Frame parser internal state.
*/
struct TinyFrame_ {
/* Public user data */
void *userdata;
uint32_t usertag;
// --- the rest of the struct is internal, do not access directly ---
/* 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 TF_State_ state;
TF_TICKS parser_timeout_ticks;
TF_ID id; //!< Incoming packet ID
TF_LEN len; //!< Payload length
uint8_t data[TF_MAX_PAYLOAD_RX]; //!< Data byte buffer
TF_LEN rxi; //!< Field size 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
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 --- */
/* Transaction callbacks */
struct TF_IdListener_ id_listeners[TF_MAX_ID_LST];
struct TF_TypeListener_ type_listeners[TF_MAX_TYPE_LST];
struct TF_GenericListener_ generic_listeners[TF_MAX_GEN_LST];
// Those counters are used to optimize look-up times.
// They point to the highest used slot number,
// or close to it, depending on the removal order.
TF_COUNT count_id_lst;
TF_COUNT count_type_lst;
TF_COUNT count_generic_lst;
};
// ------------------------ 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);
// Mutex functions
#if TF_USE_MUTEX
/** Claim the TX interface before composing and sending a frame */ /** Claim the TX interface before composing and sending a frame */
extern void TF_ClaimTx(TinyFrame *tf); extern bool TF_ClaimTx(TinyFrame *tf);
/** Free the TX interface after composing and sending a frame */ /** Free the TX interface after composing and sending a frame */
extern void TF_ReleaseTx(TinyFrame *tf); extern void TF_ReleaseTx(TinyFrame *tf);
#endif #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

7
platform/irq_dispatcher.c
Unescape 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);
} }
} }

4
units/usart/_dmas.c
Unescape 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);

Write Preview
Loading…
Cancel
Save