diff options
Diffstat (limited to 'components/drivers')
29 files changed, 4489 insertions, 0 deletions
diff --git a/components/drivers/serial/SConscript b/components/drivers/serial/SConscript index 04fa37ed44..d0b5fb0635 100644 --- a/components/drivers/serial/SConscript +++ b/components/drivers/serial/SConscript @@ -24,4 +24,9 @@ if GetDepend(['RT_USING_DM']): group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH) +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + Return('group') diff --git a/components/drivers/serial/utest/Kconfig b/components/drivers/serial/utest/Kconfig new file mode 100644 index 0000000000..cc6413374f --- /dev/null +++ b/components/drivers/serial/utest/Kconfig @@ -0,0 +1,56 @@ +menu "Serial Unit Testcases" + + config UTEST_SERIAL_BYPASS + bool "Serial Bypass testcases" + default n + depends on RT_USING_SERIAL_BYPASS + + config UTEST_SERIAL_TC + bool "Serial V2 testcases" + default n + depends on RT_USING_SERIAL_V2 + + if UTEST_SERIAL_TC + + config RT_SERIAL_TC_DEVICE_NAME + string "the device name for serial test" + default "uart2" + + config RT_SERIAL_TC_RXBUF_SIZE + int "the rx buffer size for serial test" + default 128 + + config RT_SERIAL_TC_TXBUF_SIZE + int "the tx buffer size for serial test" + default 128 + + config RT_SERIAL_TC_SEND_ITERATIONS + int "the number of iterations for the test routine." + default 100 + + config UTEST_SERIAL_QEMU_TC + bool "qemu dedicated tests" + default n + + config UTEST_SERIAL_POSIX_TC + bool "Serial posix testcase" + default n + select RT_USING_DFS + select RT_USING_POSIX_FS + select RT_USING_POSIX_TERMIOS + + if UTEST_SERIAL_POSIX_TC + + config RT_SERIAL_POSIX_TC_DEVICE_NAME + string "the device name for serial posix test" + default "dev/uart2" + + config RT_SERIAL_POSIX_TC_SEND_ITERATIONS + int "the number of iterations for the posix test routine." + default 100 + + endif + + endif + +endmenu
\ No newline at end of file diff --git a/components/drivers/serial/utest/SConscript b/components/drivers/serial/utest/SConscript new file mode 100644 index 0000000000..e98495c213 --- /dev/null +++ b/components/drivers/serial/utest/SConscript @@ -0,0 +1,15 @@ +Import('rtconfig') +from building import * + +cwd = GetCurrentDir() +src = [] +CPPPATH = [cwd] + +group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES', 'RT_USING_SERIAL'], CPPPATH = CPPPATH) + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/components/drivers/serial/utest/bypass/SConscript b/components/drivers/serial/utest/bypass/SConscript new file mode 100644 index 0000000000..86be64011b --- /dev/null +++ b/components/drivers/serial/utest/bypass/SConscript @@ -0,0 +1,11 @@ +Import('rtconfig') +from building import * + +cwd = GetCurrentDir() +src = Glob('bypass*.c') + +CPPPATH = [cwd] + +group = DefineGroup('utestcases', src, depend = ['UTEST_SERIAL_BYPASS'], CPPPATH = CPPPATH) + +Return('group') diff --git a/components/drivers/serial/utest/bypass/bypass_conflict.c b/components/drivers/serial/utest/bypass/bypass_conflict.c new file mode 100644 index 0000000000..175a45a108 --- /dev/null +++ b/components/drivers/serial/utest/bypass/bypass_conflict.c @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2024-11-20 zhujiale the first version + */ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +static struct rt_serial_device* _serial0; +static struct rt_spinlock lock; +static int cnt = 0; + +#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x))) +#define UART_FR(base) __REG32(base + 0x18) +#define UART_DR(base) __REG32(base + 0x00) +#define UARTFR_TXFF 0x20 + +static rt_err_t utest_get_c(struct rt_serial_device* serial, char ch, void* data) +{ + rt_atomic_add(&cnt, 1); + return RT_EOK; +} + +static int utest_getc(struct rt_serial_device* serial) +{ + static int num = 0; + + rt_spin_lock(&lock); + if (rt_atomic_load(&num) == 10) + { + rt_atomic_flag_clear(&num); + rt_spin_unlock(&lock); + return -1; + } + rt_atomic_add(&num, 1); + rt_spin_unlock(&lock); + return 'a'; +} + +struct hw_uart_device +{ + rt_size_t hw_base; + rt_size_t irqno; +}; + +static int uart_putc(struct rt_serial_device* serial, char c) +{ + struct hw_uart_device* uart; + + RT_ASSERT(serial != RT_NULL); + uart = (struct hw_uart_device*)serial->parent.user_data; + + while (UART_FR(uart->hw_base) & UARTFR_TXFF); + UART_DR(uart->hw_base) = c; + + return 1; +} + +static const struct rt_uart_ops _utest_ops = +{ + RT_NULL, + RT_NULL, + uart_putc, + utest_getc, +}; + + +static void thread_rx1(void* parameter) +{ + for (int i = 0; i < 10; i++) + { + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + } +} + +static void thread_rx2(void* parameter) +{ + for (int i = 0; i < 10; i++) + { + rt_workqueue_dowork(_serial0->bypass->lower_workq, &_serial0->bypass->work); + } +} + +static void thread_high_priority(void* parameter) +{ + for (int i = 1; i < 10; i++) + { + rt_bypass_upper_register(_serial0, "test", i, utest_get_c, RT_NULL); + rt_bypass_upper_unregister(_serial0, i); + } +} + +static void thread_low_priority(void* parameter) +{ + for (int i = 0; i < 20; i++) + { + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + } +} + +static void bypass_rx_stress_003(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + + rt_thread_t high = rt_thread_create("high_prio", thread_high_priority, RT_NULL, 2048, 15, 10); + rt_thread_t low = rt_thread_create("low_prio", thread_low_priority, RT_NULL, 2048, 20, 10); + + rt_atomic_flag_clear(&cnt); + _serial0->ops = &_utest_ops; + rt_bypass_upper_register(_serial0, "test", 0, utest_get_c, RT_NULL); + + rt_thread_startup(high); + rt_thread_startup(low); + + rt_thread_mdelay(1000); + _serial0->ops = tmp; + rt_bypass_upper_unregister(_serial0, 0); + uassert_true(rt_atomic_load(&cnt) == 200); +} + +static void bypass_rx_stress_002(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + rt_thread_t rx2 = rt_thread_create("rx2", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + rt_thread_t rx3 = rt_thread_create("rx3", thread_rx2, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + + rt_atomic_flag_clear(&cnt); + _serial0->ops = &_utest_ops; + rt_bypass_lower_register(_serial0, "utest", 0, utest_get_c, RT_NULL); + + rt_thread_startup(rx2); + rt_thread_startup(rx3); + + rt_thread_mdelay(1000); + + uassert_true(rt_atomic_load(&cnt) == 100); + _serial0->ops = tmp; + rt_bypass_lower_unregister(_serial0, 0); +} + +static void bypass_rx_stress_001(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + rt_thread_t rx1 = rt_thread_create("rx1", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + rt_thread_t rx2 = rt_thread_create("rx1", thread_rx1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + + cnt = 0; + _serial0->ops = &_utest_ops; + rt_bypass_upper_register(_serial0, "utest", 0, utest_get_c, RT_NULL); + + rt_thread_startup(rx1); + rt_thread_startup(rx2); + + rt_thread_mdelay(1000); + + uassert_true(rt_atomic_load(&cnt) == 200); + _serial0->ops = tmp; + rt_bypass_upper_unregister(_serial0, 0); +} + +static rt_err_t utest_tc_init(void) +{ + _serial0 = (struct rt_serial_device*)rt_console_get_device(); + rt_spin_lock_init(&lock); + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void _testcase(void) +{ + UTEST_UNIT_RUN(bypass_rx_stress_001); + UTEST_UNIT_RUN(bypass_rx_stress_002); + UTEST_UNIT_RUN(bypass_rx_stress_003); +} + +UTEST_TC_EXPORT(_testcase, "testcase.bypass.conflict.001", utest_tc_init, utest_tc_cleanup, 10); diff --git a/components/drivers/serial/utest/bypass/bypass_lower_run.c b/components/drivers/serial/utest/bypass/bypass_lower_run.c new file mode 100644 index 0000000000..5cfb3cc197 --- /dev/null +++ b/components/drivers/serial/utest/bypass/bypass_lower_run.c @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2024-11-20 zhujiale the first version + */ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +static struct rt_serial_device* _serial0; +static int cnt = 0; + +#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x))) +#define UART_FR(base) __REG32(base + 0x18) +#define UART_DR(base) __REG32(base + 0x00) +#define UARTFR_TXFF 0x20 + +struct hw_uart_device +{ + rt_size_t hw_base; + rt_size_t irqno; +}; + +static int uart_putc(struct rt_serial_device* serial, char c) +{ + struct hw_uart_device* uart; + + RT_ASSERT(serial != RT_NULL); + uart = (struct hw_uart_device*)serial->parent.user_data; + + while (UART_FR(uart->hw_base) & UARTFR_TXFF); + UART_DR(uart->hw_base) = c; + + return 1; +} + +static rt_err_t utest_lower_run_test2(struct rt_serial_device* serial, char ch, void* data) +{ + static rt_uint8_t num = 0; + num++; + uassert_true(ch == ('a' + num)); + return RT_EOK; +} + +static int utest_getc_2(struct rt_serial_device* serial) +{ + static rt_uint8_t num = 0; + if (num == 20) + return -1; + num++; + return 'a' + num; +} + +static const struct rt_uart_ops _utest_ops2 = +{ + RT_NULL, + RT_NULL, + uart_putc, + utest_getc_2, +}; + +static rt_err_t utest_lower_run(struct rt_serial_device* serial, char ch, void* data) +{ + uassert_true(ch == 'a'); + cnt++; + return RT_EOK; +} + + +static int utest_getc(struct rt_serial_device* serial) +{ + static rt_uint8_t num = 0; + if (num == 10) + return -1; + num++; + return 'a'; +} + +static const struct rt_uart_ops _utest_ops = +{ + RT_NULL, + RT_NULL, + uart_putc, + utest_getc, +}; +static void bypass_lower_001(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + _serial0->ops = &_utest_ops; + rt_bypass_lower_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run, RT_NULL); + + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + rt_thread_mdelay(100); + uassert_true(cnt == 10); + _serial0->ops = tmp; + rt_bypass_lower_unregister(_serial0, RT_BYPASS_MAX_LEVEL); +} + +static void bypass_lower_002(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + _serial0->ops = &_utest_ops2; + rt_bypass_lower_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run_test2, RT_NULL); + + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + rt_thread_mdelay(100); + uassert_true(cnt == 10); + _serial0->ops = tmp; + rt_bypass_lower_unregister(_serial0, RT_BYPASS_MAX_LEVEL); +} + +static rt_err_t utest_tc_init(void) +{ + _serial0 = (struct rt_serial_device*)rt_console_get_device(); + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void _testcase(void) +{ + UTEST_UNIT_RUN(bypass_lower_001); + UTEST_UNIT_RUN(bypass_lower_002); +} + +UTEST_TC_EXPORT(_testcase, "testcase.bypass.lower.001", utest_tc_init, utest_tc_cleanup, 10); diff --git a/components/drivers/serial/utest/bypass/bypass_register.c b/components/drivers/serial/utest/bypass/bypass_register.c new file mode 100644 index 0000000000..df4e07b9aa --- /dev/null +++ b/components/drivers/serial/utest/bypass/bypass_register.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2024-11-20 zhujiale the first version + */ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +static struct rt_serial_device* _serial0; +static struct rt_spinlock lock; + +static rt_err_t utest_001_run(struct rt_serial_device* serial, char ch, void* data) +{ + return 0; +} + +static void thread_serial_register1(void* parameter) +{ + for (int i = 2; i < 10; i += 2) + { + rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL); + } +} + +static void thread_serial_register_upper(void* parameter) +{ + for (int i = 1; i < 10; i++) + { + rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL); + } +} + +static void thread_serial_register_lower(void* parameter) +{ + for (int i = 1; i < 10; i++) + { + rt_bypass_lower_register(_serial0, "test", i, utest_001_run, RT_NULL); + } +} + +static void bypass_register_001(void) +{ + rt_thread_t t1 = rt_thread_create("serial_register", thread_serial_register1, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + rt_bypass_upper_register(_serial0, "test", 0, utest_001_run, RT_NULL); + rt_thread_startup(t1); + for (int i = 1; i < 10; i += 2) + { + rt_bypass_upper_register(_serial0, "test", i, utest_001_run, RT_NULL); + } + rt_thread_mdelay(1000); + rt_list_t* node = _serial0->bypass->upper_h->head.next; + for (int i = 0; i < 10;i++) + { + rt_list_t* next = node->next; + struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node); + uassert_true(temp->level == i); + rt_bypass_upper_unregister(_serial0, temp->level); + node = next; + } + +} + +static void bypass_register_002(void) +{ + rt_thread_t t1 = rt_thread_create("serial_register", thread_serial_register_upper, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + rt_thread_t t2 = rt_thread_create("serial_register", thread_serial_register_lower, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + rt_bypass_upper_register(_serial0, "test", 0, utest_001_run, RT_NULL); + + rt_thread_startup(t1); + rt_thread_startup(t2); + + rt_thread_mdelay(1000); + rt_list_t* node = _serial0->bypass->upper_h->head.next; + for (int i = 0; i < 10;i++) + { + rt_list_t* next = node->next; + struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node); + uassert_true(temp->level == i); + rt_bypass_upper_unregister(_serial0, temp->level); + node = next; + } + node = _serial0->bypass->lower_h->head.next; + for (int i = 1; i < 10;i++) + { + rt_list_t* next = node->next; + struct rt_serial_bypass_func* temp = rt_container_of(node, struct rt_serial_bypass_func, node); + uassert_true(temp->level == i); + rt_bypass_lower_unregister(_serial0, temp->level); + node = next; + } +} + +static rt_err_t utest_tc_init(void) +{ + _serial0 = (struct rt_serial_device*)rt_console_get_device(); + rt_spin_lock_init(&lock); + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void _testcase(void) +{ + UTEST_UNIT_RUN(bypass_register_001); + UTEST_UNIT_RUN(bypass_register_002); +} + +UTEST_TC_EXPORT(_testcase, "testcase.bypass.register.001", utest_tc_init, utest_tc_cleanup, 10); diff --git a/components/drivers/serial/utest/bypass/bypass_upper_run.c b/components/drivers/serial/utest/bypass/bypass_upper_run.c new file mode 100644 index 0000000000..c5c1499687 --- /dev/null +++ b/components/drivers/serial/utest/bypass/bypass_upper_run.c @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2024-11-20 zhujiale the first version + */ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +static struct rt_serial_device* _serial0; +static int cnt; + +#define __REG32(x) (*((volatile unsigned int*)((rt_ubase_t)x))) +#define UART_FR(base) __REG32(base + 0x18) +#define UART_DR(base) __REG32(base + 0x00) +#define UARTFR_TXFF 0x20 +static rt_err_t utest_upper_run(struct rt_serial_device* serial, char ch, void* data) +{ + uassert_true(ch == 'a'); + cnt++; + return RT_EOK; +} + +static int utest_getc(struct rt_serial_device* serial) +{ + static rt_uint8_t num = 0; + if (num == 10) + return -1; + num++; + return 'a'; +} + +struct hw_uart_device +{ + rt_size_t hw_base; + rt_size_t irqno; +}; + +static int uart_putc(struct rt_serial_device* serial, char c) +{ + struct hw_uart_device* uart; + + RT_ASSERT(serial != RT_NULL); + uart = (struct hw_uart_device*)serial->parent.user_data; + + while (UART_FR(uart->hw_base) & UARTFR_TXFF); + UART_DR(uart->hw_base) = c; + + return 1; +} + +static const struct rt_uart_ops _utest_ops = +{ + RT_NULL, + RT_NULL, + uart_putc, + utest_getc, +}; + +static rt_err_t utest_lower_run_test2(struct rt_serial_device* serial, char ch, void* data) +{ + static rt_uint8_t num = 0; + num++; + uassert_true(ch == ('a' + num)); + return RT_EOK; +} + +static int utest_getc_2(struct rt_serial_device* serial) +{ + static rt_uint8_t num = 0; + if (num == 20) + return -1; + num++; + return 'a' + num; +} + +static const struct rt_uart_ops _utest_ops2 = +{ + RT_NULL, + RT_NULL, + uart_putc, + utest_getc_2, +}; +static void bypass_upper_001(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + _serial0->ops = &_utest_ops; + rt_bypass_upper_register(_serial0, "utest", RT_BYPASS_LEVEL_1, utest_upper_run, RT_NULL); + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + uassert_true(cnt == 10); + _serial0->ops = tmp; + rt_bypass_upper_unregister(_serial0, RT_BYPASS_LEVEL_1); +} + +static void bypass_upper_002(void) +{ + const struct rt_uart_ops* tmp = _serial0->ops; + _serial0->ops = &_utest_ops2; + rt_bypass_upper_register(_serial0, "utest", RT_BYPASS_MAX_LEVEL, utest_lower_run_test2, RT_NULL); + + rt_hw_serial_isr(_serial0, RT_SERIAL_EVENT_RX_IND); + rt_thread_mdelay(100); + uassert_true(cnt == 10); + _serial0->ops = tmp; + rt_bypass_upper_unregister(_serial0, RT_BYPASS_MAX_LEVEL); +} + +static rt_err_t utest_tc_init(void) +{ + _serial0 = (struct rt_serial_device*)rt_console_get_device(); + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void _testcase(void) +{ + UTEST_UNIT_RUN(bypass_upper_001); + UTEST_UNIT_RUN(bypass_upper_002); +} + +UTEST_TC_EXPORT(_testcase, "testcase.bypass.upper.001", utest_tc_init, utest_tc_cleanup, 10); diff --git a/components/drivers/serial/utest/v2/README.md b/components/drivers/serial/utest/v2/README.md new file mode 100644 index 0000000000..1a94c20a01 --- /dev/null +++ b/components/drivers/serial/utest/v2/README.md @@ -0,0 +1,154 @@ +## 1、介绍 + +该目录下 c 文件是新版本串口的测试用例，在 `examples/utest/testcases/drivers/serial_v2` 目录结构里，该测试用例用来测试串口的各个操作模式是否正常工作。 + +## 2、 文件说明 + +| 文件 | 描述 | +| ---------------- | ----------------------------------------- | +| uart_rxb_txb.c | 串口接收阻塞和发送阻塞模式 的测试用例 | +| uart_rxb_txnb.c | 串口接收阻塞和发送非阻塞模式 的测试用例 | +| uart_rxnb_txb.c | 串口接收非阻塞和发送阻塞模式 的测试用例 | +| uart_rxnb_txnb.c | 串口接收非阻塞和发送非阻塞模式 的测试用例 | +| uart_blocking_tx.c| 串口阻塞发送模式 的测试 | +| uart_blocking_rx.c| 串口阻塞接收模式 的测试 | +| uart_nonblocking_tx.c| 串口非阻塞发送模式 的测试 | +| uart_nonblocking_rx.c | 串口非阻塞接收模式 的测试 | +| uart_flush_rx | 刷新接收缓冲区的测试 | +| uart_flush_txb | 阻塞模式下刷新发送缓冲区的测试 | +| uart_flush_txnb | 非阻塞模式下刷新发送缓冲区的测试 | +| uart_timeout_rxb_txb | 串口 发送 / 接收 超时的测试 | +| uart_overflow_rxb_txb | 串口溢出处理的测试 | +| uart_get_unread_bytes_count | 获取串口接收缓冲区中的数据长度的测试 | +| uart_posix_nonblock | posix非阻塞测试 | +| uart_posix_echo_block | posix阻塞echo测试 | + +## 3、软硬件环境 + +硬件上需要支持 RT-Thread 的完整版操作系统，版本为4.0.4及以上，且硬件有串口硬件外设，软件上需要支持 内核接口、IPC 、Device 框架。 + +## 4、测试项 + +### 4.1 测试说明 + +上文所提及的模式是指串口使用时的操作模式，不涉及硬件的工作模式的配置情况（硬件工作模式一般有轮询POLL、中断INT、DMA），因此使用时需要结合具体的硬件工作模式去配置使用。例如 发送阻塞和接收非阻塞模式 ，这个测试有很多种硬件配置，配置情况例如：DMA发送阻塞和DMA接收非阻塞，INT发送阻塞和DMA接收非阻塞，POLL发送阻塞和DMA接收非阻塞等等。因此通过排列组合后的测试场景有4*9=36种，有意义的组合方式为20种。如下表： + + +| 接收非阻塞 | 发送阻塞 | 组合 | 有意义的组合方式 | +| ---------- | -------- | ----------------- | ---------------- | +| POLL | POLL | RX_POLL + TX_POLL | | +| | INT | RX_POLL + TX_INT | | +| | DMA | RX_POLL + TX_DMA | | +| INT | POLL | RX_INT + TX_POLL | ✔ | +| | INT | RX_INT + TX_INT | ✔ | +| | DMA | RX_INT + TX_DMA | ✔ | +| DMA | POLL | RX_DMA + TX_POLL | ✔ | +| | INT | RX_DMA + TX_INT | ✔ | +| | DMA | RX_DMA + TX_DMA | ✔ | + +| 接收非阻塞 | 发送非阻塞 | 组合 | 有意义的组合方式 | +| ---------- | ---------- | ----------------- | ---------------- | +| POLL | POLL | RX_POLL + TX_POLL | | +| | INT | RX_POLL + TX_INT | | +| | DMA | RX_POLL + TX_DMA | | +| INT | POLL | RX_INT + TX_POLL | | +| | INT | RX_INT + TX_INT | ✔ | +| | DMA | RX_INT + TX_DMA | ✔ | +| DMA | POLL | RX_DMA + TX_POLL | | +| | INT | RX_DMA + TX_INT | ✔ | +| | DMA | RX_DMA + TX_DMA | ✔ | + +| 接收阻塞 | 发送阻塞 | 组合 | 有意义的组合方式 | +| -------- | -------- | ----------------- | ---------------- | +| POLL | POLL | RX_POLL + TX_POLL | | +| | INT | RX_POLL + TX_INT | | +| | DMA | RX_POLL + TX_DMA | | +| INT | POLL | RX_INT + TX_POLL | ✔ | +| | INT | RX_INT + TX_INT | ✔ | +| | DMA | RX_INT + TX_DMA | ✔ | +| DMA | POLL | RX_DMA + TX_POLL | ✔ | +| | INT | RX_DMA + TX_INT | ✔ | +| | DMA | RX_DMA + TX_DMA | ✔ | + +| 接收阻塞 | 发送非阻塞 | 组合 | 有意义的组合方式 | +| -------- | ---------- | ----------------- | ---------------- | +| POLL | POLL | RX_POLL + TX_POLL | | +| | INT | RX_POLL + TX_INT | | +| | DMA | RX_POLL + TX_DMA | | +| INT | POLL | RX_INT + TX_POLL | | +| | INT | RX_INT + TX_INT | ✔ | +| | DMA | RX_INT + TX_DMA | ✔ | +| DMA | POLL | RX_DMA + TX_POLL | | +| | INT | RX_DMA + TX_INT | ✔ | +| | DMA | RX_DMA + TX_DMA | ✔ | + +需要解释的是，为什么会存在无意义的组合模式，举个例子，非阻塞模式下，肯定是不会出现POLL（轮询）方式的，因为POLL方式已经表明是阻塞方式了。 +该测试用例在测试多种组合时，需要通过更改`rtconfig.h`文件对硬件模式进行静态配置。 + +### 4.2 测试条件 + +**短接串口的发送TX引脚和接收RX引脚，完成自发自收的回路**。 + +大致的测试思路: + +>发送测试流程 : +>>1. 先关闭串口,再以需要测试的模式打开. +>>2. 然后依次发送 UART_SEND_TIMES * （1000以内的随机数）个数据. +>>3. 打印记录的数据,通过LOG日志的时钟周期来反应发送效率, 通过成功发送的数据量来反应是否产生丢包问题. +> +>接收测试流程 : +>>1. 先关闭串口,再以需要测试的模式打开. +>>2. 然后以此接收 同发送测试流程一致的 UART_SEND_TIMES *（1000以内随机数）个数据 +>>3. 接收的同时记录成功接收的数据数量 +>>4. 打印记录的数据, 通过现实成功接收的数据量与串口发送的数据量做对比,来验证是否出现丢包问题 + +## 5、配置 + +使用该测试用例需要在 `env` 工具的 `menuconfig` 中做相关配置，配置如下所示（使用 RT-Thread-Studio 的配置路径一致 ）： + +``` +RT-Thread Utestcases ---> + [*] RT-Thread Utestcases ---> + Utest Serial Testcase ---> + [*] Serial testcase ---> + the device name for serial test: uart2 (选择测试的串口) + (128)the rx buffer size for serial test (测试串口rx缓冲区大小) + (128)the tx buffer size for serial test (测试串口tx缓冲区大小) + (100)the number of iterations for the test routine. (测试例程的迭代次数) + [*] Serial posix testcase ---> + the device name for serial posix test: dev/uart2 (posix测试的串口) + (100)the number of iterations for the posix test routine. (posix测试例程的迭代次数) +``` + +## 6、使用 + +\- 编译下载。 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_rxb_txb` 运行串口接收阻塞和发送阻塞测试用例。 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_blocking_tx` 运行串口阻塞发送测试 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_blocking_rx` 运行串口阻塞接收测试 + +\- 在 MSH 中输入 `utest_run testcases.drivers.uart_nonblocking_tx` 运行串口非阻塞发送测试 + +其余同理，可在函数内部查看命令。 + +如果仅仅配置了 `Serial testcase` 相关的测试用例，则直接输入 `utest_run *` 运行即可将上述测试用例按序测试。 + +## 7、注意事项 + +\- 需配置正确的测试用例。 + +\- 如有需要，可开启 ULOG 查看测试用例日志信息。 + +\- 需在 MSH 中输入正确的命令行。 + +\- 该测试用例需要结合硬件具体的工作模式（POLL 、INT、DMA）进行测试，而硬件工作模式只能选择一种，因此需要在 `rtconfig.h` 中对串口相应的宏进行配置，来选择不同的工作模式去进行测试。 + diff --git a/components/drivers/serial/utest/v2/SConscript b/components/drivers/serial/utest/v2/SConscript new file mode 100644 index 0000000000..7ef99d20b7 --- /dev/null +++ b/components/drivers/serial/utest/v2/SConscript @@ -0,0 +1,18 @@ +Import('rtconfig') +from building import * + +cwd = GetCurrentDir() +src = Glob('*.c') + +path = [cwd] + +if GetDepend(['UTEST_SERIAL_POSIX_TC']): + src += Glob('posix/*.c') + +if GetDepend(['UTEST_SERIAL_QEMU_TC']): + src += Glob('qemu/*.c') + +group = DefineGroup('utestcases', src, depend = ['UTEST_SERIAL_TC'], CPPPATH = path) + +Return('group') + diff --git a/components/drivers/serial/utest/v2/posix/uart_posix_echo_block.c b/components/drivers/serial/utest/v2/posix/uart_posix_echo_block.c new file mode 100644 index 0000000000..bb273f1328 --- /dev/null +++ b/components/drivers/serial/utest/v2/posix/uart_posix_echo_block.c @@ -0,0 +1,281 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <termios.h> +#include <fcntl.h> +#include <unistd.h> + + +#ifdef UTEST_SERIAL_TC + +static int32_t serial_fd; +static rt_uint8_t uart_over_flag; +static rt_bool_t uart_result = RT_TRUE; + +static rt_err_t uart_find(void) +{ + serial_fd = open(RT_SERIAL_POSIX_TC_DEVICE_NAME, O_RDWR); + if (serial_fd == -1) + { + LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME); + return -RT_ERROR; + } + + return RT_EOK; +} + +static rt_err_t configureSerial(int fd, int baud) +{ + int32_t result = 0; + struct termios options; + + result = tcgetattr(fd, &options); // 获取当前端口的属性 + if (result == -1) + return -RT_ERROR; + + // 设置波特率 + result = cfsetispeed(&options, baud); // 设置输入波特率 + if (result == -1) + return -RT_ERROR; + + result = cfsetospeed(&options, baud); // 设置输出波特率 + if (result == -1) + return -RT_ERROR; + + // 设置数据位 + options.c_cflag &= ~PARENB; // 清除校验位，无校验 + options.c_cflag &= ~CSTOPB; // 仅一个停止位 + options.c_cflag &= ~CSIZE; // 清除掩码 + options.c_cflag |= CS8; // 8位数据 + + // 设置无流控 + options.c_cflag &= ~CRTSCTS; // 不使用硬件流控制 + options.c_iflag &= ~(IXON | IXOFF | IXANY); // 不使用软件流控制 + + // 使能接收器和发送器 + options.c_cflag |= CLOCAL | CREAD; + + // 设置行终止符 + options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + + // 应用属性 + result = tcsetattr(fd, TCSANOW, &options); + if (result == -1) + return -RT_ERROR; + + return RT_EOK; +} + +static void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_uint16_t send_len; + + rt_uint32_t i = 0; + send_len = *(rt_uint16_t *)parameter; + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + /* send buffer */ + if (write(serial_fd, uart_write_buffer, send_len) != send_len) + { + LOG_E("device write failed\r\n"); + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint16_t rev_len; + + rev_len = *(rt_uint16_t *)parameter; + rt_uint8_t *uart_write_buffer; + 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 = read(serial_fd, (void *)uart_write_buffer, rev_len); + if (cnt == 0) + { + continue; + } + + if (fisrt_flag != RT_TRUE) + { + if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0]) + { + LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + else + { + fisrt_flag = RT_FALSE; + } + + for (i = 0; i < cnt - 1; i++) + { + if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1]) + { + LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]); + + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + all_receive_length += cnt; + if (all_receive_length >= rev_len) + break; + else + last_old_data = uart_write_buffer[cnt - 1]; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint16_t length) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + int flags = 0; + uart_over_flag = RT_FALSE; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + result = configureSerial(serial_fd, B115200); + if (result == -1) + { + goto __exit; + } + + + flags = fcntl(serial_fd, F_GETFL, 0); + if (flags == -1) + { + goto __exit; + } + + result = fcntl(serial_fd, F_SETFL, flags & ~O_NONBLOCK); + if (result == -1) + { + goto __exit; + } + + + thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 4, 10); + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 5, 10); + if ((thread_send != RT_NULL) && (thread_recv != RT_NULL)) + { + rt_thread_startup(thread_send); + rt_thread_startup(thread_recv); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } + +__exit: + rt_thread_mdelay(5); + close(serial_fd); + uart_over_flag = RT_FALSE; + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t times = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + + while (RT_SERIAL_POSIX_TC_SEND_ITERATIONS - times) + { + num = (rand() % 1000) + 1; + if (uart_api(num) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] times testing.", num, ++times); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + close(serial_fd); + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(tc_uart_api); +} + +UTEST_TC_EXPORT(testcase, "testcases.drivers.uart_posix_echo_block", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/posix/uart_posix_nonblock.c b/components/drivers/serial/utest/v2/posix/uart_posix_nonblock.c new file mode 100644 index 0000000000..943b47b345 --- /dev/null +++ b/components/drivers/serial/utest/v2/posix/uart_posix_nonblock.c @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <termios.h> +#include <fcntl.h> +#include <unistd.h> + + +#ifdef UTEST_SERIAL_TC + +static int32_t serial_fd; + +static rt_err_t uart_find(void) +{ + serial_fd = open(RT_SERIAL_POSIX_TC_DEVICE_NAME, O_RDWR); + if (serial_fd == -1) + { + LOG_E("find %s device failed!\n", RT_SERIAL_TC_DEVICE_NAME); + return -RT_ERROR; + } + + return RT_EOK; +} + +static rt_err_t configureSerial(int fd, int baud) +{ + int32_t result = 0; + struct termios options; + + result = tcgetattr(fd, &options); // 获取当前端口的属性 + if (result == -1) + return -RT_ERROR; + + // 设置波特率 + result = cfsetispeed(&options, baud); // 设置输入波特率 + if (result == -1) + return -RT_ERROR; + + result = cfsetospeed(&options, baud); // 设置输出波特率 + if (result == -1) + return -RT_ERROR; + + // 设置数据位 + options.c_cflag &= ~PARENB; // 清除校验位，无校验 + options.c_cflag &= ~CSTOPB; // 仅一个停止位 + options.c_cflag &= ~CSIZE; // 清除掩码 + options.c_cflag |= CS8; // 8位数据 + + // 设置无流控 + options.c_cflag &= ~CRTSCTS; // 不使用硬件流控制 + options.c_iflag &= ~(IXON | IXOFF | IXANY); // 不使用软件流控制 + + // 使能接收器和发送器 + options.c_cflag |= CLOCAL | CREAD; + + // 设置行终止符 + options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + + // 应用属性 + result = tcsetattr(fd, TCSANOW, &options); + if (result == -1) + return -RT_ERROR; + + return RT_EOK; +} + +static rt_err_t uart_api() +{ + rt_err_t result = RT_EOK; + rt_uint8_t *uart_write_buffer; + rt_int32_t cnt, i, send_size; + int flags = 0; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + result = configureSerial(serial_fd, B115200); + if (result == -1) + { + goto __exit; + } + + flags = fcntl(serial_fd, F_GETFL, 0); + if (flags == -1) + { + goto __exit; + } + + result = fcntl(serial_fd, F_SETFL, flags | O_NONBLOCK); + if (result == -1) + { + goto __exit; + } + + uart_write_buffer = (rt_uint8_t *)rt_malloc(100); + + for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++) + { + send_size = 1; + cnt = write(serial_fd, uart_write_buffer, send_size); + if (cnt != send_size) + { + result = -RT_ERROR; + goto __exit; + } + + rt_thread_mdelay(2); + cnt = read(serial_fd, (void *)uart_write_buffer, send_size); + if (cnt != send_size) + { + result = -RT_ERROR; + goto __exit; + } + + send_size = rand() % 30 + 1; + cnt = write(serial_fd, uart_write_buffer, send_size); + if (cnt != send_size) + { + LOG_E("uart write failed %d %d", cnt, send_size); + result = -RT_ERROR; + goto __exit; + } + + rt_thread_mdelay(send_size * 0.0868 + 5); + cnt = read(serial_fd, (void *)uart_write_buffer, send_size + 1); + if (cnt != send_size) + { + LOG_E("uart read failed %d %d", cnt, send_size); + result = -RT_ERROR; + goto __exit; + } + } + +__exit: + rt_thread_mdelay(5); + if (uart_write_buffer) + rt_free(uart_write_buffer); + close(serial_fd); + 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) +{ + close(serial_fd); + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(tc_uart_api); +} + +UTEST_TC_EXPORT(testcase, "testcases.drivers.uart_posix_nonblock", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/qemu/uart_qemu_echo.c b/components/drivers/serial/utest/v2/qemu/uart_qemu_echo.c new file mode 100644 index 0000000000..5fdaa97793 --- /dev/null +++ b/components/drivers/serial/utest/v2/qemu/uart_qemu_echo.c @@ -0,0 +1,171 @@ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +#define UART_SEND_TIMES 100 +#define UART_TEST_NUMBER 6 + + +#ifdef UTEST_SERIAL_TC +#define echo_test_buffer_size (1024) + +static rt_device_t u1serial; +static rt_device_t u2serial; + +static rt_uint32_t u2rx_length = 0; +static rt_uint32_t u2tx_length = 0; + +static rt_uint32_t u1rx_length = 0; +static rt_uint32_t u1tx_length = 0; + +static rt_uint8_t uart_over_flag = RT_FALSE; + +static void echo_test_u2_thread_entry(void *parameter) +{ + char *uart_name = "uart2"; + + u2serial = rt_device_find(uart_name); + if (!u2serial) + { + LOG_I("find %s failed!\n", uart_name); + return; + } + + rt_uint8_t *rx_buffer = rt_malloc(echo_test_buffer_size); + + rt_device_open(u2serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING); + + rt_ssize_t buf_datalen = 0; + while (1) + { + rt_device_control(u2serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen); + int32_t recbLen = rt_device_read(u2serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1); + if (recbLen > 0) + { + u2rx_length += recbLen; + u2tx_length += rt_device_write(u2serial, 0, rx_buffer, recbLen); + + if (uart_over_flag) + break; + } + } + rt_free(rx_buffer); +} + +static void echo_test_u1_thread_entry(void *parameter) +{ + rt_uint8_t *rx_buffer = rt_malloc(echo_test_buffer_size); + rt_ssize_t buf_datalen = 0; + while (1) + { + rt_device_control(u1serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen); + int32_t recbLen = rt_device_read(u1serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1); + if (recbLen > 0) + { + u1rx_length += recbLen; + if (uart_over_flag) + break; + } + } + + rt_free(rx_buffer); +} + + +static rt_bool_t echo_test() +{ + rt_bool_t result = RT_TRUE; + char *uart_name = "uart1"; + u1serial = rt_device_find(uart_name); + if (!u1serial) + { + LOG_I("find %s failed!\n", uart_name); + return RT_FALSE; + } + + rt_uint8_t *tx_buffer = rt_malloc(echo_test_buffer_size); + + rt_device_open(u1serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING); + rt_thread_startup(rt_thread_create("serial2", echo_test_u2_thread_entry, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 4, 5)); + rt_thread_startup(rt_thread_create("serial1", echo_test_u1_thread_entry, RT_NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 5)); + + uint32_t sendTotalCount = 0; + srand(rt_tick_get()); + for (uint32_t count = 0; count < 1000; count++) + { + // Indefinite length of data is sent + uint32_t sendCount = rand() % echo_test_buffer_size; + + + u1tx_length += rt_device_write(u1serial, 0, tx_buffer, sendCount); + sendTotalCount += sendCount; + + // Wait for the cross-send to complete + rt_thread_mdelay(UART_SEND_TIMES); + + if (count % 50 == 0) + { + LOG_I("echo, uart2: tx: %ld, rx: %ld", u2tx_length, u2rx_length); + LOG_I("echo, uart1: tx: %ld, rx: %ld", u1tx_length, u1rx_length); + if (u2tx_length != u2rx_length || u1tx_length != u1rx_length || u2tx_length != u1tx_length) + { + LOG_I("echo test error!!!"); + result = RT_FALSE; + break; + } + + if (u2tx_length != sendTotalCount) + { + LOG_I("u2tx_length != sendTotalCount echo test error!!!"); + result = RT_FALSE; + break; + } + } + } + + uart_over_flag = RT_TRUE; + // Notify the thread to exit + rt_device_write(u1serial, 0, tx_buffer, echo_test_buffer_size); + rt_thread_mdelay(30); + + { + rt_device_t uart_dev = rt_device_find("uart2"); + while (rt_device_close(uart_dev) != -RT_ERROR); + } + { + rt_device_t uart_dev = rt_device_find("uart1"); + while (rt_device_close(uart_dev) != -RT_ERROR); + } + rt_free(tx_buffer); + return result; +} + +static void uart_test_nonblocking_tx(void) +{ + uassert_true(echo_test()); +} + +static rt_err_t utest_tc_init(void) +{ + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + u1serial = RT_NULL; + u2serial = RT_NULL; + u2rx_length = 0; + u2tx_length = 0; + u1rx_length = 0; + u1tx_length = 0; + uart_over_flag = RT_FALSE; + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(uart_test_nonblocking_tx); +} +UTEST_TC_EXPORT(testcase, "testcases.drivers.uart_qemu_echo", utest_tc_init, utest_tc_cleanup, 10); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_blocking_rx.c b/components/drivers/serial/utest/v2/uart_blocking_rx.c new file mode 100644 index 0000000000..1d2ab4e586 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_blocking_rx.c @@ -0,0 +1,88 @@ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +#ifdef UTEST_SERIAL_TC + +static rt_bool_t block_read(rt_device_t uart_dev) +{ + rt_size_t total_length, recv_length; + char uart_read_buffer[1024], log_buffer[64]; + + /* make sure device is closed and reopen it */ + while (rt_device_close(uart_dev) != -RT_ERROR); + rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_RX_BLOCKING); + + rt_sprintf(log_buffer, "\nBLOCKING READ BEGIN, PLEASE SEND SOME DATAS\n"); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + total_length = 0; + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer)); + total_length += recv_length; + + 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)); + + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer)); + total_length += recv_length; + + 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)); + + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer)); + total_length += recv_length; + + 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)); + + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer)); + total_length += recv_length; + + 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)); + + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, rt_strlen(log_buffer)); + total_length += recv_length; + + 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_sprintf(log_buffer, "BLOCKING READ END"); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + return RT_TRUE; +} + +static void uart_test_blocking_rx(void) +{ + rt_device_t uart_dev; + uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME); + uassert_not_null(uart_dev); + + uassert_true(block_read(uart_dev)); +} + +static rt_err_t utest_tc_init(void) +{ + 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(uart_test_blocking_rx); +} +UTEST_TC_EXPORT(testcase, "uart_blocking_rx", utest_tc_init, utest_tc_cleanup, 10); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_blocking_tx.c b/components/drivers/serial/utest/v2/uart_blocking_tx.c new file mode 100644 index 0000000000..51eda0feb9 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_blocking_tx.c @@ -0,0 +1,119 @@ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +#define UART_SEND_TIMES 100 +#define UART_TEST_NUMBER 6 + + +#ifdef UTEST_SERIAL_TC + +static rt_bool_t block_write(rt_device_t uart_dev) +{ + rt_size_t i, wr_sz, index, write_num_array[UART_TEST_NUMBER], total_write_num[UART_TEST_NUMBER]; + rt_tick_t tick1, tick2, tick_array[UART_TEST_NUMBER]; + char uart_write_buffer[1024]; + + for (i = 0; i < 1024; i++) + uart_write_buffer[i] = '0' + (i % 49); + + /* make sure device is closed and reopen it */ + while (rt_device_close(uart_dev) != -RT_ERROR); + rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING); + + LOG_D("\nBLOCKING WRITE BEGIN\n"); + + index = 0; + wr_sz = 0; + tick1 = rt_tick_get(); + for (i = 0; i < UART_SEND_TIMES; i++) + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 1024); + + tick2 = rt_tick_get(); + total_write_num[index] = UART_SEND_TIMES * 1024; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 8); + tick2 = rt_tick_get(); + + total_write_num[index] = 8; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 32); + tick2 = rt_tick_get(); + + total_write_num[index] = 32; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 128); + tick2 = rt_tick_get(); + + total_write_num[index] = 128; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 512); + tick2 = rt_tick_get(); + + total_write_num[index] = 512; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + wr_sz += rt_device_write(uart_dev, 0, uart_write_buffer, 1024); + tick2 = rt_tick_get(); + + total_write_num[index] = 1024; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + LOG_D("\nBLOCKING_TX END\n"); + 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(10); + } + + return RT_TRUE; +} + +static void uart_test_blocking_tx(void) +{ + rt_device_t uart_dev; + uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME); + uassert_not_null(uart_dev); + + uassert_true(block_write(uart_dev)); +} + +static rt_err_t utest_tc_init(void) +{ + 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(uart_test_blocking_tx); +} +UTEST_TC_EXPORT(testcase, "uart_blocking_tx", utest_tc_init, utest_tc_cleanup, 10); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_flush_rx.c b/components/drivers/serial/utest/v2/uart_flush_rx.c new file mode 100644 index 0000000000..3d529d7f46 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_flush_rx.c @@ -0,0 +1,174 @@ +/* + * 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 test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t send_size) +{ + 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."); + return -RT_ERROR; + } + + rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL); + if (0 != rt_device_read(&serial->parent, 0, uart_write_buffer, 1)) + { + LOG_E("read failed."); + 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; +} + +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; +#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_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(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++) + { + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE + RT_SERIAL_TC_RXBUF_SIZE * (rand() % 5))) + { + LOG_E("test_item failed."); + result = -RT_ERROR; + goto __exit; + } + + if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5))) + { + 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_flush_rx", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_flush_txb.c b/components/drivers/serial/utest/v2/uart_flush_txb.c new file mode 100644 index 0000000000..2bc45a3250 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_flush_txb.c @@ -0,0 +1,188 @@ +/* + * 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 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) + { + expect_time -= send_size / 384; + } + + 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)) + { + 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; + } + else + { + 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; +} + +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 * 5 + 10; +#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_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + return RT_FALSE; + } + + rt_uint8_t *uart_write_buffer; + rt_uint32_t i; + 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); + + srand(rt_tick_get()); + for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++) + { + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_TXBUF_SIZE * (rand() % 6))) + { + result = -RT_ERROR; + goto __exit; + } + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_TXBUF_SIZE * (rand() % 6) + 1)) + { + result = -RT_ERROR; + goto __exit; + } + + if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_TXBUF_SIZE * 5))) + { + 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) +{ + 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_flush_txb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_flush_txnb.c b/components/drivers/serial/utest/v2/uart_flush_txnb.c new file mode 100644 index 0000000000..1fcfc2b99d --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_flush_txnb.c @@ -0,0 +1,188 @@ +/* + * 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 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) + { + expect_time -= send_size / 384; + } + + 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)) + { + 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; + } + else + { + 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; +} + +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_RXBUF_SIZE * 5 + 10; +#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; + rt_int32_t tx_timeout = 1; + 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); + + srand(rt_tick_get()); + for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++) + { + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * (rand() % 6))) + { + result = -RT_ERROR; + goto __exit; + } + + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * (rand() % 6) + 1)) + { + result = -RT_ERROR; + goto __exit; + } + + if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5))) + { + 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) +{ + 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_flush_txnb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_get_unread_bytes_count.c b/components/drivers/serial/utest/v2/uart_get_unread_bytes_count.c new file mode 100644 index 0000000000..f63f663ad3 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_get_unread_bytes_count.c @@ -0,0 +1,145 @@ +/* + * 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_uint8_t uart_over_flag = RT_FALSE; + +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 test_item(rt_uint8_t *uart_write_buffer, rt_uint32_t size) +{ + rt_uint32_t old_tick; + rt_ssize_t send_len; + rt_ssize_t buf_data_len; + + send_len = rt_device_write(&serial->parent, 0, uart_write_buffer, size); + if (size > RT_SERIAL_TC_RXBUF_SIZE) + { + size = RT_SERIAL_TC_RXBUF_SIZE; + } + + rt_thread_delay(5); + rt_device_control(&serial->parent, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_data_len); + if (size != buf_data_len) + { + return -RT_ERROR; + } + + rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL); + + rt_device_control(&serial->parent, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_data_len); + if (0 != buf_data_len) + { + return -RT_ERROR; + } + + 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; +#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_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(RT_SERIAL_TC_TXBUF_SIZE * 5 + 1); + + srand(rt_tick_get()); + for (i = 0; i < RT_SERIAL_TC_SEND_ITERATIONS; i++) + { + if (RT_EOK != test_item(uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE + RT_SERIAL_TC_RXBUF_SIZE * (rand() % 5))) + { + result = -RT_ERROR; + goto __exit; + } + + if (RT_EOK != test_item(uart_write_buffer, rand() % (RT_SERIAL_TC_RXBUF_SIZE * 5))) + { + 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) +{ + 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_get_unread_bytes_count", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_nonblocking_rx.c b/components/drivers/serial/utest/v2/uart_nonblocking_rx.c new file mode 100644 index 0000000000..d67a5d17ae --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_nonblocking_rx.c @@ -0,0 +1,98 @@ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +#ifdef UTEST_SERIAL_TC + +static rt_bool_t nonblock_read(rt_device_t uart_dev) +{ + rt_size_t total_length, recv_length; + char uart_read_buffer[1024], log_buffer[64]; + + /* make sure device is closed and reopen it */ + while (rt_device_close(uart_dev) != -RT_ERROR); + rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING); + + rt_sprintf(log_buffer, "\nNONBLOCKING READ BEGIN, PLEASE SEND SOME DATAS\n"); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + total_length = 0; + rt_device_write(uart_dev, 0, "5\n", 2); + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256); + rt_device_write(uart_dev, 0, uart_read_buffer, 256); + total_length += recv_length; + + rt_sprintf(log_buffer, "\nnonblock : %d bytes read, total: %d \n", recv_length, total_length); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + rt_device_write(uart_dev, 0, "4\n", 2); + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256); + rt_device_write(uart_dev, 0, uart_read_buffer, 256); + total_length += recv_length; + + rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + rt_device_write(uart_dev, 0, "3\n", 2); + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 256); + rt_device_write(uart_dev, 0, uart_read_buffer, 256); + total_length += recv_length; + + rt_sprintf(log_buffer, "\nnonblock : %d bytes read, total: %d \n", recv_length, total_length); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + rt_device_write(uart_dev, 0, "2\n", 2); + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 128); + rt_device_write(uart_dev, 0, uart_read_buffer, 128); + total_length += recv_length; + + rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + rt_device_write(uart_dev, 0, "1\n", 2); + recv_length = 0; + recv_length = rt_device_read(uart_dev, -1, uart_read_buffer, 128); + rt_device_write(uart_dev, 0, uart_read_buffer, 128); + total_length += recv_length; + + rt_sprintf(log_buffer, "\nnonblock : %d bytes read , total: %d \n", recv_length, total_length); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + rt_sprintf(log_buffer, "BLOCKING READ END"); + rt_device_write(uart_dev, 0, log_buffer, rt_strlen(log_buffer)); + + return RT_TRUE; +} + +static void uart_test_nonblocking_rx(void) +{ + rt_device_t uart_dev; + uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME); + uassert_not_null(uart_dev); + + uassert_true(nonblock_read(uart_dev)); +} + +static rt_err_t utest_tc_init(void) +{ + 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(uart_test_nonblocking_rx); +} +UTEST_TC_EXPORT(testcase, "uart_nonblocking_rx", utest_tc_init, utest_tc_cleanup, 10); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_nonblocking_tx.c b/components/drivers/serial/utest/v2/uart_nonblocking_tx.c new file mode 100644 index 0000000000..cd1297d919 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_nonblocking_tx.c @@ -0,0 +1,124 @@ +#include <rtthread.h> +#include <rtdevice.h> +#include "utest.h" + +#define UART_SEND_TIMES 100 +#define UART_TEST_NUMBER 6 + + +#ifdef UTEST_SERIAL_TC + +static rt_bool_t nonblock_write(rt_device_t uart_dev) +{ + rt_size_t wr_sz = 0, tmp = 0, i, write_num_array[UART_TEST_NUMBER], total_write_num[UART_TEST_NUMBER], index; + rt_tick_t tick1, tick2, tick_array[UART_TEST_NUMBER]; + rt_uint8_t uart_write_buffer[1024]; + + for (i = 0; i < 1024; i++) + uart_write_buffer[i] = '0' + (i % 50); + + /* make sure device is closed and reopen it */ + while (rt_device_close(uart_dev) != -RT_ERROR); + uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME); + rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_NON_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING); + + LOG_D("\nNONBLOCKING WRITE BEGIN\n"); + + index = 0; + tmp = 0; + tick1 = rt_tick_get(); + for (i = 0; i < UART_SEND_TIMES; i++) + { + wr_sz = 0; + while (wr_sz < 1024) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 1024 - wr_sz); + tmp += wr_sz; + } + tick2 = rt_tick_get(); + total_write_num[index] = UART_SEND_TIMES * 1024; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = tmp; + + wr_sz = 0; + tick1 = rt_tick_get(); + while (wr_sz < 8) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 8 - wr_sz); + tick2 = rt_tick_get(); + total_write_num[index] = 8; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + while (wr_sz < 32) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 32 - wr_sz); + tick2 = rt_tick_get(); + total_write_num[index] = 32; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + while (wr_sz < 128) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 128 - wr_sz); + tick2 = rt_tick_get(); + total_write_num[index] = 128; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + while (wr_sz < 512) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 512 - wr_sz); + tick2 = rt_tick_get(); + total_write_num[index] = 512; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + wr_sz = 0; + tick1 = rt_tick_get(); + while (wr_sz < 1024) + wr_sz += rt_device_write(uart_dev, 0, &uart_write_buffer[wr_sz], 1024 - wr_sz); + tick2 = rt_tick_get(); + total_write_num[index] = 1024; + tick_array[index] = tick2 - tick1; + write_num_array[index++] = wr_sz; + + LOG_D("\nNONBLOCKING_TX END\n"); + 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(10); + } + + return RT_TRUE; +} + +static void uart_test_nonblocking_tx(void) +{ + rt_device_t uart_dev; + uart_dev = rt_device_find(RT_SERIAL_TC_DEVICE_NAME); + uassert_not_null(uart_dev); + + uassert_true(nonblock_write(uart_dev)); +} + +static rt_err_t utest_tc_init(void) +{ + 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(uart_test_nonblocking_tx); +} +UTEST_TC_EXPORT(testcase, "uart_nonblocking_tx", utest_tc_init, utest_tc_cleanup, 10); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_overflow_rxb_txb.c b/components/drivers/serial/utest/v2/uart_overflow_rxb_txb.c new file mode 100644 index 0000000000..e5a354f75a --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_overflow_rxb_txb.c @@ -0,0 +1,251 @@ +/* + * 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_uint8_t uart_over_flag = RT_FALSE; +static rt_bool_t uart_result = RT_TRUE; + +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 void uart_send_entry(void *parameter) +{ + rt_uint32_t send_len; + rt_uint8_t *uart_write_buffer = RT_NULL; + rt_uint32_t i = 0; + send_len = *(rt_uint32_t *)parameter; + + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + /* send buffer */ + if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len) + { + LOG_E("device write failed\r\n"); + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint32_t rev_len; + 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(rev_len + 1); + + while (1) + { + cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE); + if (cnt != RT_SERIAL_TC_RXBUF_SIZE) + { + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + +#ifdef RT_SERIAL_BUF_STRATEGY_DROP + for (i = 0; i < cnt; i++) + { + if (uart_write_buffer[i] != i) + { + LOG_E("Read Different data2 -> former data: %x, current data: %x.", uart_write_buffer[i], i); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } +#else + for (i = cnt - 1; i >= 0; i--) + { + if (uart_write_buffer[i] != ((rev_len - (cnt - i)) % (UINT8_MAX + 1))) + { + LOG_E("Read Different data2 -> former data: %x, current data: %x.", uart_write_buffer[i], ((rev_len - (cnt - i)) % (UINT8_MAX + 1))); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } +#endif /* RT_SERIAL_BUF_STRATEGY_DROP */ + break; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint32_t length) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + uart_over_flag = RT_FALSE; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + /* 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; +#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_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + rt_int32_t timeout = 5000; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout); + + thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 2048, RT_THREAD_PRIORITY_MAX - 4, 10); + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + if ((thread_send != RT_NULL) && (thread_recv != RT_NULL)) + { + rt_thread_startup(thread_send); + /* waiting for data transmission to complete*/ + rt_thread_mdelay(length * 0.0868 + 10); + rt_thread_startup(thread_recv); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } +__exit: + rt_device_close(&serial->parent); + rt_thread_mdelay(5); + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t count = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + srand(rt_tick_get()); + while (RT_SERIAL_TC_SEND_ITERATIONS - count) + { + num = (rand() % RT_SERIAL_TC_RXBUF_SIZE) + 1; + if (uart_api(num + RT_SERIAL_TC_RXBUF_SIZE) == RT_EOK) + LOG_I("data_lens [%3d], it is correct to read and write data. [%d] count testing.", num, ++count); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_overflow_rxb_txb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_rxb_txb.c b/components/drivers/serial/utest/v2/uart_rxb_txb.c new file mode 100644 index 0000000000..b844cc05b2 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_rxb_txb.c @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdlib.h> + + +#ifdef UTEST_SERIAL_TC + +static struct rt_serial_device *serial; +static rt_uint8_t uart_over_flag; +static rt_bool_t uart_result = RT_TRUE; + +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 void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_uint16_t send_len; + + rt_uint32_t i = 0; + send_len = *(rt_uint16_t *)parameter; + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + /* send buffer */ + if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len) + { + LOG_E("device write failed\r\n"); + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint16_t rev_len; + + rev_len = *(rt_uint16_t *)parameter; + rt_uint8_t *uart_write_buffer; + 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); + if (cnt == 0) + { + continue; + } + + if (fisrt_flag != RT_TRUE) + { + if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0]) + { + LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + else + { + fisrt_flag = RT_FALSE; + } + + for (i = 0; i < cnt - 1; i++) + { + if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1]) + { + LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]); + + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + all_receive_length += cnt; + if (all_receive_length >= rev_len) + break; + else + last_old_data = uart_write_buffer[cnt - 1]; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint16_t length) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + uart_over_flag = RT_FALSE; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + /* 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; + +#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_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + rt_int32_t timeout = 5000; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout); + + thread_send = rt_thread_create("uart_send", uart_send_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 4, 10); + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &length, 1024, RT_THREAD_PRIORITY_MAX - 5, 10); + if ((thread_send != RT_NULL) && (thread_recv != RT_NULL)) + { + rt_thread_startup(thread_send); + rt_thread_startup(thread_recv); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } + +__exit: + rt_device_close(&serial->parent); + rt_thread_mdelay(5); + uart_over_flag = RT_FALSE; + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t count = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + srand(rt_tick_get()); + while (RT_SERIAL_TC_SEND_ITERATIONS - count) + { + num = (rand() % 1000) + 1; + if (uart_api(num) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_rxb_txb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_rxb_txnb.c b/components/drivers/serial/utest/v2/uart_rxb_txnb.c new file mode 100644 index 0000000000..b5e4fe6e86 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_rxb_txnb.c @@ -0,0 +1,292 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdlib.h> + + +#ifdef UTEST_SERIAL_TC + +static struct rt_serial_device *serial; +static rt_sem_t tx_sem; +static rt_uint8_t uart_over_flag; +static rt_bool_t uart_result = RT_TRUE; + +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 uart_tx_completion(rt_device_t device, void *buffer) +{ + rt_sem_release(tx_sem); + + return RT_EOK; +} + +static void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_uint16_t send_len, len = 0; + rt_err_t result; + + rt_uint32_t i = 0; + send_len = *(rt_uint16_t *)parameter; + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + /* send buffer */ + while (send_len - len) + { + len += rt_device_write(&serial->parent, 0, uart_write_buffer + len, send_len - len); + result = rt_sem_take(tx_sem, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + LOG_E("take sem err in send."); + } + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint16_t rev_len; + + rev_len = *(rt_uint16_t *)parameter; + rt_uint8_t *uart_write_buffer; + 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); + if (cnt != rev_len) + { + continue; + } + + if (fisrt_flag != RT_TRUE) + { + if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0]) + { + LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + else + { + fisrt_flag = RT_FALSE; + } + + for (i = 0; i < cnt - 1; i++) + { + if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1]) + { + LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]); + + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + all_receive_length += cnt; + if (all_receive_length >= rev_len) + break; + else + last_old_data = uart_write_buffer[cnt - 1]; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint16_t test_buf) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + uart_over_flag = RT_FALSE; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + tx_sem = rt_sem_create("tx_sem", 0, RT_IPC_FLAG_PRIO); + if (tx_sem == RT_NULL) + { + LOG_E("Init sem failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + /* 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; + +#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."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + rt_int32_t timeout = 5000; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout); + + /* set receive callback function */ + result = rt_device_set_tx_complete(&serial->parent, uart_tx_completion); + if (result != RT_EOK) + { + goto __exit; + } + + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10); + thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10); + + if (thread_send != RT_NULL && thread_recv != RT_NULL) + { + rt_thread_startup(thread_recv); + rt_thread_startup(thread_send); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } +__exit: + if (tx_sem) + rt_sem_delete(tx_sem); + + rt_device_close(&serial->parent); + rt_thread_mdelay(5); + uart_over_flag = RT_FALSE; + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t count = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + srand(rt_tick_get()); + while (RT_SERIAL_TC_SEND_ITERATIONS - count) + { + num = (rand() % 1000) + 1; + if (uart_api(num) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + tx_sem = RT_NULL; + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_rxb_txnb", utest_tc_init, utest_tc_cleanup, 30); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_rxnb_txb.c b/components/drivers/serial/utest/v2/uart_rxnb_txb.c new file mode 100644 index 0000000000..6dc7f68346 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_rxnb_txb.c @@ -0,0 +1,295 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdlib.h> + + +#ifdef UTEST_SERIAL_TC + +static struct rt_serial_device *serial; +static rt_sem_t rx_sem; +static rt_uint8_t uart_over_flag; +static rt_bool_t uart_result = RT_TRUE; + +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 uart_rx_indicate(rt_device_t device, rt_size_t size) +{ + rt_sem_release(rx_sem); + + return RT_EOK; +} + +static void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_uint16_t send_len; + + rt_uint32_t i = 0; + send_len = *(rt_uint16_t *)parameter; + + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + + /* send buffer */ + if (rt_device_write(&serial->parent, 0, uart_write_buffer, send_len) != send_len) + { + LOG_E("device write failed\r\n"); + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint16_t rev_len; + + rev_len = *(rt_uint16_t *)parameter; + rt_uint8_t *uart_write_buffer; + 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) + { + rt_err_t result; + + result = rt_sem_take(rx_sem, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + LOG_E("take sem err in recv."); + } + + cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len); + if (cnt == 0) + { + continue; + } + + if (fisrt_flag != RT_TRUE) + { + if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0]) + { + LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + else + { + fisrt_flag = RT_FALSE; + } + + for (i = 0; i < cnt - 1; i++) + { + if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1]) + { + LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]); + + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + all_receive_length += cnt; + if (all_receive_length >= rev_len) + break; + else + last_old_data = uart_write_buffer[cnt - 1]; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint16_t test_buf) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + rx_sem = rt_sem_create("rx_sem", 0, RT_IPC_FLAG_PRIO); + if (rx_sem == RT_NULL) + { + LOG_E("Init sem failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + /* 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; + +#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_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + uart_result = RT_FALSE; + rt_sem_delete(rx_sem); + return -RT_ERROR; + } + + rt_int32_t timeout = 5000; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout); + + /* set receive callback function */ + result = rt_device_set_rx_indicate(&serial->parent, uart_rx_indicate); + if (result != RT_EOK) + { + goto __exit; + } + + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10); + thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10); + + if (thread_send != RT_NULL && thread_recv != RT_NULL) + { + rt_thread_startup(thread_recv); + rt_thread_startup(thread_send); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } +__exit: + if (rx_sem) + rt_sem_delete(rx_sem); + rt_device_close(&serial->parent); + rt_thread_mdelay(5); + uart_over_flag = RT_FALSE; + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t count = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + srand(rt_tick_get()); + while (RT_SERIAL_TC_SEND_ITERATIONS - count) + { + num = (rand() % 1000) + 1; + if (uart_api(num) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + rx_sem = RT_NULL; + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_rxnb_txb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_rxnb_txnb.c b/components/drivers/serial/utest/v2/uart_rxnb_txnb.c new file mode 100644 index 0000000000..66c40c103d --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_rxnb_txnb.c @@ -0,0 +1,323 @@ +/* + * Copyright (c) 2006-2024 RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-06-16 KyleChan the first version + */ + +#include <rtthread.h> +#include "utest.h" +#include <rtdevice.h> +#include <stdlib.h> + + +#ifdef UTEST_SERIAL_TC + +static struct rt_serial_device *serial; +static rt_sem_t tx_sem; +static rt_sem_t rx_sem; +static rt_uint8_t uart_over_flag; +static rt_bool_t uart_result = RT_TRUE; + +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 uart_tx_completion(rt_device_t device, void *buffer) +{ + rt_sem_release(tx_sem); + return RT_EOK; +} + +static rt_err_t uart_rx_indicate(rt_device_t device, rt_size_t size) +{ + rt_sem_release(rx_sem); + return RT_EOK; +} + +static void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_uint16_t send_len, len = 0; + rt_err_t result; + + rt_uint32_t i = 0; + send_len = *(rt_uint16_t *)parameter; + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(send_len); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + rt_memset(uart_write_buffer, 0, send_len); + + for (i = 0; i < send_len; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + /* send buffer */ + while (send_len - len) + { + len += rt_device_write(&serial->parent, 0, uart_write_buffer + len, send_len - len); + result = rt_sem_take(tx_sem, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + LOG_E("take sem err in send."); + } + } + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint16_t rev_len; + + rev_len = *(rt_uint16_t *)parameter; + rt_uint8_t *uart_write_buffer; + 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) + { + rt_err_t result; + + result = rt_sem_take(rx_sem, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + LOG_E("take sem err in recv."); + } + + cnt = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, rev_len); + if (cnt == 0) + { + continue; + } + + if (fisrt_flag != RT_TRUE) + { + if ((rt_uint8_t)(last_old_data + 1) != uart_write_buffer[0]) + { + LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, uart_write_buffer[0]); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + else + { + fisrt_flag = RT_FALSE; + } + + for (i = 0; i < cnt - 1; i++) + { + if ((rt_uint8_t)(uart_write_buffer[i] + 1) != uart_write_buffer[i + 1]) + { + LOG_E("Read Different data -> former data: %x, current data: %x.", uart_write_buffer[i], uart_write_buffer[i + 1]); + + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + } + all_receive_length += cnt; + if (all_receive_length >= rev_len) + break; + else + last_old_data = uart_write_buffer[cnt - 1]; + } + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_err_t uart_api(rt_uint16_t test_buf) +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + rt_err_t result = RT_EOK; + uart_over_flag = RT_FALSE; + + result = uart_find(); + if (result != RT_EOK) + { + return -RT_ERROR; + } + + rx_sem = rt_sem_create("rx_sem", 0, RT_IPC_FLAG_PRIO); + if (rx_sem == RT_NULL) + { + LOG_E("Init rx_sem failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + tx_sem = rt_sem_create("tx_sem", 0, RT_IPC_FLAG_PRIO); + if (tx_sem == RT_NULL) + { + LOG_E("Init tx_sem failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + /* 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; + +#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_NON_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + uart_result = RT_FALSE; + return -RT_ERROR; + } + + rt_int32_t timeout = 5000; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&timeout); + + /* set receive callback function */ + result = rt_device_set_tx_complete(&serial->parent, uart_tx_completion); + if (result != RT_EOK) + { + goto __exit; + } + + result = rt_device_set_rx_indicate(&serial->parent, uart_rx_indicate); + if (result != RT_EOK) + { + goto __exit; + } + + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 5, 10); + thread_send = rt_thread_create("uart_send", uart_send_entry, &test_buf, 1024, RT_THREAD_PRIORITY_MAX - 4, 10); + + if (thread_send != RT_NULL && thread_recv != RT_NULL) + { + rt_thread_startup(thread_recv); + rt_thread_startup(thread_send); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } +__exit: + if (tx_sem) + rt_sem_delete(tx_sem); + + if (rx_sem) + rt_sem_delete(rx_sem); + + rt_device_close(&serial->parent); + rt_thread_mdelay(5); + uart_over_flag = RT_FALSE; + return result; +} + +static void tc_uart_api(void) +{ + rt_uint32_t count = 0; + rt_uint16_t num = 0; + rt_uint32_t i = 0; + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_TXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_TXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + for (i = 1; i < 10; i++) + { + if (uart_api(RT_SERIAL_TC_RXBUF_SIZE * i + i % 2) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", RT_SERIAL_TC_RXBUF_SIZE * i + i % 2, ++count); + else + { + LOG_E("uart test error"); + goto __exit; + } + } + + srand(rt_tick_get()); + while (RT_SERIAL_TC_SEND_ITERATIONS - count) + { + num = (rand() % 1000) + 1; + if (uart_api(num) == RT_EOK) + LOG_I("data_lens [%4d], it is correct to read and write data. [%d] count testing.", num, ++count); + else + { + LOG_E("uart test error"); + break; + } + } + +__exit: + uassert_true(uart_result == 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) +{ + tx_sem = RT_NULL; + uart_result = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_rxnb_txnb", utest_tc_init, utest_tc_cleanup, 30); + +#endif diff --git a/components/drivers/serial/utest/v2/uart_timeout_rxb.c b/components/drivers/serial/utest/v2/uart_timeout_rxb.c new file mode 100644 index 0000000000..7c936bbfe8 --- /dev/null +++ b/components/drivers/serial/utest/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 */ diff --git a/components/drivers/serial/utest/v2/uart_timeout_rxb_txb.c b/components/drivers/serial/utest/v2/uart_timeout_rxb_txb.c new file mode 100644 index 0000000000..7defec6803 --- /dev/null +++ b/components/drivers/serial/utest/v2/uart_timeout_rxb_txb.c @@ -0,0 +1,221 @@ +/* + * 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_bool_t uart_result = RT_TRUE; +static rt_uint8_t uart_write_flag = RT_TRUE; +static rt_uint8_t uart_over_flag = RT_FALSE; + +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 void uart_send_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer = RT_NULL; + rt_uint32_t i = 0; + + /* assign send buffer */ + uart_write_buffer = (rt_uint8_t *)rt_malloc(RT_SERIAL_TC_RXBUF_SIZE); + if (uart_write_buffer == RT_NULL) + { + LOG_E("Without spare memory for uart dma!"); + uart_result = RT_FALSE; + return; + } + + for (i = 0; i < RT_SERIAL_TC_RXBUF_SIZE; i++) + { + uart_write_buffer[i] = (rt_uint8_t)i; + } + + while (1) + { + if (uart_write_flag == RT_FALSE) + break; + + rt_device_write(&serial->parent, 0, uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE / 3); + rt_thread_mdelay(40); + } + + rt_free(uart_write_buffer); +} + +static void uart_rec_entry(void *parameter) +{ + rt_uint8_t *uart_write_buffer; + rt_tick_t old_tick; + rt_tick_t tick_diff; + rt_ssize_t recv_len; + rt_uint32_t i; + rt_int32_t timeout = 0; + 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); + + uart_write_flag = RT_TRUE; + for (i = 0; i < 10; i++) + { + rt_device_control(&serial->parent, RT_SERIAL_CTRL_RX_FLUSH, RT_NULL); + old_tick = rt_tick_get(); + recv_len = rt_device_read(&serial->parent, 0, (void *)uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE); + tick_diff = rt_tick_get() - old_tick; + if (tick_diff > 100 + 1 || tick_diff < 100) + { + LOG_E("timeout_test: recv_size [%d], RX block time [%d], expect_time [100 - 101]", recv_len, tick_diff); + uart_write_flag = RT_FALSE; + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + rt_thread_mdelay(60); + return; + } + + LOG_I("timeout_test: RX block time [%d], expect_time [100 - 101]", tick_diff); + } + uart_write_flag = RT_FALSE; + + rt_thread_mdelay(60); + timeout = 10; + rt_device_control(&serial->parent, RT_SERIAL_CTRL_SET_TX_TIMEOUT, (void *)&timeout); + + for (i = 0; i < 10; i++) + { + old_tick = rt_tick_get(); + recv_len = rt_device_write(&serial->parent, 0, uart_write_buffer, RT_SERIAL_TC_RXBUF_SIZE * 10); + tick_diff = rt_tick_get() - old_tick; + if (tick_diff > 10 + 1 || tick_diff < 10) + { + LOG_E("timeout_test: recv_size [%d], TX block time [%d], expect_time [10 - 11]", recv_len, tick_diff); + uart_result = RT_FALSE; + rt_free(uart_write_buffer); + return; + } + + LOG_I("timeout_test: TX block time [%d], expect_time [10 - 11]", tick_diff); + rt_device_control(&serial->parent, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL); + } + + rt_free(uart_write_buffer); + uart_over_flag = RT_TRUE; +} + +static rt_bool_t uart_api() +{ + rt_thread_t thread_send = RT_NULL; + rt_thread_t thread_recv = RT_NULL; + 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; +#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_BLOCKING); + if (result != RT_EOK) + { + LOG_E("Open uart device failed."); + return RT_FALSE; + } + + thread_send = rt_thread_create("uart_send", uart_send_entry, NULL, 2048, RT_THREAD_PRIORITY_MAX - 4, 10); + thread_recv = rt_thread_create("uart_recv", uart_rec_entry, NULL, 2048, RT_THREAD_PRIORITY_MAX - 5, 10); + + if ((thread_send != RT_NULL) && (thread_recv != RT_NULL)) + { + rt_thread_startup(thread_send); + rt_thread_startup(thread_recv); + } + else + { + result = -RT_ERROR; + goto __exit; + } + + while (1) + { + if (uart_result != RT_TRUE) + { + LOG_E("The test for uart dma is failure."); + result = -RT_ERROR; + goto __exit; + } + if (uart_over_flag == RT_TRUE) + { + goto __exit; + } + /* waiting for test over */ + rt_thread_mdelay(5); + } + +__exit: + 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) +{ + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + uart_result = RT_TRUE; + uart_write_flag = RT_TRUE; + uart_over_flag = RT_FALSE; + 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_txb", utest_tc_init, utest_tc_cleanup, 30); + +#endif /* TC_UART_USING_TC */ diff --git a/components/drivers/serial/utest/v2/uart_timeout_txb.c b/components/drivers/serial/utest/v2/uart_timeout_txb.c new file mode 100644 index 0000000000..9af3f40b3e --- /dev/null +++ b/components/drivers/serial/utest/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 */ |