原始版本
This commit is contained in:
冯佳
15
RT_Thread/examples/utest/testcases/drivers/SConscript
Normal file
15
RT_Thread/examples/utest/testcases/drivers/SConscript
Normal file
@ -0,0 +1,15 @@
|
||||
# RT-Thread building script for bridge
|
||||
|
||||
import os
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
objs = []
|
||||
list = os.listdir(cwd)
|
||||
|
||||
for d in list:
|
||||
path = os.path.join(cwd, d)
|
||||
if os.path.isfile(os.path.join(path, 'SConscript')):
|
||||
objs = objs + SConscript(os.path.join(d, 'SConscript'))
|
||||
|
||||
Return('objs')
|
||||
11
RT_Thread/examples/utest/testcases/drivers/ipc/Kconfig
Normal file
11
RT_Thread/examples/utest/testcases/drivers/ipc/Kconfig
Normal file
@ -0,0 +1,11 @@
|
||||
menu "Utest IPC Testcase"
|
||||
|
||||
config UTEST_COMPLETION_TC
|
||||
bool "rt_completion testcase"
|
||||
default n
|
||||
|
||||
config UTEST_WORKQUEUE_TC
|
||||
bool "rt_workqueue testcase"
|
||||
default n
|
||||
|
||||
endmenu
|
||||
16
RT_Thread/examples/utest/testcases/drivers/ipc/SConscript
Normal file
16
RT_Thread/examples/utest/testcases/drivers/ipc/SConscript
Normal file
@ -0,0 +1,16 @@
|
||||
Import('rtconfig')
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = []
|
||||
CPPPATH = [cwd]
|
||||
|
||||
if GetDepend(['UTEST_COMPLETION_TC']):
|
||||
src += ['completion_tc.c', 'completion_timeout_tc.c']
|
||||
|
||||
if GetDepend(['UTEST_WORKQUEUE_TC']):
|
||||
src += ['workqueue_tc.c']
|
||||
|
||||
group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
199
RT_Thread/examples/utest/testcases/drivers/ipc/completion_tc.c
Normal file
199
RT_Thread/examples/utest/testcases/drivers/ipc/completion_tc.c
Normal file
@ -0,0 +1,199 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024-04-30 Shell init ver.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Test Case for rt_completion API
|
||||
*
|
||||
* The test simulates a producer-consumer interaction where a producer thread
|
||||
* generates data, and a consumer thread consumes the data after waiting for its
|
||||
* availability using rt_completion synchronization primitives.
|
||||
*
|
||||
* Test Criteria:
|
||||
* - The producer should correctly increment the test data and signal
|
||||
* completion.
|
||||
* - The consumer should correctly wait for data update, consume it, and signal
|
||||
* completion.
|
||||
* - Data integrity should be maintained between producer and consumer.
|
||||
* - Synchronization is properly done so both can see consistent data.
|
||||
* - Random latency is introduced to simulate racing scenarios.
|
||||
*/
|
||||
|
||||
#define TEST_LATENCY_TICK (1)
|
||||
#define TEST_LOOP_TIMES (60 * RT_TICK_PER_SECOND)
|
||||
#define TEST_PROGRESS_ON (RT_TICK_PER_SECOND)
|
||||
|
||||
#include "utest.h"
|
||||
|
||||
#include <ipc/completion.h>
|
||||
#include <rtthread.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static struct rt_completion _prod_completion;
|
||||
static struct rt_completion _cons_completion;
|
||||
static int _test_data = 0;
|
||||
static rt_atomic_t _progress_counter;
|
||||
static struct rt_semaphore _thr_exit_sem;
|
||||
|
||||
static void done_safely(struct rt_completion *completion)
|
||||
{
|
||||
rt_err_t error;
|
||||
|
||||
/* Signal completion */
|
||||
error = rt_completion_wakeup(completion);
|
||||
|
||||
/* try again if failed to produce */
|
||||
if (error == -RT_EEMPTY)
|
||||
{
|
||||
rt_thread_yield();
|
||||
}
|
||||
else if (error)
|
||||
{
|
||||
uassert_false(0);
|
||||
rt_thread_delete(rt_thread_self());
|
||||
}
|
||||
}
|
||||
|
||||
static void wait_safely(struct rt_completion *completion)
|
||||
{
|
||||
rt_err_t error;
|
||||
do
|
||||
{
|
||||
error = rt_completion_wait_flags(completion, RT_WAITING_FOREVER,
|
||||
RT_INTERRUPTIBLE);
|
||||
if (error)
|
||||
{
|
||||
uassert_true(error == -RT_EINTR);
|
||||
rt_thread_yield();
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
} while (1);
|
||||
}
|
||||
|
||||
static void producer_thread_entry(void *parameter)
|
||||
{
|
||||
for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
|
||||
{
|
||||
/* Produce data */
|
||||
_test_data++;
|
||||
|
||||
/* notify consumer */
|
||||
done_safely(&_prod_completion);
|
||||
|
||||
/* Delay before producing next data */
|
||||
rt_thread_delay(TEST_LATENCY_TICK);
|
||||
|
||||
/* sync with consumer */
|
||||
wait_safely(&_cons_completion);
|
||||
}
|
||||
|
||||
rt_sem_release(&_thr_exit_sem);
|
||||
}
|
||||
|
||||
static void _wait_until_edge(void)
|
||||
{
|
||||
rt_tick_t entry_level, current;
|
||||
rt_base_t random_latency;
|
||||
|
||||
entry_level = rt_tick_get();
|
||||
do
|
||||
{
|
||||
current = rt_tick_get();
|
||||
} while (current == entry_level);
|
||||
|
||||
/* give a random latency for test */
|
||||
random_latency = rand();
|
||||
entry_level = current;
|
||||
for (size_t i = 0; i < random_latency; i++)
|
||||
{
|
||||
current = rt_tick_get();
|
||||
if (current != entry_level) break;
|
||||
}
|
||||
}
|
||||
|
||||
static void consumer_thread_entry(void *parameter)
|
||||
{
|
||||
int local_test_data = 0;
|
||||
|
||||
rt_thread_startup(parameter);
|
||||
|
||||
for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
|
||||
{
|
||||
/* add more random case for test */
|
||||
_wait_until_edge();
|
||||
|
||||
/* Wait for data update */
|
||||
wait_safely(&_prod_completion);
|
||||
|
||||
/* Consume data */
|
||||
if (local_test_data + 1 != _test_data)
|
||||
{
|
||||
LOG_I("local test data is %d, shared test data is %d",
|
||||
local_test_data, _test_data);
|
||||
uassert_true(0);
|
||||
}
|
||||
else if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0)
|
||||
{
|
||||
uassert_true(1);
|
||||
}
|
||||
|
||||
local_test_data = _test_data;
|
||||
done_safely(&_cons_completion);
|
||||
}
|
||||
|
||||
rt_sem_release(&_thr_exit_sem);
|
||||
}
|
||||
|
||||
static void testcase(void)
|
||||
{
|
||||
/* Initialize completion object */
|
||||
rt_completion_init(&_prod_completion);
|
||||
rt_completion_init(&_cons_completion);
|
||||
|
||||
/* Create producer and consumer threads */
|
||||
rt_thread_t producer_thread =
|
||||
rt_thread_create("producer", producer_thread_entry, RT_NULL,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
|
||||
rt_thread_t consumer_thread =
|
||||
rt_thread_create("consumer", consumer_thread_entry, producer_thread,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
|
||||
uassert_true(producer_thread != RT_NULL);
|
||||
uassert_true(consumer_thread != RT_NULL);
|
||||
|
||||
LOG_I("Summary:\n"
|
||||
"\tTest times: %ds(%d)",
|
||||
TEST_LOOP_TIMES / RT_TICK_PER_SECOND, TEST_LOOP_TIMES);
|
||||
|
||||
rt_thread_startup(consumer_thread);
|
||||
|
||||
for (size_t i = 0; i < 2; i++)
|
||||
{
|
||||
rt_sem_take(&_thr_exit_sem, RT_WAITING_FOREVER);
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
_test_data = 0;
|
||||
_progress_counter = 0;
|
||||
rt_sem_init(&_thr_exit_sem, "test", 0, RT_IPC_FLAG_PRIO);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
rt_sem_detach(&_thr_exit_sem);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(testcase, "testcases.drivers.ipc.rt_completion.basic",
|
||||
utest_tc_init, utest_tc_cleanup, 10);
|
||||
@ -0,0 +1,213 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024-04-30 Shell init ver.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Test Case for rt_completion API
|
||||
*
|
||||
* The test simulates a producer-consumer interaction where a producer thread
|
||||
* generates data, and a consumer thread consumes the data after waiting for its
|
||||
* availability using rt_completion synchronization primitives.
|
||||
*
|
||||
* Test Criteria:
|
||||
* - The producer produces data correctly and notifies the consumer thread.
|
||||
* - The consumer receives data correctly and acknowledges receipt to the
|
||||
* producer.
|
||||
* - The producer and consumer threads synchronize their operations effectively.
|
||||
* - Verify the correctness of data production and consumption between producer
|
||||
* and consumer threads.
|
||||
* - The asynchronous woken of consumer thread was handled properly so the
|
||||
* consumer don't lose woken from producer.
|
||||
*
|
||||
* Test APIs:
|
||||
* - rt_completion_init()
|
||||
* - rt_completion_wakeup()
|
||||
* - rt_completion_wait_flags()
|
||||
*/
|
||||
|
||||
#define TEST_LATENCY_TICK (1)
|
||||
#define TEST_LOOP_TIMES (60 * RT_TICK_PER_SECOND)
|
||||
#define TEST_PROGRESS_ON (RT_TICK_PER_SECOND)
|
||||
|
||||
#include "utest.h"
|
||||
|
||||
#include <ipc/completion.h>
|
||||
#include <rtthread.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static struct rt_completion _prod_completion;
|
||||
static struct rt_completion _cons_completion;
|
||||
static int _test_data;
|
||||
static int _async_intr_count;
|
||||
static rt_atomic_t _progress_counter;
|
||||
static struct rt_semaphore _thr_exit_sem;
|
||||
|
||||
static void _test_thread_exit_failure(char *string)
|
||||
{
|
||||
LOG_E("\t[TEST failed] %s", string);
|
||||
|
||||
rt_sem_release(&_thr_exit_sem);
|
||||
rt_thread_delete(rt_thread_self());
|
||||
}
|
||||
|
||||
static void done_safely(struct rt_completion *completion)
|
||||
{
|
||||
rt_err_t error;
|
||||
|
||||
/* Signal completion */
|
||||
error = rt_completion_wakeup(completion);
|
||||
|
||||
/* try again if failed to produce */
|
||||
if (error == -RT_EEMPTY)
|
||||
{
|
||||
rt_thread_yield();
|
||||
}
|
||||
else if (error)
|
||||
{
|
||||
uassert_true(error == RT_EOK);
|
||||
_test_thread_exit_failure("unexpected error");
|
||||
}
|
||||
}
|
||||
|
||||
static void wait_safely(struct rt_completion *completion)
|
||||
{
|
||||
int try_times = 3;
|
||||
rt_err_t error;
|
||||
do
|
||||
{
|
||||
/* wait for one tick, to add more random */
|
||||
error = rt_completion_wait_flags(completion, 1, RT_INTERRUPTIBLE);
|
||||
if (error)
|
||||
{
|
||||
if (error == -RT_ETIMEOUT || error == -RT_EINTR)
|
||||
{
|
||||
_async_intr_count++;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_I("Async event %d\n", error);
|
||||
uassert_true(0);
|
||||
}
|
||||
rt_thread_yield();
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
} while (try_times--);
|
||||
|
||||
if (error != RT_EOK)
|
||||
{
|
||||
uassert_true(error == RT_EOK);
|
||||
_test_thread_exit_failure("wait failed");
|
||||
}
|
||||
}
|
||||
|
||||
static void producer_thread_entry(void *parameter)
|
||||
{
|
||||
for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
|
||||
{
|
||||
/* Produce data */
|
||||
_test_data++;
|
||||
|
||||
/* Delay before producing next data */
|
||||
rt_thread_delay(TEST_LATENCY_TICK);
|
||||
|
||||
/* notify consumer */
|
||||
done_safely(&_prod_completion);
|
||||
|
||||
/* sync with consumer */
|
||||
wait_safely(&_cons_completion);
|
||||
}
|
||||
|
||||
rt_sem_release(&_thr_exit_sem);
|
||||
}
|
||||
|
||||
static void consumer_thread_entry(void *parameter)
|
||||
{
|
||||
int local_test_data = 0;
|
||||
|
||||
rt_thread_startup(parameter);
|
||||
|
||||
for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
|
||||
{
|
||||
/* Wait for data update */
|
||||
wait_safely(&_prod_completion);
|
||||
|
||||
/* Consume data */
|
||||
if (local_test_data + 1 != _test_data)
|
||||
{
|
||||
LOG_I("local test data is %d, shared test data is %d",
|
||||
local_test_data, _test_data);
|
||||
uassert_true(0);
|
||||
}
|
||||
else if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0)
|
||||
{
|
||||
uassert_true(1);
|
||||
}
|
||||
|
||||
local_test_data = _test_data;
|
||||
done_safely(&_cons_completion);
|
||||
}
|
||||
|
||||
rt_sem_release(&_thr_exit_sem);
|
||||
}
|
||||
|
||||
rt_thread_t _watching_thread1;
|
||||
rt_thread_t _watching_thread2;
|
||||
|
||||
static void testcase(void)
|
||||
{
|
||||
/* Initialize completion object */
|
||||
rt_completion_init(&_prod_completion);
|
||||
rt_completion_init(&_cons_completion);
|
||||
|
||||
/* Create producer and consumer threads */
|
||||
rt_thread_t producer_thread =
|
||||
rt_thread_create("producer", producer_thread_entry, RT_NULL,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
|
||||
rt_thread_t consumer_thread =
|
||||
rt_thread_create("consumer", consumer_thread_entry, producer_thread,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
|
||||
uassert_true(producer_thread != RT_NULL);
|
||||
uassert_true(consumer_thread != RT_NULL);
|
||||
_watching_thread1 = consumer_thread;
|
||||
_watching_thread2 = producer_thread;
|
||||
|
||||
rt_thread_startup(consumer_thread);
|
||||
|
||||
for (size_t i = 0; i < 2; i++)
|
||||
{
|
||||
rt_sem_take(&_thr_exit_sem, RT_WAITING_FOREVER);
|
||||
}
|
||||
|
||||
LOG_I("Summary:\n"
|
||||
"\tTest times: %ds(%d times)\n"
|
||||
"\tAsync interruption count: %d\n",
|
||||
TEST_LOOP_TIMES / RT_TICK_PER_SECOND, TEST_LOOP_TIMES,
|
||||
_async_intr_count);
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
_test_data = 0;
|
||||
_progress_counter = 0;
|
||||
_async_intr_count = 0;
|
||||
rt_sem_init(&_thr_exit_sem, "test", 0, RT_IPC_FLAG_PRIO);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
rt_sem_detach(&_thr_exit_sem);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(testcase, "testcases.drivers.ipc.rt_completion.timeout",
|
||||
utest_tc_init, utest_tc_cleanup, 1000);
|
||||
603
RT_Thread/examples/utest/testcases/drivers/ipc/workqueue_tc.c
Normal file
603
RT_Thread/examples/utest/testcases/drivers/ipc/workqueue_tc.c
Normal file
@ -0,0 +1,603 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-02-06 tyx first commit
|
||||
* 2024-12-31 rbb666 Adding Test Cases
|
||||
*/
|
||||
|
||||
#include "rtthread.h"
|
||||
#include "rtdevice.h"
|
||||
#include "utest.h"
|
||||
|
||||
#ifdef RT_USING_DEVICE_IPC
|
||||
|
||||
static rt_uint8_t get_test_thread_priority(rt_int8_t pos)
|
||||
{
|
||||
rt_int16_t priority;
|
||||
|
||||
priority = RT_SCHED_PRIV(rt_thread_self()).init_priority;
|
||||
if (pos == 0)
|
||||
{
|
||||
return priority;
|
||||
}
|
||||
else
|
||||
{
|
||||
priority += pos;
|
||||
}
|
||||
if (priority < 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else if (priority >= RT_THREAD_PRIORITY_MAX)
|
||||
{
|
||||
return RT_THREAD_PRIORITY_MAX - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return (rt_uint8_t)priority;
|
||||
}
|
||||
}
|
||||
|
||||
static void do_work_test_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) = 1;
|
||||
}
|
||||
|
||||
static void do_work_test(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 higher priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(-1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, do_work_test_fun, (void *)&work_flag);
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Delay 5 ticks to ensure that the task has been executed */
|
||||
rt_thread_delay(5);
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void do_delay_work_test_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((rt_tick_t *)work_data) = rt_tick_get();
|
||||
}
|
||||
|
||||
static void do_delay_work_test(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile rt_tick_t work_start = 0;
|
||||
volatile rt_tick_t work_end = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 higher priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(-1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, do_delay_work_test_fun, (void *)&work_end);
|
||||
work_start = rt_tick_get();
|
||||
/* Normal delayed work submission test */
|
||||
err = rt_workqueue_submit_work(queue, &work, 10);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Ensure that the delayed work has been executed */
|
||||
rt_thread_delay(15);
|
||||
/* Check if the delayed task is executed after 10 ticks */
|
||||
if (work_end < work_start || work_end - work_start < 10)
|
||||
{
|
||||
uassert_false(1);
|
||||
}
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancle_work_test01_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) = 1;
|
||||
}
|
||||
|
||||
static void cancle_work_test01(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work, cancle_work_test01_fun, (void *)&work_flag);
|
||||
/* Cancel the work before it is executed */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Cancel Now */
|
||||
err = rt_workqueue_cancel_work(queue, &work);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(5);
|
||||
uassert_int_equal(work_flag, 0);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancle_work_test02_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
rt_thread_delay(10);
|
||||
}
|
||||
|
||||
static void cancle_work_test02(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 higher priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(-1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, cancle_work_test02_fun, RT_NULL);
|
||||
/* Cancel the work while it is in progress */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(5);
|
||||
err = rt_workqueue_cancel_work(queue, &work);
|
||||
uassert_int_equal(err, -RT_EBUSY);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancle_work_test03_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
rt_thread_delay(5);
|
||||
}
|
||||
|
||||
static void cancle_work_test03(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, cancle_work_test03_fun, RT_NULL);
|
||||
/* Canceling a work after it has been executed */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(10);
|
||||
err = rt_workqueue_cancel_work(queue, &work);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancle_work_test04_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
rt_thread_delay(10);
|
||||
*((int *)work_data) = 1;
|
||||
}
|
||||
|
||||
static void cancle_work_test04(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, cancle_work_test04_fun, (void *)&work_flag);
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(5);
|
||||
/* Synchronized cancellation work */
|
||||
err = rt_workqueue_cancel_work_sync(queue, &work);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancle_delay_work_test01_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) = 1;
|
||||
}
|
||||
|
||||
static void cancle_delay_work_test01(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work, cancle_delay_work_test01_fun, (void *)&work_flag);
|
||||
err = rt_workqueue_submit_work(queue, &work, 20);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(10);
|
||||
/* Cancel work */
|
||||
err = rt_workqueue_cancel_work(queue, &work);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(15);
|
||||
uassert_int_equal(work_flag, 0);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void repeat_work_test01_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) += 1;
|
||||
}
|
||||
|
||||
static void repeat_work_test01(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test01", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work, repeat_work_test01_fun, (void *)&work_flag);
|
||||
/* Multiple submissions of the same work */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* The same work, before it is executed, can be submitted repeatedly and executed only once */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
if (err != RT_EOK)
|
||||
{
|
||||
LOG_E("L:%d err. %d", __LINE__, err);
|
||||
}
|
||||
rt_thread_delay(10);
|
||||
/* Check if it was executed only once */
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void repeat_work_test02_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
rt_thread_delay(10);
|
||||
*((int *)work_data) += 1;
|
||||
}
|
||||
|
||||
static void repeat_work_test02(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 priority higher than current test thread */
|
||||
curr_priority = get_test_thread_priority(-1);
|
||||
queue = rt_workqueue_create("test02", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, repeat_work_test02_fun, (void *)&work_flag);
|
||||
/* Submit work with high queue priority that will be executed immediately */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(5);
|
||||
/* Re-submission of work in progress */
|
||||
err = rt_workqueue_submit_work(queue, &work, 0);
|
||||
if (err != RT_EOK)
|
||||
{
|
||||
LOG_E("L:%d err. %d", __LINE__, err);
|
||||
}
|
||||
rt_thread_delay(10);
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(10);
|
||||
uassert_int_equal(work_flag, 2);
|
||||
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static struct rt_workqueue *queue_3;
|
||||
|
||||
static void repeat_work_test03_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
int *work_flag = (int *)work_data;
|
||||
(*work_flag) += 1;
|
||||
rt_kprintf("work_flag:%d\n", *work_flag);
|
||||
if (*work_flag < 20)
|
||||
{
|
||||
rt_workqueue_submit_work(queue_3, work, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void repeat_work_test03(void)
|
||||
{
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 priority higher than current test thread */
|
||||
curr_priority = get_test_thread_priority(-1);
|
||||
queue_3 = rt_workqueue_create("test03", 2048, curr_priority);
|
||||
if (queue_3 == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
rt_work_init(&work, repeat_work_test03_fun, (void *)&work_flag);
|
||||
/* Submit work with high queue priority that will be executed immediately */
|
||||
err = rt_workqueue_submit_work(queue_3, &work, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Wait for the work to be executed 20 times with a timeout */
|
||||
err = rt_workqueue_cancel_work_sync(queue_3, &work);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Check if the work was executed 20 times */
|
||||
uassert_int_equal(work_flag, 20);
|
||||
|
||||
rt_workqueue_destroy(queue_3);
|
||||
}
|
||||
|
||||
static void repeat_delay_work_test01_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) += 1;
|
||||
}
|
||||
|
||||
static void repeat_delay_work_test01(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work, repeat_delay_work_test01_fun, (void *)&work_flag);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work, 20);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* At this point the delayed work has not been executed */
|
||||
rt_thread_delay(10);
|
||||
/* Re-submission of time-delayed work */
|
||||
err = rt_workqueue_submit_work(queue, &work, 20);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(15);
|
||||
uassert_int_equal(work_flag, 0);
|
||||
|
||||
/* Waiting for delayed task execution */
|
||||
rt_thread_delay(15);
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void repeat_delay_work_test02_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
rt_thread_delay(10);
|
||||
*((int *)work_data) += 1;
|
||||
}
|
||||
|
||||
static void repeat_delay_work_test02(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
/* 1 lower priority than the current test thread */
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work, repeat_delay_work_test02_fun, (void *)&work_flag);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work, 20);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Waiting for delayed work execution */
|
||||
rt_thread_delay(25);
|
||||
err = rt_workqueue_submit_work(queue, &work, 20);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
/* Check if the delayed work has been run only once */
|
||||
rt_thread_delay(10);
|
||||
uassert_int_equal(work_flag, 1);
|
||||
|
||||
rt_thread_delay(25);
|
||||
/* Check if the delayed work is executed twice */
|
||||
uassert_int_equal(work_flag, 2);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static void cancel_all_work_test_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
*((int *)work_data) += 1;
|
||||
}
|
||||
|
||||
static void cancel_all_work_test(void)
|
||||
{
|
||||
struct rt_workqueue *queue;
|
||||
rt_uint8_t curr_priority;
|
||||
struct rt_work work1;
|
||||
struct rt_work work2;
|
||||
struct rt_work work3;
|
||||
struct rt_work work4;
|
||||
volatile int work_flag = 0;
|
||||
rt_err_t err;
|
||||
|
||||
curr_priority = get_test_thread_priority(1);
|
||||
queue = rt_workqueue_create("test", 2048, curr_priority);
|
||||
if (queue == RT_NULL)
|
||||
{
|
||||
LOG_E("queue create failed, L:%d", __LINE__);
|
||||
return;
|
||||
}
|
||||
work_flag = 0;
|
||||
rt_work_init(&work1, cancel_all_work_test_fun, (void *)&work_flag);
|
||||
rt_work_init(&work2, cancel_all_work_test_fun, (void *)&work_flag);
|
||||
rt_work_init(&work3, cancel_all_work_test_fun, (void *)&work_flag);
|
||||
rt_work_init(&work4, cancel_all_work_test_fun, (void *)&work_flag);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work1, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work2, 0);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work3, 10);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
err = rt_workqueue_submit_work(queue, &work4, 10);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
err = rt_workqueue_cancel_all_work(queue);
|
||||
uassert_int_equal(err, RT_EOK);
|
||||
|
||||
rt_thread_delay(20);
|
||||
uassert_int_equal(work_flag, 0);
|
||||
|
||||
rt_thread_delay(100);
|
||||
rt_workqueue_destroy(queue);
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void testcase(void)
|
||||
{
|
||||
/* General work queue test */
|
||||
UTEST_UNIT_RUN(do_work_test);
|
||||
/* Delayed work queue test */
|
||||
UTEST_UNIT_RUN(do_delay_work_test);
|
||||
/* Cancellation of work prior to implementation */
|
||||
UTEST_UNIT_RUN(cancle_work_test01);
|
||||
/* Cancellation of work during execution */
|
||||
UTEST_UNIT_RUN(cancle_work_test02);
|
||||
/* Cancellation of work after implementation */
|
||||
UTEST_UNIT_RUN(cancle_work_test03);
|
||||
/* Synchronized cancellation of work during execution */
|
||||
UTEST_UNIT_RUN(cancle_work_test04);
|
||||
/* Cancel delayed work before execution */
|
||||
UTEST_UNIT_RUN(cancle_delay_work_test01);
|
||||
/* Multiple submissions of the same work prior to implementation */
|
||||
UTEST_UNIT_RUN(repeat_work_test01);
|
||||
/* Multiple submissions of the same work during execution */
|
||||
UTEST_UNIT_RUN(repeat_work_test02);
|
||||
/* Submitting the same task multiple times in a mission */
|
||||
UTEST_UNIT_RUN(repeat_work_test03);
|
||||
/* Multiple submissions of the same delayed task before execution */
|
||||
UTEST_UNIT_RUN(repeat_delay_work_test01);
|
||||
/* Multiple submissions of the same delayed task during execution */
|
||||
UTEST_UNIT_RUN(repeat_delay_work_test02);
|
||||
/* Cancel all works */
|
||||
UTEST_UNIT_RUN(cancel_all_work_test);
|
||||
}
|
||||
UTEST_TC_EXPORT(testcase, "components.drivers.ipc.workqueue_tc", utest_tc_init, utest_tc_cleanup, 300);
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
menu "Serial-Bypass Testcase"
|
||||
|
||||
config UTEST_SERIAL_BYPASS
|
||||
bool "Serial testcase"
|
||||
default n
|
||||
|
||||
endmenu
|
||||
@ -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')
|
||||
@ -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);
|
||||
@ -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);
|
||||
@ -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);
|
||||
@ -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);
|
||||
@ -0,0 +1,7 @@
|
||||
menu "Utest Serial Testcase"
|
||||
|
||||
config UTEST_SERIAL_TC
|
||||
bool "Serial testcase"
|
||||
default n
|
||||
|
||||
endmenu
|
||||
158
RT_Thread/examples/utest/testcases/drivers/serial_v2/README.md
Normal file
158
RT_Thread/examples/utest/testcases/drivers/serial_v2/README.md
Normal file
@ -0,0 +1,158 @@
|
||||
## 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 | 串口非阻塞接收模式 的测试 |
|
||||
|
||||
## 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引脚，完成自发自收的回路**。
|
||||
>
|
||||
>软件上：创建两个线程A和B，A为接收线程，B为发送线程，设置A线程优先级比B线程优先级高。发送线程发送随机长度（长度范围是 0 到 1000）的数据，接收线程接收到数据进行校验，数据正确则测试通过，默认测试100次。
|
||||
|
||||
后四个测试用例的测试思路:
|
||||
|
||||
>硬件上: **不需要将TX,RX引脚进行短接**,每次只针对发送或接收中的一种进行测试，更为简单与直接
|
||||
>
|
||||
>软件上: 四个样例每次仅测试TX/RX中的一种引脚与一种对应的阻塞/非阻塞模式
|
||||
>四种测试模式具体分为:
|
||||
>>阻塞接收模式----(硬件工作模式可选: 轮询, 中断, DMA)
|
||||
>>阻塞发送模式----(硬件工作模式可选: 轮询, 中断, DMA)
|
||||
>>非阻塞接收模式--(硬件工作模式可选: 中断, DMA)
|
||||
>>非阻塞发送模式--(硬件工作模式可选: 中断, DMA)
|
||||
>
|
||||
>其中阻塞或非阻塞背后的具体硬件工作模式选择(如 轮询, 中断, DMA)需要对`rtconfig.h`文件做出配置,具体配置流程可见文章中关于
|
||||
[seril_v2硬件工作模式的选择](https://club.rt-thread.org/ask/article/b4c536303c8e2335.html "serial_v2源码分析")一节.
|
||||
>
|
||||
>发送测试流程 :
|
||||
>>1. 先关闭串口,再以需要测试的模式打开.
|
||||
>>2. 然后依次发送 UART_SEND_TIMES(默认为400) * 1024, 8, 32, 128, 512, 1024个数据.
|
||||
>>3. 发送的同时记录每次发送所耗费的时钟周期与成功发送的数据数量.
|
||||
>>3. 打印记录的数据,通过时钟周期来反应发送效率, 通过成功发送的数据量来反应是否产生丢包问题.
|
||||
>
|
||||
>接收测试流程 :
|
||||
>>1. 先关闭串口,再以需要测试的模式打开.
|
||||
>>2. 然后以此接收 256, 256, 256, 128, 128, 共计1024个数据
|
||||
>>3. 接收的同时记录成功接收的数据数量
|
||||
>>4. 打印记录的数据, 通过现实成功接收的数据量与串口发送的数据量做对比,来验证是否出现丢包问题
|
||||
|
||||
## 5、配置
|
||||
|
||||
使用该测试用例需要在 `env` 工具的 `menuconfig` 中做相关配置，配置如下所示（使用 RT-Thread-Studio 的配置路径一致 ）：
|
||||
|
||||
```
|
||||
RT-Thread Utestcases --->
|
||||
[*] RT-Thread Utestcases --->
|
||||
Utest Serial Testcase --->
|
||||
[*] Serial testcase
|
||||
```
|
||||
|
||||
## 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` 运行串口非阻塞发送测试
|
||||
|
||||
\- 在 MSH 中输入 `utest_run testcases.drivers.uart_nonblocking_rx` 运行串口非阻塞接收测试
|
||||
|
||||
如果仅仅配置了 `Serial testcase` 相关的测试用例，则直接输入 `utest_run` 运行即可将上述测试用例按序测试。
|
||||
|
||||
## 7、注意事项
|
||||
|
||||
\- 需配置正确的测试用例。
|
||||
|
||||
\- 如有需要，可开启 ULOG 查看测试用例日志信息。
|
||||
|
||||
\- 需在 MSH 中输入正确的命令行。
|
||||
|
||||
\- 测试用例默认的测试数据长度范围最大为1000字节，如果接收端的缓冲区大小配置为小于1000字节时，那么在测试接收阻塞模式时，将会由于获取不了1000字节长度导致线程持续阻塞（因为测试用例是按 `recv_len` 长度去接收的，而不是按照单字节去接收的），因此建议接收端的缓冲区大小 （对应宏例如为 `BSP_UART2_RX_BUFSIZE`）设置为1024即可；当然也可按需减小测试的最大数据长度。
|
||||
|
||||
\- 该测试用例需要结合硬件具体的工作模式（POLL 、INT、DMA）进行测试，而硬件工作模式只能选择一种，因此需要在 `rtconfig.h` 中对串口相应的宏进行配置，来选择不同的工作模式去进行测试。
|
||||
|
||||
@ -0,0 +1,20 @@
|
||||
Import('rtconfig')
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Split('''
|
||||
uart_rxb_txnb.c
|
||||
uart_rxb_txb.c
|
||||
uart_rxnb_txb.c
|
||||
uart_rxnb_txnb.c
|
||||
uart_blocking_rx.c
|
||||
uart_blocking_tx.c
|
||||
uart_nonblocking_rx.c
|
||||
uart_nonblocking_tx.c
|
||||
''')
|
||||
|
||||
CPPPATH = [cwd]
|
||||
|
||||
group = DefineGroup('utestcases', src, depend = ['UTEST_SERIAL_TC'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@ -0,0 +1,93 @@
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include "utest.h"
|
||||
|
||||
#define SERIAL_UART_NAME "uart2"
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
static rt_bool_t block_read(rt_device_t uart_dev)
|
||||
{
|
||||
rt_size_t total_length, recv_length;
|
||||
rt_uint8_t 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, 256);
|
||||
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, 256);
|
||||
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, 256);
|
||||
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, 128);
|
||||
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, 128);
|
||||
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_thread_mdelay(1000);
|
||||
|
||||
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(SERIAL_UART_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;
|
||||
uart_dev = rt_device_find(SERIAL_UART_NAME);
|
||||
while(rt_device_close(uart_dev) != -RT_ERROR);
|
||||
rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
|
||||
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
|
||||
@ -0,0 +1,118 @@
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include "utest.h"
|
||||
|
||||
#define SERIAL_UART_NAME "uart2"
|
||||
#define UART_SEND_TIMES 400
|
||||
#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];
|
||||
rt_uint8_t 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");
|
||||
rt_thread_mdelay(2000);
|
||||
|
||||
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;
|
||||
|
||||
rt_thread_mdelay(1000);
|
||||
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(1000);
|
||||
}
|
||||
|
||||
return RT_TRUE;
|
||||
}
|
||||
|
||||
static void uart_test_blocking_tx(void)
|
||||
{
|
||||
rt_device_t uart_dev;
|
||||
uart_dev = rt_device_find(SERIAL_UART_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;
|
||||
uart_dev = rt_device_find(SERIAL_UART_NAME);
|
||||
while(rt_device_close(uart_dev) != -RT_ERROR);
|
||||
rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
|
||||
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
|
||||
@ -0,0 +1,107 @@
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include "utest.h"
|
||||
|
||||
#define SERIAL_UART_NAME "uart2"
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
static rt_bool_t nonblock_read(rt_device_t uart_dev)
|
||||
{
|
||||
rt_size_t total_length, recv_length;
|
||||
rt_uint8_t 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_thread_mdelay(1000);
|
||||
|
||||
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_thread_mdelay(1000);
|
||||
|
||||
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_thread_mdelay(1000);
|
||||
|
||||
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_thread_mdelay(1000);
|
||||
|
||||
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_thread_mdelay(1000);
|
||||
|
||||
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(SERIAL_UART_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;
|
||||
uart_dev = rt_device_find(SERIAL_UART_NAME);
|
||||
while(rt_device_close(uart_dev) != -RT_ERROR);
|
||||
rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
|
||||
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
|
||||
@ -0,0 +1,128 @@
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include "utest.h"
|
||||
|
||||
#define SERIAL_UART_NAME "uart2"
|
||||
#define UART_SEND_TIMES 400
|
||||
#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(SERIAL_UART_NAME);
|
||||
rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_NON_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING);
|
||||
|
||||
LOG_D("\nNONBLOCKING WRITE BEGIN\n");
|
||||
rt_thread_mdelay(2000);
|
||||
|
||||
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;
|
||||
|
||||
rt_thread_mdelay(1000);
|
||||
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(1000);
|
||||
}
|
||||
|
||||
return RT_TRUE;
|
||||
}
|
||||
|
||||
static void uart_test_nonblocking_tx(void)
|
||||
{
|
||||
rt_device_t uart_dev;
|
||||
uart_dev = rt_device_find(SERIAL_UART_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;
|
||||
uart_dev = rt_device_find(SERIAL_UART_NAME);
|
||||
while(rt_device_close(uart_dev) != -RT_ERROR);
|
||||
rt_device_open(uart_dev, RT_DEVICE_FLAG_TX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
|
||||
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
|
||||
@ -0,0 +1,230 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2019, 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>
|
||||
|
||||
#define TC_UART_DEVICE_NAME "uart2"
|
||||
#define TC_UART_SEND_TIMES 100
|
||||
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
#define TEST_UART_NAME TC_UART_DEVICE_NAME
|
||||
|
||||
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(TEST_UART_NAME);
|
||||
|
||||
if (serial == RT_NULL)
|
||||
{
|
||||
LOG_E("find %s device failed!\n", TEST_UART_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 *ch;
|
||||
ch = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (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 *)ch, rev_len);
|
||||
if (cnt == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fisrt_flag != RT_TRUE)
|
||||
{
|
||||
if ((rt_uint8_t)(last_old_data + 1) != ch[0])
|
||||
{
|
||||
LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, ch[0]);
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fisrt_flag = RT_FALSE;
|
||||
}
|
||||
|
||||
for (i = 0; i < cnt - 1; i++)
|
||||
{
|
||||
if ((rt_uint8_t)(ch[i] + 1) != ch[i + 1])
|
||||
{
|
||||
LOG_E("Read Different data -> former data: %x, current data: %x.", ch[i], ch[i + 1]);
|
||||
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
all_receive_length += cnt;
|
||||
if (all_receive_length >= rev_len)
|
||||
break;
|
||||
else
|
||||
last_old_data = ch[cnt - 1];
|
||||
}
|
||||
rt_free(ch);
|
||||
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 = BSP_UART2_RX_BUFSIZE;
|
||||
config.tx_bufsz = BSP_UART2_TX_BUFSIZE;
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void tc_uart_api(void)
|
||||
{
|
||||
rt_uint32_t times = 0;
|
||||
rt_uint16_t num = 0;
|
||||
while (TC_UART_SEND_TIMES - times)
|
||||
{
|
||||
num = (rand() % 1000) + 1;
|
||||
if(uart_api(num) == RT_EOK)
|
||||
LOG_I("data_lens [%3d], it is correct to read and write data. [%d] times testing.", num, ++times);
|
||||
else
|
||||
{
|
||||
LOG_E("uart test error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
uassert_true(uart_over_flag == 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;
|
||||
|
||||
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 */
|
||||
@ -0,0 +1,263 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2019, 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>
|
||||
|
||||
#define TC_UART_DEVICE_NAME "uart2"
|
||||
#define TC_UART_SEND_TIMES 100
|
||||
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
#define TEST_UART_NAME TC_UART_DEVICE_NAME
|
||||
|
||||
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(TEST_UART_NAME);
|
||||
|
||||
if (serial == RT_NULL)
|
||||
{
|
||||
LOG_E("find %s device failed!\n", TEST_UART_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 *ch;
|
||||
ch = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (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 *)ch, rev_len);
|
||||
if (cnt != rev_len)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fisrt_flag != RT_TRUE)
|
||||
{
|
||||
if ((rt_uint8_t)(last_old_data + 1) != ch[0])
|
||||
{
|
||||
LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, ch[0]);
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fisrt_flag = RT_FALSE;
|
||||
}
|
||||
|
||||
for (i = 0; i < cnt - 1; i++)
|
||||
{
|
||||
if ((rt_uint8_t)(ch[i] + 1) != ch[i + 1])
|
||||
{
|
||||
LOG_E("Read Different data -> former data: %x, current data: %x.", ch[i], ch[i + 1]);
|
||||
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
all_receive_length += cnt;
|
||||
if (all_receive_length >= rev_len)
|
||||
break;
|
||||
else
|
||||
last_old_data = ch[cnt - 1];
|
||||
}
|
||||
rt_free(ch);
|
||||
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 = BSP_UART2_RX_BUFSIZE;
|
||||
config.tx_bufsz = BSP_UART2_TX_BUFSIZE;
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void tc_uart_api(void)
|
||||
{
|
||||
rt_uint32_t times = 0;
|
||||
rt_uint16_t num = 0;
|
||||
while (TC_UART_SEND_TIMES - times)
|
||||
{
|
||||
num = (rand() % 1000) + 1;
|
||||
if(uart_api(num) == RT_EOK)
|
||||
LOG_I("data_lens [%3d], it is correct to read and write data. [%d] times testing.", num, ++times);
|
||||
else
|
||||
{
|
||||
LOG_E("uart test error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
uassert_true(uart_over_flag == 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;
|
||||
|
||||
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
|
||||
@ -0,0 +1,266 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2019, 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>
|
||||
|
||||
#define TC_UART_DEVICE_NAME "uart2"
|
||||
#define TC_UART_SEND_TIMES 100
|
||||
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
#define TEST_UART_NAME TC_UART_DEVICE_NAME
|
||||
|
||||
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(TEST_UART_NAME);
|
||||
|
||||
if (serial == RT_NULL)
|
||||
{
|
||||
LOG_E("find %s device failed!\n", TEST_UART_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 *ch;
|
||||
ch = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (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 *)ch, rev_len);
|
||||
if (cnt == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fisrt_flag != RT_TRUE)
|
||||
{
|
||||
if ((rt_uint8_t)(last_old_data + 1) != ch[0])
|
||||
{
|
||||
LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, ch[0]);
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fisrt_flag = RT_FALSE;
|
||||
}
|
||||
|
||||
for (i = 0; i < cnt - 1; i++)
|
||||
{
|
||||
if ((rt_uint8_t)(ch[i] + 1) != ch[i + 1])
|
||||
{
|
||||
LOG_E("Read Different data -> former data: %x, current data: %x.", ch[i], ch[i + 1]);
|
||||
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
all_receive_length += cnt;
|
||||
if (all_receive_length >= rev_len)
|
||||
break;
|
||||
else
|
||||
last_old_data = ch[cnt - 1];
|
||||
}
|
||||
rt_free(ch);
|
||||
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 = BSP_UART2_RX_BUFSIZE;
|
||||
config.tx_bufsz = BSP_UART2_TX_BUFSIZE;
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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);
|
||||
uart_over_flag = RT_FALSE;
|
||||
return result;
|
||||
}
|
||||
|
||||
static void tc_uart_api(void)
|
||||
{
|
||||
rt_uint32_t times = 0;
|
||||
rt_uint16_t num = 0;
|
||||
while (TC_UART_SEND_TIMES - times)
|
||||
{
|
||||
num = (rand() % 1000) + 1;
|
||||
if(uart_api(num) == RT_EOK)
|
||||
LOG_I("data_lens [%3d], it is correct to read and write data. [%d] times testing.", num, ++times);
|
||||
else
|
||||
{
|
||||
LOG_E("uart test error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
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;
|
||||
|
||||
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 */
|
||||
@ -0,0 +1,294 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2019, 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>
|
||||
|
||||
#define TC_UART_DEVICE_NAME "uart2"
|
||||
#define TC_UART_SEND_TIMES 100
|
||||
|
||||
|
||||
#ifdef UTEST_SERIAL_TC
|
||||
|
||||
#define TEST_UART_NAME TC_UART_DEVICE_NAME
|
||||
|
||||
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(TEST_UART_NAME);
|
||||
|
||||
if (serial == RT_NULL)
|
||||
{
|
||||
LOG_E("find %s device failed!\n", TEST_UART_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 *ch;
|
||||
ch = (rt_uint8_t *)rt_calloc(1, sizeof(rt_uint8_t) * (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 *)ch, rev_len);
|
||||
if (cnt == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fisrt_flag != RT_TRUE)
|
||||
{
|
||||
if ((rt_uint8_t)(last_old_data + 1) != ch[0])
|
||||
{
|
||||
LOG_E("_Read Different data -> former data: %x, current data: %x.", last_old_data, ch[0]);
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fisrt_flag = RT_FALSE;
|
||||
}
|
||||
|
||||
for (i = 0; i < cnt - 1; i++)
|
||||
{
|
||||
if ((rt_uint8_t)(ch[i] + 1) != ch[i + 1])
|
||||
{
|
||||
LOG_E("Read Different data -> former data: %x, current data: %x.", ch[i], ch[i + 1]);
|
||||
|
||||
uart_result = RT_FALSE;
|
||||
rt_free(ch);
|
||||
return;
|
||||
}
|
||||
}
|
||||
all_receive_length += cnt;
|
||||
if (all_receive_length >= rev_len)
|
||||
break;
|
||||
else
|
||||
last_old_data = ch[cnt - 1];
|
||||
}
|
||||
rt_free(ch);
|
||||
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 = BSP_UART2_RX_BUFSIZE;
|
||||
config.tx_bufsz = BSP_UART2_TX_BUFSIZE;
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void tc_uart_api(void)
|
||||
{
|
||||
rt_uint32_t times = 0;
|
||||
rt_uint16_t num = 0;
|
||||
while (TC_UART_SEND_TIMES - times)
|
||||
{
|
||||
num = (rand() % 1000) + 1;
|
||||
if(uart_api(num) == RT_EOK)
|
||||
LOG_I("data_lens [%3d], it is correct to read and write data. [%d] times testing.", num, ++times);
|
||||
else
|
||||
{
|
||||
LOG_E("uart test error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
uassert_true(uart_over_flag == 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;
|
||||
|
||||
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
|
||||
Reference in New Issue
Block a user