1131 lines
37 KiB
C
Executable File
1131 lines
37 KiB
C
Executable File
/****************************************************************************
|
|
|
|
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;
|
|
}
|