andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
kunlun/dtest/dtest3/kl3_uart_test/kl3_uart_test.c
andy c756587541 初始提交
2024-09-28 14:24:04 +08:00

1131 lines
37 KiB
C
Executable File
Raw Permalink Blame History

/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
#include "chip_reg_base.h"
#include "hw_reg_api.h"
#include "sram.h"
#include "irq.h"
#if HW_PLATFORM > HW_PLATFORM_SIMU
#include "dbg_io.h"
#endif
#include "iot_io.h"
#include "watchdog.h"
#include "ahb.h"
#include "cpu.h"
#include "gp_timer.h"
#include "os_mem_api.h"
#include "uart.h"
#include "apb_hw.h"
#include "apb.h"
#include "os_utils_api.h"
#include "iot_errno_api.h"
#include "dtest_printf.h"
#include "iot_mem.h"
#include "iot_string.h"
#include "gpio.h"
#include "clk.h"
#include "gpio_mtx.h"
#include "iot_gpio_api.h"
#include "uart_reg.h"
#define UART_TEST_PORT (1u)
#define UART_MAX_INST (7u)
#define BAUD_RATE_1200 1200
#define BAUD_RATE_2400 2400
#define BAUD_RATE_4800 4800
#define BAUD_RATE_9600 9600
#define BAUD_RATE_14400 14400
#define BAUD_RATE_19200 19200
#define BAUD_RATE_38400 38400
#define BAUD_RATE_57600 57600
#define BAUD_RATE_115200 115200
#define BAUD_RATE_230400 230400
#define BAUD_RATE_380400 380400
#define BAUD_RATE_460800 460800
#define BAUD_RATE_921600 921600
#define BAUD_RATE_2000000 2000000
#define BAUD_RATE_3000000 3000000
#define DTEST_UART_TX_PIN 29
#define DTEST_UART_RX_PIN 28
#define DTEST_UART_TT_PIN 36
#define DTEST_UART_RXI_PIN 58
#define DTEST_UART_RX_IDLE_PIN 59
#define ITEM_NUM(items) sizeof(items) / sizeof(items[0])
#define _NEXTLINE_ "\r\n"
#define DTEST_UART_FIFO_THRED (1u << 0)
#define DTEST_UART_BAUD_RATE (1u << 1)
#define DTEST_UART_DATA_LEN (1u << 2)
#define DTEST_UART_STOP_BIT (1u << 3)
#define DTEST_UART_PARITY (1u << 4)
#define DTEST_UART_INTERRUPT (1u << 5)
#define DTEST_UART_IRDA (1u << 6)
#define DTEST_UART_FLOWCTRL (1u << 7)
#define DTEST_UART_RX_TIMEOUT_THR (1u << 8)
#define DTEST_UART_AUTO_BAUD_RATE (1u << 9)
#define DTEST_UART_485 (1u << 10)
#define DTEST_UART_MUTI_UART (1u << 11)
extern iot_gpio_op_t hw_gpio_api_table;
extern struct uart_ctrl g_uart_ctrl;
/* 串口缓冲区 */
static uint8_t g_dtest_uart_send_buf[257];
static uint8_t g_dtest_uart_recv_buf[257];
static volatile uint32_t g_rx_length;
static volatile uint32_t g_tx_length;
/* 中断接收标志 */
static volatile uint32_t g_dtest_uart_int_mask;
static void dtest_dummy_delay(uint32_t tick)
{
volatile uint32_t loop;
loop = tick;
while(loop--);
}
static uint32_t count = 0;
static uint32_t count1 = 0;
static uint32_t count2 = 0;
static uint32_t IRAM_ATTR uart_handler(uint32_t vector, iot_addrword_t data)
{
uint32_t port = (uint32_t)data;
uint32_t status;
int32_t pport;
pport = port;
status = (uint32_t)g_uart_ctrl.get_int_status(pport);
if ( status ) {
if( status & UART_RTI) {
g_uart_ctrl.clear_int(pport, UART_RTI);
g_uart_ctrl.clear_int_status(pport, UART_RTI);
iot_printf("irq:UART_RTI.\n");
g_dtest_uart_int_mask |= UART_RTI;
}
if( status & UART_RXI) {
iot_printf("irq:UART_RXI.\n");
g_uart_ctrl.clear_int(pport, UART_RXI);
g_uart_ctrl.clear_int_status(pport, UART_RXI);
g_dtest_uart_int_mask |= UART_RXI;
}
if( status & UART_RX_IDLE) {
g_uart_ctrl.clear_int(pport, UART_RX_IDLE);
g_uart_ctrl.clear_int_status(pport, UART_RX_IDLE);
iot_printf("irq:UART_RX_IDLE.\n");
g_dtest_uart_int_mask |= UART_RX_IDLE;
}
if( status & UART_TXI) {
g_uart_ctrl.clear_int(pport, UART_TXI);
g_uart_ctrl.clear_int_status(pport, UART_TXI);
iot_printf("irq:UART_TXI.\n");
g_dtest_uart_int_mask |= UART_TXI;
}
if( status & UART_TX_DONE) {
g_uart_ctrl.clear_int(pport, UART_TX_DONE);
g_uart_ctrl.clear_int_status(pport, UART_TX_DONE);
iot_printf("irq:UART_TX_DONE.\n");
g_dtest_uart_int_mask |= UART_TX_DONE;
}
if(status & UART_OVR_FL)
{
iot_printf("length = %d."_NEXTLINE_, g_uart_ctrl.rx_fifo_cnt(pport));
g_uart_ctrl.clear_int(pport, UART_OVR_FL);
g_uart_ctrl.clear_int_status(pport, UART_OVR_FL);
g_uart_ctrl.reset_fifo(pport);
g_uart_ctrl.set_int(pport, UART_OVR_FL);
iot_printf("irq:UART_OVR_FL."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_OVR_FL;
}
if(status & UART_RX_BRK)
{
g_uart_ctrl.clear_int(pport, UART_RX_BRK);
g_uart_ctrl.clear_int_status(pport, UART_RX_BRK);
g_uart_ctrl.set_int(pport, UART_RX_BRK);
iot_printf("irq:UART_RX_BRK.\n");
g_dtest_uart_int_mask |= UART_RX_BRK;
}
if(status & UART_TX_BRK)
{
g_uart_ctrl.clear_int(pport, UART_TX_BRK);
g_uart_ctrl.clear_int_status(pport, UART_TX_BRK);
g_uart_ctrl.set_int(pport, UART_TX_BRK);
iot_printf("irq:UART_TX_BRK.\n");
g_dtest_uart_int_mask |= UART_TX_BRK;
}
hw_gpio_api_table.set_value(DTEST_UART_TT_PIN,(++count %2));
}
return 0;
}
static void dtest_start_init(void)
{
clk_system_clock_tree_config(CLK_FRQ_GP_IDX_FAST);
dbg_uart_init();
apb_enable(APB_GMTX);
apb_enable(APB_GPIO);
gp_timer_init();
}
volatile int flag = 0;
extern int uart_e_read(int port, int reg);
static void dtest_send_buf_init(void)
{
os_mem_set(g_dtest_uart_send_buf, 0, sizeof(g_dtest_uart_send_buf));
for (uint32_t i = 0; i < sizeof(g_dtest_uart_send_buf); i++) {
g_dtest_uart_send_buf[i] = 'a' + i % 26;
}
}
static uint32_t IRAM_ATTR uart_rx_timeout_handler(uint32_t vector, iot_addrword_t data)
{
uint32_t port = (uint32_t)data;
uint32_t status;
int32_t pport;
hw_gpio_api_table.set_value(DTEST_UART_TT_PIN,(++count %2));
pport = port;
status = (uint32_t)g_uart_ctrl.get_int_status(pport);
int cnt = g_uart_ctrl.rx_fifo_cnt(pport);
uint32_t reg_CFG_UART_CTRL1 = uart_e_read(pport, CFG_UART_CTRL1_ADDR);
uint32_t reg_CFG_UART_RAM_CFG = uart_e_read(pport, CFG_UART_RAM_CFG_ADDR);
int rxfull = REG_FIELD_GET(RXFIFO_FULL_THRHD, reg_CFG_UART_CTRL1) +
(REG_FIELD_GET(RX_MEM_FULL_THRHD, reg_CFG_UART_RAM_CFG) << 7);
int tout = REG_FIELD_GET(RX_TOUT_THRHD, reg_CFG_UART_CTRL1) +
(REG_FIELD_GET(RX_TOUT_THRHD_H3, reg_CFG_UART_RAM_CFG) << 7);
if ( status ) {
if( status & UART_RTI) {
g_uart_ctrl.reset_fifo(pport);
g_uart_ctrl.clear_int(pport,UART_RTI);
g_uart_ctrl.clear_int_status(pport, UART_RTI);
g_uart_ctrl.set_int(pport, UART_RTI);
iot_printf("irq:UART_RTI."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_RTI;
hw_gpio_api_table.set_value(DTEST_UART_TT_PIN,(++count %2));
//iot_printf("rt cnt=%d, CTRL1=0x%08x, RAM_CFG=0x%08x", cnt, reg_CFG_UART_CTRL1, reg_CFG_UART_RAM_CFG);
iot_printf("rt:cnt=%d,rxfull=%d,tout=%d\n",cnt, rxfull, tout);
flag = 1;
}
if( status & UART_RXI) {
g_uart_ctrl.reset_fifo(pport);
g_uart_ctrl.clear_int(pport,UART_RXI);
g_uart_ctrl.clear_int_status(pport, UART_RXI);
g_uart_ctrl.set_int(pport,UART_RXI);
// iot_printf("irq:UART_RXI."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_RXI;
hw_gpio_api_table.set_value(DTEST_UART_RXI_PIN,(++count1 %2));
//iot_printf("rx cnt=%d, CTRL1=0x%08x, RAM_CFG=0x%08x", cnt, reg_CFG_UART_CTRL1, reg_CFG_UART_RAM_CFG);
iot_printf("rx:cnt=%d,rxfull=%d,tout=%d\n",cnt, rxfull, tout);
}
if( status & UART_RX_IDLE) {
g_uart_ctrl.clear_int(pport,UART_RX_IDLE);
g_uart_ctrl.clear_int_status(pport, UART_RX_IDLE);
// iot_printf("UART_RX_IDLE."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_RX_IDLE;
hw_gpio_api_table.set_value(DTEST_UART_RX_IDLE_PIN,(++count2 %2));
}
if( status & UART_TXI) {
g_uart_ctrl.clear_int(pport, UART_TXI);
g_uart_ctrl.clear_int_status(pport, UART_TXI);
iot_printf("UART_TXI."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_TXI;
}
if( status & UART_TX_DONE) {
g_uart_ctrl.clear_int(pport,UART_TX_DONE);
g_uart_ctrl.clear_int_status(pport, UART_TX_DONE);
iot_printf("UART_TX_DONE."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_TX_DONE;
}
if(status & UART_OVR_FL)
{
iot_printf("length = %d."_NEXTLINE_,g_uart_ctrl.rx_fifo_cnt(pport));
g_uart_ctrl.clear_int(pport, UART_OVR_FL);
g_uart_ctrl.clear_int_status(pport, UART_OVR_FL);
g_uart_ctrl.reset_fifo(pport);
g_uart_ctrl.set_int(pport, UART_OVR_FL);
iot_printf("UART_OVR_FL."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_OVR_FL;
}
if(status & UART_RX_BRK)
{
g_uart_ctrl.clear_int(pport, UART_RX_BRK);
g_uart_ctrl.clear_int_status(pport, UART_RX_BRK);
g_uart_ctrl.set_int(pport, UART_RX_BRK);
iot_printf("UART_RX_BRK."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_RX_BRK;
}
if(status & UART_TX_BRK)
{
g_uart_ctrl.clear_int(pport, UART_TX_BRK);
g_uart_ctrl.clear_int_status(pport, UART_TX_BRK);
g_uart_ctrl.set_int(pport, UART_TX_BRK);
iot_printf("UART_TX_BRK."_NEXTLINE_);
g_dtest_uart_int_mask |= UART_TX_BRK;
}
}
return 0;
}
int dtest_uart_test_rx_timeout_thr(void)
{
dcase_start("\ncase9.uart test rx_timeout_thr:\n");
hw_gpio_api_table.gpio_init();
gpio_pin_select(DTEST_UART_TT_PIN, 0);
hw_gpio_api_table.set_gpio_mode(DTEST_UART_TT_PIN, GPIO_OUTPUT);
hw_gpio_api_table.set_value(DTEST_UART_TT_PIN, 0);
hw_gpio_api_table.set_gpio_mode(DTEST_UART_RXI_PIN, GPIO_OUTPUT);
hw_gpio_api_table.set_value(DTEST_UART_RXI_PIN, 0);
hw_gpio_api_table.set_gpio_mode(DTEST_UART_RX_IDLE_PIN, GPIO_OUTPUT);
hw_gpio_api_table.set_value(DTEST_UART_RX_IDLE_PIN, 0);
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* config uart:115200,8N1 */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
/* attach irq */
iot_irq_t uart_irq_h = iot_interrupt_create(g_uart_ctrl.get_vector(UART_TEST_PORT),
HAL_INTR_PRI_6, UART_TEST_PORT, uart_rx_timeout_handler);
iot_interrupt_attach(uart_irq_h);
iot_interrupt_unmask(uart_irq_h);
g_uart_ctrl.threshold(UART_TEST_PORT, UART_THR_RXFULL, 2);
g_uart_ctrl.threshold(UART_TEST_PORT, UART_THR_RXTIMEOUT, 100);
/* clean interrupt mask */
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
g_uart_ctrl.set_int(UART_TEST_PORT, UART_RXI | UART_RTI);
int v = 0;
while(1)
{
if (flag) {
flag = 0;
//g_uart_ctrl.threshold(UART_TEST_PORT, UART_THR_RXTIMEOUT, v);
//iot_printf("v=%d\r\n", v);
v += 10;
if (v > 1020) {
v = 0;
}
}
}
return 0;
}
int dtest_uart_test_fifo_threshold(void)
{
uint32_t fifo_threshold_list[] = {1, 2, 5, 10, 20, 100, 200, 256};
int8_t ret = ERR_OK;
dtest_send_buf_init();
dcase_start("\ncase1.uart test fifo threshold\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart configure :115200,8N1 */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
/* clean interrupt mask */
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* attach irq */
iot_irq_t uart_irq_h = iot_interrupt_create(g_uart_ctrl.get_vector(UART_TEST_PORT),
HAL_INTR_PRI_6, UART_TEST_PORT, uart_handler);
iot_interrupt_attach(uart_irq_h);
iot_interrupt_unmask(uart_irq_h);
for (uint8_t index = 0; index < ITEM_NUM(fifo_threshold_list); index++) {
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
g_uart_ctrl.threshold(UART_TEST_PORT, UART_THR_RXFULL,
fifo_threshold_list[index]);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
g_uart_ctrl.clear_int_status(UART_TEST_PORT, UART_RXI);
g_uart_ctrl.set_int(UART_TEST_PORT, UART_RXI);
g_dtest_uart_int_mask = 0;
dprintf("set uart rx fifo threshold:%d\n", fifo_threshold_list[index]);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf,
fifo_threshold_list[index]);
/* wait interrupt */
while(!(g_dtest_uart_int_mask & UART_RXI));
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
if (g_rx_length > 0)
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("recieve length:%d\nreceived:%s\r\n", g_rx_length,
g_dtest_uart_recv_buf);
if (g_rx_length == fifo_threshold_list[index])
{
dprintf("uart rx fifo threshold is %d succeed.\n",
fifo_threshold_list[index]);
}else {
dprintf("uart rx fifo threshold is %d failed.\n",
fifo_threshold_list[index]);
ret = ERR_FAIL;
}
}
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
if (ret == ERR_FAIL){
dcase_failed();
}else {
dcase_success();
}
return ret;
}
int dtest_uart_test_baudrate(void)
{
int8_t ret = ERR_OK;
uint32_t send_data_len = 20;
uint32_t baud_rate_list[] = {
BAUD_RATE_1200, BAUD_RATE_2400, BAUD_RATE_4800,
BAUD_RATE_9600, BAUD_RATE_14400, BAUD_RATE_19200,
BAUD_RATE_38400, BAUD_RATE_57600, BAUD_RATE_115200,
BAUD_RATE_230400, BAUD_RATE_380400, BAUD_RATE_460800,
BAUD_RATE_921600, BAUD_RATE_2000000, BAUD_RATE_3000000};
dtest_send_buf_init();
g_dtest_uart_send_buf[send_data_len] = 0;
dcase_start("\ncase2.uart test baudrate:1200,2400,4800,9600,14400,19200,38400,57600,"
"115200,230400,38400,460800,921600,2000000,3000000.\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
for (uint8_t index = 0; index < ITEM_NUM(baud_rate_list); index++) {
g_uart_ctrl.config(UART_TEST_PORT, baud_rate_list[index],
UART_DATA_8_BITS, UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
dprintf("set uart%d baudrate:%d\n", UART_TEST_PORT, baud_rate_list[index]);
g_rx_length = 0;
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
dprintf("uart%d puts:%d char\n", UART_TEST_PORT, send_data_len);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, send_data_len);
/* 等待接收 */
while (g_rx_length < send_data_len)
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("uart%d recieve:%s"_NEXTLINE_, UART_TEST_PORT,
g_dtest_uart_recv_buf);
if (0 == iot_strcmp((const char *)g_dtest_uart_send_buf,
(const char *)g_dtest_uart_recv_buf)) {
dprintf("set uart%d baudrate:%d,test succeed\n", UART_TEST_PORT,
baud_rate_list[index]);
}else {
dprintf("set uart%d baudrate:%d,test failed\n", UART_TEST_PORT,
baud_rate_list[index]);
ret = ERR_FAIL;
}
g_uart_ctrl.puts(UART_TEST_PORT, (uint8_t*)"end", 4);
dtest_dummy_delay(2000000);
}
if (ret == ERR_FAIL){
dcase_failed();
} else {
dcase_success();
}
return ret;
}
int dtest_uart_test_datalen(void)
{
int8_t ret = ERR_OK;
uint8_t mask1, mask2, tmp;
uint32_t send_data_len = 20;
uint32_t datalen_list[] = {IOT_UART_DLEN_5_BITS, IOT_UART_DLEN_6_BITS,
IOT_UART_DLEN_7_BITS, IOT_UART_DLEN_8_BITS};
dtest_send_buf_init();
g_dtest_uart_send_buf[send_data_len] = 0;
dcase_start("\ncase3.uart test data length 5,6,7 and 8\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
for (uint8_t index = 0; index < ITEM_NUM(datalen_list); index++) {
/* uart configure */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, datalen_list[index],
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
dprintf("set uart data length:%d bits\n", datalen_list[index]);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
g_rx_length = 0;
dprintf("uart%d puts:%d char\n", UART_TEST_PORT, send_data_len);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, send_data_len);
/* waiting recieve data from slaver/pc */
while (g_rx_length < send_data_len)
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
mask1 = 0xFF >> (8 - datalen_list[index]);
mask2 = 0xFF << datalen_list[index];
for(uint32_t i = 0; i < send_data_len; i++) {
g_dtest_uart_recv_buf[i] &= mask1;
tmp = g_dtest_uart_send_buf[i] & mask2;
g_dtest_uart_recv_buf[i] |= tmp;
}
dprintf("uart recieved:%s\n", g_dtest_uart_recv_buf);
/* compare the recievd data */
for (uint8_t i = 0; i < send_data_len; i++) {
if ((g_dtest_uart_recv_buf[i] & mask1) != (g_dtest_uart_send_buf[i] &
mask1)) {
ret = ERR_FAIL;
break;
}
}
if (ERR_FAIL == ret) {
dprintf("set uart data length:%d,test failed\n", datalen_list[index]);
} else {
dprintf("set uart data length:%d,test succeed\n", datalen_list[index]);
}
dtest_dummy_delay(2000000);
}
if (ret == ERR_FAIL) {
dcase_failed();
}else {
dcase_success();
}
return ret;
}
int dtest_uart_test_stopbits(void)
{
int8_t ret = ERR_OK;
char *str_list[] = {"1", "1.5", "2"};
uint32_t send_data_len = 20;
uint32_t stop_bit_list[] = {UART_STOP_BITS_1, UART_STOP_BITS_1_5,
UART_STOP_BITS_2};
dtest_send_buf_init();
g_dtest_uart_send_buf[send_data_len] = 0;
dcase_start("\ncase4.uart test stop bit:1bit,1.5bits and 2bits\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
for (uint8_t index = 0; index < ITEM_NUM(stop_bit_list); index++) {
/* uart configure */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
stop_bit_list[index], UART_PARITY_DISABLE);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
dprintf("set uart stop bit :%s bits.\n", str_list[index]);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
g_rx_length = 0;
dprintf("uart%d puts:%d char\n", UART_TEST_PORT, send_data_len);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, send_data_len);
/* waiting recieve data from slaver/pc */
while (g_rx_length < send_data_len)
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("uart recieved:%s\n", g_dtest_uart_recv_buf);
if (0 == iot_strcmp((const char *)g_dtest_uart_send_buf,
(const char *)g_dtest_uart_recv_buf)) {
dprintf("set uart%d stop bit:%s,test succeed\n", UART_TEST_PORT,
str_list[index]);
} else {
dprintf("set uart%d stop bit:%s,test failed\n", UART_TEST_PORT,
str_list[index]);
ret = ERR_FAIL;
}
dtest_dummy_delay(2000000);
}
if (ret == ERR_FAIL){
dcase_failed();
}else {
dcase_success();
}
return ret;
}
int dtest_uart_test_parity(void)
{
char *str_list[] = {"NONE","odd","even"};
int8_t ret = ERR_OK;
uint32_t send_data_len = 20;
uint32_t parity_list[] = {UART_PARITY_DISABLE, UART_PARITY_ODD,
UART_PARITY_EVEN};
dtest_send_buf_init();
g_dtest_uart_send_buf[send_data_len] = 0;
dcase_start("\ncase5.uart test parity none,even and odd\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
for (uint8_t index = 0; index < ITEM_NUM(parity_list); index++) {
/* uart configure */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, parity_list[index]);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
dprintf("set uart parity :%s\n", str_list[index]);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, send_data_len);
dprintf("uart%d puts:%d char\n", UART_TEST_PORT, send_data_len);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
g_rx_length = 0;
/* waiting recieve data from slaver/pc */
while (g_rx_length < send_data_len)
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("uart recieved:%s\n", g_dtest_uart_recv_buf);
if (0 == iot_strcmp((const char *)g_dtest_uart_send_buf,
(const char *)g_dtest_uart_recv_buf)) {
dprintf("set uart%d party:%s,test succeed\n", UART_TEST_PORT,
str_list[index]);
} else {
dprintf("set uart%d party:%s,test failed\n", UART_TEST_PORT,
str_list[index]);
ret = ERR_FAIL;
}
}
if (ret == ERR_FAIL){
dcase_failed();
}else {
dcase_success();
}
return ret;
}
int dtest_uart_test_interrupt(void)
{
int8_t ret = ERR_OK;
uint32_t send_data_len = 60;
uint32_t interrupt_mask_list[] = {UART_RXI, UART_TXI, UART_RTI, UART_TX_DONE,
UART_OVR_FL, UART_RX_BRK, UART_TX_BRK, UART_RX_IDLE};
const char *interrupt_mask_str[] = {"UART_RXI", "UART_TXI", "UART_RTI",
"UART_TX_DONE", "UART_OVR_FL", "UART_RX_BRK", "UART_TX_BRK",
"UART_RX_IDLE"};
dcase_start("\ncase6.uart test interrupt\n");
dtest_send_buf_init();
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* config uart:115200,8N1 */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
/* attach irq */
iot_irq_t uart_irq_h = iot_interrupt_create(g_uart_ctrl.get_vector(UART_TEST_PORT),
HAL_INTR_PRI_6, UART_TEST_PORT, uart_handler);
iot_interrupt_attach(uart_irq_h);
iot_interrupt_unmask(uart_irq_h);
g_uart_ctrl.threshold(UART_TEST_PORT, UART_THR_RXFULL, 2);
g_uart_ctrl.set_brk(UART_TEST_PORT, 1);
/* clean interrupt mask */
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
g_uart_ctrl.clear_int_status(UART_TEST_PORT, 0xFF);
for (uint8_t index = 0; index < ITEM_NUM(interrupt_mask_list); index++) {
dprintf("uart set interrupt:%s.\n", interrupt_mask_str[index]);
g_dtest_uart_int_mask = 0;
g_uart_ctrl.clear_int_status(UART_TEST_PORT, 0xFF);
g_uart_ctrl.set_int(UART_TEST_PORT, interrupt_mask_list[index]);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, send_data_len);
if (UART_RX_IDLE == interrupt_mask_list[index]) {
dtest_dummy_delay(3000000);
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("%s g_rx_length:%d\n", interrupt_mask_str[index], g_rx_length);
}
while (!(g_dtest_uart_int_mask & interrupt_mask_list[index]));
dprintf("uart set interrupt:%s,test success\n", interrupt_mask_str[index]);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
dtest_dummy_delay(2000000);
}
if (ret == ERR_FAIL){
dcase_failed();
}else {
dcase_success();
}
return ret;
}
static void dtest_uart_set_flow_pin(uint8_t port, uint8_t cts_pin, uint8_t rts_pin)
{
gpio_sig_info_t uart_gpio_mtx = {
2,
{
{IO_TYPE_OUT, 0, 0x3, 0xff, 13},
{IO_TYPE_IN, 0, 0x3, 9, 0xff}
}
};
uart_gpio_mtx.CFG[0].gpio = rts_pin;
uart_gpio_mtx.CFG[0].outid = 2 * port;
uart_gpio_mtx.CFG[1].gpio = cts_pin;
uart_gpio_mtx.CFG[1].inid = 2 * port;
gpio_module_pin_select(&uart_gpio_mtx);
gpio_module_sig_select(&uart_gpio_mtx, GPIO_MTX_MODE_MATRIX);
}
int dtest_uart_test_flowctrl(void)
{
dtest_send_buf_init();
dcase_start("\ncase8.uart test flowctr\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* config uart:115200,8N1 */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.flow_ctrl(UART_TEST_PORT, UART_HW_FLOWCTRL_CTS_RTS, 1);
dtest_uart_set_flow_pin(UART_TEST_PORT, 30, 31);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
g_uart_ctrl.puts(UART_TEST_PORT, (uint8_t *)"123456", 6);
while (1) {
dtest_dummy_delay(4000000);
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
if (g_rx_length) {
dprintf("rx length :%d\n", g_rx_length);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("receive:%s\n", g_dtest_uart_recv_buf);
g_uart_ctrl.puts(UART_TEST_PORT, (uint8_t *)g_dtest_uart_recv_buf,
g_rx_length);
}
}
return 0;
}
int dtest_uart_test_irda(void)
{
int8_t ret = ERR_OK;
dcase_start("\ncase7.uart irDA test:\n");
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* config uart:1200,8N1 */
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_1200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.set_irda(UART_TEST_PORT, DTEST_UART_TX_PIN);
while(1) {
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
if (g_rx_length >= 1) {
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
iot_printf("recieve data:");
for (uint8_t i = 0 ; i < g_rx_length; i++) {
iot_printf("0x%02x ", g_dtest_uart_recv_buf[i]);
}
iot_printf("\n");
/* send */
g_uart_ctrl.rx_disable(UART_TEST_PORT, DTEST_UART_RX_PIN);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
while(0 != g_uart_ctrl.tx_fifo_cnt(UART_TEST_PORT));
dtest_dummy_delay(0xFFFFF);
/* recv */
g_uart_ctrl.rx_enable(UART_TEST_PORT, DTEST_UART_RX_PIN);
}
dtest_dummy_delay(0xFFFFF);
}
if (ret == ERR_FAIL){
dcase_failed();
}else {
dcase_success();
}
return ret;
}
static int dtest_uart_puls_cnt_get(int port)
{
extern int IRAM_ATTR uart_e_read(int port, int reg);
int tmp1, tmp2;
tmp1 = uart_e_read(port, CFG_UART_HIG_HPULSE_ADDR);
tmp1 &= HIGHPULSE_MIN_CNT_MASK;
dprintf("measure high cnt = %d."_NEXTLINE_, tmp1);
tmp2 = uart_e_read(port, CFG_UART_LOW_PULSE_ADDR);
tmp2 &= HIGHPULSE_MIN_CNT_MASK;
dprintf("measure low cnt = %d."_NEXTLINE_, tmp2);
return (tmp1 > tmp2 ? tmp2 : tmp1);
}
int dtest_uart_test_auto_br(void)
{
int temp,baudrate,ret = ERR_OK;
dtest_send_buf_init();
dcase_start("\ncase10.uart test auto baudrate\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
/* 设置自动计算波特率 */
g_uart_ctrl.set_baud_rate(UART_TEST_PORT, UART_BANDRATE_AUTO);
/* 延时采集高低脉冲,PC串口应发送数据 */
dtest_dummy_delay(0xFFFFFFu);
temp = dtest_uart_puls_cnt_get(UART_TEST_PORT);
dprintf("measure plus average cnt = %d.\n",temp);
baudrate = (int)(clk_apb_freq_get()/temp);
dprintf("auto baudrate is:%d\n", baudrate);
g_uart_ctrl.set_baud_rate(UART_TEST_PORT, baudrate);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
/* 等待接收 */
while ((g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT)) < 10);
if (g_rx_length) {
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("recieve data:%s\n bytes:", g_dtest_uart_recv_buf);
for (uint32_t x = 0; x < g_rx_length; x++) {
iot_printf("%d ", g_dtest_uart_recv_buf[x]);
}
iot_printf("\n");
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_send_buf, g_rx_length);
}
if (ret == ERR_FAIL){
dcase_failed();
} else {
dcase_success();
}
return ret;
}
int dtest_uart_test_485(void)
{
int ret = ERR_OK;
hw_gpio_api_table.gpio_init();
hw_gpio_api_table.set_gpio_mode(30, GPIO_OUTPUT);
dcase_start("\ncase11.uart test 485\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_9600, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.clear_int(UART_TEST_PORT, 0xFF);
g_uart_ctrl.reset_fifo(UART_TEST_PORT);
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
/* 等待接收 */
// while ((g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT)) < 10);
hw_gpio_api_table.set_value(30, 0);
while (1) {
os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
if (g_rx_length >= 5) {
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
dprintf("recieve data:%s\n bytes:", g_dtest_uart_recv_buf);
for (uint32_t x = 0; x < g_rx_length; x++) {
iot_printf("0x%x ", g_dtest_uart_recv_buf[x]);
}
iot_printf("\n");
dtest_dummy_delay(0xfffff);
hw_gpio_api_table.set_value(30, 1);
g_uart_ctrl.puts(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
while (g_uart_ctrl.tx_fifo_cnt(UART_TEST_PORT) == 0);
dtest_dummy_delay(0xfffff);
hw_gpio_api_table.set_value(30, 0);
dtest_dummy_delay(0xffff);
}
}
if (ret == ERR_FAIL){
dcase_failed();
} else {
dcase_success();
}
return ret;
}
/* 多串口测试 */
int dtest_uart_test_muti_uart(void)
{
dcase_start("\ncase12.uart test hand capacity\n");
/* init uart device */
g_uart_ctrl.init(UART_TEST_PORT);
/* uart IO remap */
iot_uart_set_pin(UART_TEST_PORT, DTEST_UART_RX_PIN, DTEST_UART_TX_PIN);
g_uart_ctrl.config(UART_TEST_PORT, BAUD_RATE_3000000, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
/* init uart device */
g_uart_ctrl.init(5);
/* uart IO remap */
iot_uart_set_pin(5, 30, 31);
g_uart_ctrl.config(5, 1000000, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_uart_ctrl.init(7);
/* uart IO remap */
iot_uart_set_pin(7, 32, 33);
g_uart_ctrl.config(7, BAUD_RATE_115200, UART_DATA_8_BITS,
UART_STOP_BITS_1, UART_PARITY_DISABLE);
g_rx_length = 0;
while (1) {
g_rx_length = g_uart_ctrl.rx_fifo_cnt(UART_TEST_PORT);
if (g_rx_length) {
// os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
// dprintf("uart%d rx length :%d\n", UART_TEST_PORT, g_rx_length);
g_uart_ctrl.gets(UART_TEST_PORT, g_dtest_uart_recv_buf, g_rx_length);
// iot_printf("recv:%s\n", g_dtest_uart_recv_buf);
g_uart_ctrl.puts(UART_TEST_PORT, (uint8_t *)g_dtest_uart_recv_buf,
g_rx_length);
}
g_rx_length = g_uart_ctrl.rx_fifo_cnt(5);
if (g_rx_length) {
// os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
// dprintf("uart%d rx length :%d\n", 5, g_rx_length);
g_uart_ctrl.gets(5, g_dtest_uart_recv_buf, g_rx_length);
// iot_printf("recv:%s\n", g_dtest_uart_recv_buf);
g_uart_ctrl.puts(5, (uint8_t *)g_dtest_uart_recv_buf, g_rx_length);
}
g_rx_length = g_uart_ctrl.rx_fifo_cnt(7);
if (g_rx_length) {
// os_mem_set(g_dtest_uart_recv_buf, 0, sizeof(g_dtest_uart_recv_buf));
// dprintf("uart%d rx length :%d\n", 7, g_rx_length);
g_uart_ctrl.gets(7, g_dtest_uart_recv_buf, g_rx_length);
// iot_printf("recv:%s\n", g_dtest_uart_recv_buf);
g_uart_ctrl.puts(7, (uint8_t *)g_dtest_uart_recv_buf, g_rx_length);
}
}
return 0;
}
static void dtest_uart_main(void)
{
uint32_t case_group = 0xffffffff, failed_cnt = 0;
dconfig();
dstart();
dversion();
case_group = DTEST_UART_FIFO_THRED | DTEST_UART_BAUD_RATE |
DTEST_UART_DATA_LEN | DTEST_UART_STOP_BIT | DTEST_UART_PARITY |
DTEST_UART_INTERRUPT | DTEST_UART_FLOWCTRL | DTEST_UART_RX_TIMEOUT_THR |
DTEST_UART_AUTO_BAUD_RATE | DTEST_UART_485 | DTEST_UART_MUTI_UART;
dprintf("dtest_uart case group:0x%08x\n", case_group);
/* 1. */
if (case_group & DTEST_UART_FIFO_THRED) {
if (ERR_OK != dtest_uart_test_fifo_threshold()) {
failed_cnt++;
}
}
/* 2 */
if (case_group & DTEST_UART_BAUD_RATE) {
if (dtest_uart_test_baudrate() != ERR_OK) {
failed_cnt++;
}
}
/* 3 */
if (case_group & DTEST_UART_DATA_LEN) {
if (dtest_uart_test_datalen() != ERR_OK) {
failed_cnt++;
}
}
/* 4 */
if (case_group & DTEST_UART_STOP_BIT) {
if (dtest_uart_test_stopbits() != ERR_OK) {
failed_cnt++;
}
}
/* 5 */
if (case_group & DTEST_UART_PARITY) {
if (dtest_uart_test_parity() != ERR_OK) {
failed_cnt++;
}
}
/* 6 */
if (case_group & DTEST_UART_INTERRUPT) {
if (dtest_uart_test_interrupt() != ERR_OK) {
failed_cnt++;
}
}
/* 7 */
if (case_group & DTEST_UART_IRDA) {
if (dtest_uart_test_irda() != ERR_OK) {
failed_cnt++;
}
}
/* 8 */
if (case_group & DTEST_UART_FLOWCTRL) {
if (dtest_uart_test_flowctrl() != ERR_OK) {
failed_cnt++;
}
}
/* 9 */
if (case_group & DTEST_UART_RX_TIMEOUT_THR) {
if (dtest_uart_test_rx_timeout_thr() != ERR_OK) {
failed_cnt++;
}
}
/* 10 */
if (case_group & DTEST_UART_AUTO_BAUD_RATE) {
if (dtest_uart_test_auto_br() != ERR_OK) {
failed_cnt++;
}
}
/* 11 */
if (case_group & DTEST_UART_485) {
if (dtest_uart_test_485() != ERR_OK) {
failed_cnt++;
}
}
/* 12 */
if (case_group & DTEST_UART_MUTI_UART) {
if (dtest_uart_test_muti_uart() != ERR_OK) {
failed_cnt++;
}
}
if (failed_cnt) {
dprintf("uart dtest failed\n");
} else {
dprintf("uart dtest succeed\n");
}
dend();
return;
}
int main(void) {
dtest_start_init();
dtest_uart_main();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink