playground-stm32/f4ll_c
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

packetusart unit tests

Browse source
This commit is contained in:
Attila Body 2019-12-04 15:57:18 +01:00
parent c2f84b23ee
commit 5d26fdc64d
8 changed files with 219 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

176
packetusart.c
View file

@ -15,6 +15,10 @@
#include "f4ll_c/dmahelper.h"
#include "f4ll_c/crcscheduler.h"
#ifndef MOCKABLE
#define MOCKABLE(x) x
#endif
#ifndef DIAG_RX_BUFFER_SWITCH
# define DIAG_RX_BUFFER_SWITCH(x)
#endif
@ -32,7 +36,51 @@ static inline uint32_t RoundUpTo4(uint32_t inp)
return (inp + 3) & 0xfffc;
}
void Pku_Init(
#ifndef USART_STATS_DISABLED
static inline void StatsIncOverrun(struct usart_stats *s) {
++s->overrun;
}
static inline void StatsIncHdrError(struct usart_stats *s, uint32_t hdr) {
++s->hdrError;
s->lastErrHdr = hdr;
}
static inline void StatsIncPayloadError(struct usart_stats *s, uint32_t pep1, uint32_t pep2) {
++s->payloadErrror;
s->pep1 = pep1;
s->pep2 = pep2;
}
static inline void StatsIncDmaError(struct usart_stats *s) {
++s->dmaError;
}
static inline void StatsIncRcvd(struct usart_stats *s) {
++s->rcvd;
}
static inline void StatsIncPremature_hdr(struct usart_stats *s) {
++s->premature_hdr;
}
static inline void StatsIncPremature_payload(struct usart_stats *s) {
++s->premature_payload;
}
static inline void StatsIncSent(struct usart_stats *s) {
++s->sent;
}
static inline void StatsAddSkiped(struct usart_stats *s, uint8_t cnt) {
s->skiped += s->rcvd > 2 ? cnt : 0;
}
#else // USART_STATS_DISABLED
#define StatsIncOverrun(x)
#define StatsIncHdrError(x,y)
#define StatsIncPayloadError(x,y,z)
#define StatsIncDmaError(x)
#define StatsIncRcvd(x)
#define StatsIncPremature_hdr(x)
#define StatsIncPremature_payload(x)
#define StatsIncSent(x)
#define StatsAddSkiped(x)
#endif // USART_STATS_DISABLED
void MOCKABLE(Pu_Init)(
struct usartstatus_t *st, USART_TypeDef *usart, DMA_TypeDef *dma,
uint32_t stream_rx, uint32_t stream_tx,
struct crcstatus_t *crcStatus,
@ -49,17 +97,17 @@ void Pku_Init(
st->txBuffer.busy = 0;
st->txBuffer.error = 0;
st->txBuffer.requestedLength = 0;
st->txBuffer.usartStatus = st;
st->rxBuffers[0].busy = 0;
st->rxBuffers[1].busy = 0;
st->rxBuffers[0].error = 0;
st->rxBuffers[1].error = 0;
st->rxBuffers[0].requestedLength = 0;
st->rxBuffers[1].requestedLength = 0;
st->txBuffer.usartStatus = st;
st->rxBuffers[0].usartStatus = st;
st->rxBuffers[1].usartStatus = st;
st->packetReceivedCallback = packetReceivedCallback;
st->packetReceivedCallbacParam = packetReceivedCallbackParam;
st->packetReceivedCallbackParam = packetReceivedCallbackParam;
st->rxSerial = -1;
st->txSerial = 0;
st->activeRxBuf = 0;
@ -82,52 +130,46 @@ void Pku_Init(
}
uint8_t* Pku_GetTxBuffer(struct usartstatus_t *status)
uint8_t* MOCKABLE(Pu_GetTxBuffer)(struct usartstatus_t *status)
{
return status->txBuffer.packet.payload;
}
static inline void BuildHeader(struct usart_buffer_t *buffer, uint8_t serial, uint8_t length)
{
uint8_t hash = STARTMARKER;
buffer->packet.header.startByte = STARTMARKER;
buffer->packet.header.serial = serial;
hash ^= serial;
buffer->packet.header.payloadLength = length - 1;
hash ^= length - 1;
buffer->packet.header.hash = hash;
}
static inline uint8_t CheckHeader(struct usartpacket_t *packet)
uint8_t MOCKABLE(Pu_CheckHeader)(struct usartpacket_t *packet)
{
return packet->header.startByte == STARTMARKER && (packet->header.startByte ^ packet->header.serial ^ packet->header.payloadLength) == packet->header.hash;
}
uint8_t Pku_Post(struct usartstatus_t *status, uint8_t const *payload, uint16_t length, struct crcstatus_t *crcStatus, uint8_t waitForCrcQueue)
uint8_t MOCKABLE(Pu_Post)(struct usartstatus_t *status, uint8_t const *payload, uint8_t length, struct crcstatus_t *crcStatus, uint8_t waitForCrcQueue)
{
if(length > 256)
return 1;
struct usart_buffer_t *buffer = &status->txBuffer;
uint8_t hash = STARTMARKER;
buffer->packet.header.startByte = STARTMARKER;
buffer->packet.header.serial = status->txSerial;
hash ^= status->txSerial++;
buffer->packet.header.payloadLength = length;
hash ^= length;
buffer->packet.header.hash = hash;
BuildHeader(&status->txBuffer, status->txSerial++, length);
uint16_t payloadLength = RoundUpTo4(length);
if(payload)
memcpy(status->txBuffer.packet.payload, payload, length);
status->txBuffer.requestedLength = sizeof(struct usartpacketheader_t) + payloadLength + sizeof(uint32_t); // +4 for the hash
status->txBuffer.busy = 1;
status->txBuffer.error = 0;
Crc_Enqueue(status->crcStatus, &status->crcSlot, 0, status->txBuffer.packet.payload, length,
Crc_Enqueue(status->crcStatus, &status->crcSlot, 0, &status->txBuffer.packet, sizeof(status->txBuffer.packet.header) + payloadLength,
NULL, (uint32_t*)(status->txBuffer.packet.payload + payloadLength));
while(waitForCrcQueue && Crc_IsSlotQueued(&status->crcSlot, 0));
Pku_SetupTransmit(status->usart, status->txDmaInfo.dma, status->txDmaInfo.stream, &status->txBuffer.packet, status->txBuffer.requestedLength);
Pu_SetupTransmit(status->usart, status->txDmaInfo.dma, status->txDmaInfo.stream, &status->txBuffer.packet, status->txBuffer.requestedLength);
StatsIncSent(&status->stats);
return 0;
}
void Pku_SetupReceive(struct usartstatus_t *status)
void MOCKABLE(Pu_SetupReceive)(struct usartstatus_t *status)
{
uint8_t packetIndex = status->activeRxBuf;
@ -141,12 +183,21 @@ void Pku_SetupReceive(struct usartstatus_t *status)
}
void Pku_ConsumePacket(struct usartstatus_t *status, uint8_t packetIndex)
void MOCKABLE(Pu_SetupTransmit)(USART_TypeDef *usart, DMA_TypeDef* dma, uint32_t stream, void *buffer, uint32_t length)
{
LL_DMA_ConfigAddresses(dma, stream, (uint32_t)buffer, LL_USART_DMA_GetRegAddr(usart), LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
LL_DMA_SetDataLength(dma, stream, length);
LL_USART_EnableDMAReq_TX(usart);
LL_DMA_EnableStream(dma, stream);
}
void MOCKABLE(Pu_ConsumePacket)(struct usartstatus_t *status, uint8_t packetIndex)
{
struct usart_buffer_t *buffer = &status->rxBuffers[packetIndex];
if(buffer->busy) {
if(buffer->error)
StatsIncPayloadError(&status->stats, buffer->errorInfo, *(uint32_t*) (buffer->packet.payload + RoundUpTo4(buffer->packet.header.payloadLength + 1)));
StatsIncPayloadError(&status->stats, buffer->errorInfo, *(uint32_t*) (buffer->packet.payload + RoundUpTo4(buffer->packet.header.payloadLength)));
else {
uint8_t diff = buffer->packet.header.serial - status->rxSerial;
if(diff > 1)
@ -159,45 +210,24 @@ void Pku_ConsumePacket(struct usartstatus_t *status, uint8_t packetIndex)
}
void Pku_SetupTransmit(USART_TypeDef *usart, DMA_TypeDef* dma, uint32_t stream, void *buffer, uint32_t length)
{
LL_DMA_ConfigAddresses(dma, stream, (uint32_t)buffer, LL_USART_DMA_GetRegAddr(usart), LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
LL_DMA_SetDataLength(dma, stream, length);
LL_USART_EnableDMAReq_TX(usart);
LL_DMA_EnableStream(dma, stream);
}
void RxCrcComputedCallback(void *callbackParm, uint32_t calculatedCrc, uint8_t success)
{
struct usart_buffer_t *ub = (struct usart_buffer_t*) callbackParm;
if(!success)
ub->error = 1;
else if(*(uint32_t*) (ub->packet.payload + RoundUpTo4(ub->packet.header.payloadLength + 1)) == calculatedCrc)
ub->busy = 1;
else {
ub->error = ub->busy = 1;
ub->errorInfo = calculatedCrc;
}
if(ub->usartStatus->packetReceivedCallback)
ub->usartStatus->packetReceivedCallback(ub->usartStatus->packetReceivedCallbacParam, ub);
}
void Pku_HandleRxDmaIrq(struct usartstatus_t *status)
void MOCKABLE(Pu_HandleRxDmaIrq)(struct usartstatus_t *status)
{
DIAG_INTERRUPT_IN();
StatsIncRcvd(&status->stats);
if(*status->rxDmaInfo.isReg & status->rxDmaInfo.tcMask) {
*status->rxDmaInfo.ifcReg = status->rxDmaInfo.tcMask;
if(CheckHeader(&status->rxBuffers[status->activeRxBuf].packet))
if(Pu_CheckHeader(&status->rxBuffers[status->activeRxBuf].packet)) {
Crc_Enqueue(status->crcStatus, &status->crcSlot, 1,
status->rxBuffers[status->activeRxBuf].packet.payload,
status->rxBuffers[status->activeRxBuf].packet.header.payloadLength +1,
RxCrcComputedCallback, &status->rxBuffers[status->activeRxBuf]);
else {
&status->rxBuffers[status->activeRxBuf].packet,
RoundUpTo4(status->rxBuffers[status->activeRxBuf].packet.header.payloadLength) + sizeof(struct usartpacketheader_t),
Pu_RxCrcComputedCallback, &status->rxBuffers[status->activeRxBuf]);
} else {
StatsIncHdrError(&status->stats, *(uint32_t*)&status->rxBuffers[status->activeRxBuf].packet.header);
status->rxBuffers[status->activeRxBuf].error = 1;
}
} else if(*status->rxDmaInfo.isReg & status->rxDmaInfo.teMask) {
}
if(*status->rxDmaInfo.isReg & status->rxDmaInfo.teMask) {
*status->rxDmaInfo.ifcReg = status->rxDmaInfo.teMask;
status->rxBuffers[status->activeRxBuf].error = 1;
}
@ -207,11 +237,28 @@ void Pku_HandleRxDmaIrq(struct usartstatus_t *status)
DIAG_RX_BUFFER_SWITCH(status->activeRxBuf);
if(status->rxBuffers[status->activeRxBuf].busy)
StatsIncOverrun(&status->stats);
Pku_SetupReceive(status);
Pu_SetupReceive(status);
DIAG_INTERRUPT_OUT();
}
void Pku_HandleTxDmaIrq(struct usartstatus_t *status)
void MOCKABLE(Pu_RxCrcComputedCallback)(void *callbackParm, uint32_t calculatedCrc, uint8_t success)
{
struct usart_buffer_t *ub = (struct usart_buffer_t*) callbackParm;
if(!success)
ub->error = 1;
else if(*(uint32_t*) (ub->packet.payload + RoundUpTo4(ub->packet.header.payloadLength)) == calculatedCrc)
ub->busy = 1;
else {
ub->error = ub->busy = 1;
ub->errorInfo = calculatedCrc;
}
if(ub->usartStatus->packetReceivedCallback)
ub->usartStatus->packetReceivedCallback(ub->usartStatus->packetReceivedCallbackParam, ub);
}
void MOCKABLE(Pu_HandleTxDmaIrq)(struct usartstatus_t *status)
{
DIAG_INTERRUPT_IN();
if(*status->txDmaInfo.isReg & status->txDmaInfo.tcMask) { // DMA transfer complete
@ -219,9 +266,11 @@ void Pku_HandleTxDmaIrq(struct usartstatus_t *status)
LL_USART_EnableIT_TC(status->usart);
LL_DMA_DisableStream(status->txDmaInfo.dma, status->txDmaInfo.stream);
}
else if(*status->txDmaInfo.isReg & status->txDmaInfo.teMask) {
if(*status->txDmaInfo.isReg & status->txDmaInfo.teMask) {
*status->txDmaInfo.ifcReg = status->txDmaInfo.teMask;
status->txBuffer.error = 1;
LL_USART_EnableIT_TC(status->usart);
LL_DMA_DisableStream(status->txDmaInfo.dma, status->txDmaInfo.stream);
StatsIncDmaError(&status->stats);
}
if(*status->txDmaInfo.isReg & status->txDmaInfo.feMask)
@ -233,26 +282,29 @@ void Pku_HandleTxDmaIrq(struct usartstatus_t *status)
DIAG_INTERRUPT_OUT();
}
void Pku_HandleUsartIrq(struct usartstatus_t *status)
void MOCKABLE(Pu_HandleUsartIrq)(struct usartstatus_t *status)
{
DIAG_INTERRUPT_IN();
if(LL_USART_IsActiveFlag_IDLE(status->usart) && LL_USART_IsEnabledIT_IDLE(status->usart)) { // receiver idle
LL_USART_ClearFlag_IDLE(status->usart);
uint16_t rcvdLen = status->rxBuffers[status->activeRxBuf].requestedLength - LL_DMA_GetDataLength(status->rxDmaInfo.dma, status->rxDmaInfo.stream);
if(rcvdLen >= sizeof(struct usartpacketheader_t)) {
if(CheckHeader(&status->rxBuffers[status->activeRxBuf].packet)) {
if(rcvdLen >= sizeof(struct usartpacketheader_t) + RoundUpTo4(status->rxBuffers[status->activeRxBuf].packet.header.payloadLength + 1) + sizeof(uint32_t))
if(Pu_CheckHeader(&status->rxBuffers[status->activeRxBuf].packet)) {
if(rcvdLen >= sizeof(struct usartpacketheader_t) + RoundUpTo4(status->rxBuffers[status->activeRxBuf].packet.header.payloadLength) + sizeof(uint32_t))
LL_DMA_DisableStream(status->rxDmaInfo.dma, status->rxDmaInfo.stream);
else
StatsIncPremature_payload(&status->stats);
} else {
status->rxBuffers[status->activeRxBuf].error = 1;
status->rxBuffers[status->activeRxBuf].busy = 1;
LL_DMA_DisableStream(status->rxDmaInfo.dma, status->rxDmaInfo.stream);
}
} else
StatsIncPremature_hdr(&status->stats);
}
else if(LL_USART_IsActiveFlag_TC(status->usart) && LL_USART_IsEnabledIT_TC(status->usart)) { // transmission complete
if(LL_USART_IsActiveFlag_TC(status->usart) && LL_USART_IsEnabledIT_TC(status->usart)) { // transmission complete
LL_USART_DisableIT_TC(status->usart);
LL_USART_DisableDirectionTx(status->usart); // enforcing an idle frame
LL_USART_EnableDirectionTx(status->usart);