[component][drivers][serial_v2] 优化serial_v2 (#10603)

* [bsp][stm32][drv_usart_v2] uart_isr不再使用链式调用，RXNE内循环读空，一些细节优化

* [componnents][drivers][serial_v2] 增加获取config接口，使用rt_tick_get_delta替代内部的时间绕回判断，写满丢弃策略rx接收数据错乱修复，clang-tidy和cppcheck审查优化

* [utest][drivers][serial_v2] 测试例程进行优化

* [bsp][stm32][drv_usart_v2] 撤回DMAMUX1修改

* [componnents][drivers][serial_v2] read和write不再返回-RT_ETIMEOUT改为已发送或读取的字节数，细节优化

* [utest][drivers][serial_v2] 增加单独的timeout测试，减少测试中的硬延时

* [utest][drivers][serial_v2] 漏提交的posix下标志位

* [utest][drivers][serial_v2] 优化测试例程

* [bsp][stm32][drv_usart_v2] transmit返回错误值，RXNE增加超时逻辑

* [componnents][drivers][serial_v2] 增加transmit错误处理，增加超时退出机制显式的避免死循环

* [componnents][drivers][serial_v2] 适配serial_v2和posix非libc标准库下的console和shell

components/drivers/include/drivers/dev_serial_v2.h

@@ -210,6 +210,7 @@
 #define RT_SERIAL_CTRL_RX_FLUSH                 0x45    /* clear rx buffer. Discard all data */
 #define RT_SERIAL_CTRL_TX_FLUSH                 0x46    /* clear tx buffer. Blocking and wait for the send buffer data to be sent. not supported in poll mode */
 #define RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT   0x47    /* get unread bytes count. not supported in poll mode */
+#define RT_SERIAL_CTRL_GET_CONFIG               0x48    /* get serial config */
 
 #define RT_SERIAL_ERR_OVERRUN           0x01
 #define RT_SERIAL_ERR_FRAMING           0x02
@@ -336,7 +337,12 @@ struct rt_serial_device
 #ifdef RT_USING_SERIAL_BYPASS
     struct rt_serial_bypass* bypass;
 #endif
+
     struct rt_device_notify rx_notify;
+
+#ifdef RT_USING_POSIX_STDIO
+    rt_bool_t is_posix_mode;
+#endif
 };
 
 /**

examples/utest/testcases/drivers/serial_v2/posix/uart_posix_echo_block.c

@@ -115,7 +115,7 @@ static void uart_rec_entry(void *parameter)
 
     rev_len = *(rt_uint16_t *)parameter;
     rt_uint8_t *uart_write_buffer;
-    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
     rt_int32_t  cnt, i;
     rt_uint8_t  last_old_data;
     rt_bool_t   fisrt_flag         = RT_TRUE;

examples/utest/testcases/drivers/serial_v2/posix/uart_posix_nonblock.c

@@ -108,7 +108,7 @@ static rt_err_t uart_api()
         goto __exit;
     }
 
-    uart_write_buffer = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * 100);
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(100);
 
     for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
     {

examples/utest/testcases/drivers/serial_v2/uart_blocking_rx.c

@@ -51,7 +51,6 @@ static rt_bool_t block_read(rt_device_t uart_dev)
 
     rt_sprintf(log_buffer, "\nblock : %d bytes read , total: %d \n", recv_length, total_length);
     rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));
-    rt_thread_mdelay(1000);
 
     rt_sprintf(log_buffer, "BLOCKING READ END");
     rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer));

examples/utest/testcases/drivers/serial_v2/uart_blocking_tx.c

@@ -83,7 +83,7 @@ static rt_bool_t block_write(rt_device_t uart_dev)
     for (i = 0; i < index; i++)
     {
         LOG_D("\nBLOCKING_MODE : write %d / %d bytes in %d ticks\n", write_num_array[i], total_write_num[i], tick_array[i]);
-        rt_thread_mdelay(1000);
+        rt_thread_mdelay(10);
     }
 
     return RT_TRUE;

examples/utest/testcases/drivers/serial_v2/uart_flush_rx.c

@@ -31,10 +31,26 @@ static rt_err_t uart_find(void)
     return RT_EOK;
 }
 
-static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t size)
+static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
 {
-    rt_device_write(&serial->parent, 0, uart_write_buffer, size);
-    rt_thread_mdelay(size * 0.0868 + 5);
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+    rt_thread_mdelay(send_size * 0.0868 + 5);
     if (1 != rt_device_read(&serial->parent, 0, uart_write_buffer, 1))
     {
         LOG_E("read failed.");
@@ -48,6 +64,25 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t size)
         return -RT_ERROR;
     }
 
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_thread_mdelay(readSize * 0.0868 + 5);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
+    LOG_I("flush rx send_size [%4d]", send_size);
+
     return RT_EOK;
 }
 
@@ -80,7 +115,11 @@ static rt_bool_t uart_api()
 
     rt_uint8_t *uart_write_buffer;
     rt_uint32_t i;
-    uart_write_buffer = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (RT_SERIAL_TC_TXBUF_SIZE * 5 + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 5 + 1);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_RXBUF_SIZE * 5 + 1); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
 
     srand(rt_tick_get());
     for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)

examples/utest/testcases/drivers/serial_v2/uart_flush_txb.c

@@ -37,18 +37,34 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
     rt_tick_t   tick_diff;
     rt_tick_t   expect_time = send_size * 0.0868;
 
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
+
     /* In interrupt mode, ticks may be inaccurate; compensation should be applied*/
     if (send_size > 384)
     {
         expect_time -= send_size / 384;
     }
 
-    old_tick = rt_tick_get();
-    rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    old_tick        = rt_tick_get();
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
     rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
     tick_diff = rt_tick_get() - old_tick;
 
-    if (tick_diff < expect_time || tick_diff > expect_time + 10)
+    if (tick_diff < expect_time || tick_diff > (expect_time + 10))
     {
         LOG_E("send_size [%4d], time required for TXB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
         return -RT_ERROR;
@@ -58,6 +74,24 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
         LOG_I("send_size [%4d], time required for TXB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
     }
 
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
+
     return RT_EOK;
 }
 
@@ -81,7 +115,7 @@ static rt_bool_t uart_api()
 #endif
     rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
 
-    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
     if (result != RT_EOK)
     {
         LOG_E("Open uart device failed.");
@@ -90,8 +124,12 @@ static rt_bool_t uart_api()
 
     rt_uint8_t *uart_write_buffer;
     rt_uint32_t i;
-    rt_int32_t  tx_timeout = 1;
-    uart_write_buffer      = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (RT_SERIAL_TC_TXBUF_SIZE * 5 + 10));
+    rt_int32_t  tx_timeout = 10 * 1000;
+    uart_write_buffer      = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_TXBUF_SIZE * 5 + 10);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_TXBUF_SIZE * 5 + 10); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
 
     rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
 

examples/utest/testcases/drivers/serial_v2/uart_flush_txnb.c

@@ -36,6 +36,16 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
     rt_uint32_t old_tick;
     rt_tick_t   tick_diff;
     rt_tick_t   expect_time = send_size * 0.0868;
+    rt_uint8_t  readBuf[16] = {0};
+    rt_uint32_t readSize    = 0;
+    if (send_size >= sizeof(readBuf))
+    {
+        readSize = sizeof(readBuf);
+    }
+    else
+    {
+        readSize = send_size;
+    }
 
     /* In interrupt mode, ticks may be inaccurate; compensation should be applied */
     if (send_size > 384)
@@ -43,11 +53,18 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
         expect_time -= send_size / 384;
     }
 
-    old_tick         = rt_tick_get();
-    rt_uint32_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    old_tick        = rt_tick_get();
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+
     rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
     tick_diff = rt_tick_get() - old_tick;
-    if (tick_diff < expect_time)
+
+    if (tick_diff < expect_time || tick_diff > (expect_time + 10))
     {
         LOG_E("send_size [%4d], time required for TXNB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
         return -RT_ERROR;
@@ -57,6 +74,23 @@ static rt_err_t test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
         LOG_I("send_size [%4d], time required for TXNB mode transmission to complete [%3d], expect_time [%3d]", send_size, tick_diff, expect_time);
     }
 
+    /* Resend the data and check for any discrepancies upon reception */
+    if (readSize > 0)
+    {
+        rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL);
+        rt_device_write(&serial->parent, 0, uart_write_buffer, readSize);
+        rt_device_read(&serial->parent, 0, readBuf, readSize);
+
+        for (rt_uint32_t i = 0; i < readSize; i++)
+        {
+            if (readBuf[i] != uart_write_buffer[i])
+            {
+                LOG_E("index: %d, Read Different data -> former data: %x, current data: %x.", i, uart_write_buffer[i], readBuf[i]);
+                return -RT_ERROR;
+            }
+        }
+    }
+
     return RT_EOK;
 }
 
@@ -80,7 +114,7 @@ static rt_bool_t uart_api()
 #endif
     rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
 
-    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
     if (result != RT_EOK)
     {
         LOG_E("Open uart device failed.");
@@ -90,7 +124,11 @@ static rt_bool_t uart_api()
     rt_uint8_t *uart_write_buffer;
     rt_uint32_t i;
     rt_int32_t  tx_timeout = 1;
-    uart_write_buffer      = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (RT_SERIAL_TC_RXBUF_SIZE * 5 + 10));
+    uart_write_buffer      = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 5 + 10);
+    for (rt_uint32_t count = 0; count < (RT_SERIAL_TC_TXBUF_SIZE * 5 + 10); count++)
+    {
+        uart_write_buffer[count] = count;
+    }
 
     rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
 

examples/utest/testcases/drivers/serial_v2/uart_get_unread_bytes_count.c

@@ -92,7 +92,7 @@ static rt_bool_t uart_api()
 
     rt_uint8_t *uart_write_buffer;
     rt_uint32_t i;
-    uart_write_buffer = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (RT_SERIAL_TC_TXBUF_SIZE * 5 + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_TXBUF_SIZE * 5 + 1);
 
     srand(rt_tick_get());
     for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)

examples/utest/testcases/drivers/serial_v2/uart_nonblocking_tx.c

@@ -88,7 +88,7 @@ static rt_bool_t nonblock_write(rt_device_t uart_dev)
     for (i = 0; i < index; i++)
     {
         LOG_D("\nNONBLOCKING_MODE : write %d / %d bytes in %d ticks\n", write_num_array[i], total_write_num[i], tick_array[i]);
-        rt_thread_mdelay(1000);
+        rt_thread_mdelay(10);
     }
 
     return RT_TRUE;

examples/utest/testcases/drivers/serial_v2/uart_overflow_rxb_txb.c

@@ -70,7 +70,7 @@ static void uart_rec_entry(void *parameter)
     rt_uint8_t *uart_write_buffer;
     rt_int32_t  cnt, i;
     rev_len           = *(rt_uint32_t *)parameter;
-    uart_write_buffer = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(rev_len + 1);
 
     while (1)
     {

examples/utest/testcases/drivers/serial_v2/uart_rxb_txb.c

@@ -69,13 +69,12 @@ static void uart_rec_entry(void *parameter)
 
     rev_len = *(rt_uint16_t *)parameter;
     rt_uint8_t *uart_write_buffer;
-    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
     rt_int32_t  cnt, i;
     rt_uint8_t  last_old_data;
     rt_bool_t   fisrt_flag         = RT_TRUE;
     rt_uint32_t all_receive_length = 0;
 
-
     while (1)
     {
         cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len);

examples/utest/testcases/drivers/serial_v2/uart_rxb_txnb.c

@@ -83,7 +83,7 @@ static void uart_rec_entry(void *parameter)
 
     rev_len = *(rt_uint16_t *)parameter;
     rt_uint8_t *uart_write_buffer;
-    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
     rt_int32_t  cnt, i;
     rt_uint8_t  last_old_data;
     rt_bool_t   fisrt_flag         = RT_TRUE;

examples/utest/testcases/drivers/serial_v2/uart_rxnb_txb.c

@@ -79,7 +79,7 @@ static void uart_rec_entry(void *parameter)
 
     rev_len = *(rt_uint16_t *)parameter;
     rt_uint8_t *uart_write_buffer;
-    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
     rt_int32_t  cnt, i;
     rt_uint8_t  last_old_data;
     rt_bool_t   fisrt_flag         = RT_TRUE;

examples/utest/testcases/drivers/serial_v2/uart_rxnb_txnb.c

@@ -89,7 +89,7 @@ static void uart_rec_entry(void *parameter)
 
     rev_len = *(rt_uint16_t *)parameter;
     rt_uint8_t *uart_write_buffer;
-    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (rev_len + 1));
+    uart_write_buffer = (rt_uint8_t *)rt_calloc(1, rev_len + 1);
     rt_int32_t  cnt, i;
     rt_uint8_t  last_old_data;
     rt_bool_t   fisrt_flag         = RT_TRUE;

examples/utest/testcases/drivers/serial_v2/uart_timeout_rxb.c

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+
+#ifdef UTEST_SERIAL_TC
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t rx_timeout_test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t readSize             = 0;
+    rt_int32_t  rx_timeout_send_size = send_size - send_size / 3;
+    rt_int32_t  rx_timeout           = rt_tick_from_millisecond(0.0868 * rx_timeout_send_size + 1);
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&rx_timeout);
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size != send_size)
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, send_size);
+        return -RT_ERROR;
+    }
+
+    readSize = rt_device_read(&serial->parent, 0, uart_write_buffer, size);
+    if (readSize < (rx_timeout_send_size - 70) || readSize > (send_size - 80))
+    {
+        LOG_E("readSize [%4d], rx_timeout_send_size [%4d]", readSize, rx_timeout_send_size);
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    /* Waiting for rx to complete reception */
+    rt_thread_mdelay(0.0868 * (send_size / 3));
+
+    LOG_I("rx timeout send_size [%4d]", send_size);
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = 2048;
+#ifdef RT_SERIAL_USING_DMA
+    config.dma_ping_bufsz = RT_SERIAL_TC_RXBUF_SIZE / 2;
+#endif
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(2048);
+
+
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        srand(rt_tick_get());
+        if (RT_EOK != rx_timeout_test_item(uart_write_buffer, 1024 + (rand() % 1024)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "testcases.drivers.uart_timeout_rxb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* TC_UART_USING_TC */

examples/utest/testcases/drivers/serial_v2/uart_timeout_rxb_txb.c

@@ -75,7 +75,7 @@ static void uart_rec_entry(void *parameter)
     rt_ssize_t  recv_len;
     rt_uint32_t i;
     rt_int32_t  timeout = 0;
-    uart_write_buffer   = (rt_uint8_t *)rt_malloc(sizeof(rt_uint8_t) * (RT_SERIAL_TC_RXBUF_SIZE * 10 + 1));
+    uart_write_buffer   = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE * 10 + 1);
 
     timeout = 100;
     rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout);

examples/utest/testcases/drivers/serial_v2/uart_timeout_txb.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2006-2024 RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ *
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <rtdevice.h>
+#include <stdlib.h>
+
+#ifdef UTEST_SERIAL_TC
+#ifndef BSP_UART2_TX_USING_DMA
+
+static struct rt_serial_device *serial;
+
+static rt_err_t uart_find(void)
+{
+    serial = (struct rt_serial_device *)rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+
+    if (serial == RT_NULL)
+    {
+        LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t tx_timeout_test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size)
+{
+    rt_uint32_t readSize             = 0;
+    rt_int32_t  tx_timeout_send_size = send_size - send_size / 3;
+    rt_int32_t  tx_timeout           = rt_tick_from_millisecond(0.0868 * tx_timeout_send_size + 1);
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&tx_timeout);
+
+    rt_ssize_t size = rt_device_write(&serial->parent, 0, uart_write_buffer, send_size);
+    if (size < (tx_timeout_send_size - 70) || size > (send_size - 80))
+    {
+        LOG_E("size [%4d], send_size [%4d]", size, tx_timeout_send_size);
+        return -RT_ERROR;
+    }
+
+    rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
+    /* Waiting for rx to complete reception */
+    rt_thread_mdelay(0.0868 * (send_size / 3));
+
+    LOG_I("tx timeout send_size [%4d]", send_size);
+
+    return RT_EOK;
+}
+
+static rt_bool_t uart_api()
+{
+    rt_err_t result = RT_EOK;
+
+    result = uart_find();
+    if (result != RT_EOK)
+    {
+        return RT_FALSE;
+    }
+
+    /* Reinitialize */
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    config.baud_rate               = BAUD_RATE_115200;
+    config.rx_bufsz                = RT_SERIAL_TC_RXBUF_SIZE;
+    config.tx_bufsz                = RT_SERIAL_TC_TXBUF_SIZE;
+
+    rt_device_control(&serial->parent, RT_DEVICE_CTRL_CONFIG, &config);
+
+    result = rt_device_open(&serial->parent, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
+    if (result != RT_EOK)
+    {
+        LOG_E("Open uart device failed.");
+        return RT_FALSE;
+    }
+
+    rt_uint8_t *uart_write_buffer;
+    rt_uint32_t i;
+    uart_write_buffer = (rt_uint8_t *)rt_malloc(2048);
+    for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++)
+    {
+        srand(rt_tick_get());
+        if (RT_EOK != tx_timeout_test_item(uart_write_buffer, 1024 + (rand() % 1024)))
+        {
+            LOG_E("test_item failed.");
+            result = -RT_ERROR;
+            goto __exit;
+        }
+    }
+
+__exit:
+    rt_free(uart_write_buffer);
+    rt_device_close(&serial->parent);
+    rt_thread_mdelay(5);
+    return result == RT_EOK ? RT_TRUE : RT_FALSE;
+}
+
+static void tc_uart_api(void)
+{
+    uassert_true(uart_api() == RT_TRUE);
+}
+
+static rt_err_t utest_tc_init(void)
+{
+    LOG_I("UART TEST: Please connect Tx and Rx directly for self testing.");
+    return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+    rt_device_t uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME);
+    while (rt_device_close(uart_dev) != -RT_ERROR);
+    return RT_EOK;
+}
+
+static void testcase(void)
+{
+    UTEST_UNIT_RUN(tc_uart_api);
+}
+
+UTEST_TC_EXPORT(testcase, "testcases.drivers.uart_timeout_txb", utest_tc_init, utest_tc_cleanup, 30);
+
+#endif /* BSP_UART2_TX_USING_DMA */
+#endif /* TC_UART_USING_TC */