|
|
@@ -12,186 +12,400 @@ volatile uint32 VarNotification_0 = 0;
|
|
|
volatile uint32 VarNotification_1 = 0;
|
|
|
TP_Value_Type ConvertedBuffer[NUM_RESULTS];
|
|
|
Adc_ValueGroupType ResultBuffer[NUM_RESULTS];
|
|
|
+ volatile Uart_StatusType Uart_TransmitStatus[3] = {UART_STATUS_TIMEOUT,UART_STATUS_TIMEOUT,UART_STATUS_TIMEOUT};
|
|
|
+ QueueHandle_t UartRecvQueue[3];
|
|
|
+ QueueHandle_t UartSendQueue[3];
|
|
|
+ QueueHandle_t UartHalQueueHandle;
|
|
|
+ void Uart_Hal_RecvTask(void *pvParameters);
|
|
|
+ void Uart_Hal_SendTask(void *pvParameters);
|
|
|
+ Std_ReturnType UartStartRecvFunc(uint8 channel);
|
|
|
Std_ReturnType ADC_Converter(Adc_ValueGroupType *Buffer, TP_Value_Type *ConvertedValueR);
|
|
|
-Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen, uint32 T_timeout)
|
|
|
+Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 **rxBuffer, uint16 *rxlen, uint32 T_timeout)
|
|
|
{
|
|
|
- volatile Std_ReturnType R_Uart_Status;
|
|
|
- volatile Std_ReturnType T_Uart_Status;
|
|
|
- volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
|
|
|
- volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
|
|
|
- uint32 T_bytesRemaining;
|
|
|
- uint32 R_bytesRemaining;
|
|
|
- uint32 timeout = T_timeout;
|
|
|
- uint32 retVal = E_NOT_OK;
|
|
|
- bufferIdx[recvChannel] = 0;
|
|
|
- switch (recvChannel)
|
|
|
- {
|
|
|
- case 0:
|
|
|
- IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- case 1:
|
|
|
- IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- if (txBuffer == NULL || rxBuffer == NULL)
|
|
|
- {
|
|
|
- return retVal;
|
|
|
- }
|
|
|
-
|
|
|
- /* Uart_AsyncSend transmit data */
|
|
|
- Uart_SetBuffer(transChannel, txBuffer, sendLength, UART_SEND);
|
|
|
- T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
|
|
|
- if (E_OK != T_Uart_Status)
|
|
|
- {
|
|
|
- Uart_Abort(transChannel, UART_SEND);
|
|
|
- return E_NOT_OK;
|
|
|
- }
|
|
|
- Uart_SetBuffer(recvChannel, &RX_Buffer[recvChannel][0], DMA_SIZE, UART_RECEIVE);
|
|
|
- R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
|
|
|
- if (E_OK != R_Uart_Status)
|
|
|
- {
|
|
|
- Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
- return E_NOT_OK;
|
|
|
- }
|
|
|
- /* Check for no on-going transmission */
|
|
|
- do
|
|
|
- {
|
|
|
- if (Uart_TransmitStatus != UART_STATUS_NO_ERROR)
|
|
|
- {
|
|
|
- Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
|
|
|
- }
|
|
|
- if (Uart_ReceiveStatus != UART_STATUS_NO_ERROR)
|
|
|
- {
|
|
|
- Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &R_bytesRemaining, UART_RECEIVE);
|
|
|
- }
|
|
|
- vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
- } while (((UART_STATUS_NO_ERROR != Uart_TransmitStatus || UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < --timeout));
|
|
|
- if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
|
|
|
- {
|
|
|
- Uart_Abort(transChannel, UART_SEND);
|
|
|
- retVal = E_NOT_OK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- retVal = E_OK;
|
|
|
- }
|
|
|
- if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
|
|
|
- {
|
|
|
- Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
- *rxlen = bufferIdx[recvChannel];
|
|
|
- retVal = E_NOT_OK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- *rxlen = bufferIdx[recvChannel];
|
|
|
- retVal = E_OK;
|
|
|
- }
|
|
|
- return retVal;
|
|
|
+ UartMsg_t UartRecvMsg;
|
|
|
+ UartMsg_t UartSendMsg;
|
|
|
+ BaseType_t Sendret = pdFALSE;
|
|
|
+ BaseType_t Recvret = pdFALSE;
|
|
|
+ uint32 retVal = E_NOT_OK;
|
|
|
+ UartSendMsg.DataLen = sendLength;
|
|
|
+ UartSendMsg.dataPrt = txBuffer;
|
|
|
+ *rxlen = 0;
|
|
|
+ Sendret = xQueueSend(UartSendQueue[transChannel],&UartSendMsg,10);
|
|
|
+
|
|
|
+ memset(&UartRecvMsg,0,sizeof(UartMsg_t));
|
|
|
+
|
|
|
+ if(Sendret == pdTRUE)
|
|
|
+ {
|
|
|
+ Recvret = xQueueReceive(UartRecvQueue[recvChannel],&UartRecvMsg,T_timeout);
|
|
|
+ if(Recvret == pdTRUE)
|
|
|
+ {
|
|
|
+ *rxlen = UartRecvMsg.DataLen;
|
|
|
+ *rxBuffer = UartRecvMsg.dataPrt;
|
|
|
+ retVal = E_OK;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return retVal;
|
|
|
}
|
|
|
-
|
|
|
-Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout)
|
|
|
+Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 **rxBuffer, uint16 *rxlen, sint32 T_timeout)
|
|
|
{
|
|
|
-
|
|
|
- volatile Std_ReturnType T_Uart_Status;
|
|
|
- volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
|
|
|
- uint32 T_bytesRemaining;
|
|
|
- uint32 timeout = T_timeout;
|
|
|
- uint32 retVal = E_NOT_OK;
|
|
|
- if (txBuffer == NULL)
|
|
|
- {
|
|
|
- return retVal;
|
|
|
- }
|
|
|
-
|
|
|
- /* Uart_AsyncSend transmit data */
|
|
|
- T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
|
|
|
- if (E_OK != T_Uart_Status)
|
|
|
- {
|
|
|
- Uart_Abort(transChannel, UART_SEND);
|
|
|
- return E_NOT_OK;
|
|
|
- }
|
|
|
- /* Check for no on-going transmission */
|
|
|
- do
|
|
|
- {
|
|
|
- Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
|
|
|
- vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
- } while ((UART_STATUS_NO_ERROR != Uart_TransmitStatus && 0 < --timeout));
|
|
|
-
|
|
|
- if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
|
|
|
- {
|
|
|
- retVal = E_NOT_OK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- retVal = E_OK;
|
|
|
- }
|
|
|
- return retVal;
|
|
|
+ UartMsg_t UartRecvMsg;
|
|
|
+ BaseType_t ret = pdFALSE;
|
|
|
+ uint32 retVal = E_NOT_OK;
|
|
|
+ *rxlen = 0;
|
|
|
+ ret = xQueueReceive(UartRecvQueue[recvChannel],&UartRecvMsg,T_timeout);
|
|
|
+ if(ret == pdTRUE)
|
|
|
+ {
|
|
|
+ *rxlen = UartRecvMsg.DataLen;
|
|
|
+ *rxBuffer = UartRecvMsg.dataPrt;
|
|
|
+ retVal = E_OK;
|
|
|
+ }
|
|
|
+ return retVal;
|
|
|
}
|
|
|
-
|
|
|
-Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer, uint16 *rxlen, sint32 T_timeout)
|
|
|
+Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout)
|
|
|
{
|
|
|
- volatile Std_ReturnType R_Uart_Status = E_NOT_OK;
|
|
|
- volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
|
|
|
- uint32 T_bytesRemaining = 0;
|
|
|
- uint32 retVal = E_NOT_OK;
|
|
|
- // uint8 Rx_Buffer[MSG_LEN];
|
|
|
- bufferIdx[recvChannel] = 0;
|
|
|
- *rxlen = 0;
|
|
|
- if (rxBuffer == NULL)
|
|
|
- {
|
|
|
- return retVal;
|
|
|
- }
|
|
|
- /* Uart_AsyncReceive transmit data */
|
|
|
- switch (recvChannel)
|
|
|
- {
|
|
|
- case 0:
|
|
|
- IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- case 1:
|
|
|
- IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
- break;
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- Uart_SetBuffer(recvChannel, rxBuffer, DMA_SIZE, UART_RECEIVE);
|
|
|
- R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
|
|
|
- if (E_OK != R_Uart_Status)
|
|
|
- {
|
|
|
- Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
- return E_NOT_OK;
|
|
|
- }
|
|
|
- /* Check for no on-going transmission */
|
|
|
- do
|
|
|
- {
|
|
|
- Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &T_bytesRemaining, UART_RECEIVE);
|
|
|
- vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
-
|
|
|
- } while ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < T_timeout--);
|
|
|
- if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
|
|
|
- {
|
|
|
- Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
- *rxlen = bufferIdx[recvChannel];
|
|
|
- retVal = E_NOT_OK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- *rxlen = bufferIdx[recvChannel];
|
|
|
- retVal = E_OK;
|
|
|
- }
|
|
|
- return retVal;
|
|
|
+ UartMsg_t UartSendMsg;
|
|
|
+ BaseType_t ret = pdFALSE;
|
|
|
+ uint32 retVal = E_NOT_OK;
|
|
|
+ UartSendMsg.DataLen = sendLength;
|
|
|
+ UartSendMsg.dataPrt = txBuffer;
|
|
|
+ ret = xQueueSend(UartSendQueue[transChannel],&UartSendMsg,T_timeout);
|
|
|
+ if(ret == pdTRUE)
|
|
|
+ {
|
|
|
+ retVal = E_OK;
|
|
|
+ }
|
|
|
+ return retVal;
|
|
|
}
|
|
|
+ void UartInit(void)
|
|
|
+ {
|
|
|
+ UartRecvQueue[0] = xQueueCreate(3, sizeof(UartMsg_t));
|
|
|
+ UartRecvQueue[1] = xQueueCreate(3, sizeof(UartMsg_t));
|
|
|
+ UartRecvQueue[2] = xQueueCreate(3, sizeof(UartMsg_t));
|
|
|
+ UartSendQueue[0] = xQueueCreate(1, sizeof(UartMsg_t));
|
|
|
+ UartSendQueue[1] = xQueueCreate(1, sizeof(UartMsg_t));
|
|
|
+ UartSendQueue[2] = xQueueCreate(1, sizeof(UartMsg_t));
|
|
|
+ UartHalQueueHandle = xQueueCreate(6, sizeof(UartHalMsg_t));
|
|
|
+
|
|
|
+ xTaskCreate(Uart_Hal_RecvTask, (const char *const)"UartRecv", 1024, (void *)0, main_TASK_PRIORITY + 3, NULL);
|
|
|
+ xTaskCreate(Uart_Hal_SendTask, (const char *const)"UartSend", 1024, (void *)0, main_TASK_PRIORITY + 2, NULL);
|
|
|
+ }
|
|
|
+ Std_ReturnType UartStartRecvFunc(uint8 channel)
|
|
|
+ {
|
|
|
+ sint8 out = 0;
|
|
|
+ volatile Std_ReturnType R_Uart_Status=E_NOT_OK;
|
|
|
+ bufferIdx[channel]=0;
|
|
|
+ memset(RX_Buffer[channel],0x00,BUFFER_SIZE);
|
|
|
+ switch(channel)
|
|
|
+ {
|
|
|
+ case 0:
|
|
|
+ IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ Uart_SetBuffer(channel, RX_Buffer[channel], DMA_SIZE, UART_RECEIVE);
|
|
|
+ R_Uart_Status = Uart_AsyncReceive(channel, RX_Buffer[channel], DMA_SIZE);
|
|
|
+ if (E_OK != R_Uart_Status)
|
|
|
+ {
|
|
|
+ Uart_Abort(channel, UART_RECEIVE);
|
|
|
+ out = E_NOT_OK;
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+ }
|
|
|
+ void Uart_Hal_RecvTask(void *pvParameters)
|
|
|
+ {
|
|
|
+ UartMsg_t UartMsg;
|
|
|
+ UartHalMsg_t UartHalMsgRecv;
|
|
|
+ BaseType_t ret = pdFALSE;
|
|
|
+ uint32 T_bytesRemaining[3] = {0};
|
|
|
+ uint16 T_timeout[3] = {0};
|
|
|
+ volatile Uart_StatusType Uart_ReceiveStatus[3] = {UART_STATUS_TIMEOUT,UART_STATUS_TIMEOUT,UART_STATUS_TIMEOUT};
|
|
|
+ uint8 UartIdx = UART_LPUART0;
|
|
|
+ uint8 UartState[3] = {UartAbortRecv,UartAbortRecv,UartAbortRecv};
|
|
|
+ while(1)
|
|
|
+ {
|
|
|
+ if((T_timeout[UartIdx]>1000) && (Uart_ReceiveStatus[UartIdx] != UART_STATUS_NO_ERROR) )//判定UART停止，超时停止，不是接收状态则停止
|
|
|
+ {
|
|
|
+ Uart_Abort(UartIdx, UART_RECEIVE);
|
|
|
+ UartState[UartIdx] = UartAbortRecv;
|
|
|
+ T_timeout[UartIdx] = 0;
|
|
|
+ }
|
|
|
+ else if(Uart_ReceiveStatus[UartIdx] == UART_STATUS_NO_ERROR)
|
|
|
+ {
|
|
|
+ UartState[UartIdx] = UartRecvComplete;
|
|
|
+ }
|
|
|
+
|
|
|
+ if((UartState[UartIdx] == UartAbortRecv) || (UartState[UartIdx] == UartRecvComplete)) //判定UART开始接收：UART停止后开始接收
|
|
|
+ {
|
|
|
+ if(E_OK == UartStartRecvFunc(UartIdx))
|
|
|
+ {
|
|
|
+ UartState[UartIdx] = UartStartRecv;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = xQueueReceive(UartHalQueueHandle,&UartHalMsgRecv,1);
|
|
|
+
|
|
|
+ Uart_ReceiveStatus[UartIdx] = Uart_GetStatus(UartIdx, &T_bytesRemaining[UartIdx], UART_RECEIVE);
|
|
|
+ T_timeout[UartIdx]++;
|
|
|
+ UartIdx = (UartIdx + 1) > 2 ? 0 : (UartIdx + 1);
|
|
|
+
|
|
|
+
|
|
|
+ if(ret==pdTRUE)
|
|
|
+ {
|
|
|
+ if(UartHalMsgRecv.event==LPUART_UART_IP_EVENT_RECV_IDLE)
|
|
|
+ {
|
|
|
+ UartMsg.DataLen = UartHalMsgRecv.value;
|
|
|
+// UartMsg.dataPrt = RX_Buffer[UartHalMsgRecv.Channel];
|
|
|
+
|
|
|
+ UartMsg.dataPrt = malloc(UartMsg.DataLen);
|
|
|
+ memset(UartMsg.dataPrt,0,UartMsg.DataLen);
|
|
|
+ memcpy(UartMsg.dataPrt,RX_Buffer[UartHalMsgRecv.Channel],UartMsg.DataLen);
|
|
|
+
|
|
|
+ xQueueSendToFront(UartRecvQueue[UartHalMsgRecv.Channel],&UartMsg,1);
|
|
|
+
|
|
|
+ T_timeout[UartHalMsgRecv.Channel] = 0;
|
|
|
+ UartState[UartHalMsgRecv.Channel] = UartRecvComplete;
|
|
|
+
|
|
|
+// Uart_ReceiveStatus[UartHalMsgRecv.Channel] = Uart_GetStatus(UartIdx, &T_bytesRemaining[UartIdx], UART_RECEIVE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ void Uart_Hal_SendTask(void *pvParameters)
|
|
|
+ {
|
|
|
+ UartMsg_t UartSendMsg;
|
|
|
+ BaseType_t ret = pdFALSE;
|
|
|
+ uint32 T_bytesRemaining[3] = {0};
|
|
|
+ uint16 T_timeout[3] = {0};
|
|
|
+ volatile Std_ReturnType T_Uart_Status[3];
|
|
|
+ uint8 UartIdx = UART_LPUART0;
|
|
|
+ uint8 UartSendState[3] = {UartNoDataSend,UartNoDataSend,UartNoDataSend};
|
|
|
+ while(1)
|
|
|
+ {
|
|
|
+ ret = xQueueReceive(UartSendQueue[UartIdx],&UartSendMsg,1);
|
|
|
+ if(ret==pdTRUE)
|
|
|
+ {
|
|
|
+ T_Uart_Status[UartIdx] = Uart_AsyncSend(UartIdx, UartSendMsg.dataPrt, UartSendMsg.DataLen);
|
|
|
+ if (E_OK != T_Uart_Status[UartIdx])
|
|
|
+ {
|
|
|
+ Uart_Abort(UartIdx, UART_SEND);
|
|
|
+ UartSendState[UartIdx] = UartAbortSend;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ UartSendState[UartIdx] = UartStartSend;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /*开始发送后的判定*/
|
|
|
+ if(UartSendState[UartIdx] == UartStartSend)
|
|
|
+ {
|
|
|
+ Uart_TransmitStatus[UartIdx] = Uart_GetStatus(UartIdx, &T_bytesRemaining[UartIdx], UART_SEND);
|
|
|
+ T_timeout[UartIdx]++;
|
|
|
+ }
|
|
|
+ if(T_timeout[UartIdx]>=1000 || ((Uart_TransmitStatus[UartIdx] != UART_STATUS_OPERATION_ONGOING) && (UartSendState[UartIdx] == UartStartSend)))
|
|
|
+ {
|
|
|
+ if(T_timeout[UartIdx]>=1000)
|
|
|
+ {
|
|
|
+ Uart_Abort(UartIdx, UART_SEND);
|
|
|
+ UartSendState[UartIdx] = UartAbortSend;
|
|
|
+ }
|
|
|
+ else if(Uart_TransmitStatus[UartIdx] == UART_STATUS_NO_ERROR)
|
|
|
+ {
|
|
|
+ UartSendState[UartIdx] = UartSendComplete;
|
|
|
+ }
|
|
|
+ T_timeout[UartIdx] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ UartIdx = (UartIdx + 1) > 2 ? 0 : (UartIdx + 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+//
|
|
|
+//Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen, uint32 T_timeout)
|
|
|
+//{
|
|
|
+// volatile Std_ReturnType R_Uart_Status;
|
|
|
+// volatile Std_ReturnType T_Uart_Status;
|
|
|
+// volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
|
|
|
+// volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
|
|
|
+// uint32 T_bytesRemaining;
|
|
|
+// uint32 R_bytesRemaining;
|
|
|
+// uint32 timeout = T_timeout;
|
|
|
+// uint32 retVal = E_NOT_OK;
|
|
|
+// bufferIdx[recvChannel] = 0;
|
|
|
+// switch (recvChannel)
|
|
|
+// {
|
|
|
+// case 0:
|
|
|
+// IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// case 1:
|
|
|
+// IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// case 2:
|
|
|
+// IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// default:
|
|
|
+// break;
|
|
|
+// }
|
|
|
+// if (txBuffer == NULL || rxBuffer == NULL)
|
|
|
+// {
|
|
|
+// return retVal;
|
|
|
+// }
|
|
|
+//
|
|
|
+// /* Uart_AsyncSend transmit data */
|
|
|
+// Uart_SetBuffer(transChannel, txBuffer, sendLength, UART_SEND);
|
|
|
+// T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
|
|
|
+// if (E_OK != T_Uart_Status)
|
|
|
+// {
|
|
|
+// Uart_Abort(transChannel, UART_SEND);
|
|
|
+// return E_NOT_OK;
|
|
|
+// }
|
|
|
+// Uart_SetBuffer(recvChannel, &RX_Buffer[recvChannel][0], DMA_SIZE, UART_RECEIVE);
|
|
|
+// R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
|
|
|
+// if (E_OK != R_Uart_Status)
|
|
|
+// {
|
|
|
+// Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
+// return E_NOT_OK;
|
|
|
+// }
|
|
|
+// /* Check for no on-going transmission */
|
|
|
+// do
|
|
|
+// {
|
|
|
+// if (Uart_TransmitStatus != UART_STATUS_NO_ERROR)
|
|
|
+// {
|
|
|
+// Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
|
|
|
+// }
|
|
|
+// if (Uart_ReceiveStatus != UART_STATUS_NO_ERROR)
|
|
|
+// {
|
|
|
+// Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &R_bytesRemaining, UART_RECEIVE);
|
|
|
+// }
|
|
|
+// vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
+// } while (((UART_STATUS_NO_ERROR != Uart_TransmitStatus || UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < --timeout));
|
|
|
+// if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
|
|
|
+// {
|
|
|
+// Uart_Abort(transChannel, UART_SEND);
|
|
|
+// retVal = E_NOT_OK;
|
|
|
+// }
|
|
|
+// else
|
|
|
+// {
|
|
|
+// retVal = E_OK;
|
|
|
+// }
|
|
|
+// if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
|
|
|
+// {
|
|
|
+// Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
+// *rxlen = bufferIdx[recvChannel];
|
|
|
+// retVal = E_NOT_OK;
|
|
|
+// }
|
|
|
+// else
|
|
|
+// {
|
|
|
+// *rxlen = bufferIdx[recvChannel];
|
|
|
+// retVal = E_OK;
|
|
|
+// }
|
|
|
+// return retVal;
|
|
|
+//}
|
|
|
+//
|
|
|
+//Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout)
|
|
|
+//{
|
|
|
+//
|
|
|
+// volatile Std_ReturnType T_Uart_Status;
|
|
|
+// volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
|
|
|
+// uint32 T_bytesRemaining;
|
|
|
+// uint32 timeout = T_timeout;
|
|
|
+// uint32 retVal = E_NOT_OK;
|
|
|
+// if (txBuffer == NULL)
|
|
|
+// {
|
|
|
+// return retVal;
|
|
|
+// }
|
|
|
+//
|
|
|
+// /* Uart_AsyncSend transmit data */
|
|
|
+// T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
|
|
|
+// if (E_OK != T_Uart_Status)
|
|
|
+// {
|
|
|
+// Uart_Abort(transChannel, UART_SEND);
|
|
|
+// return E_NOT_OK;
|
|
|
+// }
|
|
|
+// /* Check for no on-going transmission */
|
|
|
+// do
|
|
|
+// {
|
|
|
+// Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
|
|
|
+// vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
+// } while ((UART_STATUS_NO_ERROR != Uart_TransmitStatus && 0 < --timeout));
|
|
|
+//
|
|
|
+// if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
|
|
|
+// {
|
|
|
+// retVal = E_NOT_OK;
|
|
|
+// }
|
|
|
+// else
|
|
|
+// {
|
|
|
+// retVal = E_OK;
|
|
|
+// }
|
|
|
+// return retVal;
|
|
|
+//}
|
|
|
+//
|
|
|
+//Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer, uint16 *rxlen, sint32 T_timeout)
|
|
|
+//{
|
|
|
+// volatile Std_ReturnType R_Uart_Status = E_NOT_OK;
|
|
|
+// volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
|
|
|
+// uint32 T_bytesRemaining = 0;
|
|
|
+// uint32 retVal = E_NOT_OK;
|
|
|
+// // uint8 Rx_Buffer[MSG_LEN];
|
|
|
+// bufferIdx[recvChannel] = 0;
|
|
|
+// *rxlen = 0;
|
|
|
+// if (rxBuffer == NULL)
|
|
|
+// {
|
|
|
+// return retVal;
|
|
|
+// }
|
|
|
+// /* Uart_AsyncReceive transmit data */
|
|
|
+// switch (recvChannel)
|
|
|
+// {
|
|
|
+// case 0:
|
|
|
+// IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// case 1:
|
|
|
+// IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// case 2:
|
|
|
+// IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
|
|
|
+// break;
|
|
|
+// default:
|
|
|
+// break;
|
|
|
+// }
|
|
|
+// Uart_SetBuffer(recvChannel, rxBuffer, DMA_SIZE, UART_RECEIVE);
|
|
|
+// R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
|
|
|
+// if (E_OK != R_Uart_Status)
|
|
|
+// {
|
|
|
+// Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
+// return E_NOT_OK;
|
|
|
+// }
|
|
|
+// /* Check for no on-going transmission */
|
|
|
+// do
|
|
|
+// {
|
|
|
+// Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &T_bytesRemaining, UART_RECEIVE);
|
|
|
+// vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
+//
|
|
|
+// } while ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < T_timeout--);
|
|
|
+// if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
|
|
|
+// {
|
|
|
+// Uart_Abort(recvChannel, UART_RECEIVE);
|
|
|
+// *rxlen = bufferIdx[recvChannel];
|
|
|
+// retVal = E_NOT_OK;
|
|
|
+// }
|
|
|
+// else
|
|
|
+// {
|
|
|
+// *rxlen = bufferIdx[recvChannel];
|
|
|
+// retVal = E_OK;
|
|
|
+// }
|
|
|
+// return retVal;
|
|
|
+//}
|
|
|
extern Lpuart_Uart_Ip_StateStructureType *Lpuart_Uart_Ip_apStateStructuresArray[LPUART_UART_IP_NUMBER_OF_INSTANCES];
|
|
|
void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event)
|
|
|
{
|
|
|
// (void)userData;
|
|
|
- uint32_t temp;
|
|
|
+ Lpuart_Uart_Ip_StateStructureType * UartState;
|
|
|
+ UartState = (Lpuart_Uart_Ip_StateStructureType *)Lpuart_Uart_Ip_apStateStructuresArray[hwInstance];
|
|
|
/* Check the event type */
|
|
|
if (event == LPUART_UART_IP_EVENT_RX_FULL)
|
|
|
{
|
|
|
@@ -217,18 +431,20 @@ void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event)
|
|
|
}
|
|
|
if (event == LPUART_UART_IP_EVENT_RECV_IDLE)
|
|
|
{
|
|
|
+ uint32_t temp;
|
|
|
+ UartHalMsg_t UartHalMsg;
|
|
|
+ UartHalMsg.Channel = hwInstance;
|
|
|
+ UartHalMsg.event = event;
|
|
|
/*Get the transfered data size. DMA Channel 1 is used for LPUART DMA receiving, please modify accordingly.*/
|
|
|
temp = DMA_SIZE - (uint32_t)IP_DMA->TCD[hwInstance].CITER.ELINKNO;
|
|
|
/*Add the remaining data size to the sum of the received size*/
|
|
|
bufferIdx[hwInstance] += temp;
|
|
|
/*Abort the receiving after detecting IDLE receiving*/
|
|
|
-
|
|
|
- Lpuart_Uart_Ip_StateStructureType *UartState;
|
|
|
- UartState = (Lpuart_Uart_Ip_StateStructureType *)Lpuart_Uart_Ip_apStateStructuresArray[hwInstance];
|
|
|
UartState->IsRxBusy = FALSE;
|
|
|
UartState->ReceiveStatus = LPUART_UART_IP_STATUS_SUCCESS;
|
|
|
Lpuart_Uart_Ip_CompleteReceiveUsingDma(hwInstance);
|
|
|
- // rxSuccess = true;
|
|
|
+ UartHalMsg.value = bufferIdx[hwInstance];
|
|
|
+ xQueueSendFromISR(UartHalQueueHandle,&UartHalMsg,pdFALSE);
|
|
|
}
|
|
|
}
|
|
|
|
