mirror of
https://github.com/RT-Thread/rt-thread.git
synced 2026-10-02 14:23:19 +08:00
utest: serial: move from examples to components/drivers/serial
Signed-off-by: Chen Wang <unicorn_wang@outlook.com>
This commit is contained in:
Chen Wang
R b b666
@@ -1,8 +0,0 @@
|
||||
menu "Serial-Bypass Testcase"
|
||||
|
||||
config UTEST_SERIAL_BYPASS
|
||||
bool "Serial testcase"
|
||||
default n
|
||||
depends on RT_USING_SERIAL_BYPASS
|
||||
|
||||
endmenu
|
||||
@@ -1,11 +0,0 @@
|
||||
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')
|
||||
@@ -1,185 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
@@ -1,133 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
@@ -1,116 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
@@ -1,129 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
@@ -1,51 +0,0 @@
|
||||
menu "Utest Serial Testcase"
|
||||
|
||||
config UTEST_SERIAL_TC
|
||||
bool "Serial testcase"
|
||||
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
|
||||
@@ -1,154 +0,0 @@
|
||||
## 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` 中对串口相应的宏进行配置，来选择不同的工作模式去进行测试。
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
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')
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,182 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
@@ -1,171 +0,0 @@
|
||||
#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
|
||||
@@ -1,88 +0,0 @@
|
||||
#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
|
||||
@@ -1,119 +0,0 @@
|
||||
#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
|
||||
@@ -1,174 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
@@ -1,188 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
@@ -1,188 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
@@ -1,145 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
@@ -1,98 +0,0 @@
|
||||
#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
|
||||
@@ -1,124 +0,0 @@
|
||||
#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
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,139 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,129 +0,0 @@
|
||||
/*
|
||||
* 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 */
|
||||
Reference in New Issue
Block a user