git subrepo pull components/f4ll_c

subrepo: subdir: "components/f4ll_c" merged: "5d26fdc" upstream: origin: "git@git.pcmuhely.hu:compi/f4ll_c.git" branch: "master" commit: "5d26fdc" git-subrepo: version: "0.4.0" origin: "https://github.com/ingydotnet/git-subrepo" commit: "5d6aba9"
2019-12-06 14:32:53 +01:00 · 2019-12-06 14:32:53 +01:00 · b9114f049a
commit b9114f049a
parent 357b30b344
10 changed files with 243 additions and 189 deletions
--- a/components/f4ll_c/packetusart.c
+++ b/components/f4ll_c/packetusart.c
@ -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);