commit 9f316c246baafa15c542a5aea81a94f26e3d6507

Author: David Vrabel <david.vrabel@cambridgeconsultants.com>
Date:   Mon Mar 16 11:21:46 2020 +0000

    Demo/Posix_GCC: add demo application for Posix port using GCC

    This is largely a copy of the Windows demo application with a few key
    changes:

    - heap_3 (use malloc()/free()) so tools like valgrind "just work".

    - printf() wrapped in a mutex to prevent deadlocks on the internal
      pthread mutexes inside printf().

    SCons (https://scons.org/) is used as the build system.

    This will be built as a 64-bit application, but note that the memory
    allocation trace points only record the lower 32-bits of the address.

commit f78f919b3e2f0d707531a301a8ca07cd02bc4778
Author: Markus Rinne <markus.ka.rinne@gmail.com>
Date:   Thu Mar 19 21:00:24 2020 +0200

    Fix function comments

commit 1cd2d38d960a3576addb224582c88489bade5141
Author: David Chalco <david@chalco.io>
Date:   Fri Mar 20 10:29:05 2020 -0700

    unix separators for path and remove .exe suffix from risc compiler (works on windows/mac)

commit 938b19419eded12817737ab0644e94ed2ba7e95d
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Thu Mar 19 18:23:09 2020 -0700

    Removing ./FreeRTOS-Labs directory, since:
    - IoT libraries are now in LTS branch.
    - FAT/POSIX/Light-weight MQTT are in https://github.com/FreeRTOS/FreeRTOS-Labs.

commit 1a4abbc9e91b13fd6394464ade59d5e048320c7c
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Mar 17 19:30:02 2020 -0700

    Maintenance -- clean up readme.txt and add url to GitHub. (#38)

    * Removing readme.txt, as now we have README.md in place.

    The only information missing from README.md is about FAQ.

    * Adding FAQ information in README.md.

    * Adding a .url to root to redict user to FreeRTOS github home page.

commit 47bb466aa19395b7785bcb830e2e4dd35f6bafc5
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Mar 17 13:07:44 2020 -0700

    Update issue templates

    Template maintenance.

    - adding title prefix.
    - adding examples to "additional context" section.

commit f506290041f56867765f8efa70ed2862125bdb7c
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Mar 17 10:15:07 2020 -0700

    Create SECURITY.md

    Apply the recommended SECURITY.md from AWS to our repo.

commit 8982a2f80a80a2a0a47cf82de07b52101bd9d606
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Fri Mar 13 12:50:10 2020 -0700

    Add ./lib directory to make sure Zynq project compiles.

commit ecf0f12aa14ad6fdafe1ef37257cbb4e03e2abd5
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date:   Wed Mar 11 10:19:48 2020 -0700

    Sync up with Amazon-freertos repo (10th March 2020) (#34)

    * Sync up with amazon-freertos

    * Sync up with amazon-freertos

    * Sync up with amazon-freertos

commit 0acffef047973e2e61c2201fd69cd9bbd317f674
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Mar 10 10:20:48 2020 -0700

    GitHub PR template. (#29)

commit c40a6da2e4cb8042b56d1b174051cbbe9813781a
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date:   Mon Mar 9 11:18:48 2020 -0700

    pass payload length when calling UDP callback (#30)

    * pass payload length when calling UDP callback

commit 12d580e93d4d9074b9a867632f0681a511b4ad12
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Fri Mar 6 18:16:51 2020 -0800

    Update issue templates

    Initial issue template. Created following https://help.github.com/en/github/building-a-strong-community/configuring-issue-templates-for-your-repository#configuring-the-template-chooser.

    If change is needed, we could go another round.

commit 9debffb5e0e42ff716f58b2270b3af09652294af
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Fri Mar 6 17:27:46 2020 -0800

    Update README.md to remove dead link.

    See the conversation https://github.com/FreeRTOS/FreeRTOS/commit/42c627b2b88cb3b487fea983d8b566a8bbae54fa#comments .

    Linkage for both ```./FreeRTOS/Source``` and ```./FreeRTOS/Demo``` are removed, since it looks weird to only provide linkage to Demo.

commit 7e1a4bf563240501fc45167aee9d929c533939dd
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date:   Fri Mar 6 15:18:09 2020 -0800

    Fix DHCP option Client-identifier (#28)

commit 42c627b2b88cb3b487fea983d8b566a8bbae54fa
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Fri Mar 6 09:15:11 2020 -0800

    Update readme and revert relative URL.  (#27)

    * Reordering: bumping cloning instruction up.

    * Rewording readme.md to be clear kernel code is a submodule of this repository.

    * Reverting relative URL, since user cannot click through on GitHub page.

    (With URL, user could still download the correct version of the code. Reverting simply due to UI issue.)

commit 5751ae9b60e248ebd0b4dd7c58df54364d2bb9d5
Author: Gaurav-Aggarwal-AWS <33462878+aggarg@users.noreply.github.com>
Date:   Fri Mar 6 09:11:42 2020 -0800

    Update CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso project (#26)

    This commit updates the project for LPC55S69 so that it works with the
    latest version of MCUXpresso and SDK.

    Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>

commit a9ffffe1f01f45f79e127c15727784984077932f
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date:   Thu Mar 5 17:16:13 2020 -0800

    Using Relative URL For Submoduling. (#24)

commit 52c82076b38fe73d1dc46c97abf74ae9b803696c
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date:   Thu Mar 5 09:16:31 2020 -0800

    use relative path to point to bundled toolchain instead (#25)

commit b877e4ec478de2c24d07ab46241070d7c66f375c
Author: lundinc2 <53273776+lundinc2@users.noreply.github.com>
Date:   Tue Feb 25 13:18:38 2020 -0800

    Moved vulnerability reporting and code of conduct to top of CONTRIBUTING.md (#20)

commit bef165d46799fb8faa58aaa224f80c16b6538e69
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Feb 18 22:06:38 2020 -0800

    Linking test source file from relative path. (#19)

commit 89e7bbe292afd3912d1f0b2402cc506878bad869
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Tue Feb 18 17:47:55 2020 -0800

    A preliminary .gitignore file, to prevent us checking in files unnecessary. (#18)

    https://github.com/github/gitignore.

commit c2a98127acb48c4562233230e66ca5c282688579
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date:   Sun Feb 16 13:19:53 2020 -0800

    Minor wording changes in the 'previous releases' section of the readme.me file. (#17)

commit 24c772d1439e5c291c0a29fce0a46996ca8afaa9
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date:   Fri Feb 14 12:47:01 2020 -0800

    Submodule kernel directory. (#16)

    * Removing FreeRTOS/Source in readiness for submoduling.

    * Submoduling kernel.

    * README.md update due to submoduling.

    When releasing, please follow these steps:
    1. in local directory, clean directory and check "git status" shows "nothing to commit, working tree clean" for ALL subdirectories.
    2. copy source code and instructions only to an empty folder. Git related should not be in this folder -- this covers .git, .gitignore, .github, .gitmodules, gitmessages, ......
    3. zip the folder from step 2. (create both .zip and .7z)
    4. attach .zip and .7z to the release. (e.g. attach these two in new release -- https://github.com/FreeRTOS/FreeRTOS/releases/new)
    5. PLEASE download both, unzip, diff with your local git repo. (should not see any difference other than git related.) And, sanity check a couple of projects.

commit c3f8b91652392dc55e0d7067b90a40de5f5f0837
Author: Rashed Talukder <9218468+rashedtalukder@users.noreply.github.com>
Date:   Thu Feb 13 17:47:14 2020 -0800

    Update readme. Fixed typos and cli commands (#14)

commit 4723b825f2989213c1cdb2ebf4d6793e0292e363
Author: Julian Poidevin <julian-poidevin@users.noreply.github.com>
Date:   Fri Feb 14 02:43:36 2020 +0100

    Fixed wrong git clone SSH command (#13)

    Replaced bad https URL with proper SSH URL

commit fc819b821715c42602819e58499846147a6394f5
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date:   Thu Feb 13 17:42:22 2020 -0800

    Correct the xTimerCreate() documentation which said NULL was returned if the timer period was passed into the function as 0, whereas that is not the case. (#15)

    Add a note to the documentation for both the xTimerCreate() and xTimerCreateStatic() functions that the timer period must be greater than 0.

commit 1c711ab530b5f0dbd811d7d62e0a3763706ffff4
Author: Rashed Talukder <9218468+rashedtalukder@users.noreply.github.com>
Date:   Wed Feb 12 23:00:18 2020 -0800

    Updated contributions guidelines (#12)

commit 84fcc0d5317d96c6b086034093c8c1c83e050819
Author: Cobus van Eeden <35851496+cobusve@users.noreply.github.com>
Date:   Wed Feb 12 15:05:06 2020 -0800

    Updates to Markdown files and readme.txt (#11)

commit 4b53196b71e02708ef1010a639d90236fbbd4032
Author: Cobus van Eeden <35851496+cobusve@users.noreply.github.com>
Date:   Tue Feb 11 18:23:08 2020 -0800

    Adding Contributions.md (#8)



git-svn-id: http://svn.code.sf.net/p/freertos/code/trunk@2825 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

1 files changed, 365 insertions, 126 deletions

diff --git a/FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/utilities/fsl_debug_console.c b/FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/utilities/fsl_debug_console.c
index a79e7af34..76aee9c2a 100644
--- a/FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/utilities/fsl_debug_console.c
+++ b/FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/utilities/fsl_debug_console.c
@@ -30,7 +30,7 @@
  *  of this software

 

  * Copyright (c) 2015, Freescale Semiconductor, Inc.

- * Copyright 2016-2018 NXP

+ * Copyright 2016-2019 NXP

  *

  * SPDX-License-Identifier: BSD-3-Clause

  */

@@ -43,8 +43,8 @@
 

 #ifdef FSL_RTOS_FREE_RTOS

 #include "FreeRTOS.h"

-#include "task.h"

 #include "semphr.h"

+#include "task.h"

 #endif

 

 #include "fsl_debug_console_conf.h"

@@ -65,18 +65,28 @@
 #endif

 #endif

 

+#if SDK_DEBUGCONSOLE

+#define DEBUG_CONSOLE_FUNCTION_PREFIX

+#else

+#define DEBUG_CONSOLE_FUNCTION_PREFIX static

+#endif

+

 /*! @brief character backspace ASCII value */

-#define DEBUG_CONSOLE_BACKSPACE 127

+#define DEBUG_CONSOLE_BACKSPACE 127U

 

 /* lock definition */

 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)

 

 static SemaphoreHandle_t s_debugConsoleReadSemaphore;

+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

 static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore;

+#endif

 

-#elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM)

+#elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM)

 

+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

 static volatile uint8_t s_debugConsoleReadWaitSemaphore;

+#endif

 

 #else

 

@@ -93,14 +103,23 @@ static volatile uint8_t s_debugConsoleReadWaitSemaphore;
 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)

 

 /* mutex semaphore */

-#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) (mutex = xSemaphoreCreateMutex())

-

 /* clang-format off */

+#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())

+#define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex)   \

+        do                                             \

+        {                                              \

+            if(NULL != mutex)                          \

+            {                                          \

+                vSemaphoreDelete(mutex);               \

+                mutex = NULL;                          \

+            }                                          \

+        } while(0)

+

 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \

 {                                                 \

         if (IS_RUNNING_IN_ISR() == 0U)            \

         {                                         \

-            xSemaphoreGive(mutex);                \

+            (void)xSemaphoreGive(mutex);          \

         }                                         \

 }

 

@@ -108,7 +127,7 @@ static volatile uint8_t s_debugConsoleReadWaitSemaphore;
 {                                                          \

         if (IS_RUNNING_IN_ISR() == 0U)                     \

         {                                                  \

-            xSemaphoreTake(mutex, portMAX_DELAY);          \

+            (void)xSemaphoreTake(mutex, portMAX_DELAY);    \

         }                                                  \

 }

 

@@ -123,21 +142,31 @@ static volatile uint8_t s_debugConsoleReadWaitSemaphore;
             result = 1U;                                              \

         }                                                             \

 }

-/* clang-format on */

 

 /* Binary semaphore */

-#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) (binary = xSemaphoreCreateBinary())

-#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) (xSemaphoreTake(binary, portMAX_DELAY))

-#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (xSemaphoreGiveFromISR(binary, NULL))

-

-#elif(DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)

+#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary())

+#define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary) \

+        do                                             \

+        {                                              \

+            if(NULL != binary)                         \

+            {                                          \

+                vSemaphoreDelete(binary);              \

+                binary = NULL;                         \

+            }                                          \

+        } while(0)

+#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake(binary, portMAX_DELAY))

+#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR(binary, NULL))

+

+#elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)

 

 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex)

+#define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex)

 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex)

 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex)

 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)

 

 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary)

+#define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary)

 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING

 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \

     {                                                        \

@@ -151,11 +180,12 @@ static volatile uint8_t s_debugConsoleReadWaitSemaphore;
 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary)

 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary)

 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */

+/* clang-format on */

 

 /* add other implementation here

-*such as :

-* #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)

-*/

+ *such as :

+ * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)

+ */

 

 #else

 

@@ -191,7 +221,11 @@ typedef struct _debug_console_state_struct
  ******************************************************************************/

 

 /*! @brief Debug console state information. */

+#if (defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE > 0))

+AT_NONCACHEABLE_SECTION(static debug_console_state_struct_t s_debugConsoleState);

+#else

 static debug_console_state_struct_t s_debugConsoleState;

+#endif

 serial_handle_t g_serialHandle; /*!< serial manager handle */

 

 /*******************************************************************************

@@ -208,11 +242,20 @@ serial_handle_t g_serialHandle; /*!< serial manager handle */
  *

  */

 #if SDK_DEBUGCONSOLE

-static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len);

+static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);

 #endif

 

+status_t DbgConsole_ReadOneCharacter(uint8_t *ch);

 int DbgConsole_SendData(uint8_t *ch, size_t size);

-

+int DbgConsole_SendDataReliable(uint8_t *ch, size_t size);

+int DbgConsole_ReadLine(uint8_t *buf, size_t size);

+int DbgConsole_ReadCharacter(uint8_t *ch);

+

+#if ((SDK_DEBUGCONSOLE > 0U) ||                                                   \

+     ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \

+      (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))

+DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void);

+#endif

 /*******************************************************************************

  * Code

  ******************************************************************************/

@@ -252,13 +295,19 @@ static void DbgConsole_SerialManagerTxCallback(void *callbackParam,
                 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;

             }

 

-            SerialManager_WriteNonBlocking(((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),

-                                           &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail],

-                                           sendDataLength);

+            (void)SerialManager_WriteNonBlocking(

+                ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),

+                &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength);

         }

     }

+    else if (kStatus_SerialManager_Canceled == status)

+    {

+        ioState->writeRingBuffer.ringTail = 0U;

+        ioState->writeRingBuffer.ringHead = 0U;

+    }

     else

     {

+        /*MISRA rule 16.4*/

     }

 }

 

@@ -283,6 +332,7 @@ static void DbgConsole_SerialManagerRxCallback(void *callbackParam,
     }

     else

     {

+        /*MISRA rule 16.4*/

     }

 }

 #endif

@@ -294,31 +344,32 @@ status_t DbgConsole_ReadOneCharacter(uint8_t *ch)
 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

 

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \

-    (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)

+    (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)

     return kStatus_Fail;

 #else

-    status_t status = kStatus_SerialManager_Error;

+    status_t status = (status_t)kStatus_SerialManager_Error;

 

 /* recieve one char every time */

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

-    status =

-        SerialManager_ReadNonBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);

+    status = (status_t)SerialManager_ReadNonBlocking(

+        ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);

 #else

-    status = SerialManager_ReadBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);

+    status = (status_t)SerialManager_ReadBlocking(

+        ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);

 #endif

-    if (kStatus_SerialManager_Success != status)

+    if ((status_t)kStatus_SerialManager_Success != status)

     {

-        return kStatus_Fail;

+        return (status_t)kStatus_Fail;

     }

     /* wait s_debugConsoleReadWaitSemaphore from RX callback */

     DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);

 

-    return kStatus_Success;

+    return (status_t)kStatus_Success;

 #endif

 

 #else

 

-    return kStatus_Fail;

+    return (status_t)kStatus_Fail;

 

 #endif

 }

@@ -327,16 +378,16 @@ status_t DbgConsole_ReadOneCharacter(uint8_t *ch)
 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)

 {

     /* Due to scanf take \n and \r as end of string,should not echo */

-    if (((*ch != '\r') && (*ch != '\n')) || (isGetChar))

+    if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar))

     {

         /* recieve one char every time */

-        if (1 != DbgConsole_SendData(ch, 1U))

+        if (1 != DbgConsole_SendDataReliable(ch, 1U))

         {

-            return kStatus_Fail;

+            return (status_t)kStatus_Fail;

         }

     }

 

-    if ((!isGetChar) && (index))

+    if ((!isGetChar) && (index != NULL))

     {

         if (DEBUG_CONSOLE_BACKSPACE == *ch)

         {

@@ -351,13 +402,13 @@ static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index
         }

     }

 

-    return kStatus_Success;

+    return (status_t)kStatus_Success;

 }

 #endif

 

 int DbgConsole_SendData(uint8_t *ch, size_t size)

 {

-    status_t status = kStatus_SerialManager_Error;

+    status_t status = (status_t)kStatus_SerialManager_Error;

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

     uint32_t sendDataLength;

     int txBusy = 0;

@@ -379,13 +430,13 @@ int DbgConsole_SendData(uint8_t *ch, size_t size)
     {

         sendDataLength = 0U;

     }

-    sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength;

-    if (sendDataLength <= size)

+    sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1;

+    if (sendDataLength < size)

     {

         EnableGlobalIRQ(regPrimask);

         return -1;

     }

-    for (int i = 0; i < size; i++)

+    for (int i = 0; i < (int)size; i++)

     {

         s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];

         if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)

@@ -394,9 +445,9 @@ int DbgConsole_SendData(uint8_t *ch, size_t size)
         }

     }

 

-    status = kStatus_SerialManager_Success;

+    status = (status_t)kStatus_SerialManager_Success;

 

-    if (!txBusy)

+    if (txBusy == 0)

     {

         if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)

         {

@@ -419,50 +470,143 @@ int DbgConsole_SendData(uint8_t *ch, size_t size)
     status = (status_t)SerialManager_WriteBlocking(

         ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);

 #endif

-    return ((kStatus_Success == status) ? (int)size : -1);

+    return (((status_t)kStatus_Success == status) ? (int)size : -1);

+}

+

+int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)

+{

+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

+#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))

+    status_t status = kStatus_SerialManager_Error;

+    uint32_t sendDataLength;

+    uint32_t totalLength = size;

+    int sentLength;

+#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */

+#else

+    status_t status = kStatus_SerialManager_Error;

+#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */

+

+    assert(NULL != ch);

+    assert(0 != size);

+

+    if (NULL == g_serialHandle)

+    {

+        return 0;

+    }

+

+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

+

+#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))

+    do

+    {

+        uint32_t regPrimask = DisableGlobalIRQ();

+        if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)

+        {

+            sendDataLength =

+                (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -

+                 s_debugConsoleState.writeRingBuffer.ringTail) %

+                s_debugConsoleState.writeRingBuffer.ringBufferSize;

+        }

+        else

+        {

+            sendDataLength = 0U;

+        }

+        sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;

+

+        if (sendDataLength > 0U)

+        {

+            if (sendDataLength > totalLength)

+            {

+                sendDataLength = totalLength;

+            }

+

+            sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength);

+            if (sentLength > 0)

+            {

+                totalLength = totalLength - (uint32_t)sentLength;

+            }

+        }

+        EnableGlobalIRQ(regPrimask);

+

+        if (totalLength != 0U)

+        {

+            status = DbgConsole_Flush();

+            if ((status_t)kStatus_Success != status)

+            {

+                break;

+            }

+        }

+    } while (totalLength != 0U);

+    return (status_t)(uint32_t)((uint32_t)size - totalLength);

+#else

+    return DbgConsole_SendData(ch, size);

+#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */

+

+#else

+    status          = (status_t)SerialManager_WriteBlocking(

+        ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);

+    return (((status_t)kStatus_Success == status) ? (int)size : -1);

+#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */

 }

 

 int DbgConsole_ReadLine(uint8_t *buf, size_t size)

 {

-    int i;

+    int i = 0;

 

     assert(buf != NULL);

 

+    if (NULL == g_serialHandle)

+    {

+        return -1;

+    }

+

     /* take mutex lock function */

     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);

 

-    for (i = 0; i < size; i++)

+    do

     {

         /* recieve one char every time */

-        if (kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))

+        if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))

         {

             /* release mutex lock function */

             DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);

-            return -1;

+            i = -1;

+            break;

         }

 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION

-        DbgConsole_EchoCharacter(&buf[i], false, &i);

+        (void)DbgConsole_EchoCharacter(&buf[i], false, &i);

 #endif

         /* analysis data */

-        if (('\r' == buf[i]) || ('\n' == buf[i]))

+        if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))

         {

             /* End of Line. */

             if (0 == i)

             {

-                buf[i] = '\0';

-                i = -1;

+                buf[i] = (uint8_t)'\0';

+                continue;

             }

             else

             {

                 break;

             }

         }

+        i++;

+    } while (i < (int)size);

+

+    /* get char should not add '\0'*/

+    if (i == (int)size)

+    {

+        buf[i] = (uint8_t)'\0';

+    }

+    else

+    {

+        buf[i + 1] = (uint8_t)'\0';

     }

 

     /* release mutex lock function */

     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);

 

-    return i + 1;

+    return i;

 }

 

 int DbgConsole_ReadCharacter(uint8_t *ch)

@@ -471,14 +615,19 @@ int DbgConsole_ReadCharacter(uint8_t *ch)
 

     assert(ch);

 

+    if (NULL == g_serialHandle)

+    {

+        return -1;

+    }

+

     /* take mutex lock function */

     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);

     /* read one character */

-    if (kStatus_Success == DbgConsole_ReadOneCharacter(ch))

+    if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch))

     {

         ret = 1;

 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION

-        DbgConsole_EchoCharacter(ch, true, NULL);

+        (void)DbgConsole_EchoCharacter(ch, true, NULL);

 #endif

     }

     else

@@ -493,19 +642,19 @@ int DbgConsole_ReadCharacter(uint8_t *ch)
 }

 

 #if SDK_DEBUGCONSOLE

-static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, int len)

+static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)

 {

     int i = 0;

 

     for (i = 0; i < len; i++)

     {

-        if ((*indicator + 1) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)

+        if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)

         {

-            DbgConsole_SendData((uint8_t *)buf, *indicator);

-            *indicator = 0U;

+            (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator));

+            *indicator = 0;

         }

 

-        buf[*indicator] = val;

+        buf[*indicator] = dbgVal;

         (*indicator)++;

     }

 }

@@ -513,21 +662,22 @@ static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char val, in
 

 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/

 

+#if ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART))

 /* See fsl_debug_console.h for documentation of this function. */

 status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)

 {

     serial_manager_config_t serialConfig;

-    status_t status = kStatus_SerialManager_Error;

+    status_t status = (status_t)kStatus_SerialManager_Error;

 

 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))

     serial_port_uart_config_t uartConfig = {

-        .instance = instance,

-        .clockRate = clkSrcFreq,

-        .baudRate = baudRate,

-        .parityMode = kSerialManager_UartParityDisabled,

+        .instance     = instance,

+        .clockRate    = clkSrcFreq,

+        .baudRate     = baudRate,

+        .parityMode   = kSerialManager_UartParityDisabled,

         .stopBitCount = kSerialManager_UartOneStopBit,

-        .enableRx = 1,

-        .enableTx = 1,

+        .enableRx     = 1,

+        .enableTx     = 1,

     };

 #endif

 

@@ -539,13 +689,21 @@ status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t
 

 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))

     serial_port_swo_config_t swoConfig = {

-        .clockRate = clkSrcFreq, .baudRate = baudRate, .port = instance, .protocol = kSerialManager_SwoProtocolNrz,

+        .clockRate = clkSrcFreq,

+        .baudRate  = baudRate,

+        .port      = instance,

+        .protocol  = kSerialManager_SwoProtocolNrz,

     };

 #endif

 

+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))

+    serial_port_usb_cdc_virtual_config_t usbCdcVirtualConfig = {

+        .controllerIndex = (serial_port_usb_cdc_virtual_controller_index_t)instance,

+    };

+#endif

     serialConfig.type = device;

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

-    serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];

+    serialConfig.ringBuffer     = &s_debugConsoleState.readRingBuffer[0];

     serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;

 #endif

 

@@ -573,47 +731,59 @@ status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t
         return status;

 #endif

     }

+    else if (kSerialPort_UsbCdcVirtual == device)

+    {

+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))

+        serialConfig.portConfig = &usbCdcVirtualConfig;

+#else

+        return status;

+#endif

+    }

     else

     {

         return status;

     }

 

-    memset(&s_debugConsoleState, 0U, sizeof(s_debugConsoleState));

+    (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));

+

+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

+    s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;

+#endif

 

     s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];

-    g_serialHandle = s_debugConsoleState.serialHandle;

-    status = SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);

+    status                           = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);

 

     assert(kStatus_SerialManager_Success == status);

 

     DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);

+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

     DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);

-

-#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

-    s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;

 #endif

 

     {

-        status = SerialManager_OpenWriteHandle(

+        status = (status_t)SerialManager_OpenWriteHandle(

             s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));

         assert(kStatus_SerialManager_Success == status);

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

-        SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),

-                                        DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);

+        (void)SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),

+                                              DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);

 #endif

     }

 

 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

     {

-        status = SerialManager_OpenReadHandle(s_debugConsoleState.serialHandle,

-                                              ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));

+        status = (status_t)SerialManager_OpenReadHandle(

+            s_debugConsoleState.serialHandle, ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));

         assert(kStatus_SerialManager_Success == status);

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

-        SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),

-                                        DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);

+        (void)SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),

+                                              DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);

 #endif

     }

 #endif

+

+    g_serialHandle = s_debugConsoleState.serialHandle;

+

     return kStatus_Success;

 }

 

@@ -621,26 +791,49 @@ status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t
 status_t DbgConsole_Deinit(void)

 {

     {

-        SerialManager_CloseWriteHandle(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));

+        if (s_debugConsoleState.serialHandle != NULL)

+        {

+            (void)SerialManager_CloseWriteHandle(

+                ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));

+        }

     }

 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

     {

-        SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));

+        if (s_debugConsoleState.serialHandle != NULL)

+        {

+            (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));

+        }

+    }

+#endif

+    if (s_debugConsoleState.serialHandle)

+    {

+        if (kStatus_SerialManager_Success == SerialManager_Deinit(s_debugConsoleState.serialHandle))

+        {

+            s_debugConsoleState.serialHandle = NULL;

+            g_serialHandle                   = NULL;

+        }

     }

+#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

+    DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);

 #endif

+    DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);

 

-    return kStatus_Success;

+    return (status_t)kStatus_Success;

 }

+#endif /* ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART)) */

 

-status_t DbgConsole_Flush(void)

+#if ((SDK_DEBUGCONSOLE > 0U) ||                                                   \

+     ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \

+      (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))

+DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void)

 {

 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

 

-#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)

+#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)

 

     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)

     {

-        return kStatus_Fail;

+        return (status_t)kStatus_Fail;

     }

 

 #else

@@ -648,13 +841,16 @@ status_t DbgConsole_Flush(void)
     while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)

     {

 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)

-        if (IS_RUNNING_IN_ISR() == 0U)

+        if (0U == IS_RUNNING_IN_ISR())

         {

-            vTaskDelay(1);

+            if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())

+            {

+                vTaskDelay(1);

+            }

         }

         else

         {

-            return kStatus_Fail;

+            return (status_t)kStatus_Fail;

         }

 #endif

     }

@@ -662,16 +858,17 @@ status_t DbgConsole_Flush(void)
 #endif

 

 #endif

-    return kStatus_Success;

+    return (status_t)kStatus_Success;

 }

+#endif

 

 #if SDK_DEBUGCONSOLE

 /* See fsl_debug_console.h for documentation of this function. */

 int DbgConsole_Printf(const char *formatString, ...)

 {

     va_list ap;

-    int logLength = 0U, result = 0U;

-    char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {0U};

+    int logLength = 0, dbgResult = 0;

+    char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};

 

     if (NULL == g_serialHandle)

     {

@@ -682,37 +879,66 @@ int DbgConsole_Printf(const char *formatString, ...)
     /* format print log first */

     logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);

     /* print log */

-    result = DbgConsole_SendData((uint8_t *)printBuf, logLength);

+    dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);

 

     va_end(ap);

 

-    return result;

+    return dbgResult;

 }

 

 /* See fsl_debug_console.h for documentation of this function. */

 int DbgConsole_Putchar(int ch)

 {

     /* print char */

-    return DbgConsole_SendData((uint8_t *)&ch, 1U);

+    return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);

 }

 

 /* See fsl_debug_console.h for documentation of this function. */

 int DbgConsole_Scanf(char *formatString, ...)

 {

     va_list ap;

-    int result;

-    char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {0U};

+    int formatResult;

+    char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};

 

     /* scanf log */

-    DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);

+    (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);

     /* get va_list */

     va_start(ap, formatString);

     /* format scanf log */

-    result = StrFormatScanf(scanfBuf, formatString, ap);

+    formatResult = StrFormatScanf(scanfBuf, formatString, ap);

+

+    va_end(ap);

+

+    return formatResult;

+}

+/* See fsl_debug_console.h for documentation of this function. */

+int DbgConsole_BlockingPrintf(const char *formatString, ...)

+{

+    va_list ap;

+    status_t status = (status_t)kStatus_SerialManager_Error;

+    int logLength = 0, dbgResult = 0;

+    char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};

+

+    if (NULL == g_serialHandle)

+    {

+        return 0;

+    }

+

+    va_start(ap, formatString);

+    /* format print log first */

+    logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);

 

+#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)

+    SerialManager_CancelWriting(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));

+#endif

+    /* print log */

+    status =

+        (status_t)SerialManager_WriteBlocking(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),

+                                              (uint8_t *)printBuf, (size_t)logLength);

+    dbgResult = (((status_t)kStatus_Success == status) ? (int)logLength : -1);

     va_end(ap);

 

-    return result;

+    return dbgResult;

 }

 

 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING

@@ -720,10 +946,15 @@ status_t DbgConsole_TryGetchar(char *ch)
 {

 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))

     uint32_t length = 0;

-    status_t status = kStatus_Fail;

+    status_t status = (status_t)kStatus_Fail;

 

     assert(ch);

 

+    if (NULL == g_serialHandle)

+    {

+        return kStatus_Fail;

+    }

+

     /* take mutex lock function */

     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);

 

@@ -731,19 +962,19 @@ status_t DbgConsole_TryGetchar(char *ch)
         SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,

                               &length))

     {

-        if (length)

+        if (length != 0U)

         {

 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION

-            DbgConsole_EchoCharacter(ch, true, NULL);

+            (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);

 #endif

-            status = kStatus_Success;

+            status = (status_t)kStatus_Success;

         }

     }

     /* release mutex lock function */

     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);

     return status;

 #else

-    return kStatus_Fail;

+    return (status_t)kStatus_Fail;

 #endif

 }

 #endif

@@ -754,7 +985,7 @@ int DbgConsole_Getchar(void)
     uint8_t ch = 0U;

 

     /* Get char */

-    DbgConsole_ReadCharacter(&ch);

+    (void)DbgConsole_ReadCharacter(&ch);

 

     return (int)ch;

 }

@@ -784,7 +1015,7 @@ size_t __write(int handle, const unsigned char *buffer, size_t size)
     }

 

     /* Send data. */

-    DbgConsole_SendData((uint8_t *)buffer, size);

+    DbgConsole_SendDataReliable((uint8_t *)buffer, size);

 

     return size;

 }

@@ -792,8 +1023,9 @@ size_t __write(int handle, const unsigned char *buffer, size_t size)
 #pragma weak __read

 size_t __read(int handle, unsigned char *buffer, size_t size)

 {

-    uint8_t ch = 0U;

-    size_t actualSize = 0U;

+    uint8_t ch     = 0U;

+    int actualSize = 0U;

+

     /* This function only reads from "standard in", for all other file  handles it returns failure. */

     if (handle != 0)

     {

@@ -818,9 +1050,9 @@ size_t __read(int handle, unsigned char *buffer, size_t size)
 #endif /* SDK_DEBUGCONSOLE_UART */

 

 /* support LPC Xpresso with RedLib */

-#elif(defined(__REDLIB__))

+#elif (defined(__REDLIB__))

 

-#if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))

+#if (defined(SDK_DEBUGCONSOLE_UART))

 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)

 {

     if (buffer == 0)

@@ -836,7 +1068,7 @@ int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)
     }

 

     /* Send data. */

-    DbgConsole_SendData((uint8_t *)buffer, size);

+    DbgConsole_SendDataReliable((uint8_t *)buffer, size);

 

     return 0;

 }

@@ -876,7 +1108,7 @@ FILE __stdin;
 int fputc(int ch, FILE *f)

 {

     /* Send data. */

-    return DbgConsole_SendData((uint8_t *)(&ch), 1);

+    return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);

 }

 

 #pragma weak fgetc

@@ -908,7 +1140,7 @@ void _sys_exit(int returncode)
 void _ttywrch(int ch)

 {

     char ench = ch;

-    DbgConsole_SendData((uint8_t *)(&ench), 1);

+    DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);

 }

 

 char *_sys_command_string(char *cmd, int len)

@@ -916,15 +1148,16 @@ char *_sys_command_string(char *cmd, int len)
     return (cmd);

 }

 #endif /* SDK_DEBUGCONSOLE_UART */

+

 /* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/

-#elif(defined(__GNUC__))

+#elif (defined(__GNUC__))

 

 #if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \

-     (defined(__MCUXPRESSO) && (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))))

-

+     (defined(__MCUXPRESSO) && (defined(SDK_DEBUGCONSOLE_UART))))

+int __attribute__((weak)) _write(int handle, char *buffer, int size);

 int __attribute__((weak)) _write(int handle, char *buffer, int size)

 {

-    if (buffer == 0)

+    if (buffer == NULL)

     {

         /* return -1 if error. */

         return -1;

@@ -937,15 +1170,16 @@ int __attribute__((weak)) _write(int handle, char *buffer, int size)
     }

 

     /* Send data. */

-    DbgConsole_SendData((uint8_t *)buffer, size);

+    (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);

 

     return size;

 }

 

+int __attribute__((weak)) _read(int handle, char *buffer, int size);

 int __attribute__((weak)) _read(int handle, char *buffer, int size)

 {

-    uint8_t ch = 0U;

-    int actualSize = 0U;

+    uint8_t ch     = 0U;

+    int actualSize = 0;

 

     /* This function only reads from "standard in", for all other file handles it returns failure. */

     if (handle != 0)

@@ -953,20 +1187,25 @@ int __attribute__((weak)) _read(int handle, char *buffer, int size)
         return -1;

     }

 

+    /* Receive data. */

     for (; size > 0; size--)

     {

-        DbgConsole_ReadCharacter(&ch);

+        if (DbgConsole_ReadCharacter(&ch) < 0)

+        {

+            break;

+        }

 

-        *buffer++ = ch;

+        *buffer++ = (char)ch;

         actualSize++;

 

-        if ((ch == 0) || (ch == '\n') || (ch == '\r'))

+        if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))

         {

             break;

         }

     }

 

-    return actualSize;

+    return (actualSize > 0) ? actualSize : -1;

 }

 #endif

+

 #endif /* __ICCARM__ */