* of this software\r
\r
* Copyright (c) 2015, Freescale Semiconductor, Inc.\r
- * Copyright 2016-2018 NXP\r
+ * Copyright 2016-2019 NXP\r
*\r
* SPDX-License-Identifier: BSD-3-Clause\r
*/\r
\r
#ifdef FSL_RTOS_FREE_RTOS\r
#include "FreeRTOS.h"\r
-#include "task.h"\r
#include "semphr.h"\r
+#include "task.h"\r
#endif\r
\r
#include "fsl_debug_console_conf.h"\r
#endif\r
#endif\r
\r
+#if SDK_DEBUGCONSOLE\r
+#define DEBUG_CONSOLE_FUNCTION_PREFIX\r
+#else\r
+#define DEBUG_CONSOLE_FUNCTION_PREFIX static\r
+#endif\r
+\r
/*! @brief character backspace ASCII value */\r
-#define DEBUG_CONSOLE_BACKSPACE 127\r
+#define DEBUG_CONSOLE_BACKSPACE 127U\r
\r
/* lock definition */\r
#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
\r
static SemaphoreHandle_t s_debugConsoleReadSemaphore;\r
+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore;\r
+#endif\r
\r
-#elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM)\r
+#elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM)\r
\r
+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
static volatile uint8_t s_debugConsoleReadWaitSemaphore;\r
+#endif\r
\r
#else\r
\r
#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
\r
/* mutex semaphore */\r
-#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) (mutex = xSemaphoreCreateMutex())\r
-\r
/* clang-format off */\r
+#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())\r
+#define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex) \\r
+ do \\r
+ { \\r
+ if(NULL != mutex) \\r
+ { \\r
+ vSemaphoreDelete(mutex); \\r
+ mutex = NULL; \\r
+ } \\r
+ } while(0)\r
+\r
#define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \\r
{ \\r
if (IS_RUNNING_IN_ISR() == 0U) \\r
{ \\r
- xSemaphoreGive(mutex); \\r
+ (void)xSemaphoreGive(mutex); \\r
} \\r
}\r
\r
{ \\r
if (IS_RUNNING_IN_ISR() == 0U) \\r
{ \\r
- xSemaphoreTake(mutex, portMAX_DELAY); \\r
+ (void)xSemaphoreTake(mutex, portMAX_DELAY); \\r
} \\r
}\r
\r
result = 1U; \\r
} \\r
}\r
-/* clang-format on */\r
\r
/* Binary semaphore */\r
-#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) (binary = xSemaphoreCreateBinary())\r
-#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) (xSemaphoreTake(binary, portMAX_DELAY))\r
-#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (xSemaphoreGiveFromISR(binary, NULL))\r
-\r
-#elif(DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)\r
+#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary())\r
+#define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary) \\r
+ do \\r
+ { \\r
+ if(NULL != binary) \\r
+ { \\r
+ vSemaphoreDelete(binary); \\r
+ binary = NULL; \\r
+ } \\r
+ } while(0)\r
+#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake(binary, portMAX_DELAY))\r
+#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR(binary, NULL))\r
+\r
+#elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)\r
\r
#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex)\r
+#define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex)\r
#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex)\r
#define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex)\r
#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)\r
\r
#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary)\r
+#define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary)\r
#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \\r
{ \\r
#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary)\r
#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary)\r
#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
+/* clang-format on */\r
\r
/* add other implementation here\r
-*such as :\r
-* #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)\r
-*/\r
+ *such as :\r
+ * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)\r
+ */\r
\r
#else\r
\r
******************************************************************************/\r
\r
/*! @brief Debug console state information. */\r
+#if (defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE > 0))\r
+AT_NONCACHEABLE_SECTION(static debug_console_state_struct_t s_debugConsoleState);\r
+#else\r
static debug_console_state_struct_t s_debugConsoleState;\r
+#endif\r
serial_handle_t g_serialHandle; /*!< serial manager handle */\r
\r
/*******************************************************************************\r
*\r
*/\r
#if SDK_DEBUGCONSOLE\r
-static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len);\r
+static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);\r
#endif\r
\r
+status_t DbgConsole_ReadOneCharacter(uint8_t *ch);\r
int DbgConsole_SendData(uint8_t *ch, size_t size);\r
-\r
+int DbgConsole_SendDataReliable(uint8_t *ch, size_t size);\r
+int DbgConsole_ReadLine(uint8_t *buf, size_t size);\r
+int DbgConsole_ReadCharacter(uint8_t *ch);\r
+\r
+#if ((SDK_DEBUGCONSOLE > 0U) || \\r
+ ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
+ (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))\r
+DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void);\r
+#endif\r
/*******************************************************************************\r
* Code\r
******************************************************************************/\r
sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;\r
}\r
\r
- SerialManager_WriteNonBlocking(((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),\r
- &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail],\r
- sendDataLength);\r
+ (void)SerialManager_WriteNonBlocking(\r
+ ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),\r
+ &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength);\r
}\r
}\r
+ else if (kStatus_SerialManager_Canceled == status)\r
+ {\r
+ ioState->writeRingBuffer.ringTail = 0U;\r
+ ioState->writeRingBuffer.ringHead = 0U;\r
+ }\r
else\r
{\r
+ /*MISRA rule 16.4*/\r
}\r
}\r
\r
}\r
else\r
{\r
+ /*MISRA rule 16.4*/\r
}\r
}\r
#endif\r
#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
- (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
+ (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
return kStatus_Fail;\r
#else\r
- status_t status = kStatus_SerialManager_Error;\r
+ status_t status = (status_t)kStatus_SerialManager_Error;\r
\r
/* recieve one char every time */\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
- status =\r
- SerialManager_ReadNonBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
+ status = (status_t)SerialManager_ReadNonBlocking(\r
+ ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
#else\r
- status = SerialManager_ReadBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
+ status = (status_t)SerialManager_ReadBlocking(\r
+ ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
#endif\r
- if (kStatus_SerialManager_Success != status)\r
+ if ((status_t)kStatus_SerialManager_Success != status)\r
{\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
}\r
/* wait s_debugConsoleReadWaitSemaphore from RX callback */\r
DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);\r
\r
- return kStatus_Success;\r
+ return (status_t)kStatus_Success;\r
#endif\r
\r
#else\r
\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
\r
#endif\r
}\r
static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)\r
{\r
/* Due to scanf take \n and \r as end of string,should not echo */\r
- if (((*ch != '\r') && (*ch != '\n')) || (isGetChar))\r
+ if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar))\r
{\r
/* recieve one char every time */\r
- if (1 != DbgConsole_SendData(ch, 1U))\r
+ if (1 != DbgConsole_SendDataReliable(ch, 1U))\r
{\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
}\r
}\r
\r
- if ((!isGetChar) && (index))\r
+ if ((!isGetChar) && (index != NULL))\r
{\r
if (DEBUG_CONSOLE_BACKSPACE == *ch)\r
{\r
}\r
}\r
\r
- return kStatus_Success;\r
+ return (status_t)kStatus_Success;\r
}\r
#endif\r
\r
int DbgConsole_SendData(uint8_t *ch, size_t size)\r
{\r
- status_t status = kStatus_SerialManager_Error;\r
+ status_t status = (status_t)kStatus_SerialManager_Error;\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
uint32_t sendDataLength;\r
int txBusy = 0;\r
{\r
sendDataLength = 0U;\r
}\r
- sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength;\r
- if (sendDataLength <= size)\r
+ sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1;\r
+ if (sendDataLength < size)\r
{\r
EnableGlobalIRQ(regPrimask);\r
return -1;\r
}\r
- for (int i = 0; i < size; i++)\r
+ for (int i = 0; i < (int)size; i++)\r
{\r
s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];\r
if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)\r
}\r
}\r
\r
- status = kStatus_SerialManager_Success;\r
+ status = (status_t)kStatus_SerialManager_Success;\r
\r
- if (!txBusy)\r
+ if (txBusy == 0)\r
{\r
if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)\r
{\r
status = (status_t)SerialManager_WriteBlocking(\r
((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
#endif\r
- return ((kStatus_Success == status) ? (int)size : -1);\r
+ return (((status_t)kStatus_Success == status) ? (int)size : -1);\r
+}\r
+\r
+int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)\r
+{\r
+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
+#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))\r
+ status_t status = kStatus_SerialManager_Error;\r
+ uint32_t sendDataLength;\r
+ uint32_t totalLength = size;\r
+ int sentLength;\r
+#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
+#else\r
+ status_t status = kStatus_SerialManager_Error;\r
+#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
+\r
+ assert(NULL != ch);\r
+ assert(0 != size);\r
+\r
+ if (NULL == g_serialHandle)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
+\r
+#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))\r
+ do\r
+ {\r
+ uint32_t regPrimask = DisableGlobalIRQ();\r
+ if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
+ {\r
+ sendDataLength =\r
+ (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
+ s_debugConsoleState.writeRingBuffer.ringTail) %\r
+ s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
+ }\r
+ else\r
+ {\r
+ sendDataLength = 0U;\r
+ }\r
+ sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;\r
+\r
+ if (sendDataLength > 0U)\r
+ {\r
+ if (sendDataLength > totalLength)\r
+ {\r
+ sendDataLength = totalLength;\r
+ }\r
+\r
+ sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength);\r
+ if (sentLength > 0)\r
+ {\r
+ totalLength = totalLength - (uint32_t)sentLength;\r
+ }\r
+ }\r
+ EnableGlobalIRQ(regPrimask);\r
+\r
+ if (totalLength != 0U)\r
+ {\r
+ status = DbgConsole_Flush();\r
+ if ((status_t)kStatus_Success != status)\r
+ {\r
+ break;\r
+ }\r
+ }\r
+ } while (totalLength != 0U);\r
+ return (status_t)(uint32_t)((uint32_t)size - totalLength);\r
+#else\r
+ return DbgConsole_SendData(ch, size);\r
+#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
+\r
+#else\r
+ status = (status_t)SerialManager_WriteBlocking(\r
+ ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
+ return (((status_t)kStatus_Success == status) ? (int)size : -1);\r
+#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
}\r
\r
int DbgConsole_ReadLine(uint8_t *buf, size_t size)\r
{\r
- int i;\r
+ int i = 0;\r
\r
assert(buf != NULL);\r
\r
+ if (NULL == g_serialHandle)\r
+ {\r
+ return -1;\r
+ }\r
+\r
/* take mutex lock function */\r
DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
\r
- for (i = 0; i < size; i++)\r
+ do\r
{\r
/* recieve one char every time */\r
- if (kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))\r
+ if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))\r
{\r
/* release mutex lock function */\r
DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
- return -1;\r
+ i = -1;\r
+ break;\r
}\r
#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
- DbgConsole_EchoCharacter(&buf[i], false, &i);\r
+ (void)DbgConsole_EchoCharacter(&buf[i], false, &i);\r
#endif\r
/* analysis data */\r
- if (('\r' == buf[i]) || ('\n' == buf[i]))\r
+ if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))\r
{\r
/* End of Line. */\r
if (0 == i)\r
{\r
- buf[i] = '\0';\r
- i = -1;\r
+ buf[i] = (uint8_t)'\0';\r
+ continue;\r
}\r
else\r
{\r
break;\r
}\r
}\r
+ i++;\r
+ } while (i < (int)size);\r
+\r
+ /* get char should not add '\0'*/\r
+ if (i == (int)size)\r
+ {\r
+ buf[i] = (uint8_t)'\0';\r
+ }\r
+ else\r
+ {\r
+ buf[i + 1] = (uint8_t)'\0';\r
}\r
\r
/* release mutex lock function */\r
DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
\r
- return i + 1;\r
+ return i;\r
}\r
\r
int DbgConsole_ReadCharacter(uint8_t *ch)\r
\r
assert(ch);\r
\r
+ if (NULL == g_serialHandle)\r
+ {\r
+ return -1;\r
+ }\r
+\r
/* take mutex lock function */\r
DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
/* read one character */\r
- if (kStatus_Success == DbgConsole_ReadOneCharacter(ch))\r
+ if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch))\r
{\r
ret = 1;\r
#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
- DbgConsole_EchoCharacter(ch, true, NULL);\r
+ (void)DbgConsole_EchoCharacter(ch, true, NULL);\r
#endif\r
}\r
else\r
}\r
\r
#if SDK_DEBUGCONSOLE\r
-static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len)\r
+static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)\r
{\r
int i = 0;\r
\r
for (i = 0; i < len; i++)\r
{\r
- if ((*indicator + 1) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)\r
+ if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)\r
{\r
- DbgConsole_SendData((uint8_t *)buf, *indicator);\r
- *indicator = 0U;\r
+ (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator));\r
+ *indicator = 0;\r
}\r
\r
- buf[*indicator] = val;\r
+ buf[*indicator] = dbgVal;\r
(*indicator)++;\r
}\r
}\r
\r
/*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/\r
\r
+#if ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART))\r
/* See fsl_debug_console.h for documentation of this function. */\r
status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)\r
{\r
serial_manager_config_t serialConfig;\r
- status_t status = kStatus_SerialManager_Error;\r
+ status_t status = (status_t)kStatus_SerialManager_Error;\r
\r
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
serial_port_uart_config_t uartConfig = {\r
- .instance = instance,\r
- .clockRate = clkSrcFreq,\r
- .baudRate = baudRate,\r
- .parityMode = kSerialManager_UartParityDisabled,\r
+ .instance = instance,\r
+ .clockRate = clkSrcFreq,\r
+ .baudRate = baudRate,\r
+ .parityMode = kSerialManager_UartParityDisabled,\r
.stopBitCount = kSerialManager_UartOneStopBit,\r
- .enableRx = 1,\r
- .enableTx = 1,\r
+ .enableRx = 1,\r
+ .enableTx = 1,\r
};\r
#endif\r
\r
\r
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
serial_port_swo_config_t swoConfig = {\r
- .clockRate = clkSrcFreq, .baudRate = baudRate, .port = instance, .protocol = kSerialManager_SwoProtocolNrz,\r
+ .clockRate = clkSrcFreq,\r
+ .baudRate = baudRate,\r
+ .port = instance,\r
+ .protocol = kSerialManager_SwoProtocolNrz,\r
};\r
#endif\r
\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ serial_port_usb_cdc_virtual_config_t usbCdcVirtualConfig = {\r
+ .controllerIndex = (serial_port_usb_cdc_virtual_controller_index_t)instance,\r
+ };\r
+#endif\r
serialConfig.type = device;\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
- serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];\r
+ serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];\r
serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;\r
#endif\r
\r
serialConfig.portConfig = &swoConfig;\r
#else\r
return status;\r
+#endif\r
+ }\r
+ else if (kSerialPort_UsbCdcVirtual == device)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ serialConfig.portConfig = &usbCdcVirtualConfig;\r
+#else\r
+ return status;\r
#endif\r
}\r
else\r
return status;\r
}\r
\r
- memset(&s_debugConsoleState, 0U, sizeof(s_debugConsoleState));\r
+ (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));\r
+\r
+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
+ s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;\r
+#endif\r
\r
s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];\r
- g_serialHandle = s_debugConsoleState.serialHandle;\r
- status = SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);\r
+ status = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);\r
\r
assert(kStatus_SerialManager_Success == status);\r
\r
DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);\r
-\r
-#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
- s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;\r
#endif\r
\r
{\r
- status = SerialManager_OpenWriteHandle(\r
+ status = (status_t)SerialManager_OpenWriteHandle(\r
s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
assert(kStatus_SerialManager_Success == status);\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
- SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
- DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);\r
+ (void)SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
+ DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);\r
#endif\r
}\r
\r
#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
{\r
- status = SerialManager_OpenReadHandle(s_debugConsoleState.serialHandle,\r
- ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
+ status = (status_t)SerialManager_OpenReadHandle(\r
+ s_debugConsoleState.serialHandle, ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
assert(kStatus_SerialManager_Success == status);\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
- SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),\r
- DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);\r
+ (void)SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),\r
+ DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);\r
#endif\r
}\r
#endif\r
+\r
+ g_serialHandle = s_debugConsoleState.serialHandle;\r
+\r
return kStatus_Success;\r
}\r
\r
status_t DbgConsole_Deinit(void)\r
{\r
{\r
- SerialManager_CloseWriteHandle(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
+ if (s_debugConsoleState.serialHandle != NULL)\r
+ {\r
+ (void)SerialManager_CloseWriteHandle(\r
+ ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
+ }\r
}\r
#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
{\r
- SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
+ if (s_debugConsoleState.serialHandle != NULL)\r
+ {\r
+ (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
+ }\r
+ }\r
+#endif\r
+ if (s_debugConsoleState.serialHandle)\r
+ {\r
+ if (kStatus_SerialManager_Success == SerialManager_Deinit(s_debugConsoleState.serialHandle))\r
+ {\r
+ s_debugConsoleState.serialHandle = NULL;\r
+ g_serialHandle = NULL;\r
+ }\r
}\r
+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
+ DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);\r
#endif\r
+ DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
\r
- return kStatus_Success;\r
+ return (status_t)kStatus_Success;\r
}\r
+#endif /* ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART)) */\r
\r
-status_t DbgConsole_Flush(void)\r
+#if ((SDK_DEBUGCONSOLE > 0U) || \\r
+ ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
+ (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))\r
+DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void)\r
{\r
#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
\r
-#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
+#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
\r
if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
{\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
}\r
\r
#else\r
while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
{\r
#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
- if (IS_RUNNING_IN_ISR() == 0U)\r
+ if (0U == IS_RUNNING_IN_ISR())\r
{\r
- vTaskDelay(1);\r
+ if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())\r
+ {\r
+ vTaskDelay(1);\r
+ }\r
}\r
else\r
{\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
}\r
#endif\r
}\r
#endif\r
\r
#endif\r
- return kStatus_Success;\r
+ return (status_t)kStatus_Success;\r
}\r
+#endif\r
\r
#if SDK_DEBUGCONSOLE\r
/* See fsl_debug_console.h for documentation of this function. */\r
int DbgConsole_Printf(const char *formatString, ...)\r
{\r
va_list ap;\r
- int logLength = 0U, result = 0U;\r
- char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {0U};\r
+ int logLength = 0, dbgResult = 0;\r
+ char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};\r
\r
if (NULL == g_serialHandle)\r
{\r
/* format print log first */\r
logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
/* print log */\r
- result = DbgConsole_SendData((uint8_t *)printBuf, logLength);\r
+ dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);\r
\r
va_end(ap);\r
\r
- return result;\r
+ return dbgResult;\r
}\r
\r
/* See fsl_debug_console.h for documentation of this function. */\r
int DbgConsole_Putchar(int ch)\r
{\r
/* print char */\r
- return DbgConsole_SendData((uint8_t *)&ch, 1U);\r
+ return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);\r
}\r
\r
/* See fsl_debug_console.h for documentation of this function. */\r
int DbgConsole_Scanf(char *formatString, ...)\r
{\r
va_list ap;\r
- int result;\r
- char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {0U};\r
+ int formatResult;\r
+ char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};\r
\r
/* scanf log */\r
- DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);\r
+ (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);\r
/* get va_list */\r
va_start(ap, formatString);\r
/* format scanf log */\r
- result = StrFormatScanf(scanfBuf, formatString, ap);\r
+ formatResult = StrFormatScanf(scanfBuf, formatString, ap);\r
+\r
+ va_end(ap);\r
+\r
+ return formatResult;\r
+}\r
+/* See fsl_debug_console.h for documentation of this function. */\r
+int DbgConsole_BlockingPrintf(const char *formatString, ...)\r
+{\r
+ va_list ap;\r
+ status_t status = (status_t)kStatus_SerialManager_Error;\r
+ int logLength = 0, dbgResult = 0;\r
+ char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};\r
+\r
+ if (NULL == g_serialHandle)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ va_start(ap, formatString);\r
+ /* format print log first */\r
+ logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
\r
+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
+ SerialManager_CancelWriting(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
+#endif\r
+ /* print log */\r
+ status =\r
+ (status_t)SerialManager_WriteBlocking(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
+ (uint8_t *)printBuf, (size_t)logLength);\r
+ dbgResult = (((status_t)kStatus_Success == status) ? (int)logLength : -1);\r
va_end(ap);\r
\r
- return result;\r
+ return dbgResult;\r
}\r
\r
#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
{\r
#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
uint32_t length = 0;\r
- status_t status = kStatus_Fail;\r
+ status_t status = (status_t)kStatus_Fail;\r
\r
assert(ch);\r
\r
+ if (NULL == g_serialHandle)\r
+ {\r
+ return kStatus_Fail;\r
+ }\r
+\r
/* take mutex lock function */\r
DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
\r
SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,\r
&length))\r
{\r
- if (length)\r
+ if (length != 0U)\r
{\r
#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
- DbgConsole_EchoCharacter(ch, true, NULL);\r
+ (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);\r
#endif\r
- status = kStatus_Success;\r
+ status = (status_t)kStatus_Success;\r
}\r
}\r
/* release mutex lock function */\r
DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
return status;\r
#else\r
- return kStatus_Fail;\r
+ return (status_t)kStatus_Fail;\r
#endif\r
}\r
#endif\r
uint8_t ch = 0U;\r
\r
/* Get char */\r
- DbgConsole_ReadCharacter(&ch);\r
+ (void)DbgConsole_ReadCharacter(&ch);\r
\r
return (int)ch;\r
}\r
}\r
\r
/* Send data. */\r
- DbgConsole_SendData((uint8_t *)buffer, size);\r
+ DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
\r
return size;\r
}\r
#pragma weak __read\r
size_t __read(int handle, unsigned char *buffer, size_t size)\r
{\r
- uint8_t ch = 0U;\r
- size_t actualSize = 0U;\r
+ uint8_t ch = 0U;\r
+ int actualSize = 0U;\r
+\r
/* This function only reads from "standard in", for all other file handles it returns failure. */\r
if (handle != 0)\r
{\r
#endif /* SDK_DEBUGCONSOLE_UART */\r
\r
/* support LPC Xpresso with RedLib */\r
-#elif(defined(__REDLIB__))\r
+#elif (defined(__REDLIB__))\r
\r
-#if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))\r
+#if (defined(SDK_DEBUGCONSOLE_UART))\r
int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)\r
{\r
if (buffer == 0)\r
}\r
\r
/* Send data. */\r
- DbgConsole_SendData((uint8_t *)buffer, size);\r
+ DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
\r
return 0;\r
}\r
int fputc(int ch, FILE *f)\r
{\r
/* Send data. */\r
- return DbgConsole_SendData((uint8_t *)(&ch), 1);\r
+ return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);\r
}\r
\r
#pragma weak fgetc\r
void _ttywrch(int ch)\r
{\r
char ench = ch;\r
- DbgConsole_SendData((uint8_t *)(&ench), 1);\r
+ DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);\r
}\r
\r
char *_sys_command_string(char *cmd, int len)\r
return (cmd);\r
}\r
#endif /* SDK_DEBUGCONSOLE_UART */\r
+\r
/* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/\r
-#elif(defined(__GNUC__))\r
+#elif (defined(__GNUC__))\r
\r
#if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \\r
- (defined(__MCUXPRESSO) && (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))))\r
-\r
+ (defined(__MCUXPRESSO) && (defined(SDK_DEBUGCONSOLE_UART))))\r
+int __attribute__((weak)) _write(int handle, char *buffer, int size);\r
int __attribute__((weak)) _write(int handle, char *buffer, int size)\r
{\r
- if (buffer == 0)\r
+ if (buffer == NULL)\r
{\r
/* return -1 if error. */\r
return -1;\r
}\r
\r
/* Send data. */\r
- DbgConsole_SendData((uint8_t *)buffer, size);\r
+ (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);\r
\r
return size;\r
}\r
\r
+int __attribute__((weak)) _read(int handle, char *buffer, int size);\r
int __attribute__((weak)) _read(int handle, char *buffer, int size)\r
{\r
- uint8_t ch = 0U;\r
- int actualSize = 0U;\r
+ uint8_t ch = 0U;\r
+ int actualSize = 0;\r
\r
/* This function only reads from "standard in", for all other file handles it returns failure. */\r
if (handle != 0)\r
return -1;\r
}\r
\r
+ /* Receive data. */\r
for (; size > 0; size--)\r
{\r
- DbgConsole_ReadCharacter(&ch);\r
+ if (DbgConsole_ReadCharacter(&ch) < 0)\r
+ {\r
+ break;\r
+ }\r
\r
- *buffer++ = ch;\r
+ *buffer++ = (char)ch;\r
actualSize++;\r
\r
- if ((ch == 0) || (ch == '\n') || (ch == '\r'))\r
+ if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))\r
{\r
break;\r
}\r
}\r
\r
- return actualSize;\r
+ return (actualSize > 0) ? actualSize : -1;\r
}\r
#endif\r
+\r
#endif /* __ICCARM__ */\r
projects / freertos / blobdiff