From 95149b8998cdcfc31da16471b16242f1c9bda7bc Mon Sep 17 00:00:00 2001 From: cfif Date: Tue, 9 Dec 2025 10:50:30 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Inc/fc7xxx_driver_fcuart.h | 3 + Src/fc7xxx_driver_fcuart.c | 1386 ++++++++++++++++-------------------- 2 files changed, 607 insertions(+), 782 deletions(-) diff --git a/Inc/fc7xxx_driver_fcuart.h b/Inc/fc7xxx_driver_fcuart.h index b7f4201..1ae3a21 100644 --- a/Inc/fc7xxx_driver_fcuart.h +++ b/Inc/fc7xxx_driver_fcuart.h @@ -431,4 +431,7 @@ FCUART_ErrorType FCUART_AssignTxInterruptData(uint8_t u8UartIndex, uint8_t * pDa /** @}*/ + +FCUART_ErrorType FCUART_BufTransmitted(uint8_t u8UartIndex, FCUART_InterruptType *pInterruptCfg); + #endif diff --git a/Src/fc7xxx_driver_fcuart.c b/Src/fc7xxx_driver_fcuart.c index 88a775b..a74d1cd 100644 --- a/Src/fc7xxx_driver_fcuart.c +++ b/Src/fc7xxx_driver_fcuart.c @@ -26,8 +26,7 @@ /********* Local typedef ************/ -typedef enum -{ +typedef enum { UART_PRINT_RADIX_BIN = 2U, UART_PRINT_RADIX_OCT = 8U, UART_PRINT_RADIX_DEC = 10U, @@ -38,8 +37,7 @@ typedef enum * @brief FCUART Operation Sequence * */ -typedef enum -{ +typedef enum { FCUART_SEQUENCE_VAR_NOINIT, /**< FCUART_SEQUENCE_DEINIT means fcuart variables data is not initialed */ FCUART_SEQUENCE_DEINIT, /**< FCUART_SEQUENCE_DEINIT means fcuart driver is not initialed */ FCUART_SEQUENCE_NOTSTART_RECEIVE, /**< FCUART_SEQUENCE_NOTSTART_RECEIVE means fcuart driver initialed and write/erase is allowed */ @@ -111,17 +109,13 @@ static uint8_t FCUART_Int2Char(int i32Value, char *pOutStr, UART_PrintIntType eR * @param u8UartIndex UART instance number * @return */ -static FCUART_ErrorType FCUART_LL_CheckInstance(uint8_t u8UartIndex) -{ +static FCUART_ErrorType FCUART_LL_CheckInstance(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; - if (u8UartIndex < FCUART_INSTANCE_COUNT) - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + if (u8UartIndex < FCUART_INSTANCE_COUNT) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -135,8 +129,7 @@ static FCUART_ErrorType FCUART_LL_CheckInstance(uint8_t u8UartIndex) * @param u32Sbr out * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_ProcessBaud(uint32_t u32Smb, uint32_t *u32OverSamp, uint32_t *u32Sbr) -{ +static FCUART_ErrorType FCUART_LL_ProcessBaud(uint32_t u32Smb, uint32_t *u32OverSamp, uint32_t *u32Sbr) { FCUART_ErrorType tRetVal; uint32_t u32SbrTemp; uint32_t u32OverSampTemp; @@ -150,67 +143,54 @@ static FCUART_ErrorType FCUART_LL_ProcessBaud(uint32_t u32Smb, uint32_t *u32Over u32OverSamp1 = 4U; /* 4..32 */ /* sbr = smb / oversamp */ - u32Sbr1 = (uint16_t)(u32Smb / (u32OverSamp1)); + u32Sbr1 = (uint16_t) (u32Smb / (u32OverSamp1)); u32CalcSmb = (u32OverSamp1) * (u32Sbr1); - if (u32CalcSmb > u32Smb) - { + if (u32CalcSmb > u32Smb) { u32SmbDiff = u32CalcSmb - u32Smb; - } - else - { + } else { u32SmbDiff = u32Smb - u32CalcSmb; } u32OriginDiff = u32SmbDiff; - if (u32SmbDiff != 0U) - { + if (u32SmbDiff != 0U) { /* loop to find the best u32OverSamp1 value possible, one that generates minimum u32SmbDiff * iterate through the rest of the supported values of u32OverSamp */ - for (u32OverSampTemp = 5U; u32OverSampTemp <= 32U; u32OverSampTemp++) - { + for (u32OverSampTemp = 5U; u32OverSampTemp <= 32U; u32OverSampTemp++) { /* calculate the temporary u32Sbr value */ - u32SbrTemp = (uint32_t)(u32Smb / u32OverSampTemp); + u32SbrTemp = (uint32_t) (u32Smb / u32OverSampTemp); /* calculate the baud rate based on the temporary u32OverSamp and u32Sbr values */ - u32CalcSmb = (uint32_t)(u32OverSampTemp * u32SbrTemp); + u32CalcSmb = (uint32_t) (u32OverSampTemp * u32SbrTemp); - if (u32CalcSmb > u32Smb) - { + if (u32CalcSmb > u32Smb) { u32TempSmbDiff = u32CalcSmb - u32Smb; - } - else - { + } else { u32TempSmbDiff = u32Smb - u32CalcSmb; } - if (u32TempSmbDiff < u32SmbDiff) - { + if (u32TempSmbDiff < u32SmbDiff) { u32SmbDiff = u32TempSmbDiff; u32OverSamp1 = u32OverSampTemp; /* update and store the best u32OverSamp value calculated */ u32Sbr1 = u32SbrTemp; /* update store the best u32Sbr value calculated */ } /* when differ is 0U, break */ - if (u32SmbDiff == 0U) - { + if (u32SmbDiff == 0U) { break; } } } /* check differ */ - if (u32SmbDiff <= u32OriginDiff) - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; + if (u32SmbDiff <= u32OriginDiff) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; /* out the calculated value */ *u32Sbr = u32Sbr1; *u32OverSamp = u32OverSamp1; - } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_FAILED; + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_FAILED; } return tRetVal; @@ -223,24 +203,21 @@ static FCUART_ErrorType FCUART_LL_ProcessBaud(uint32_t u32Smb, uint32_t *u32Over * @param u8Data UART data * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_Transmit_Char(FCUART_Type *pUart, uint8_t u8Data, uint32_t u32TimeoutTick) -{ +static FCUART_ErrorType FCUART_LL_Transmit_Char(FCUART_Type *pUart, uint8_t u8Data, uint32_t u32TimeoutTick) { uint32_t u32Result; uint32_t u32TryCount; /* check transmit ready flag */ u32Result = FCUART_HWA_GetStatus(pUart, FCUART_STAT_TDREF); - if (u32Result != 0U) - { - FCUART_HWA_SetData(pUart, (uint32_t)u8Data); /* Send data */ + if (u32Result != 0U) { + FCUART_HWA_SetData(pUart, (uint32_t) u8Data); /* Send data */ FCUART_HWA_SetTxTransfer(pUart, true); /* start transmit */ u32Result = 0U; u32TryCount = 0U; - while ((u32Result == 0U) && (u32TryCount < u32TimeoutTick)) - { + while ((u32Result == 0U) && (u32TryCount < u32TimeoutTick)) { /* check transmit flag */ u32Result = FCUART_HWA_GetStatus(pUart, FCUART_STAT_TCF); u32TryCount++; @@ -250,7 +227,7 @@ static FCUART_ErrorType FCUART_LL_Transmit_Char(FCUART_Type *pUart, uint8_t u8Da FCUART_HWA_SetTxTransfer(pUart, false); } - return (u32Result == 0U) ? (FCUART_ErrorType)FCUART_ERROR_FAILED : (FCUART_ErrorType)FCUART_ERROR_OK; + return (u32Result == 0U) ? (FCUART_ErrorType) FCUART_ERROR_FAILED : (FCUART_ErrorType) FCUART_ERROR_OK; } /** @@ -260,69 +237,56 @@ static FCUART_ErrorType FCUART_LL_Transmit_Char(FCUART_Type *pUart, uint8_t u8Da * @param pUartData UART receive buffer * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_Transmit_Empty(uint8_t u8UartIndex, FCUART_DataType *pUartData) -{ - FCUART_ErrorType tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; +static FCUART_ErrorType FCUART_LL_Transmit_Empty(uint8_t u8UartIndex, FCUART_DataType *pUartData) { + FCUART_ErrorType tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; FCUART_Type *pUart; uint32_t u32TempStats; uint32_t u32Index; - uint8_t u8Index; - uint8_t u8TxWaterMark; + uint8_t u8Index; + uint8_t u8TxWaterMark; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; - if ((pUartData != NULL) && (pUartData->pDatas != NULL)) - { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; + if ((pUartData != NULL) && (pUartData->pDatas != NULL)) { /* get and clear receive flag */ u32TempStats = FCUART_HWA_GetStatus(pUart, FCUART_STAT_TDREF); - if (u32TempStats > 0U) - { + if (u32TempStats > 0U) { /* TDRFF Flag has been got */ - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - if(pUartData->u32DataLen > 0U) - { - if(true == FCUART_HWA_GetEnStatusTxFifo(pUart)) - { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + if (pUartData->u32DataLen > 0U) { + if (true == FCUART_HWA_GetEnStatusTxFifo(pUart)) { /* Tx fifo enable */ u8TxWaterMark = FCUART_HWA_GetTxWaterMark(pUart); - if(((pUartData->u32DataLen) >= (uint32_t)(FCUART_FIFO_DEPTH - u8TxWaterMark) )) - { - for(u8Index=0U; u8Index<(FCUART_FIFO_DEPTH - u8TxWaterMark); u8Index++) - { - FCUART_HWA_SetData(pUart, (uint8_t)(pUartData->pDatas[0U])); /* Send data */ + if (((pUartData->u32DataLen) >= (uint32_t) (FCUART_FIFO_DEPTH - u8TxWaterMark))) { + for (u8Index = 0U; u8Index < (FCUART_FIFO_DEPTH - u8TxWaterMark); u8Index++) { + FCUART_HWA_SetData(pUart, (uint8_t) (pUartData->pDatas[0U])); /* Send data */ + + /* Update pointer position */ + (pUartData->pDatas)++; + (pUartData->u32DataLen)--; + } + } else { + for (u32Index = 0U; u32Index < (pUartData->u32DataLen); u32Index++) { + FCUART_HWA_SetData(pUart, (uint8_t) (pUartData->pDatas[0U])); /* Send data */ /* Update pointer position */ (pUartData->pDatas)++; (pUartData->u32DataLen)--; } } - else - { - for(u32Index=0U; u32Index<(pUartData->u32DataLen); u32Index++) - { - FCUART_HWA_SetData(pUart, (uint8_t)(pUartData->pDatas[0U])); /* Send data */ - - /* Update pointer position */ - (pUartData->pDatas)++; - (pUartData->u32DataLen)--; - } - } - } - else - { + } else { /* Tx fifo disable */ - FCUART_HWA_SetData(pUart, (uint8_t)(pUartData->pDatas[0U])); /* Send data */ + FCUART_HWA_SetData(pUart, (uint8_t) (pUartData->pDatas[0U])); /* Send data */ /* Update pointer position */ (pUartData->pDatas)++; (pUartData->u32DataLen)--; } - if(0U == pUartData->u32DataLen) - { + if (0U == pUartData->u32DataLen) { /* There's no new data, disable transmit empty interrupt and enable transmit complete interrupt */ - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_TIE); - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_TCIE); + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_TIE); + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_TCIE); } } } @@ -337,23 +301,21 @@ static FCUART_ErrorType FCUART_LL_Transmit_Empty(uint8_t u8UartIndex, FCUART_Dat * @param u8UartIndex UART Instance * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_Transmit_Complete(uint8_t u8UartIndex) -{ - FCUART_ErrorType tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; +static FCUART_ErrorType FCUART_LL_Transmit_Complete(uint8_t u8UartIndex) { + FCUART_ErrorType tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; FCUART_Type *pUart; uint32_t u32TempStats; /* No need to check instance */ - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* get and clear receive flag */ u32TempStats = FCUART_HWA_GetStatus(pUart, FCUART_STAT_TCF); - if (u32TempStats > 0U) - { + if (u32TempStats > 0U) { /* TCF Flag has been got */ - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)(FCUART_INT_CTRL_TE | FCUART_INT_CTRL_TCIE)); + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) (FCUART_INT_CTRL_TE | FCUART_INT_CTRL_TCIE)); } return tRetVal; } @@ -364,22 +326,20 @@ static FCUART_ErrorType FCUART_LL_Transmit_Complete(uint8_t u8UartIndex) * @param u8UartIndex UART Instance * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_Idle(uint8_t u8UartIndex) -{ - FCUART_ErrorType tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; +static FCUART_ErrorType FCUART_LL_Idle(uint8_t u8UartIndex) { + FCUART_ErrorType tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; FCUART_Type *pUart; uint32_t u32TempStats; /* get and clear receive flag */ - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* No need to check instance */ u32TempStats = FCUART_HWA_GetStatus(pUart, FCUART_STAT_IDLEF); - if (u32TempStats > 0U) - { + if (u32TempStats > 0U) { /* IDLF Flag has been got */ - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - FCUART_HWA_ClearStatus(pUart, (uint32_t)FCUART_STAT_IDLEF); + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + FCUART_HWA_ClearStatus(pUart, (uint32_t) FCUART_STAT_IDLEF); } return tRetVal; } @@ -391,41 +351,34 @@ static FCUART_ErrorType FCUART_LL_Idle(uint8_t u8UartIndex) * @param pUartData UART receive buffer * @return FCUART_ERROR_OK is ok, others are not ok */ -static FCUART_ErrorType FCUART_LL_Receive(uint8_t u8UartIndex, FCUART_DataType *pUartData) -{ - FCUART_ErrorType tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; +static FCUART_ErrorType FCUART_LL_Receive(uint8_t u8UartIndex, FCUART_DataType *pUartData) { + FCUART_ErrorType tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; FCUART_Type *pUart; uint8_t u8ReadData; uint32_t u32TempStats; - uint8_t u8RxCount; - uint8_t u8Index; + uint8_t u8RxCount; + uint8_t u8Index; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - if ((pUartData != NULL) && (pUartData->pDatas != NULL)) - { + if ((pUartData != NULL) && (pUartData->pDatas != NULL)) { /* get and clear receive flag */ u32TempStats = FCUART_HWA_GetStatus(pUart, FCUART_STAT_RDRFF); - if (u32TempStats > 0U) - { + if (u32TempStats > 0U) { /* RDRFF Flag has been got */ - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; pUartData->u32DataLen = 0U; - if( true == FCUART_HWA_GetEnStatusRxFifo(pUart)) - { + if (true == FCUART_HWA_GetEnStatusRxFifo(pUart)) { /* Rx fifo enable */ u8RxCount = FCUART_HWA_GetFifoRxCount(pUart); - for(u8Index = 0U; u8Index < u8RxCount; u8Index++) - { + for (u8Index = 0U; u8Index < u8RxCount; u8Index++) { u8ReadData = FCUART_HWA_GetData(pUart); pUartData->pDatas[u8Index] = u8ReadData; pUartData->u32DataLen++; } - } - else - { + } else { /* Rx fifo disable */ u8ReadData = FCUART_HWA_GetData(pUart); pUartData->pDatas[0U] = u8ReadData; @@ -443,68 +396,61 @@ static FCUART_ErrorType FCUART_LL_Receive(uint8_t u8UartIndex, FCUART_DataType * * @param u8UartIndex * @return All Error Combine, 0U is no error */ -static uint32_t FCUART_LL_Error(uint8_t u8UartIndex) -{ +static uint32_t FCUART_LL_Error(uint8_t u8UartIndex) { uint32_t u32RetVal; uint32_t u32ErrorValue; FCUART_Type *pUart; u32ErrorValue = 0U; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* receive overrun */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_RORF); /* FCUART_HWA_ClearStatus(pUart, FCUART_STAT_RORF); */ - if (u32RetVal != 0U) - { - u32ErrorValue = (uint32_t)FCUART_ERROR_RORF; + if (u32RetVal != 0U) { + u32ErrorValue = (uint32_t) FCUART_ERROR_RORF; } /* noise flag */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_NF); /*FCUART_HWA_ClearStatus(pUart, FCUART_STAT_NF);*/ - if (u32RetVal != 0U) - { - u32ErrorValue |= (uint32_t)FCUART_ERROR_NF; + if (u32RetVal != 0U) { + u32ErrorValue |= (uint32_t) FCUART_ERROR_NF; } /* Frame Error flag */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_FEF); /*FCUART_HWA_ClearStatus(pUart, FCUART_STAT_FEF);*/ - if (u32RetVal != 0U) - { - u32ErrorValue |= (uint32_t)FCUART_ERROR_FEF; + if (u32RetVal != 0U) { + u32ErrorValue |= (uint32_t) FCUART_ERROR_FEF; } /* Parity Error Flag */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_PEF); /*FCUART_HWA_ClearStatus(pUart, FCUART_STAT_PEF);*/ - if (u32RetVal != 0U) - { - u32ErrorValue |= (uint32_t)FCUART_ERROR_PEF; + if (u32RetVal != 0U) { + u32ErrorValue |= (uint32_t) FCUART_ERROR_PEF; } /* Receive Data Parity Error Flag */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_RPEF); /*FCUART_HWA_ClearStatus(pUart, FCUART_STAT_RPEF);*/ - if (u32RetVal != 0U) - { - u32ErrorValue |= (uint32_t)FCUART_ERROR_RPEF; + if (u32RetVal != 0U) { + u32ErrorValue |= (uint32_t) FCUART_ERROR_RPEF; } /* Transmit Data Parity Error Flag */ u32RetVal = FCUART_HWA_GetStatus(pUart, FCUART_STAT_TPEF); /*FCUART_HWA_ClearStatus(pUart, FCUART_STAT_TPEF);*/ - if (u32RetVal != 0U) - { - u32ErrorValue |= (uint32_t)FCUART_ERROR_TPEF; + if (u32RetVal != 0U) { + u32ErrorValue |= (uint32_t) FCUART_ERROR_TPEF; } /* clear error flags */ @@ -519,8 +465,7 @@ static uint32_t FCUART_LL_Error(uint8_t u8UartIndex) * @brief Initial UART variables Memory * */ -void FCUART_InitMemory(uint8_t u8UartIndex) -{ +void FCUART_InitMemory(uint8_t u8UartIndex) { s_aFCUART_ErrorNotifyTable[u8UartIndex] = NULL; @@ -546,138 +491,183 @@ void FCUART_InitMemory(uint8_t u8UartIndex) * @param pInitCfg contains clock, baud-rate, Bit Mode, parity and so on. * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_Init(uint8_t u8UartIndex, FCUART_InitType *pInitCfg) -{ +FCUART_ErrorType FCUART_Init(uint8_t u8UartIndex, FCUART_InitType *pInitCfg) { FCUART_ErrorType tRetVal; - uint32_t u32TempBaudReg; - uint32_t u32TempCtrlReg; - uint32_t u32TempFifoReg; - uint32_t u32TempWatermarkReg; - uint32_t u32TempStat; - uint32_t u32TempModir; - FCUART_Type *pUart; - uint32_t u32Sbr = 0U; - uint32_t u32OverSamp = 0U; - uint32_t u32Smb = 0U; + uint32_t u32TempBaudReg; + uint32_t u32TempCtrlReg; + uint32_t u32TempFifoReg; + uint32_t u32TempWatermarkReg; + uint32_t u32TempStat; + uint32_t u32TempModir; + FCUART_Type *pUart; + uint32_t u32Sbr = 0U; + uint32_t u32OverSamp = 0U; + uint32_t u32Smb = 0U; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_DEINIT)) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_DEINIT)) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (pInitCfg != NULL) - { - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (pInitCfg != NULL) { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { /* set not start state */ s_aCurrentSequence[u8UartIndex] = FCUART_SEQUENCE_NOTSTART_RECEIVE; - if(0U != pInitCfg->u32Baudrate) - { + if (0U != pInitCfg->u32Baudrate) { u32Smb = pInitCfg->u32ClkSrcHz / pInitCfg->u32Baudrate; - } - else - { + } else { u32Smb = 0; - tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* process for baud-rate */ - if ((FCUART_ErrorType)FCUART_ERROR_OK == FCUART_LL_ProcessBaud(u32Smb, &u32OverSamp, &u32Sbr)) - { + if ((FCUART_ErrorType) FCUART_ERROR_OK == FCUART_LL_ProcessBaud(u32Smb, &u32OverSamp, &u32Sbr)) { /* temporary BAUD register */ - u32TempBaudReg = (uint32_t)0U | /* initial value */ - FCUART_BAUD_MAEN0(0U) | /* Match mode enable 0 */ - FCUART_BAUD_MAEN1(0U) | /* Match mode enable 1 */ - FCUART_BAUD_10BIT_MODE(0U) | /* 10bit mode select */ - FCUART_BAUD_OVR_SAMP(u32OverSamp - 1U) | /* Over sampling Ratio, n+1 */ - FCUART_BAUD_TDMAEN(pInitCfg->bEnTxEmptyDma) | /* Transmitter DMA Enable */ - FCUART_BAUD_RDMAEN(pInitCfg->bEnRxFullDma) | /* Receiver Full DMA Enable */ - FCUART_BAUD_RIDMAEN(0U) | /* Receiver Idle DMA Enable */ - FCUART_BAUD_MATCH_CFG(0U) | /* Match Configuration */ - FCUART_BAUD_BEDGE_SAMP(1U) | /* Both Edge Sampling */ - FCUART_BAUD_RESYNC_DIS(0U) | /* Re-synchronization Disable */ - FCUART_BAUD_LBKDIE(0U) | /* LIN Break Detect Interrupt Enable */ - FCUART_BAUD_RIAEIE(0U) | /* RX Input Active Edge Interrupt Enable */ - FCUART_BAUD_SBNS(pInitCfg->eStopBit) | /* Stop Bit Number Select */ - FCUART_BAUD_SBR(u32Sbr); /* Baud Rate Modulo Divisor. baud-rate = baud clock / ((OVR_SAMP+1) * SBR) */ + u32TempBaudReg = (uint32_t) 0U | + /* initial value */ + FCUART_BAUD_MAEN0(0U) | + /* Match mode enable 0 */ + FCUART_BAUD_MAEN1(0U) | + /* Match mode enable 1 */ + FCUART_BAUD_10BIT_MODE(0U) | + /* 10bit mode select */ + FCUART_BAUD_OVR_SAMP(u32OverSamp - 1U) | + /* Over sampling Ratio, n+1 */ + FCUART_BAUD_TDMAEN(pInitCfg->bEnTxEmptyDma) | + /* Transmitter DMA Enable */ + FCUART_BAUD_RDMAEN(pInitCfg->bEnRxFullDma) | + /* Receiver Full DMA Enable */ + FCUART_BAUD_RIDMAEN(0U) | + /* Receiver Idle DMA Enable */ + FCUART_BAUD_MATCH_CFG(0U) | + /* Match Configuration */ + FCUART_BAUD_BEDGE_SAMP(1U) | + /* Both Edge Sampling */ + FCUART_BAUD_RESYNC_DIS(0U) | + /* Re-synchronization Disable */ + FCUART_BAUD_LBKDIE(0U) | + /* LIN Break Detect Interrupt Enable */ + FCUART_BAUD_RIAEIE(0U) | + /* RX Input Active Edge Interrupt Enable */ + FCUART_BAUD_SBNS(pInitCfg->eStopBit) | + /* Stop Bit Number Select */ + FCUART_BAUD_SBR( + u32Sbr); /* Baud Rate Modulo Divisor. baud-rate = baud clock / ((OVR_SAMP+1) * SBR) */ /* temporary CTRL register */ - u32TempCtrlReg = (uint32_t)0U | /* initial value */ - FCUART_CTRL_R8T9(0U) | /* Receive Bit 8 / Transmit Bit 9 */ - FCUART_CTRL_R9T8(0U) | /* Receive Bit 9 / Transmit Bit 8 */ - FCUART_CTRL_TXDIR(0U) | /* TXD Pin Direction in Single-Wire Mode */ - FCUART_CTRL_TXINV(0U) | /* Transmit Data Inversion */ - FCUART_CTRL_ORIE(0U) | /* Overrun Interrupt Enable */ - FCUART_CTRL_NEIE(0U) | /* Noise Error Interrupt Enable */ - FCUART_CTRL_FEIE(0U) | /* Frame Error Interrupt Enable */ - FCUART_CTRL_PEIE(0U) | /* Parity Error Interrupt Enable */ - FCUART_CTRL_TIE(0U) | /* Transmit Interrupt Enable */ - FCUART_CTRL_TCIE(0U) | /* Transmission Complete Interrupt Enable */ - FCUART_CTRL_RIE(0U) | /* Receiver Interrupt Enable */ - FCUART_CTRL_IIE(0U) | /* Idle Line Interrupt Enable */ - FCUART_CTRL_TE(0U) | /* Transmitter Enable */ - FCUART_CTRL_RE(0U) | /* Receiver Enable */ - FCUART_CTRL_RWC(0U) | /* Receiver WakeUp Control */ - FCUART_CTRL_SBK(0U) | /* Send Break */ - FCUART_CTRL_M0IE(0U) | /* Match address 0 Interrupt Enable */ - FCUART_CTRL_M1IE(0U) | /* Match address 1 Interrupt Enable */ - FCUART_CTRL_7BMS(0U) | /* 7-Bit Mode Select */ - FCUART_CTRL_IDLECFG(pInitCfg->eIdleCharNum) | /* Idle Configuration 2^n bytes time no data entry IDLE */ - FCUART_CTRL_LOOPMS(0U) | /* Loop Mode Select */ - FCUART_CTRL_WAITEN(0U) | /* WAIT Enable */ - FCUART_CTRL_RXSRC(0U) | /* Receiver Source Select */ - FCUART_CTRL_BMSEL(pInitCfg->eBitMode) | /* 9-Bit or 8-Bit Mode Select */ - FCUART_CTRL_RSWMS(0U) | /* Receiver WakeUp Method Select */ - FCUART_CTRL_ITS(pInitCfg->eIdleStart) | /* Idle Line Type Select */ - FCUART_CTRL_PE(pInitCfg->bParityEnable) | /* Parity Enable */ - FCUART_CTRL_PT(pInitCfg->eParityType); /* Parity Type */ + u32TempCtrlReg = (uint32_t) 0U |/* initial value */ + FCUART_CTRL_R8T9(0U) | + /* Receive Bit 8 / Transmit Bit 9 */ + FCUART_CTRL_R9T8(0U) | + /* Receive Bit 9 / Transmit Bit 8 */ + FCUART_CTRL_TXDIR(0U) | + /* TXD Pin Direction in Single-Wire Mode */ + FCUART_CTRL_TXINV(0U) | + /* Transmit Data Inversion */ + FCUART_CTRL_ORIE(0U) | + /* Overrun Interrupt Enable */ + FCUART_CTRL_NEIE(0U) | + /* Noise Error Interrupt Enable */ + FCUART_CTRL_FEIE(0U) | + /* Frame Error Interrupt Enable */ + FCUART_CTRL_PEIE(0U) | + /* Parity Error Interrupt Enable */ + FCUART_CTRL_TIE(0U) | + /* Transmit Interrupt Enable */ + FCUART_CTRL_TCIE(0U) | + /* Transmission Complete Interrupt Enable */ + FCUART_CTRL_RIE(0U) | + /* Receiver Interrupt Enable */ + FCUART_CTRL_IIE(0U) | + /* Idle Line Interrupt Enable */ + FCUART_CTRL_TE(0U) | + /* Transmitter Enable */ + FCUART_CTRL_RE(0U) | + /* Receiver Enable */ + FCUART_CTRL_RWC(0U) | + /* Receiver WakeUp Control */ + FCUART_CTRL_SBK(0U) | + /* Send Break */ + FCUART_CTRL_M0IE(0U) | + /* Match address 0 Interrupt Enable */ + FCUART_CTRL_M1IE(0U) | + /* Match address 1 Interrupt Enable */ + FCUART_CTRL_7BMS(0U) | + /* 7-Bit Mode Select */ + FCUART_CTRL_IDLECFG(pInitCfg->eIdleCharNum) | + /* Idle Configuration 2^n bytes time no data entry IDLE */ + FCUART_CTRL_LOOPMS(0U) | + /* Loop Mode Select */ + FCUART_CTRL_WAITEN(0U) | + /* WAIT Enable */ + FCUART_CTRL_RXSRC(0U) | + /* Receiver Source Select */ + FCUART_CTRL_BMSEL(pInitCfg->eBitMode) | + /* 9-Bit or 8-Bit Mode Select */ + FCUART_CTRL_RSWMS(0U) | + /* Receiver WakeUp Method Select */ + FCUART_CTRL_ITS(pInitCfg->eIdleStart) | + /* Idle Line Type Select */ + FCUART_CTRL_PE(pInitCfg->bParityEnable) | + /* Parity Enable */ + FCUART_CTRL_PT( + pInitCfg->eParityType); /* Parity Type */ /* temporary FIFO register */ - u32TempFifoReg = (uint32_t)0U | /* initial value */ - FCUART_FIFO_TXEMPTY(0U) | /* Transmit Buffer/FIFO Empty */ - FCUART_FIFO_RXEMPTY(0U) | /* Receive Buffer/FIFO Empty */ - FCUART_FIFO_TXOF(0U) | /* Transmitter Buffer Overflow Flag */ - FCUART_FIFO_RXUF(0U) | /* Receiver Buffer Underflow Flag */ - FCUART_FIFO_TXFLUSH(1U) | /* Transmit FIFO/Buffer Flush */ - FCUART_FIFO_RXFLUSH(1U) | /* Receive FIFO/Buffer Flush */ - FCUART_FIFO_RXIDEN(pInitCfg->eFifoRxIdleCharNum) | /* Receiver Idle Empty Enable */ - FCUART_FIFO_TXOFIE(0U) | /* Transmit FIFO Overflow Interrupt Enable */ - FCUART_FIFO_RXUFIE(0U) | /* Receive FIFO Underflow Interrupt Enable */ - FCUART_FIFO_TXFEN(pInitCfg->bEnTxFifo) | /* Transmit FIFO Enable */ - FCUART_FIFO_TXFIFODEP(1U) | /* Transmit FIFO Buffer Depth */ - FCUART_FIFO_RXFEN(pInitCfg->bEnRxFifo) | /* Receive FIFO Enable, enable RX FIFO */ - FCUART_FIFO_RXFIFODEP(1U); /* Receive FIFO Buffer Depth */ + u32TempFifoReg = + (uint32_t) 0U | /* initial value */ + FCUART_FIFO_TXEMPTY(0U) | /* Transmit Buffer/FIFO Empty */ + FCUART_FIFO_RXEMPTY(0U) | /* Receive Buffer/FIFO Empty */ + FCUART_FIFO_TXOF(0U) | /* Transmitter Buffer Overflow Flag */ + FCUART_FIFO_RXUF(0U) | /* Receiver Buffer Underflow Flag */ + FCUART_FIFO_TXFLUSH(1U) | /* Transmit FIFO/Buffer Flush */ + FCUART_FIFO_RXFLUSH(1U) | /* Receive FIFO/Buffer Flush */ + FCUART_FIFO_RXIDEN(pInitCfg->eFifoRxIdleCharNum) | + /* Receiver Idle Empty Enable */ + FCUART_FIFO_TXOFIE(0U) | /* Transmit FIFO Overflow Interrupt Enable */ + FCUART_FIFO_RXUFIE(0U) | /* Receive FIFO Underflow Interrupt Enable */ + FCUART_FIFO_TXFEN(pInitCfg->bEnTxFifo) | /* Transmit FIFO Enable */ + FCUART_FIFO_TXFIFODEP(1U) | /* Transmit FIFO Buffer Depth */ + FCUART_FIFO_RXFEN(pInitCfg->bEnRxFifo) | /* Receive FIFO Enable, enable RX FIFO */ + FCUART_FIFO_RXFIFODEP(1U); /* Receive FIFO Buffer Depth */ /* temporary WATERMARK register */ - u32TempWatermarkReg = (uint32_t)0U | /* initial value */ - FCUART_WATERMARK_RXCOUNT(0U) | /* Receive Counter */ - FCUART_WATERMARK_RXWATER(pInitCfg->u8RxFifoWaterMark) | /* Receive WaterMark, receive n-1 request interrupt or DMA */ - FCUART_WATERMARK_TXCOUNT(0U) | /* Transmit Counter */ - FCUART_WATERMARK_TXWATER(pInitCfg->u8TxFifoWaterMark); /* Transmit WaterMark */ + u32TempWatermarkReg = (uint32_t) 0U |/* initial value */ + FCUART_WATERMARK_RXCOUNT(0U) | + /* Receive Counter */ + FCUART_WATERMARK_RXWATER(pInitCfg->u8RxFifoWaterMark) | + /* Receive WaterMark, receive n-1 request interrupt or DMA */ + FCUART_WATERMARK_TXCOUNT(0U) | + /* Transmit Counter */ + FCUART_WATERMARK_TXWATER( + pInitCfg->u8TxFifoWaterMark); /* Transmit WaterMark */ - /* temporary MODIR register */ - u32TempModir = (uint32_t)0U | /* initial value */ - FCUART_MODIR_RXRTSCFG(0U) | /* Receive RTS Configuration */ - FCUART_MODIR_TXCTSSRC(0U) | /* Transmit CTS Source */ - FCUART_MODIR_TXCTSCFG(0U) | /* Transmit CTS Configuration */ - FCUART_MODIR_RXRTSEN(0U) | /* Receiver Request-to-Send Enable */ - FCUART_MODIR_TXRTSPOL(0U) | /* Transmitter Request-to-Send Polarity */ - FCUART_MODIR_TXRTSEN(0U) | /* Transmitter Request-to-Send Enable */ - FCUART_MODIR_TXCTSEN(0U); /* Transmitter Clear-to-Send Enable */ + /* temporary MODIR register */ + u32TempModir = (uint32_t) 0U | /* initial value */ + FCUART_MODIR_RXRTSCFG(0U) | + /* Receive RTS Configuration */ + FCUART_MODIR_TXCTSSRC(0U) | + /* Transmit CTS Source */ + FCUART_MODIR_TXCTSCFG(0U) | + /* Transmit CTS Configuration */ + FCUART_MODIR_RXRTSEN(0U) | /* Receiver Request-to-Send Enable */ + FCUART_MODIR_TXRTSPOL(0U) | + /* Transmitter Request-to-Send Polarity */ + FCUART_MODIR_TXRTSEN(0U) | /* Transmitter Request-to-Send Enable */ + FCUART_MODIR_TXCTSEN( + 0U); /* Transmitter Clear-to-Send Enable */ - /* write register with temporary data */ + /* write register with temporary data */ FCUART_HWA_SetBaud(pUart, u32TempBaudReg); /* 0x19000008; */ FCUART_HWA_SetFifo(pUart, u32TempFifoReg); FCUART_HWA_SetWaterMark(pUart, u32TempWatermarkReg); @@ -692,17 +682,14 @@ FCUART_ErrorType FCUART_Init(uint8_t u8UartIndex, FCUART_InitType *pInitCfg) /* instance used */ s_aFCUART_UartUsed[u8UartIndex] = 1U; - s_aFCUART_TransmitTimeout[u8UartIndex] = pInitCfg->u32TransmitTimeout > 0U ? pInitCfg->u32TransmitTimeout : 3000U; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_FAILED; + s_aFCUART_TransmitTimeout[u8UartIndex] = + pInitCfg->u32TransmitTimeout > 0U ? pInitCfg->u32TransmitTimeout : 3000U; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_FAILED; } } - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -714,29 +701,24 @@ FCUART_ErrorType FCUART_Init(uint8_t u8UartIndex, FCUART_InitType *pInitCfg) * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_DeInit(uint8_t u8UartIndex) -{ +FCUART_ErrorType FCUART_DeInit(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] > FCUART_SEQUENCE_DEINIT)) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] > FCUART_SEQUENCE_DEINIT)) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { /* set deinit state */ s_aCurrentSequence[u8UartIndex] = FCUART_SEQUENCE_DEINIT; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; FCUART_HWA_SetSoftWareReset(pUart); } @@ -744,6 +726,26 @@ FCUART_ErrorType FCUART_DeInit(uint8_t u8UartIndex) return tRetVal; } +FCUART_ErrorType FCUART_BufTransmitted(uint8_t u8UartIndex, FCUART_InterruptType *pInterruptCfg) { + FCUART_ErrorType tRetVal; + + /* check parameter */ + tRetVal = FCUART_LL_CheckInstance(u8UartIndex); + + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE)) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; + } + + s_aFCUART_TxMsg[u8UartIndex] = pInterruptCfg->pTxBuf; + s_aFCUART_TxEmptyNotifyTable[u8UartIndex] = pInterruptCfg->pTxEmptyNotify; + s_aFCUART_TxCompleteNotifyTable[u8UartIndex] = pInterruptCfg->pTxCompleteNotify; + + return tRetVal; +} + /** * @brief This Function is used to set UART interrupt * @@ -751,103 +753,78 @@ FCUART_ErrorType FCUART_DeInit(uint8_t u8UartIndex) * @param pIntCfg contains callback functions * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_SetInterrupt(uint8_t u8UartIndex, FCUART_InterruptType *pInterruptCfg) -{ +FCUART_ErrorType FCUART_SetInterrupt(uint8_t u8UartIndex, FCUART_InterruptType *pInterruptCfg) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE)) - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE)) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - if (pInterruptCfg != NULL) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + if (pInterruptCfg != NULL) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* error interrupt */ - if (true == pInterruptCfg->bEnErrorInterrupt) - { - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)(FCUART_INT_CTRL_ORIE |FCUART_INT_CTRL_NEIE |FCUART_INT_CTRL_FEIE |FCUART_INT_CTRL_PEIE)); + if (true == pInterruptCfg->bEnErrorInterrupt) { + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) (FCUART_INT_CTRL_ORIE | FCUART_INT_CTRL_NEIE | + FCUART_INT_CTRL_FEIE | FCUART_INT_CTRL_PEIE)); s_aFCUART_ErrorNotifyTable[u8UartIndex] = pInterruptCfg->pErrorNotify; - } - else - { - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)(FCUART_INT_CTRL_ORIE |FCUART_INT_CTRL_NEIE |FCUART_INT_CTRL_FEIE |FCUART_INT_CTRL_PEIE)); + } else { + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) (FCUART_INT_CTRL_ORIE | FCUART_INT_CTRL_NEIE | + FCUART_INT_CTRL_FEIE | FCUART_INT_CTRL_PEIE)); } /* receive interrupt */ - if (true == pInterruptCfg->bEnRxInterrupt) - { + if (true == pInterruptCfg->bEnRxInterrupt) { /* check buffer point if it is null */ - if (pInterruptCfg->pRxBuf != NULL) - { - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_RIE); + if (pInterruptCfg->pRxBuf != NULL) { + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_RIE); s_aFCUART_RxMsg[u8UartIndex] = pInterruptCfg->pRxBuf; s_aFCUART_RxNotifyTable[u8UartIndex] = pInterruptCfg->pRxNotify; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - } - else - { - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_RIE); + } else { + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_RIE); } /* Transfer interrupt */ - if (true == pInterruptCfg->bEnTxInterrupt) - { + if (true == pInterruptCfg->bEnTxInterrupt) { /* check buffer point if it is null */ - if (pInterruptCfg->pTxBuf != NULL) - { - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_TIE); + if (pInterruptCfg->pTxBuf != NULL) { + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_TIE); s_aFCUART_TxMsg[u8UartIndex] = pInterruptCfg->pTxBuf; s_aFCUART_TxEmptyNotifyTable[u8UartIndex] = pInterruptCfg->pTxEmptyNotify; s_aFCUART_TxCompleteNotifyTable[u8UartIndex] = pInterruptCfg->pTxCompleteNotify; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - } - else - { - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_TIE); + } else { + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_TIE); } /* Idle interrupt */ - if (true == pInterruptCfg->bEnIdleInterrupt) - { - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_IIE); + if (true == pInterruptCfg->bEnIdleInterrupt) { + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_IIE); s_aFCUART_IdleNotifyTable[u8UartIndex] = pInterruptCfg->pIdleNotify; + } else { + FCUART_HWA_DisableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_IIE); } - else - { - FCUART_HWA_DisableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_IIE); - } + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; - } - } - else - { + } else { /* No deal with */ } @@ -861,28 +838,23 @@ FCUART_ErrorType FCUART_SetInterrupt(uint8_t u8UartIndex, FCUART_InterruptType * * @param pWakeupCfg contains UART wake-up parameters * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_SetWakeup(uint8_t u8UartIndex, FCUART_WakeupType *pWakeupCfg) -{ +FCUART_ErrorType FCUART_SetWakeup(uint8_t u8UartIndex, FCUART_WakeupType *pWakeupCfg) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE)) - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE)) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (pWakeupCfg != NULL) - { - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (pWakeupCfg != NULL) { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* * RWC MATCH0|MATCH1 MATCH_CFG [RSWMS,RWUID] Receiver Wakeup @@ -899,14 +871,14 @@ FCUART_ErrorType FCUART_SetWakeup(uint8_t u8UartIndex, FCUART_WakeupType *pWakeu * */ - FCUART_HWA_AttachCtrl(pUart, FCUART_CTRL_RWC_MASK | FCUART_CTRL_RSWMS_MASK); /* WakeUp enable and method select address-mark */ - FCUART_HWA_AttachBaud(pUart, FCUART_BAUD_MATCH_CFG(3U) | FCUART_BAUD_MAEN0(1U)); /* match0 data */ + FCUART_HWA_AttachCtrl(pUart, FCUART_CTRL_RWC_MASK | + FCUART_CTRL_RSWMS_MASK); /* WakeUp enable and method select address-mark */ + FCUART_HWA_AttachBaud(pUart, FCUART_BAUD_MATCH_CFG(3U) | + FCUART_BAUD_MAEN0(1U)); /* match0 data */ FCUART_HWA_AttachMatch(pUart, FCUART_MATCH_MATCH0(pWakeupCfg->u32WakeUpData)); /* set wake-up data*/ } - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -918,34 +890,27 @@ FCUART_ErrorType FCUART_SetWakeup(uint8_t u8UartIndex, FCUART_WakeupType *pWakeu * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_StartReceive(uint8_t u8UartIndex) -{ +FCUART_ErrorType FCUART_StartReceive(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if((FCUART_ErrorType)FCUART_ERROR_OK == tRetVal) - { - if (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE) - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; + if ((FCUART_ErrorType) FCUART_ERROR_OK == tRetVal) { + if (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE) { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; /* set started receive state */ s_aCurrentSequence[u8UartIndex] = FCUART_SEQUENCE_START_RECEIVE; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* start receive */ FCUART_HWA_SetRxTransfer(pUart, true); + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; - } - } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -957,29 +922,26 @@ FCUART_ErrorType FCUART_StartReceive(uint8_t u8UartIndex) * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_StopReceive(uint8_t u8UartIndex) -{ +FCUART_ErrorType FCUART_StopReceive(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && ((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + ((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { /* set stop state */ s_aCurrentSequence[u8UartIndex] = FCUART_SEQUENCE_NOTSTART_RECEIVE; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* stop receive */ FCUART_HWA_SetRxTransfer(pUart, false); @@ -994,31 +956,26 @@ FCUART_ErrorType FCUART_StopReceive(uint8_t u8UartIndex) * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_StartTransmit(uint8_t u8UartIndex) -{ +FCUART_ErrorType FCUART_StartTransmit(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if((FCUART_ErrorType)FCUART_ERROR_OK == tRetVal) - { + if ((FCUART_ErrorType) FCUART_ERROR_OK == tRetVal) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* start transmit */ FCUART_HWA_SetTxTransfer(pUart, true); - if(false == FCUART_GetInterruptMode(u8UartIndex, (uint32_t)FCUART_INT_CTRL_TIE)) - { - FCUART_HWA_EnableInterrupt(pUart, (uint32_t)FCUART_INT_CTRL_TIE); + if (false == FCUART_GetInterruptMode(u8UartIndex, (uint32_t) FCUART_INT_CTRL_TIE)) { + FCUART_HWA_EnableInterrupt(pUart, (uint32_t) FCUART_INT_CTRL_TIE); } - } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -1030,25 +987,21 @@ FCUART_ErrorType FCUART_StartTransmit(uint8_t u8UartIndex) * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_StopTransmit(uint8_t u8UartIndex) -{ +FCUART_ErrorType FCUART_StopTransmit(uint8_t u8UartIndex) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* stop receive */ FCUART_HWA_SetTxTransfer(pUart, false); - } - else - { + } else { /* No deal with */ } @@ -1062,57 +1015,46 @@ FCUART_ErrorType FCUART_StopTransmit(uint8_t u8UartIndex) * @param pUartData contains UART data and length * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_Transmit(uint8_t u8UartIndex, FCUART_DataType *pUartData) -{ +FCUART_ErrorType FCUART_Transmit(uint8_t u8UartIndex, FCUART_DataType *pUartData) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; uint8_t *pData; uint32_t u32DataLen; - uint8_t u8Index; + uint8_t u8Index; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) &&((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + ((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (pUartData != NULL) - { - if (pUartData->pDatas != NULL) - { - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (pUartData != NULL) { + if (pUartData->pDatas != NULL) { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { pData = pUartData->pDatas; u32DataLen = pUartData->u32DataLen; - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - for (u8Index = 0U; u8Index < u32DataLen; u8Index++) - { + for (u8Index = 0U; u8Index < u32DataLen; u8Index++) { tRetVal |= FCUART_LL_Transmit_Char(pUart, pData[u8Index], s_aFCUART_TransmitTimeout[u8UartIndex]); - if (tRetVal != (FCUART_ErrorType)FCUART_ERROR_OK) - { + if (tRetVal != (FCUART_ErrorType) FCUART_ERROR_OK) { break; } } } + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; - } - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -1125,8 +1067,7 @@ FCUART_ErrorType FCUART_Transmit(uint8_t u8UartIndex, FCUART_DataType *pUartData * @param eStatusType stat type * @return FCUART STAT status flag */ -uint32_t FCUART_GetStatus(uint8_t u8UartIndex, FCUART_StatType eStatusType) -{ +uint32_t FCUART_GetStatus(uint8_t u8UartIndex, FCUART_StatType eStatusType) { FCUART_ErrorType tRetVal; FCUART_Type *pUart; uint32_t u32RetVal; @@ -1134,13 +1075,10 @@ uint32_t FCUART_GetStatus(uint8_t u8UartIndex, FCUART_StatType eStatusType) /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; u32RetVal = FCUART_HWA_GetStatus(pUart, eStatusType); - } - else - { + } else { u32RetVal = 0U; } @@ -1154,40 +1092,30 @@ uint32_t FCUART_GetStatus(uint8_t u8UartIndex, FCUART_StatType eStatusType) * @param pRxMsg is data buffer address, and pDatas need to be initialed with external buffer * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_Receive_Polling(uint8_t u8UartIndex, FCUART_DataType *pRxMsg) -{ +FCUART_ErrorType FCUART_Receive_Polling(uint8_t u8UartIndex, FCUART_DataType *pRxMsg) { FCUART_ErrorType tRetVal; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE)) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE)) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (pRxMsg != NULL) - { - if (pRxMsg->pDatas != NULL) - { - if (s_aFCUART_UartUsed[u8UartIndex] == 1U) - { + if (pRxMsg != NULL) { + if (pRxMsg->pDatas != NULL) { + if (s_aFCUART_UartUsed[u8UartIndex] == 1U) { tRetVal = FCUART_LL_Receive(u8UartIndex, pRxMsg); } + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; - } - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } return tRetVal; @@ -1200,33 +1128,26 @@ FCUART_ErrorType FCUART_Receive_Polling(uint8_t u8UartIndex, FCUART_DataType *pR * @param pErrorValue is error value * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_Error_Polling(uint8_t u8UartIndex, uint32_t *pErrorValue) -{ +FCUART_ErrorType FCUART_Error_Polling(uint8_t u8UartIndex, uint32_t *pErrorValue) { FCUART_ErrorType tRetVal; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aCurrentSequence[u8UartIndex] >= FCUART_SEQUENCE_NOTSTART_RECEIVE)) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aCurrentSequence[u8UartIndex] >= FCUART_SEQUENCE_NOTSTART_RECEIVE)) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - if (s_aFCUART_UartUsed[u8UartIndex] == 1U) - { + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + if (s_aFCUART_UartUsed[u8UartIndex] == 1U) { /* check error */ *pErrorValue = FCUART_LL_Error(u8UartIndex); - } - else - { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_FAILED; + } else { + tRetVal = (FCUART_ErrorType) FCUART_ERROR_FAILED; } } @@ -1241,29 +1162,22 @@ FCUART_ErrorType FCUART_Error_Polling(uint8_t u8UartIndex, uint32_t *pErrorValue * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_SetLoopMode(uint8_t u8UartIndex, bool bStatus) -{ +FCUART_ErrorType FCUART_SetLoopMode(uint8_t u8UartIndex, bool bStatus) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - if (true == bStatus) - { + if (true == bStatus) { FCUART_HWA_EnableLoopMode(pUart); - } - else - { + } else { FCUART_HWA_DisableLoopMode(pUart); } - } - else - { + } else { /* No deal with */ } return tRetVal; @@ -1277,27 +1191,23 @@ FCUART_ErrorType FCUART_SetLoopMode(uint8_t u8UartIndex, bool bStatus) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_SendData_9Bits(uint8_t u8UartIndex, uint16_t u16Data) -{ +FCUART_ErrorType FCUART_SendData_9Bits(uint8_t u8UartIndex, uint16_t u16Data) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; uint8_t u8SingleBit_8; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - u8SingleBit_8 = (uint8_t)((u16Data >> 8U) & 1U); + u8SingleBit_8 = (uint8_t) ((u16Data >> 8U) & 1U); /* Set bit8 */ FCUART_HWA_SetR9T8(pUart, u8SingleBit_8); /* Set 0 ~ 7 bits */ - FCUART_HWA_SetData(pUart, (uint8_t)u16Data); - } - else - { + FCUART_HWA_SetData(pUart, (uint8_t) u16Data); + } else { /* No deal with */ } return tRetVal; @@ -1312,8 +1222,7 @@ FCUART_ErrorType FCUART_SendData_9Bits(uint8_t u8UartIndex, uint16_t u16Data) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_GetData_9Bits(uint8_t u8UartIndex, uint16_t *pData) -{ +FCUART_ErrorType FCUART_GetData_9Bits(uint8_t u8UartIndex, uint16_t *pData) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; uint8_t u8SingleBit_8; @@ -1321,18 +1230,15 @@ FCUART_ErrorType FCUART_GetData_9Bits(uint8_t u8UartIndex, uint16_t *pData) /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* Get bit8 */ - u8SingleBit_8 = FCUART_HWA_GetR8T9(pUart); + u8SingleBit_8 = FCUART_HWA_GetR8T9(pUart); /* Get 0 ~ 7 bits */ - u8Temp = FCUART_HWA_GetData(pUart); + u8Temp = FCUART_HWA_GetData(pUart); /* Get 0 ~ 8 bits */ - *pData = (((uint16_t)u8SingleBit_8 << 8U) | (uint16_t)u8Temp); - } - else - { + *pData = (((uint16_t) u8SingleBit_8 << 8U) | (uint16_t) u8Temp); + } else { /* No deal with */ } return tRetVal; @@ -1347,8 +1253,7 @@ FCUART_ErrorType FCUART_GetData_9Bits(uint8_t u8UartIndex, uint16_t *pData) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_SendData_10Bits(uint8_t u8UartIndex, uint16_t u16Data) -{ +FCUART_ErrorType FCUART_SendData_10Bits(uint8_t u8UartIndex, uint16_t u16Data) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; uint8_t u8SingleBit_8; @@ -1356,22 +1261,19 @@ FCUART_ErrorType FCUART_SendData_10Bits(uint8_t u8UartIndex, uint16_t u16Data) /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - u8SingleBit_8 = (uint8_t)((u16Data >> 8U) & 1U); - u8SingleBit_9 = (uint8_t)((u16Data >> 9U) & 1U); + u8SingleBit_8 = (uint8_t) ((u16Data >> 8U) & 1U); + u8SingleBit_9 = (uint8_t) ((u16Data >> 9U) & 1U); /* Set bit8 */ FCUART_HWA_SetR9T8(pUart, u8SingleBit_8); /* Set bit9 */ FCUART_HWA_SetR8T9(pUart, u8SingleBit_9); /* Set 0 ~ 7 bits */ - FCUART_HWA_SetData(pUart, (uint8_t)u16Data); - } - else - { + FCUART_HWA_SetData(pUart, (uint8_t) u16Data); + } else { /* No deal with */ } return tRetVal; @@ -1386,8 +1288,7 @@ FCUART_ErrorType FCUART_SendData_10Bits(uint8_t u8UartIndex, uint16_t u16Data) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_GetData_10Bits(uint8_t u8UartIndex, uint16_t *pData) -{ +FCUART_ErrorType FCUART_GetData_10Bits(uint8_t u8UartIndex, uint16_t *pData) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; uint8_t u8SingleBit_8; @@ -1396,20 +1297,17 @@ FCUART_ErrorType FCUART_GetData_10Bits(uint8_t u8UartIndex, uint16_t *pData) /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; /* Get bit8 */ - u8SingleBit_8 = FCUART_HWA_GetR8T9(pUart); + u8SingleBit_8 = FCUART_HWA_GetR8T9(pUart); /* Get bit9 */ - u8SingleBit_9 = FCUART_HWA_GetR9T8(pUart); + u8SingleBit_9 = FCUART_HWA_GetR9T8(pUart); /* Get 0 ~ 7 bits */ - u8Temp = FCUART_HWA_GetData(pUart); + u8Temp = FCUART_HWA_GetData(pUart); /* Get 0 ~ 9 bits */ - *pData = (((uint16_t)u8SingleBit_8 << 8U) | ((uint16_t)u8SingleBit_9 << 9U) | (uint16_t)u8Temp); - } - else - { + *pData = (((uint16_t) u8SingleBit_8 << 8U) | ((uint16_t) u8SingleBit_9 << 9U) | (uint16_t) u8Temp); + } else { /* No deal with */ } return tRetVal; @@ -1424,28 +1322,24 @@ FCUART_ErrorType FCUART_GetData_10Bits(uint8_t u8UartIndex, uint16_t *pData) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_SetBitModeAndParity( uint8_t u8UartIndex, - FCUART_BitModeType eBitMode, - FCUART_StopBitNumType eStopBit, - FCUART_ParityType eParityType, - bool bParityEnable - ) -{ +FCUART_ErrorType FCUART_SetBitModeAndParity(uint8_t u8UartIndex, + FCUART_BitModeType eBitMode, + FCUART_StopBitNumType eStopBit, + FCUART_ParityType eParityType, + bool bParityEnable +) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; FCUART_HWA_SetBitMode(pUart, eBitMode); FCUART_HWA_SetStopBit(pUart, eStopBit); FCUART_HWA_SetParity(pUart, eParityType, bParityEnable); - } - else - { + } else { /* No deal with */ } return tRetVal; @@ -1459,8 +1353,7 @@ FCUART_ErrorType FCUART_SetBitModeAndParity( uint8_t u8UartIndex, * @return true/false * */ -bool FCUART_GetInterruptMode(uint8_t u8UartIndex, uint32_t u32Data) -{ +bool FCUART_GetInterruptMode(uint8_t u8UartIndex, uint32_t u32Data) { FCUART_ErrorType tTempVal; bool bRetVal; FCUART_Type *pUart; @@ -1468,15 +1361,12 @@ bool FCUART_GetInterruptMode(uint8_t u8UartIndex, uint32_t u32Data) /* check parameter */ tTempVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; u32CtrlRegData = FCUART_HWA_GetCtrl(pUart); - bRetVal = ((u32CtrlRegData & u32Data) > 0U ) ? true : false; - } - else - { + bRetVal = ((u32CtrlRegData & u32Data) > 0U) ? true : false; + } else { bRetVal = false; } @@ -1492,25 +1382,18 @@ bool FCUART_GetInterruptMode(uint8_t u8UartIndex, uint32_t u32Data) * @return FCUART_ERROR_OK is ok, others are not ok * */ -FCUART_ErrorType FCUART_AssignTxInterruptData(uint8_t u8UartIndex, uint8_t * pData, uint32_t u32Length) -{ +FCUART_ErrorType FCUART_AssignTxInterruptData(uint8_t u8UartIndex, uint8_t *pData, uint32_t u32Length) { FCUART_ErrorType tTempVal; /* check parameter */ tTempVal = FCUART_LL_CheckInstance(u8UartIndex); - if (tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - if(pData != NULL) - { - s_aFCUART_TxMsg[u8UartIndex]->pDatas = pData; + if (tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + if (pData != NULL) { + s_aFCUART_TxMsg[u8UartIndex]->pDatas = pData; s_aFCUART_TxMsg[u8UartIndex]->u32DataLen = u32Length; + } else { + tTempVal = (FCUART_ErrorType) FCUART_ERROR_INVALID_PARAM; } - else - { - tTempVal = (FCUART_ErrorType)FCUART_ERROR_INVALID_PARAM; - } - } - else - { + } else { /* No deal with */ } @@ -1526,8 +1409,7 @@ FCUART_ErrorType FCUART_AssignTxInterruptData(uint8_t u8UartIndex, uint8_t * pDa * @param u8UartIndex is UART instance, 0U..(FCUART_INSTANCE_COUNT-1U) * */ -void FCUARTN_RxTx_IRQHandler(uint8_t u8UartIndex) -{ +void FCUARTN_RxTx_IRQHandler(uint8_t u8UartIndex) { FCUART_ErrorType tTempVal; FCUART_DataType *pRxMsgList; FCUART_DataType *pTxMsgList; @@ -1535,72 +1417,62 @@ void FCUARTN_RxTx_IRQHandler(uint8_t u8UartIndex) uint32_t u32CtrlRegData; //Do not check instance because it should be checked before - u32CtrlRegData = FCUART_HWA_GetCtrl((FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]); + u32CtrlRegData = FCUART_HWA_GetCtrl((FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]); /* Handle receive interrupt */ - if(((uint32_t)FCUART_INT_CTRL_RIE) == (u32CtrlRegData & ((uint32_t)FCUART_INT_CTRL_RIE))) - { + if (((uint32_t) FCUART_INT_CTRL_RIE) == (u32CtrlRegData & ((uint32_t) FCUART_INT_CTRL_RIE))) { /* get buffer point and it stored when called SetInterrupt */ pRxMsgList = s_aFCUART_RxMsg[u8UartIndex]; /* check pUart receive data */ tTempVal = FCUART_LL_Receive(u8UartIndex, pRxMsgList); /* check buffer valid */ - if ( (tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (pRxMsgList != NULL)) - { - if (s_aFCUART_RxNotifyTable[u8UartIndex] != NULL) - { + if ((tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) && (pRxMsgList != NULL)) { + if (s_aFCUART_RxNotifyTable[u8UartIndex] != NULL) { s_aFCUART_RxNotifyTable[u8UartIndex](u8UartIndex, pRxMsgList); } } } /* Handle transmit interrupt */ - if(((uint32_t)FCUART_INT_CTRL_TIE) == (u32CtrlRegData & ((uint32_t)FCUART_INT_CTRL_TIE))) - { + if (((uint32_t) FCUART_INT_CTRL_TIE) == (u32CtrlRegData & ((uint32_t) FCUART_INT_CTRL_TIE))) { /* get buffer point and it stored when called SetInterrupt */ pTxMsgList = s_aFCUART_TxMsg[u8UartIndex]; /* transfer data */ tTempVal = FCUART_LL_Transmit_Empty(u8UartIndex, pTxMsgList); - if((tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (pTxMsgList != NULL)) - { - if (s_aFCUART_TxEmptyNotifyTable[u8UartIndex] != NULL) - { + if ((tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) && (pTxMsgList != NULL)) { + if (s_aFCUART_TxEmptyNotifyTable[u8UartIndex] != NULL) { s_aFCUART_TxEmptyNotifyTable[u8UartIndex](u8UartIndex, pTxMsgList); } } } /* Handle transmit complete interrupt */ - if(((uint32_t)FCUART_INT_CTRL_TCIE) == (u32CtrlRegData & ((uint32_t)FCUART_INT_CTRL_TCIE))) - { + if (((uint32_t) FCUART_INT_CTRL_TCIE) == (u32CtrlRegData & ((uint32_t) FCUART_INT_CTRL_TCIE))) { tTempVal = FCUART_LL_Transmit_Complete(u8UartIndex); - if ((tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aFCUART_TxCompleteNotifyTable[u8UartIndex] != NULL)) - { + if ((tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + (s_aFCUART_TxCompleteNotifyTable[u8UartIndex] != NULL)) { s_aFCUART_TxCompleteNotifyTable[u8UartIndex](u8UartIndex, NULL); } } /* Handle idle interrupt */ - if(((uint32_t)FCUART_INT_CTRL_IIE) == (u32CtrlRegData & ((uint32_t)FCUART_INT_CTRL_IIE))) - { + if (((uint32_t) FCUART_INT_CTRL_IIE) == (u32CtrlRegData & ((uint32_t) FCUART_INT_CTRL_IIE))) { tTempVal = FCUART_LL_Idle(u8UartIndex); - if ((tTempVal == (FCUART_ErrorType)FCUART_ERROR_OK) && (s_aFCUART_IdleNotifyTable[u8UartIndex] != NULL)) - { + if ((tTempVal == (FCUART_ErrorType) FCUART_ERROR_OK) && (s_aFCUART_IdleNotifyTable[u8UartIndex] != NULL)) { s_aFCUART_IdleNotifyTable[u8UartIndex](u8UartIndex); } } /* Handle error interrupt */ - if(0U != (u32CtrlRegData & ((uint32_t)(FCUART_INT_CTRL_ORIE | FCUART_INT_CTRL_NEIE | FCUART_INT_CTRL_FEIE | FCUART_INT_CTRL_PEIE)))) - { + if (0U != (u32CtrlRegData & ((uint32_t) (FCUART_INT_CTRL_ORIE | FCUART_INT_CTRL_NEIE | FCUART_INT_CTRL_FEIE | + FCUART_INT_CTRL_PEIE)))) { /* check error */ u32ErrorValue = FCUART_LL_Error(u8UartIndex); - if ((u32ErrorValue != 0U) && (s_aFCUART_ErrorNotifyTable[u8UartIndex] != NULL)) - { + if ((u32ErrorValue != 0U) && (s_aFCUART_ErrorNotifyTable[u8UartIndex] != NULL)) { s_aFCUART_ErrorNotifyTable[u8UartIndex](u8UartIndex, u32ErrorValue); } @@ -1617,8 +1489,7 @@ void FCUARTN_RxTx_IRQHandler(uint8_t u8UartIndex) * @param fmt is char format * @return FCUART_ERROR_OK is ok, others are not ok */ -FCUART_ErrorType FCUART_Printf(uint8_t u8UartIndex, char *fmt, ...) -{ +FCUART_ErrorType FCUART_Printf(uint8_t u8UartIndex, char *fmt, ...) { FCUART_Type *pUart; FCUART_ErrorType tRetVal; const char *pStr; @@ -1633,148 +1504,124 @@ FCUART_ErrorType FCUART_Printf(uint8_t u8UartIndex, char *fmt, ...) /* check parameter */ tRetVal = FCUART_LL_CheckInstance(u8UartIndex); - if ((tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) && ((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) - { + if ((tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) && + ((s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_START_RECEIVE) || + (s_aCurrentSequence[u8UartIndex] == FCUART_SEQUENCE_NOTSTART_RECEIVE))) { - tRetVal = (FCUART_ErrorType)FCUART_ERROR_OK; - } - else - { - tRetVal |= (FCUART_ErrorType)FCUART_ERROR_INVALID_SEQUENCE; + tRetVal = (FCUART_ErrorType) FCUART_ERROR_OK; + } else { + tRetVal |= (FCUART_ErrorType) FCUART_ERROR_INVALID_SEQUENCE; } - if (tRetVal == (FCUART_ErrorType)FCUART_ERROR_OK) - { - pUart = (FCUART_Type *)s_aFCUART_InstanceTable[u8UartIndex]; + if (tRetVal == (FCUART_ErrorType) FCUART_ERROR_OK) { + pUart = (FCUART_Type *) s_aFCUART_InstanceTable[u8UartIndex]; - while (*fmt != (char)0) - { + while (*fmt != (char) 0) { /* Escape character */ - if ((*fmt) == ESCAPE_CHARACTER) - { - switch (*(++fmt)) - { - case 'r': - { - TxData = ENTER; - tRetVal = FCUART_LL_Transmit_Char(pUart, TxData, s_aFCUART_TransmitTimeout[u8UartIndex]); - fmt++; - } - break; - - case 'n': - { - TxData = NEW_LINE; - tRetVal = FCUART_LL_Transmit_Char(pUart, TxData, s_aFCUART_TransmitTimeout[u8UartIndex]); - fmt++; - } - break; - - default: - fmt++; - break; - } - } - else if ((*fmt) == (char)'%') - { - switch (*(++fmt)) - { - case 's': - { - pStr = va_arg(ap, const char *); - for (; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); + if ((*fmt) == ESCAPE_CHARACTER) { + switch (*(++fmt)) { + case 'r': { + TxData = ENTER; + tRetVal = FCUART_LL_Transmit_Char(pUart, TxData, s_aFCUART_TransmitTimeout[u8UartIndex]); + fmt++; } - fmt++; - } - break; + break; - case 'd': - { - i32Temp = va_arg(ap, int); - if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_DEC, false)) - { - for (pStr = TempBuffer; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); + case 'n': { + TxData = NEW_LINE; + tRetVal = FCUART_LL_Transmit_Char(pUart, TxData, s_aFCUART_TransmitTimeout[u8UartIndex]); + fmt++; + } + break; + + default: + fmt++; + break; + } + } else if ((*fmt) == (char) '%') { + switch (*(++fmt)) { + case 's': { + pStr = va_arg(ap, const char *); + for (; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); } + fmt++; } - fmt++; - } - break; + break; - case 'x': - { - i32Temp = va_arg(ap, int); - if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_HEX, false)) - { - for (pStr = TempBuffer; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); - } - } - fmt++; - } - break; - - case 'X': - { - i32Temp = va_arg(ap, int); - if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_HEX, true)) - { - for (pStr = TempBuffer; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); - } - } - fmt++; - } - break; - - case '.': - { - u8Number = (uint8_t)(*(++fmt) - '0'); - if ((*(++fmt)) == 'f') - { - double num = va_arg(ap, double); - if (0U == FCUART_Float2Char(num, TempBuffer, u8Number)) - { - for (pStr = TempBuffer; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); + case 'd': { + i32Temp = va_arg(ap, int); + if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_DEC, false)) { + for (pStr = TempBuffer; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); } } fmt++; } - } - break; + break; - case 'f': - { - double num = va_arg(ap, double); - if (0U == FCUART_Float2Char(num, TempBuffer, u8LenthNumber)) - { - for (pStr = TempBuffer; *pStr; pStr++) - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)pStr), s_aFCUART_TransmitTimeout[u8UartIndex]); + case 'x': { + i32Temp = va_arg(ap, int); + if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_HEX, false)) { + for (pStr = TempBuffer; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); + } + } + fmt++; + } + break; + + case 'X': { + i32Temp = va_arg(ap, int); + if (0U == FCUART_Int2Char(i32Temp, TempBuffer, UART_PRINT_RADIX_HEX, true)) { + for (pStr = TempBuffer; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); + } + } + fmt++; + } + break; + + case '.': { + u8Number = (uint8_t) (*(++fmt) - '0'); + if ((*(++fmt)) == 'f') { + double num = va_arg(ap, double); + if (0U == FCUART_Float2Char(num, TempBuffer, u8Number)) { + for (pStr = TempBuffer; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); + } + } + fmt++; } } - fmt++; - } - break; + break; - default: - fmt++; - break; - } - } - else - { - tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *)fmt), s_aFCUART_TransmitTimeout[u8UartIndex]); + case 'f': { + double num = va_arg(ap, double); + if (0U == FCUART_Float2Char(num, TempBuffer, u8LenthNumber)) { + for (pStr = TempBuffer; *pStr; pStr++) { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) pStr), + s_aFCUART_TransmitTimeout[u8UartIndex]); + } + } + fmt++; + } + break; - if (tRetVal != FCUART_ERROR_OK) - { + default: + fmt++; + break; + } + } else { + tRetVal = FCUART_LL_Transmit_Char(pUart, *((unsigned char *) fmt), + s_aFCUART_TransmitTimeout[u8UartIndex]); + + if (tRetVal != FCUART_ERROR_OK) { break; } @@ -1796,12 +1643,11 @@ FCUART_ErrorType FCUART_Printf(uint8_t u8UartIndex, char *fmt, ...) * @param eRadix * @return 0 is ok */ -static uint8_t FCUART_Int2Char(int i32Value, char *pOutStr, UART_PrintIntType eRadix, bool bHexUpper) -{ +static uint8_t FCUART_Int2Char(int i32Value, char *pOutStr, UART_PrintIntType eRadix, bool bHexUpper) { uint8_t u8Retval; char aCharListUpper[] = "0123456789ABCDEF"; char aCharListLower[] = "0123456789abcdef"; - char aNumList[] = "0123456789"; + char aNumList[] = "0123456789"; char *pCharList; uint32_t u32Temp; uint8_t u8Index = 0U; @@ -1809,46 +1655,35 @@ static uint8_t FCUART_Int2Char(int i32Value, char *pOutStr, UART_PrintIntType eR char Temp = 0; uint32_t j; - if (NULL == pOutStr) - { + if (NULL == pOutStr) { u8Retval = 1U; - } - else - { + } else { u8Retval = 0U; - if ((UART_PRINT_RADIX_DEC == eRadix) && (i32Value < 0)) - { + if ((UART_PRINT_RADIX_DEC == eRadix) && (i32Value < 0)) { // Decimal and negative - u32Temp = (uint32_t)(0 - i32Value); + u32Temp = (uint32_t) (0 - i32Value); pOutStr[u8Index++] = '-'; u8ValueStart = 1U; pCharList = aNumList; - } - else - { - if (true == bHexUpper) - { + } else { + if (true == bHexUpper) { pCharList = aCharListUpper; - } - else - { + } else { pCharList = aCharListLower; } - u32Temp = (uint32_t)i32Value; + u32Temp = (uint32_t) i32Value; } // Data is converted to a string and stored in reverse order - do - { - pOutStr[u8Index++] = pCharList[u32Temp % (uint8_t)eRadix]; - u32Temp /= (uint8_t)eRadix; + do { + pOutStr[u8Index++] = pCharList[u32Temp % (uint8_t) eRadix]; + u32Temp /= (uint8_t) eRadix; } while (u32Temp); pOutStr[u8Index] = '\0'; // Convert the string with reverse order to positive - for (j = u8ValueStart; j < (u8Index + u8ValueStart) / 2U; j++) - { + for (j = u8ValueStart; j < (u8Index + u8ValueStart) / 2U; j++) { Temp = pOutStr[j]; pOutStr[j] = pOutStr[u8Index - j - 1U + u8ValueStart]; pOutStr[u8Index - j - 1U + u8ValueStart] = Temp; @@ -1865,8 +1700,7 @@ static uint8_t FCUART_Int2Char(int i32Value, char *pOutStr, UART_PrintIntType eR * @param U32Eps * @return 0 is ok */ -static uint8_t FCUART_Float2Char(double Value, char *pOutStr, uint32_t u32Eps) -{ +static uint8_t FCUART_Float2Char(double Value, char *pOutStr, uint32_t u32Eps) { uint32_t u32Integer; double Decimal; char aCharList[] = "0123456789"; @@ -1879,29 +1713,22 @@ static uint8_t FCUART_Float2Char(double Value, char *pOutStr, uint32_t u32Eps) uint8_t u8Retval; uint32_t j; - if (NULL == pOutStr) - { + if (NULL == pOutStr) { u8Retval = 1U; - } - else - { + } else { u8Retval = 0U; // Extract integer and decimal from the input number - if (Value < FLOAT_ZERO) - { - Decimal = (double)((int32_t)Value - Value); - u32Integer = (uint32_t)(0.0 - Value); + if (Value < FLOAT_ZERO) { + Decimal = (double) ((int32_t) Value - Value); + u32Integer = (uint32_t) (0.0 - Value); pOutStr[u8Index++] = '-'; u8ValueStart = 1U; - } - else - { - u32Integer = (uint32_t)Value; - Decimal = (double)(Value - u32Integer); + } else { + u32Integer = (uint32_t) Value; + Decimal = (double) (Value - u32Integer); } // The integer part of the data is converted into a string and stored in reverse order - do - { + do { pOutStr[u8Index++] = aCharList[u32Integer % 10U]; u32Integer /= 10U; } while (0U != u32Integer); @@ -1909,33 +1736,28 @@ static uint8_t FCUART_Float2Char(double Value, char *pOutStr, uint32_t u32Eps) pOutStr[u8Index] = '\0'; // Convert the string with reverse order to positive - for (j = u8ValueStart; j < (u8Index + u8ValueStart) / 2U; j++) - { + for (j = u8ValueStart; j < (u8Index + u8ValueStart) / 2U; j++) { Temp = pOutStr[j]; pOutStr[j] = pOutStr[u8Index - j - 1U + u8ValueStart]; pOutStr[u8Index - j - 1U + u8ValueStart] = Temp; } // Accuracy problem, preventing input 1.2 and output 1.19 - for (j = 0U; j <= u32Eps; j++) - { + for (j = 0U; j <= u32Eps; j++) { TempFactor *= 0.1; } Decimal += TempFactor; - for (j = 0; j < u32Eps; j++) - { - Decimal *= (double)10.0; + for (j = 0; j < u32Eps; j++) { + Decimal *= (double) 10.0; u32TempCnt *= 10U; } - u32TempDecimal = (uint32_t)Decimal; + u32TempDecimal = (uint32_t) Decimal; pOutStr[u8Index++] = '.'; - for (j = 0; j < u32Eps; j++) - { + for (j = 0; j < u32Eps; j++) { u32TempCnt /= 10U; - if (0U != u32TempCnt) - { + if (0U != u32TempCnt) { pOutStr[u8Index++] = u32TempDecimal / u32TempCnt + '0'; u32TempDecimal %= u32TempCnt; }