Mirrors_Framework/rt-thread
1
0
Fork 0
mirror of https://github.com/RT-Thread/rt-thread.git synced 2026-02-05 15:23:03 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

utest: serial: move from examples to components/drivers/serial

Browse Source 
Signed-off-by: Chen Wang <unicorn_wang@outlook.com>
This commit is contained in:
Chen Wang
2025-10-10 14:56:32 +08:00
committed by R b b666
parent e72182d7f4
commit 3b97667323
31 changed files with 32 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
components/drivers/serial/SConscript
View File

@@ -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')

56
components/drivers/serial/utest/Kconfig Normal file
View File

@@ -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

15
components/drivers/serial/utest/SConscript Normal file
View File

@@ -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')

11
components/drivers/serial/utest/bypass/SConscript Normal file
View File

@@ -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')

185
components/drivers/serial/utest/bypass/bypass_conflict.c Normal file
View File

@@ -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);

133
components/drivers/serial/utest/bypass/bypass_lower_run.c Normal file
View File

@@ -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);

116
components/drivers/serial/utest/bypass/bypass_register.c Normal file
View File

@@ -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);

129
components/drivers/serial/utest/bypass/bypass_upper_run.c Normal file
View File

@@ -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);

154
components/drivers/serial/utest/v2/README.md Normal file
View File

@@ -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` 中对串口相应的宏进行配置，来选择不同的工作模式去进行测试。

18
components/drivers/serial/utest/v2/SConscript Normal file
View File

@@ -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')

281
components/drivers/serial/utest/v2/posix/uart_posix_echo_block.c Normal file
View File

@@ -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 */

182
components/drivers/serial/utest/v2/posix/uart_posix_nonblock.c Normal file
View File

@@ -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 */

171
components/drivers/serial/utest/v2/qemu/uart_qemu_echo.c Normal file
View File

@@ -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

88
components/drivers/serial/utest/v2/uart_blocking_rx.c Normal file
View File

@@ -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

119
components/drivers/serial/utest/v2/uart_blocking_tx.c Normal file
View File

@@ -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

174
components/drivers/serial/utest/v2/uart_flush_rx.c Normal file
View File

@@ -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 */

188
components/drivers/serial/utest/v2/uart_flush_txb.c Normal file
View File

@@ -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 */

188
components/drivers/serial/utest/v2/uart_flush_txnb.c Normal file
View File

@@ -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 */

145
components/drivers/serial/utest/v2/uart_get_unread_bytes_count.c Normal file
View File

@@ -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 */

98
components/drivers/serial/utest/v2/uart_nonblocking_rx.c Normal file
View File

@@ -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

124
components/drivers/serial/utest/v2/uart_nonblocking_tx.c Normal file
View File

@@ -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

251
components/drivers/serial/utest/v2/uart_overflow_rxb_txb.c Normal file
View File

@@ -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 */

259
components/drivers/serial/utest/v2/uart_rxb_txb.c Normal file
View File

@@ -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 */

292
components/drivers/serial/utest/v2/uart_rxb_txnb.c Normal file
View File

@@ -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

295
components/drivers/serial/utest/v2/uart_rxnb_txb.c Normal file
View File

@@ -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 */

323
components/drivers/serial/utest/v2/uart_rxnb_txnb.c Normal file
View File

@@ -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

139
components/drivers/serial/utest/v2/uart_timeout_rxb.c Normal file
View File

@@ -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 */

221
components/drivers/serial/utest/v2/uart_timeout_rxb_txb.c Normal file
View File

@@ -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 */

129
components/drivers/serial/utest/v2/uart_timeout_txb.c Normal file
View File

@@ -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 */