git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/utilities/fsl_debug_console.c

   1 /*\r
   2  * This is a modified version of the file printf.c, which was distributed\r
   3  * by Motorola as part of the M5407C3BOOT.zip package used to initialize\r
   4  * the M5407C3 evaluation board.\r
   5  *\r
   6  * Copyright:\r
   7  *      1999-2000 MOTOROLA, INC. All Rights Reserved.\r
   8  *  You are hereby granted a copyright license to use, modify, and\r
   9  *  distribute the SOFTWARE so long as this entire notice is\r
  10  *  retained without alteration in any modified and/or redistributed\r
  11  *  versions, and that such modified versions are clearly identified\r
  12  *  as such. No licenses are granted by implication, estoppel or\r
  13  *  otherwise under any patents or trademarks of Motorola, Inc. This\r
  14  *  software is provided on an "AS IS" basis and without warranty.\r
  15  *\r
  16  *  To the maximum extent permitted by applicable law, MOTOROLA\r
  17  *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING\r
  18  *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR\r
  19  *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE\r
  20  *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY\r
  21  *  ACCOMPANYING WRITTEN MATERIALS.\r
  22  *\r
  23  *  To the maximum extent permitted by applicable law, IN NO EVENT\r
  24  *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING\r
  25  *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS\r
  26  *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY\r
  27  *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.\r
  28  *\r
  29  *  Motorola assumes no responsibility for the maintenance and support\r
  30  *  of this software\r
  31 \r
  32  * Copyright (c) 2015, Freescale Semiconductor, Inc.\r
  33  * Copyright 2016-2018 NXP\r
  34  *\r
  35  * SPDX-License-Identifier: BSD-3-Clause\r
  36  */\r
  37 \r
  38 #include <stdarg.h>\r
  39 #include <stdlib.h>\r
  40 #if defined(__CC_ARM) || defined(__ARMCC_VERSION)\r
  41 #include <stdio.h>\r
  42 #endif\r
  43 \r
  44 #ifdef FSL_RTOS_FREE_RTOS\r
  45 #include "FreeRTOS.h"\r
  46 #include "task.h"\r
  47 #include "semphr.h"\r
  48 #endif\r
  49 \r
  50 #include "fsl_debug_console_conf.h"\r
  51 #include "fsl_str.h"\r
  52 \r
  53 #include "fsl_common.h"\r
  54 #include "serial_manager.h"\r
  55 \r
  56 #include "fsl_debug_console.h"\r
  57 \r
  58 /*******************************************************************************\r
  59  * Definitions\r
  60  ******************************************************************************/\r
  61 #ifndef NDEBUG\r
  62 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
  63 #undef assert\r
  64 #define assert(n)\r
  65 #endif\r
  66 #endif\r
  67 \r
  68 /*! @brief character backspace ASCII value */\r
  69 #define DEBUG_CONSOLE_BACKSPACE 127\r
  70 \r
  71 /* lock definition */\r
  72 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
  73 \r
  74 static SemaphoreHandle_t s_debugConsoleReadSemaphore;\r
  75 static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore;\r
  76 \r
  77 #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM)\r
  78 \r
  79 static volatile uint8_t s_debugConsoleReadWaitSemaphore;\r
  80 \r
  81 #else\r
  82 \r
  83 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */\r
  84 \r
  85 /*! @brief get current runing environment is ISR or not */\r
  86 #ifdef __CA7_REV\r
  87 #define IS_RUNNING_IN_ISR() SystemGetIRQNestingLevel()\r
  88 #else\r
  89 #define IS_RUNNING_IN_ISR() __get_IPSR()\r
  90 #endif /* __CA7_REV */\r
  91 \r
  92 /* semaphore definition */\r
  93 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
  94 \r
  95 /* mutex semaphore */\r
  96 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) (mutex = xSemaphoreCreateMutex())\r
  97 \r
  98 /* clang-format off */\r
  99 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \\r
 100 {                                                 \\r
 101         if (IS_RUNNING_IN_ISR() == 0U)            \\r
 102         {                                         \\r
 103             xSemaphoreGive(mutex);                \\r
 104         }                                         \\r
 105 }\r
 106 \r
 107 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \\r
 108 {                                                          \\r
 109         if (IS_RUNNING_IN_ISR() == 0U)                     \\r
 110         {                                                  \\r
 111             xSemaphoreTake(mutex, portMAX_DELAY);          \\r
 112         }                                                  \\r
 113 }\r
 114 \r
 115 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \\r
 116 {                                                                     \\r
 117         if (IS_RUNNING_IN_ISR() == 0U)                                \\r
 118         {                                                             \\r
 119             result = xSemaphoreTake(mutex, 0U);                       \\r
 120         }                                                             \\r
 121         else                                                          \\r
 122         {                                                             \\r
 123             result = 1U;                                              \\r
 124         }                                                             \\r
 125 }\r
 126 /* clang-format on */\r
 127 \r
 128 /* Binary semaphore */\r
 129 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) (binary = xSemaphoreCreateBinary())\r
 130 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) (xSemaphoreTake(binary, portMAX_DELAY))\r
 131 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (xSemaphoreGiveFromISR(binary, NULL))\r
 132 \r
 133 #elif(DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)\r
 134 \r
 135 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex)\r
 136 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex)\r
 137 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex)\r
 138 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)\r
 139 \r
 140 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary)\r
 141 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 142 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \\r
 143     {                                                        \\r
 144         while (!binary)                                      \\r
 145         {                                                    \\r
 146         }                                                    \\r
 147         binary = false;                                      \\r
 148     }\r
 149 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (binary = true)\r
 150 #else\r
 151 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary)\r
 152 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary)\r
 153 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
 154 \r
 155 /* add other implementation here\r
 156 *such as :\r
 157 * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)\r
 158 */\r
 159 \r
 160 #else\r
 161 \r
 162 #error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE.\r
 163 \r
 164 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */\r
 165 \r
 166 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 167 /* receive state structure */\r
 168 typedef struct _debug_console_write_ring_buffer\r
 169 {\r
 170     uint32_t ringBufferSize;\r
 171     volatile uint32_t ringHead;\r
 172     volatile uint32_t ringTail;\r
 173     uint8_t ringBuffer[DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN];\r
 174 } debug_console_write_ring_buffer_t;\r
 175 #endif\r
 176 \r
 177 typedef struct _debug_console_state_struct\r
 178 {\r
 179     uint8_t serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE];\r
 180     serial_handle_t serialHandle; /*!< serial manager handle */\r
 181 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 182     debug_console_write_ring_buffer_t writeRingBuffer;\r
 183     uint8_t readRingBuffer[DEBUG_CONSOLE_RECEIVE_BUFFER_LEN];\r
 184 #endif\r
 185     uint8_t serialWriteHandleBuffer[SERIAL_MANAGER_WRITE_HANDLE_SIZE];\r
 186     uint8_t serialReadHandleBuffer[SERIAL_MANAGER_READ_HANDLE_SIZE];\r
 187 } debug_console_state_struct_t;\r
 188 \r
 189 /*******************************************************************************\r
 190  * Variables\r
 191  ******************************************************************************/\r
 192 \r
 193 /*! @brief Debug console state information. */\r
 194 static debug_console_state_struct_t s_debugConsoleState;\r
 195 serial_handle_t g_serialHandle; /*!< serial manager handle */\r
 196 \r
 197 /*******************************************************************************\r
 198  * Prototypes\r
 199  ******************************************************************************/\r
 200 /*!\r
 201  * @brief This is a printf call back function which is used to relocate the log to buffer\r
 202  * or print the log immediately when the local buffer is full.\r
 203  *\r
 204  * @param[in] buf   Buffer to store log.\r
 205  * @param[in] indicator Buffer index.\r
 206  * @param[in] val Target character to store.\r
 207  * @param[in] len length of the character\r
 208  *\r
 209  */\r
 210 #if SDK_DEBUGCONSOLE\r
 211 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len);\r
 212 #endif\r
 213 \r
 214 int DbgConsole_SendData(uint8_t *ch, size_t size);\r
 215 \r
 216 /*******************************************************************************\r
 217  * Code\r
 218  ******************************************************************************/\r
 219 \r
 220 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 221 \r
 222 static void DbgConsole_SerialManagerTxCallback(void *callbackParam,\r
 223                                                serial_manager_callback_message_t *message,\r
 224                                                serial_manager_status_t status)\r
 225 {\r
 226     debug_console_state_struct_t *ioState;\r
 227     uint32_t sendDataLength;\r
 228 \r
 229     if ((NULL == callbackParam) || (NULL == message))\r
 230     {\r
 231         return;\r
 232     }\r
 233 \r
 234     ioState = (debug_console_state_struct_t *)callbackParam;\r
 235 \r
 236     ioState->writeRingBuffer.ringTail += message->length;\r
 237     if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)\r
 238     {\r
 239         ioState->writeRingBuffer.ringTail = 0U;\r
 240     }\r
 241 \r
 242     if (kStatus_SerialManager_Success == status)\r
 243     {\r
 244         if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead)\r
 245         {\r
 246             if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail)\r
 247             {\r
 248                 sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail;\r
 249             }\r
 250             else\r
 251             {\r
 252                 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;\r
 253             }\r
 254 \r
 255             SerialManager_WriteNonBlocking(((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),\r
 256                                            &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail],\r
 257                                            sendDataLength);\r
 258         }\r
 259     }\r
 260     else\r
 261     {\r
 262     }\r
 263 }\r
 264 \r
 265 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 266 \r
 267 static void DbgConsole_SerialManagerRxCallback(void *callbackParam,\r
 268                                                serial_manager_callback_message_t *message,\r
 269                                                serial_manager_status_t status)\r
 270 {\r
 271     if ((NULL == callbackParam) || (NULL == message))\r
 272     {\r
 273         return;\r
 274     }\r
 275 \r
 276     if (kStatus_SerialManager_Notify == status)\r
 277     {\r
 278     }\r
 279     else if (kStatus_SerialManager_Success == status)\r
 280     {\r
 281         /* release s_debugConsoleReadWaitSemaphore from RX callback */\r
 282         DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore);\r
 283     }\r
 284     else\r
 285     {\r
 286     }\r
 287 }\r
 288 #endif\r
 289 \r
 290 #endif\r
 291 \r
 292 status_t DbgConsole_ReadOneCharacter(uint8_t *ch)\r
 293 {\r
 294 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 295 \r
 296 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
 297     (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
 298     return kStatus_Fail;\r
 299 #else\r
 300     status_t status = kStatus_SerialManager_Error;\r
 301 \r
 302 /* recieve one char every time */\r
 303 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 304     status =\r
 305         SerialManager_ReadNonBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
 306 #else\r
 307     status = SerialManager_ReadBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
 308 #endif\r
 309     if (kStatus_SerialManager_Success != status)\r
 310     {\r
 311         return kStatus_Fail;\r
 312     }\r
 313     /* wait s_debugConsoleReadWaitSemaphore from RX callback */\r
 314     DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);\r
 315 \r
 316     return kStatus_Success;\r
 317 #endif\r
 318 \r
 319 #else\r
 320 \r
 321     return kStatus_Fail;\r
 322 \r
 323 #endif\r
 324 }\r
 325 \r
 326 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 327 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)\r
 328 {\r
 329     /* Due to scanf take \n and \r as end of string,should not echo */\r
 330     if (((*ch != '\r') && (*ch != '\n')) || (isGetChar))\r
 331     {\r
 332         /* recieve one char every time */\r
 333         if (1 != DbgConsole_SendData(ch, 1U))\r
 334         {\r
 335             return kStatus_Fail;\r
 336         }\r
 337     }\r
 338 \r
 339     if ((!isGetChar) && (index))\r
 340     {\r
 341         if (DEBUG_CONSOLE_BACKSPACE == *ch)\r
 342         {\r
 343             if ((*index >= 2))\r
 344             {\r
 345                 *index -= 2;\r
 346             }\r
 347             else\r
 348             {\r
 349                 *index = 0;\r
 350             }\r
 351         }\r
 352     }\r
 353 \r
 354     return kStatus_Success;\r
 355 }\r
 356 #endif\r
 357 \r
 358 int DbgConsole_SendData(uint8_t *ch, size_t size)\r
 359 {\r
 360     status_t status = kStatus_SerialManager_Error;\r
 361 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 362     uint32_t sendDataLength;\r
 363     int txBusy = 0;\r
 364 #endif\r
 365     assert(NULL != ch);\r
 366     assert(0 != size);\r
 367 \r
 368 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 369     uint32_t regPrimask = DisableGlobalIRQ();\r
 370     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 371     {\r
 372         txBusy = 1;\r
 373         sendDataLength =\r
 374             (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
 375              s_debugConsoleState.writeRingBuffer.ringTail) %\r
 376             s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
 377     }\r
 378     else\r
 379     {\r
 380         sendDataLength = 0U;\r
 381     }\r
 382     sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength;\r
 383     if (sendDataLength <= size)\r
 384     {\r
 385         EnableGlobalIRQ(regPrimask);\r
 386         return -1;\r
 387     }\r
 388     for (int i = 0; i < size; i++)\r
 389     {\r
 390         s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];\r
 391         if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)\r
 392         {\r
 393             s_debugConsoleState.writeRingBuffer.ringHead = 0U;\r
 394         }\r
 395     }\r
 396 \r
 397     status = kStatus_SerialManager_Success;\r
 398 \r
 399     if (!txBusy)\r
 400     {\r
 401         if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)\r
 402         {\r
 403             sendDataLength =\r
 404                 s_debugConsoleState.writeRingBuffer.ringHead - s_debugConsoleState.writeRingBuffer.ringTail;\r
 405         }\r
 406         else\r
 407         {\r
 408             sendDataLength =\r
 409                 s_debugConsoleState.writeRingBuffer.ringBufferSize - s_debugConsoleState.writeRingBuffer.ringTail;\r
 410         }\r
 411 \r
 412         status = (status_t)SerialManager_WriteNonBlocking(\r
 413             ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
 414             &s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringTail],\r
 415             sendDataLength);\r
 416     }\r
 417     EnableGlobalIRQ(regPrimask);\r
 418 #else\r
 419     status = (status_t)SerialManager_WriteBlocking(\r
 420         ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
 421 #endif\r
 422     return ((kStatus_Success == status) ? (int)size : -1);\r
 423 }\r
 424 \r
 425 int DbgConsole_ReadLine(uint8_t *buf, size_t size)\r
 426 {\r
 427     int i;\r
 428 \r
 429     assert(buf != NULL);\r
 430 \r
 431     /* take mutex lock function */\r
 432     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 433 \r
 434     for (i = 0; i < size; i++)\r
 435     {\r
 436         /* recieve one char every time */\r
 437         if (kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))\r
 438         {\r
 439             /* release mutex lock function */\r
 440             DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 441             return -1;\r
 442         }\r
 443 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 444         DbgConsole_EchoCharacter(&buf[i], false, &i);\r
 445 #endif\r
 446         /* analysis data */\r
 447         if (('\r' == buf[i]) || ('\n' == buf[i]))\r
 448         {\r
 449             /* End of Line. */\r
 450             if (0 == i)\r
 451             {\r
 452                 buf[i] = '\0';\r
 453                 i = -1;\r
 454             }\r
 455             else\r
 456             {\r
 457                 break;\r
 458             }\r
 459         }\r
 460     }\r
 461 \r
 462     /* release mutex lock function */\r
 463     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 464 \r
 465     return i + 1;\r
 466 }\r
 467 \r
 468 int DbgConsole_ReadCharacter(uint8_t *ch)\r
 469 {\r
 470     int ret;\r
 471 \r
 472     assert(ch);\r
 473 \r
 474     /* take mutex lock function */\r
 475     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 476     /* read one character */\r
 477     if (kStatus_Success == DbgConsole_ReadOneCharacter(ch))\r
 478     {\r
 479         ret = 1;\r
 480 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 481         DbgConsole_EchoCharacter(ch, true, NULL);\r
 482 #endif\r
 483     }\r
 484     else\r
 485     {\r
 486         ret = -1;\r
 487     }\r
 488 \r
 489     /* release mutex lock function */\r
 490     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 491 \r
 492     return ret;\r
 493 }\r
 494 \r
 495 #if SDK_DEBUGCONSOLE\r
 496 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len)\r
 497 {\r
 498     int i = 0;\r
 499 \r
 500     for (i = 0; i < len; i++)\r
 501     {\r
 502         if ((*indicator + 1) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)\r
 503         {\r
 504             DbgConsole_SendData((uint8_t *)buf, *indicator);\r
 505             *indicator = 0U;\r
 506         }\r
 507 \r
 508         buf[*indicator] = val;\r
 509         (*indicator)++;\r
 510     }\r
 511 }\r
 512 #endif\r
 513 \r
 514 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/\r
 515 \r
 516 /* See fsl_debug_console.h for documentation of this function. */\r
 517 status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)\r
 518 {\r
 519     serial_manager_config_t serialConfig;\r
 520     status_t status = kStatus_SerialManager_Error;\r
 521 \r
 522 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 523     serial_port_uart_config_t uartConfig = {\r
 524         .instance = instance,\r
 525         .clockRate = clkSrcFreq,\r
 526         .baudRate = baudRate,\r
 527         .parityMode = kSerialManager_UartParityDisabled,\r
 528         .stopBitCount = kSerialManager_UartOneStopBit,\r
 529         .enableRx = 1,\r
 530         .enableTx = 1,\r
 531     };\r
 532 #endif\r
 533 \r
 534 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 535     serial_port_usb_cdc_config_t usbCdcConfig = {\r
 536         .controllerIndex = (serial_port_usb_cdc_controller_index_t)instance,\r
 537     };\r
 538 #endif\r
 539 \r
 540 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 541     serial_port_swo_config_t swoConfig = {\r
 542         .clockRate = clkSrcFreq, .baudRate = baudRate, .port = instance, .protocol = kSerialManager_SwoProtocolNrz,\r
 543     };\r
 544 #endif\r
 545 \r
 546     serialConfig.type = device;\r
 547 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 548     serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];\r
 549     serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;\r
 550 #endif\r
 551 \r
 552     if (kSerialPort_Uart == device)\r
 553     {\r
 554 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 555         serialConfig.portConfig = &uartConfig;\r
 556 #else\r
 557         return status;\r
 558 #endif\r
 559     }\r
 560     else if (kSerialPort_UsbCdc == device)\r
 561     {\r
 562 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 563         serialConfig.portConfig = &usbCdcConfig;\r
 564 #else\r
 565         return status;\r
 566 #endif\r
 567     }\r
 568     else if (kSerialPort_Swo == device)\r
 569     {\r
 570 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 571         serialConfig.portConfig = &swoConfig;\r
 572 #else\r
 573         return status;\r
 574 #endif\r
 575     }\r
 576     else\r
 577     {\r
 578         return status;\r
 579     }\r
 580 \r
 581     memset(&s_debugConsoleState, 0U, sizeof(s_debugConsoleState));\r
 582 \r
 583     s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];\r
 584     g_serialHandle = s_debugConsoleState.serialHandle;\r
 585     status = SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);\r
 586 \r
 587     assert(kStatus_SerialManager_Success == status);\r
 588 \r
 589     DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 590     DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);\r
 591 \r
 592 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 593     s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;\r
 594 #endif\r
 595 \r
 596     {\r
 597         status = SerialManager_OpenWriteHandle(\r
 598             s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 599         assert(kStatus_SerialManager_Success == status);\r
 600 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 601         SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
 602                                         DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);\r
 603 #endif\r
 604     }\r
 605 \r
 606 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 607     {\r
 608         status = SerialManager_OpenReadHandle(s_debugConsoleState.serialHandle,\r
 609                                               ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
 610         assert(kStatus_SerialManager_Success == status);\r
 611 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 612         SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),\r
 613                                         DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);\r
 614 #endif\r
 615     }\r
 616 #endif\r
 617     return kStatus_Success;\r
 618 }\r
 619 \r
 620 /* See fsl_debug_console.h for documentation of this function. */\r
 621 status_t DbgConsole_Deinit(void)\r
 622 {\r
 623     {\r
 624         SerialManager_CloseWriteHandle(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 625     }\r
 626 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 627     {\r
 628         SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
 629     }\r
 630 #endif\r
 631 \r
 632     return kStatus_Success;\r
 633 }\r
 634 \r
 635 status_t DbgConsole_Flush(void)\r
 636 {\r
 637 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 638 \r
 639 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
 640 \r
 641     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 642     {\r
 643         return kStatus_Fail;\r
 644     }\r
 645 \r
 646 #else\r
 647 \r
 648     while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 649     {\r
 650 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
 651         if (IS_RUNNING_IN_ISR() == 0U)\r
 652         {\r
 653             vTaskDelay(1);\r
 654         }\r
 655         else\r
 656         {\r
 657             return kStatus_Fail;\r
 658         }\r
 659 #endif\r
 660     }\r
 661 \r
 662 #endif\r
 663 \r
 664 #endif\r
 665     return kStatus_Success;\r
 666 }\r
 667 \r
 668 #if SDK_DEBUGCONSOLE\r
 669 /* See fsl_debug_console.h for documentation of this function. */\r
 670 int DbgConsole_Printf(const char *formatString, ...)\r
 671 {\r
 672     va_list ap;\r
 673     int logLength = 0U, result = 0U;\r
 674     char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {0U};\r
 675 \r
 676     if (NULL == g_serialHandle)\r
 677     {\r
 678         return 0;\r
 679     }\r
 680 \r
 681     va_start(ap, formatString);\r
 682     /* format print log first */\r
 683     logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
 684     /* print log */\r
 685     result = DbgConsole_SendData((uint8_t *)printBuf, logLength);\r
 686 \r
 687     va_end(ap);\r
 688 \r
 689     return result;\r
 690 }\r
 691 \r
 692 /* See fsl_debug_console.h for documentation of this function. */\r
 693 int DbgConsole_Putchar(int ch)\r
 694 {\r
 695     /* print char */\r
 696     return DbgConsole_SendData((uint8_t *)&ch, 1U);\r
 697 }\r
 698 \r
 699 /* See fsl_debug_console.h for documentation of this function. */\r
 700 int DbgConsole_Scanf(char *formatString, ...)\r
 701 {\r
 702     va_list ap;\r
 703     int result;\r
 704     char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {0U};\r
 705 \r
 706     /* scanf log */\r
 707     DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);\r
 708     /* get va_list */\r
 709     va_start(ap, formatString);\r
 710     /* format scanf log */\r
 711     result = StrFormatScanf(scanfBuf, formatString, ap);\r
 712 \r
 713     va_end(ap);\r
 714 \r
 715     return result;\r
 716 }\r
 717 \r
 718 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 719 status_t DbgConsole_TryGetchar(char *ch)\r
 720 {\r
 721 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 722     uint32_t length = 0;\r
 723     status_t status = kStatus_Fail;\r
 724 \r
 725     assert(ch);\r
 726 \r
 727     /* take mutex lock function */\r
 728     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 729 \r
 730     if (kStatus_SerialManager_Success ==\r
 731         SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,\r
 732                               &length))\r
 733     {\r
 734         if (length)\r
 735         {\r
 736 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 737             DbgConsole_EchoCharacter(ch, true, NULL);\r
 738 #endif\r
 739             status = kStatus_Success;\r
 740         }\r
 741     }\r
 742     /* release mutex lock function */\r
 743     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 744     return status;\r
 745 #else\r
 746     return kStatus_Fail;\r
 747 #endif\r
 748 }\r
 749 #endif\r
 750 \r
 751 /* See fsl_debug_console.h for documentation of this function. */\r
 752 int DbgConsole_Getchar(void)\r
 753 {\r
 754     uint8_t ch = 0U;\r
 755 \r
 756     /* Get char */\r
 757     DbgConsole_ReadCharacter(&ch);\r
 758 \r
 759     return (int)ch;\r
 760 }\r
 761 \r
 762 #endif /* SDK_DEBUGCONSOLE */\r
 763 \r
 764 /*************Code to support toolchain's printf, scanf *******************************/\r
 765 /* These function __write and __read is used to support IAR toolchain to printf and scanf*/\r
 766 #if (defined(__ICCARM__))\r
 767 #if defined(SDK_DEBUGCONSOLE_UART)\r
 768 #pragma weak __write\r
 769 size_t __write(int handle, const unsigned char *buffer, size_t size)\r
 770 {\r
 771     if (buffer == 0)\r
 772     {\r
 773         /*\r
 774          * This means that we should flush internal buffers.  Since we don't we just return.\r
 775          * (Remember, "handle" == -1 means that all handles should be flushed.)\r
 776          */\r
 777         return 0;\r
 778     }\r
 779 \r
 780     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
 781     if ((handle != 1) && (handle != 2))\r
 782     {\r
 783         return ((size_t)-1);\r
 784     }\r
 785 \r
 786     /* Send data. */\r
 787     DbgConsole_SendData((uint8_t *)buffer, size);\r
 788 \r
 789     return size;\r
 790 }\r
 791 \r
 792 #pragma weak __read\r
 793 size_t __read(int handle, unsigned char *buffer, size_t size)\r
 794 {\r
 795     uint8_t ch = 0U;\r
 796     size_t actualSize = 0U;\r
 797     /* This function only reads from "standard in", for all other file  handles it returns failure. */\r
 798     if (handle != 0)\r
 799     {\r
 800         return ((size_t)-1);\r
 801     }\r
 802 \r
 803     /* Receive data.*/\r
 804     for (; size > 0; size--)\r
 805     {\r
 806         DbgConsole_ReadCharacter(&ch);\r
 807         if (ch == 0)\r
 808         {\r
 809             break;\r
 810         }\r
 811 \r
 812         *buffer++ = ch;\r
 813         actualSize++;\r
 814     }\r
 815 \r
 816     return actualSize;\r
 817 }\r
 818 #endif /* SDK_DEBUGCONSOLE_UART */\r
 819 \r
 820 /* support LPC Xpresso with RedLib */\r
 821 #elif(defined(__REDLIB__))\r
 822 \r
 823 #if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))\r
 824 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)\r
 825 {\r
 826     if (buffer == 0)\r
 827     {\r
 828         /* return -1 if error. */\r
 829         return -1;\r
 830     }\r
 831 \r
 832     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
 833     if ((handle != 1) && (handle != 2))\r
 834     {\r
 835         return -1;\r
 836     }\r
 837 \r
 838     /* Send data. */\r
 839     DbgConsole_SendData((uint8_t *)buffer, size);\r
 840 \r
 841     return 0;\r
 842 }\r
 843 \r
 844 int __attribute__((weak)) __sys_readc(void)\r
 845 {\r
 846     char tmp;\r
 847 \r
 848     /* Receive data. */\r
 849     DbgConsole_ReadCharacter((uint8_t *)&tmp);\r
 850 \r
 851     return tmp;\r
 852 }\r
 853 #endif\r
 854 \r
 855 /* These function fputc and fgetc is used to support KEIL toolchain to printf and scanf*/\r
 856 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION)\r
 857 #if defined(SDK_DEBUGCONSOLE_UART)\r
 858 #if defined(__CC_ARM)\r
 859 struct __FILE\r
 860 {\r
 861     int handle;\r
 862     /*\r
 863      * Whatever you require here. If the only file you are using is standard output using printf() for debugging,\r
 864      * no file handling is required.\r
 865      */\r
 866 };\r
 867 #endif\r
 868 \r
 869 /* FILE is typedef in stdio.h. */\r
 870 #pragma weak __stdout\r
 871 #pragma weak __stdin\r
 872 FILE __stdout;\r
 873 FILE __stdin;\r
 874 \r
 875 #pragma weak fputc\r
 876 int fputc(int ch, FILE *f)\r
 877 {\r
 878     /* Send data. */\r
 879     return DbgConsole_SendData((uint8_t *)(&ch), 1);\r
 880 }\r
 881 \r
 882 #pragma weak fgetc\r
 883 int fgetc(FILE *f)\r
 884 {\r
 885     char ch;\r
 886 \r
 887     /* Receive data. */\r
 888     DbgConsole_ReadCharacter((uint8_t *)&ch);\r
 889 \r
 890     return ch;\r
 891 }\r
 892 \r
 893 /*\r
 894  * Terminate the program, passing a return code back to the user.\r
 895  * This function may not return.\r
 896  */\r
 897 void _sys_exit(int returncode)\r
 898 {\r
 899     while (1)\r
 900     {\r
 901     }\r
 902 }\r
 903 \r
 904 /*\r
 905  * Writes a character to the output channel. This function is used\r
 906  * for last-resort error message output.\r
 907  */\r
 908 void _ttywrch(int ch)\r
 909 {\r
 910     char ench = ch;\r
 911     DbgConsole_SendData((uint8_t *)(&ench), 1);\r
 912 }\r
 913 \r
 914 char *_sys_command_string(char *cmd, int len)\r
 915 {\r
 916     return (cmd);\r
 917 }\r
 918 #endif /* SDK_DEBUGCONSOLE_UART */\r
 919 /* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/\r
 920 #elif(defined(__GNUC__))\r
 921 \r
 922 #if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \\r
 923      (defined(__MCUXPRESSO) && (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))))\r
 924 \r
 925 int __attribute__((weak)) _write(int handle, char *buffer, int size)\r
 926 {\r
 927     if (buffer == 0)\r
 928     {\r
 929         /* return -1 if error. */\r
 930         return -1;\r
 931     }\r
 932 \r
 933     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
 934     if ((handle != 1) && (handle != 2))\r
 935     {\r
 936         return -1;\r
 937     }\r
 938 \r
 939     /* Send data. */\r
 940     DbgConsole_SendData((uint8_t *)buffer, size);\r
 941 \r
 942     return size;\r
 943 }\r
 944 \r
 945 int __attribute__((weak)) _read(int handle, char *buffer, int size)\r
 946 {\r
 947     uint8_t ch = 0U;\r
 948     int actualSize = 0U;\r
 949 \r
 950     /* This function only reads from "standard in", for all other file handles it returns failure. */\r
 951     if (handle != 0)\r
 952     {\r
 953         return -1;\r
 954     }\r
 955 \r
 956     for (; size > 0; size--)\r
 957     {\r
 958         DbgConsole_ReadCharacter(&ch);\r
 959 \r
 960         *buffer++ = ch;\r
 961         actualSize++;\r
 962 \r
 963         if ((ch == 0) || (ch == '\n') || (ch == '\r'))\r
 964         {\r
 965             break;\r
 966         }\r
 967     }\r
 968 \r
 969     return actualSize;\r
 970 }\r
 971 #endif\r
 972 #endif /* __ICCARM__ */\r