HC32F4A0 10路串口UART 配置

最新推荐文章于 2024-10-11 15:50:14 发布
最新推荐文章于 2024-10-11 15:50:14 发布
阅读量487 收藏 2
点赞数 10
文章标签： windows c语言 arm开发 mcu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40545297/article/details/140892493
版权

HC32 小华MCU 使用一段时间了，反正芯片BUG 是比较多了，比如串口接收错误后导致再也无法接收，PWM模块无法输出 低电平 ， CAN 接收错误导致 输出引脚 CAN_TXD 一直输出脉冲  。。。；好的一面也存在吧，IO 引脚 可以重定义的比较多 ，这里使用内部10路串口，初始化如下 ：

源文件 ：

#include "hc32_ddl.h"
#include "bsp_usart.h"
#include <stdio.h>
#include "systick.h"
#include "string.h"
#include "Global_GpioDefine.h"


static int8_t golbal_regTimeout_enable =0;
static struct uart_list_table *golbal_uart_list;
static uint32_t uart_list_table_size =0;

int fputc(int ch, FILE *f)
{
	while (Reset == USART_GetStatus(M4_USART1, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
	USART_SendData(M4_USART1, ch);
	return ch;
}

static void _uart_list_init(void){
	golbal_uart_list=NULL;
	uart_list_table_size =0;
}

static int _add_uart_list(struct uart_list_table* add_list){
	struct uart_list_table *list_p = golbal_uart_list;
	struct uart_list_table **next_ptr=&golbal_uart_list;
 	if(add_list==NULL)return -2;
    __disable_irq();
	if(uart_list_table_size!=0){
		next_ptr = &list_p->end_list;
		list_p= list_p->end_list;
		*next_ptr = add_list;
		next_ptr = &add_list->end_list;
		*next_ptr = list_p;
	}else{
		*next_ptr = add_list;
		next_ptr = &add_list->end_list;
		*next_ptr = add_list;
	}
	uart_list_table_size++;
  __enable_irq();
	return 0;   
}

static int _del_uart_list(struct uart_list_table* del_list){
	struct uart_list_table *list_p = golbal_uart_list;
	struct uart_list_table **target = &golbal_uart_list;
	uint32_t i=0;
	if(del_list==NULL)return -2;
	if(uart_list_table_size==0) return -4;
	__disable_irq();
	for(i=0;i<uart_list_table_size;i++){
		if(list_p==del_list){
			*target = list_p->end_list;
			break;
		}
		target = &list_p->end_list;
		list_p = list_p->end_list;	
	}
	uart_list_table_size--;
	__enable_irq();;
	return i>0?0:-1;
}


static void TMR0_1_ChACmp_IrqCallback(void)
{
#if	configUSE_PREEMPTION>0
	uint32_t ulPreviousMask= portSET_INTERRUPT_MASK_FROM_ISR();
	BaseType_t pxHigherPriorityTaskWoken;
#endif
	
	M4_TMR0_1->STFLR =0;  /* Clear the compare matching flag */
	struct uart_list_table *list_p = golbal_uart_list;
	uint32_t i=0,curr_dma_ptr;
	UART_MAG *uart_sel;

	for(i=0;i<uart_list_table_size;i++){
		uart_sel =list_p->uart_sel;
		if(uart_sel!=NULL){
			curr_dma_ptr = uart_sel->dma_mon_ptr[0];
			if(curr_dma_ptr != uart_sel->last_ptr){
				uart_sel->last_ptr = curr_dma_ptr;
				uart_sel->recv_flag  |=(1UL<<30) ;
				uart_sel->delay_tick_cnt =0;
			}else if(uart_sel->recv_flag &(1UL<<30)){
				if(++uart_sel->delay_tick_cnt >=  uart_sel->delay_tick_set){
					uart_sel->delay_tick_cnt =0;
					uart_sel->recv_flag  &=~(1UL<<30);
					uart_sel->recv_flag ++ ;
#if	(configUSE_PREEMPTION>0) 
					xSemaphoreGiveFromISR(uart_sel->suart_xsem,&pxHigherPriorityTaskWoken);
#endif 
				}
			}
			if(uart_sel->uart_SR[0]&(5UL<<1)){/*UART-ORE / FE -error*/
				uart_sel->uart_SR[3] |=(1UL<<19)|(1UL<<17); /*clear ORE ,FE*/
			}
		}
		list_p = list_p->end_list;
	}
#if	configUSE_PREEMPTION>0	
	portCLEAR_INTERRUPT_MASK_FROM_ISR( ulPreviousMask );
#endif
}

static void _uart_timeout_scan_init(uint32_t output_clk){
    stc_tmr0_init_t stcTmr0Init;
    /* Enable timer0 peripheral clock */
    PWC_Fcg2PeriphClockCmd(PWC_FCG2_TMR0_1, Enable);
		uint32_t arr =0;
		int32_t psc =0;
		do{
			psc*=2;
			if(psc==0)psc=1;
			arr =HCLK_VALUE/2/(psc)/output_clk -1;
			if(psc>1024){/*param error*/
				psc = 1024;
				arr = 0xffff;
				break;
			}
		}while(arr>=0xffff);
		int i=0;
		for(i=0;i<10;i++){
			if(psc&(1UL<<i)){
				break;
			}
		}
    /* TIMER0 basetimer function initialize */
    (void)TMR0_StructInit(&stcTmr0Init);
    stcTmr0Init.u32ClockDivision = (uint32_t)i<<TMR0_BCONR_CKDIVA_POS;        
    stcTmr0Init.u32ClockSource = TMR0_CLK_SRC_PCLK1;        
    stcTmr0Init.u32Tmr0Func = TMR0_FUNC_CMP;          
    stcTmr0Init.u32HwTrigFunc = TMR0_BT_HWTRG_FUNC_NONE;
    stcTmr0Init.u16CmpValue = arr;            
    (void)TMR0_Init(M4_TMR0_1, TMR0_CH_A, &stcTmr0Init);
		
    DDL_DelayMS(1U); 
    TMR0_IntCmd(M4_TMR0_1, TMR0_CH_A, Enable);

		stc_irq_signin_config_t stcIrqSignConfig;
    stcIrqSignConfig.enIRQn = Int014_IRQn;
    stcIrqSignConfig.enIntSrc = INT_TMR0_1_CMPA;
    stcIrqSignConfig.pfnCallback = &TMR0_1_ChACmp_IrqCallback;
    (void)INTC_IrqSignIn(&stcIrqSignConfig);
    NVIC_ClearPendingIRQ(stcIrqSignConfig.enIRQn);
    NVIC_SetPriority(stcIrqSignConfig.enIRQn, DDL_IRQ_PRIORITY_15);
    NVIC_EnableIRQ(stcIrqSignConfig.enIRQn);
	
	_uart_list_init();

	TMR0_Cmd(M4_TMR0_1, TMR0_CH_A, Enable);
}
void _uart_timeout_scan_deinit(void){
	TMR0_Cmd(M4_TMR0_1, TMR0_CH_A, Disable);
	TMR0_IntCmd(M4_TMR0_1, TMR0_CH_A, Disable);
}

#if defined UART1_SERIAL_TXD_GPIOX &&  \
    defined UART1_SERIAL_RXD_GPIOX
UART_MAG uart1_msg;
static struct uart_list_table uart1_list;
void uart1_deinit(void){
	__DMA_UART_DEINIT(1,0);
	USART_FuncCmd(M4_USART1, (USART_RX | USART_TX), Disable);
	
	_del_uart_list(&uart1_list);
}
void uart1_init(uint32_t baudrate)
{
	static uint8_t Uart1RecvBuf[UART1_BUFSIZEMAX];
	GPIO_SetFunc( UART1_SERIAL_RXD_GPIOX, \
								UART1_SERIAL_RXD, \
								UART1_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(	UART1_SERIAL_TXD_GPIOX, \
								UART1_SERIAL_TXD, \
								UART1_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
	__DMA_UART_INIT(1,0,1,\
									uart1_msg,\
									Uart1RecvBuf,\
									UART1_BUFSIZEMAX,\
									uart1_list,DMA1_TRGSEL,\
						 EVT_USART1_RI);
#if	configUSE_PREEMPTION>0
	uart1_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart1_list);
}

uint16_t uart1_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART1->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART1->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart1_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart1_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart1_init(uint32_t baudrate){}
#endif

// uart 2

#if defined UART2_SERIAL_TXD_GPIOX &&  \
    defined UART2_SERIAL_RXD_GPIOX
   UART_MAG uart2_msg;
static struct uart_list_table uart2_list;
void uart2_deinit(void){
	__DMA_UART_DEINIT(1,1);
  USART_FuncCmd(M4_USART2, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart2_list);
}
void uart2_init(uint32_t baudrate)
{
	static uint8_t Uart2RecvBuf[UART2_BUFSIZEMAX];
	GPIO_SetFunc( 				UART2_SERIAL_RXD_GPIOX, \
								UART2_SERIAL_RXD, \
								UART2_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART2_SERIAL_TXD_GPIOX, \
								UART2_SERIAL_TXD, \
								UART2_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
	__DMA_UART_INIT(1,1,2,\
									uart2_msg,\
									Uart2RecvBuf,\
									UART2_BUFSIZEMAX,\
									uart2_list,DMA1_TRGSEL,\
						 	   EVT_USART2_RI);
#if	configUSE_PREEMPTION>0
	uart2_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart2_list);
}

uint16_t uart2_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART2->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART2->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart2_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart2_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart2_init(uint32_t baudrate){}
#endif

// uart3

#if defined UART3_SERIAL_TXD_GPIOX &&  \
    defined UART3_SERIAL_RXD_GPIOX
   UART_MAG uart3_msg;
static struct uart_list_table uart3_list;
void uart3_deinit(void){
	__DMA_UART_DEINIT(1,2);
  USART_FuncCmd(M4_USART3, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart3_list);
}
void uart3_init(uint32_t baudrate)
{
	static uint8_t Uart3RecvBuf[UART3_BUFSIZEMAX];
	GPIO_SetFunc( 				UART3_SERIAL_RXD_GPIOX, \
								UART3_SERIAL_RXD, \
								UART3_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART3_SERIAL_TXD_GPIOX, \
								UART3_SERIAL_TXD, \
								UART3_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
	__DMA_UART_INIT(1,2,3,\
									uart3_msg,\
									Uart3RecvBuf,\
									UART3_BUFSIZEMAX,\
									uart3_list,DMA1_TRGSEL,\
						 	   EVT_USART3_RI);
#if	configUSE_PREEMPTION>0
	uart3_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart3_list);
}

uint16_t uart3_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART3->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART3->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart3_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart3_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart3_init(uint32_t baudrate){}
#endif

//uart 4

#if defined UART4_SERIAL_TXD_GPIOX &&  \
    defined UART4_SERIAL_RXD_GPIOX
   UART_MAG uart4_msg;
static struct uart_list_table uart4_list;
void uart4_deinit(void){
	__DMA_UART_DEINIT(1,3);
  USART_FuncCmd(M4_USART4, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart4_list);
}
void uart4_init(uint32_t baudrate)
{
	static uint8_t Uart4RecvBuf[UART4_BUFSIZEMAX];
	GPIO_SetFunc( 				UART4_SERIAL_RXD_GPIOX, \
								UART4_SERIAL_RXD, \
								UART4_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART4_SERIAL_TXD_GPIOX, \
								UART4_SERIAL_TXD, \
								UART4_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(1,3,4,\
								uart4_msg,\
								Uart4RecvBuf,\
								UART4_BUFSIZEMAX,\
								uart4_list,DMA1_TRGSEL,\
						   EVT_USART4_RI);
#if	configUSE_PREEMPTION>0
	uart4_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart4_list);
}

uint16_t uart4_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART4->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART4->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart4_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart4_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart4_init(uint32_t baudrate){}
#endif
// 5

#if defined UART5_SERIAL_TXD_GPIOX &&  \
    defined UART5_SERIAL_RXD_GPIOX
   UART_MAG uart5_msg;
static struct uart_list_table uart5_list;
void uart5_deinit(void){
	__DMA_UART_DEINIT(1,4);
  USART_FuncCmd(M4_USART5, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart5_list);
}
void uart5_init(uint32_t baudrate)
{
	static uint8_t Uart5RecvBuf[UART5_BUFSIZEMAX];
	GPIO_SetFunc( 				UART5_SERIAL_RXD_GPIOX, \
								UART5_SERIAL_RXD, \
								UART5_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART5_SERIAL_TXD_GPIOX, \
								UART5_SERIAL_TXD, \
								UART5_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(1,4,5,\
								uart5_msg,\
								Uart5RecvBuf,\
								UART5_BUFSIZEMAX,\
								uart5_list,DMA1_TRGSEL,\
						   EVT_USART5_RI);
#if	configUSE_PREEMPTION>0
	uart5_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart5_list);
}

uint16_t uart5_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART5->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART5->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart5_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart5_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart5_init(uint32_t baudrate){}
#endif

// 6

#if defined UART6_SERIAL_TXD_GPIOX &&  \
    defined UART6_SERIAL_RXD_GPIOX
   UART_MAG uart6_msg;
static struct uart_list_table uart6_list;
void uart6_deinit(void){
	__DMA_UART_DEINIT(1,5);
  USART_FuncCmd(M4_USART6, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart6_list);
}
void uart6_init(uint32_t baudrate)
{
	static uint8_t Uart6RecvBuf[UART6_BUFSIZEMAX];
	GPIO_SetFunc( 				UART6_SERIAL_RXD_GPIOX, \
								UART6_SERIAL_RXD, \
								UART6_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART6_SERIAL_TXD_GPIOX, \
								UART6_SERIAL_TXD, \
								UART6_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(1,5,6,\
								uart6_msg,\
								Uart6RecvBuf,\
								UART6_BUFSIZEMAX,\
								uart6_list,DMA1_TRGSEL,\
						   EVT_USART6_RI);
#if	configUSE_PREEMPTION>0
	uart6_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart6_list);
}

uint16_t uart6_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART6->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART6->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart6_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart6_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart6_init(uint32_t baudrate){}
#endif
//7 

#if defined UART7_SERIAL_TXD_GPIOX &&  \
    defined UART7_SERIAL_RXD_GPIOX
   UART_MAG uart7_msg;
static struct uart_list_table uart7_list;
void uart7_deinit(void){
	__DMA_UART_DEINIT(1,6);
  USART_FuncCmd(M4_USART7, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart7_list);
}
void uart7_init(uint32_t baudrate)
{
	static uint8_t Uart7RecvBuf[UART7_BUFSIZEMAX];
	GPIO_SetFunc( 				UART7_SERIAL_RXD_GPIOX, \
								UART7_SERIAL_RXD, \
								UART7_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART7_SERIAL_TXD_GPIOX, \
								UART7_SERIAL_TXD, \
								UART7_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(1,6,7,\
								uart7_msg,\
								Uart7RecvBuf,\
								UART7_BUFSIZEMAX,\
								uart7_list,DMA1_TRGSEL,\
						   EVT_USART7_RI);
#if	configUSE_PREEMPTION>0
	uart7_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart7_list);
}

uint16_t uart7_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART7->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART7->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart7_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart7_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart7_init(uint32_t baudrate){}
#endif

// 8

#if defined UART8_SERIAL_TXD_GPIOX &&  \
    defined UART8_SERIAL_RXD_GPIOX
   UART_MAG uart8_msg;
static struct uart_list_table uart8_list;
void uart8_deinit(void){
	__DMA_UART_DEINIT(1,7);
  USART_FuncCmd(M4_USART8, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart8_list);
}
void uart8_init(uint32_t baudrate)
{
	static uint8_t Uart8RecvBuf[UART8_BUFSIZEMAX];
	GPIO_SetFunc( 				UART8_SERIAL_RXD_GPIOX, \
								UART8_SERIAL_RXD, \
								UART8_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART8_SERIAL_TXD_GPIOX, \
								UART8_SERIAL_TXD, \
								UART8_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(1,7,8,\
								uart8_msg,\
								Uart8RecvBuf,\
								UART8_BUFSIZEMAX,\
								uart8_list,DMA1_TRGSEL,\
						   EVT_USART8_RI);
#if	configUSE_PREEMPTION>0
	uart8_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart8_list);
}

uint16_t uart8_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART8->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART8->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart8_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart8_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart8_init(uint32_t baudrate){}
#endif
//9

#if defined UART9_SERIAL_TXD_GPIOX &&  \
    defined UART9_SERIAL_RXD_GPIOX
   UART_MAG uart9_msg;
static struct uart_list_table uart9_list;
void uart9_deinit(void){
	__DMA_UART_DEINIT(2,0);
  USART_FuncCmd(M4_USART9, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart9_list);
}
void uart9_init(uint32_t baudrate)
{
	static uint8_t Uart9RecvBuf[UART9_BUFSIZEMAX];
	GPIO_SetFunc( 				UART9_SERIAL_RXD_GPIOX, \
								UART9_SERIAL_RXD, \
								UART9_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART9_SERIAL_TXD_GPIOX, \
								UART9_SERIAL_TXD, \
								UART9_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(2,0,9,\
								uart9_msg,\
								Uart9RecvBuf,\
								UART9_BUFSIZEMAX,\
								uart9_list,DMA1_TRGSEL,\
						   EVT_USART9_RI);
#if	configUSE_PREEMPTION>0
	uart9_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart9_list);
}

uint16_t uart9_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART9->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART9->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart9_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart9_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart9_init(uint32_t baudrate){}
#endif
//10

#if defined UART10_SERIAL_TXD_GPIOX &&  \
    defined UART10_SERIAL_RXD_GPIOX
   UART_MAG uart10_msg;
static struct uart_list_table uart10_list;
void uart10_deinit(void){
	__DMA_UART_DEINIT(2,1);
  USART_FuncCmd(M4_USART10, (USART_RX | USART_TX), Disable);
	_del_uart_list(&uart10_list);
}
void uart10_init(uint32_t baudrate)
{
	static uint8_t Uart8RecvBuf[UART10_BUFSIZEMAX];
	GPIO_SetFunc( 				UART10_SERIAL_RXD_GPIOX, \
								UART10_SERIAL_RXD, \
								UART10_SERIAL_RXD_FUNC, PIN_SUBFUNC_DISABLE);
	GPIO_SetFunc(				UART10_SERIAL_TXD_GPIOX, \
								UART10_SERIAL_TXD, \
								UART10_SERIAL_TXD_FUNC, PIN_SUBFUNC_DISABLE);
				__DMA_UART_INIT(2,1,10,\
								uart10_msg,\
								Uart10RecvBuf,\
								UART10_BUFSIZEMAX,\
								uart10_list,DMA1_TRGSEL,\
						   EVT_USART10_RI);
#if	configUSE_PREEMPTION>0
	uart10_msg.suart_xsem = xSemaphoreCreateBinary();
#endif
	_add_uart_list(&uart10_list);
}

uint16_t uart10_Send(uint8_t *dat ,uint16_t len){
	uint16_t lens =len;
	while(len--){
		while (0 ==READ_REG32_BIT(M4_USART10->SR, USART_FLAG_TXE)){;} /* Wait Tx data register empty */
		M4_USART10->DR=((uint32_t)*dat++ & 0x01FFUL);
	}
return lens;
}

uint16_t uart10_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms){
	uint32_t cur_tick ;	
	uint16_t cur_count ;
	UART_MAG *uartv =&uart10_msg;	
#if	configUSE_PREEMPTION>0
	if((uartv->recv_flag&0xffff)>0){uartv->recv_flag--;}
	else{
		if(pdTRUE!=xSemaphoreTake(uartv->suart_xsem, recvtimeout_ms))return 0;
		if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
		else return 0;
	}
#else
	if(recvtimeout_ms){
		while(((uartv->recv_flag&0xffff)==0)&&(recvtimeout_ms>0)){
			delay_ms(1);
			recvtimeout_ms--;
		}
	}else{
		while((uartv->recv_flag&0xffff)==0){
			delay_ms(1);
		}
	}
	if((uartv->recv_flag&0xffff)>0)uartv->recv_flag --;
	else return 0;
#endif

	/*calc  recevice */
	uint32_t	last_ptr = uartv->last_ptr; //lock varable ,!!
	if(last_ptr> uartv->data_read_ptr){
		cur_tick = last_ptr - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
	}else{
		cur_tick = (uint32_t)uartv->data_buf ;
		cur_tick += uartv->data_buf_size;/*buffer end*/
		cur_tick = cur_tick - uartv->data_read_ptr;
		memcpy(data ,(void*)uartv->data_read_ptr,cur_tick);
		data += cur_tick;
		cur_count=  last_ptr - (uint32_t)uartv->data_buf;
		memcpy(data ,(void*)uartv->data_buf,cur_count);
		cur_tick +=cur_count;
	}
	uartv->data_read_ptr = last_ptr;
	return cur_tick;
}
#else
void uart10_init(uint32_t baudrate){}
#endif

void (*ttyScom_init[_SYS_TTYS_NUM_SIZE_MAX])(uint32_t bound)=
{
	&uart1_init,
	&uart2_init,
	&uart3_init,
	&uart4_init,
	&uart5_init,
	&uart6_init,
	&uart7_init,
	&uart8_init,
	&uart9_init,
	&uart10_init,
};

H 文件

#ifndef _BSP_USART_H_
#define _BSP_USART_H_
#include <stdint.h>
#ifndef __PROJ_TARGET_UBOOT
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#endif

typedef struct
{
	uint32_t	last_ptr;
	uint16_t 	delay_tick_set;
	uint16_t    delay_tick_cnt;
	uint32_t	data_read_ptr;
	uint32_t    data_buf_size;
	uint8_t 	*data_buf;
	uint32_t 	recv_flag;
	uint32_t    *dma_mon_ptr;
		uint32_t  *uart_SR;
#if	configUSE_PREEMPTION>0
	SemaphoreHandle_t suart_xsem;
#endif
}UART_MAG;


#define			UART1_BUFSIZEMAX				64
#define			UART2_BUFSIZEMAX				1024
#define			UART3_BUFSIZEMAX				64
#define			UART4_BUFSIZEMAX				64
#define			UART5_BUFSIZEMAX				64
#define			UART6_BUFSIZEMAX				64
#define			UART7_BUFSIZEMAX				64
#define			UART8_BUFSIZEMAX				2048
#define			UART9_BUFSIZEMAX				64
#define			UART10_BUFSIZEMAX				64

#define			__DMA_UART_DEINIT(dmax,CH){\
	M4_DMA##dmax->CHEN &=~(1UL<<CH) ;\
	M4_DMA##dmax->CHENCLR |=(1UL<<CH); \
}

#define		__DMA_UART_INIT(dmax,CH,utx,uartx_msg,UartxRecvBuf,UARTx_BUFSIZEMAX,uartx_list,DMAx_TRGSEL,EVT_USARTx_RI){\
	uartx_msg.last_ptr = (uint32_t)UartxRecvBuf;\
	uartx_msg.delay_tick_set = 2;\
	uartx_msg.delay_tick_cnt =0;\
	uartx_msg.data_read_ptr = \
	uartx_msg.last_ptr;\
	uartx_msg.data_buf_size = UARTx_BUFSIZEMAX;\
	uartx_msg.data_buf = UartxRecvBuf;\
	uartx_msg.recv_flag =0;\
	uartx_msg.dma_mon_ptr = (uint32_t*)&M4_DMA##dmax->MONDAR##CH;\
	uartx_msg.uart_SR  = (uint32_t*)&M4_USART##utx->SR;\
	\
	uartx_list.uart_sel = &uartx_msg;\
	if(golbal_regTimeout_enable==0){\
		golbal_regTimeout_enable = 1;\
		_uart_timeout_scan_init(125);\
	}\
	\
	PWC_Fcg0PeriphClockCmd((PWC_FCG0_DMA##dmax | PWC_FCG0_AOS), Enable);\
	PWC_Fcg3PeriphClockCmd(PWC_FCG3_USART##utx, Enable);\
	\
	M4_DMA##dmax->EN |=0x1 ;\
	M4_DMA##dmax->CHENCLR |=(1UL<<CH) ;\
	\
	M4_DMA##dmax->SAR##CH =(uint32_t)(&M4_USART##utx->DR)+2UL;\
	M4_DMA##dmax->DAR##CH = (uint32_t)UartxRecvBuf;\
	M4_DMA##dmax->DTCTL##CH = 0x1;\
	\
	M4_DMA##dmax->RPT##CH = (uint32_t)UARTx_BUFSIZEMAX<<16;\
	M4_DMA##dmax->RPTB##CH = (uint32_t)UARTx_BUFSIZEMAX<<16;\
	\
	M4_DMA##dmax->CHCTL##CH = 0UL<<8 | \
										1UL<<5 | \
										1UL<<2 ; \
	\
	M4_AOS->DMAx_TRGSEL##CH = EVT_USARTx_RI; \
	M4_DMA##dmax->CHEN |=(1UL<<CH) ; \
	\
	const stc_usart_uart_init_t stcUartInit = { \
			.u32Baudrate = baudrate, \
			.u32BitDirection = USART_LSB, \
			.u32StopBit = USART_STOPBIT_1BIT, \
			.u32Parity = USART_PARITY_NONE, \
			.u32DataWidth = USART_DATA_LENGTH_8BIT, \
			.u32ClkMode = USART_INTERNCLK_NONE_OUTPUT, \
			.u32PclkDiv = USART_PCLK_DIV64, \
			.u32OversamplingBits = USART_OVERSAMPLING_8BIT, \
			.u32NoiseFilterState = USART_NOISE_FILTER_DISABLE, \
			.u32SbDetectPolarity = USART_SB_DETECT_FALLING, \
	}; \
	USART_UartInit(M4_USART##utx, &stcUartInit);\
	\
	USART_FuncCmd(M4_USART##utx, (USART_RX | USART_TX), Enable); \
	\
}

/*uart x recvice timeout list_table*/
struct uart_list_table{
	UART_MAG *uart_sel;
	struct uart_list_table *end_list;
};
extern void _uart_timeout_scan_deinit(void);
extern UART_MAG uart1_msg;
extern void uart1_init(uint32_t baudrate);
extern uint16_t uart1_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart1_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart2_msg;
extern void uart2_init(uint32_t baudrate);
extern uint16_t uart2_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart2_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart3_msg;
extern void uart3_init(uint32_t baudrate);
extern uint16_t uart3_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart3_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart4_msg;
extern void uart4_init(uint32_t baudrate);
extern uint16_t uart4_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart4_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart5_msg;
extern void uart5_init(uint32_t baudrate);
extern uint16_t uart5_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart5_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart6_msg;
extern void 		uart6_init(uint32_t baudrate);
extern uint16_t uart6_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart6_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart7_msg;
extern void 		uart7_init(uint32_t baudrate);
extern uint16_t uart7_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart7_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart8_msg;
extern void uart8_init(uint32_t baudrate);
extern uint16_t uart8_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart8_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart9_msg;
extern void 		uart9_init(uint32_t baudrate);
extern uint16_t uart9_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart9_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);
extern UART_MAG uart10_msg;
extern void 		uart10_init(uint32_t baudrate);
extern uint16_t uart10_Send(uint8_t *dat ,uint16_t len);
extern uint16_t uart10_RecvForm(uint8_t *data ,uint32_t recvtimeout_ms);

#define		_SYS_TTYS_NUM_SIZE_MAX			10
extern void (*ttyScom_init[_SYS_TTYS_NUM_SIZE_MAX])(uint32_t bound);
#endif

外部定义全局头文件 ，如 ：

//串口 --调试
#define     UART1_SERIAL_TXD_GPIOX        GPIO_PORT_I /*FG1*/
#define     UART1_SERIAL_RXD_GPIOX        GPIO_PORT_I
#define     UART1_SERIAL_TXD          GPIO_PIN_04
#define     UART1_SERIAL_RXD          GPIO_PIN_05
#define     UART1_SERIAL_TXD_FUNC            GPIO_FUNC_32_USART1_TX
#define     UART1_SERIAL_RXD_FUNC            GPIO_FUNC_33_USART1_RX
//RS 485 -3
#define     UART2_SERIAL_TXD_GPIOX        GPIO_PORT_B
#define     UART2_SERIAL_RXD_GPIOX        GPIO_PORT_B
#define     UART2_SERIAL_TXD          GPIO_PIN_03 /*FG1 */
#define     UART2_SERIAL_RXD          GPIO_PIN_04
#define     UART2_SERIAL_TXD_FUNC            GPIO_FUNC_34_USART2_TX
#define     UART2_SERIAL_RXD_FUNC            GPIO_FUNC_35_USART2_RX

自动激活相关函数配置 ，串口接收采用 独立定时器 判断接收超时，统一处理 ，并且串口错误后自动清除相关BIT 

kensey
关注
华大半导体HC32F4A0笔记（三），RS485通信，使用串口USART1，DMA接收
cypressxt926的博客
01-28 7878
一、USART的工作频率和波特率 看用户手册一上来就糊涂了，手册里面写的PCLK是什么？翻看手册第4章有关CMU章节。似乎这里说的PCLK就是PCLK1？手册是第一版，纰漏其实蛮多的。 在官方库函数验证了猜测，这里说的PCLK指的就是PCLK1： en_result_t USART_SetBaudrate(M4_USART_TypeDef *USARTx, uint32_t u32Baudrate,
HC32F4A0SITB 串口3 DMA发送 中断接收
weixin_44435343的博客
04-30 258
HC32F4A0SITB 工程基于官方例程“usart_uart_dma”，由于usart 3没有Timeout功能，删除了Timer0相关初始化，否则会死机。上班摸鱼发的，有空再细说。
华大HC32F4A0/F460串口裸机驱动
与其用泪水悔恨昨天，不如用汗水拼搏今天
11-19 2758
使用了DMA以及中断，测试比较简单，代码是F460上面用的，今天试了F4A0也可以直接用，需要提前初始化DMA,INT，以及IO复用功能； /************************************************************************************************************* * 文件名: uart.c * 功能: HC32F4A0 UART通讯支持 * 作者: cp1300@139.com * 创建
华大半导体 HC32F4A0 系列开发笔记
ZYP_KVG的博客
11-14 7086
反观stm32f4，最多就支持端口重映射，所以它规定是哪个脚，你就必须用哪个脚。 而我用HC32F4A0，我哪个io想用spi就用spi，想用USART用USART，哪怕后面后悔了，哪个io不想用spi了，也可以通过配置寄存器来修改他的功能。
小华HC32F448串口使用
weixin_38743772的博客
10-13 1548
参考小华官方库例程代码 ...\HC32F448_DDL_Rev1.0.0\projects\ev_hc32f448_lqfp80\examples\usart 实现串口的使用，实现4G、GPS、WIFI等模块通讯。
华大半导体HC32F4A0笔记（一），PWM输入捕获，使用TIM6
cypressxt926的博客
01-22 6309
一、启动时钟 PWC_Fcg2PeriphClockCmd(PWC_FCG2_TMR6_x, Enable); TMR6对应FCG2，根据PWM输入引脚来确定是TMR6_x（本例为TMR6_2）。运行以后PWC的FCG2寄存器相应位被清0。 同时TM62的这些寄存器被全部置1，GCONR的DIR位被置一。 以上步骤类似STM32的开启RCC时钟。 二、功能初始化 设置TIM62的GCONR寄存器。 /* Timer6 general count function configuration
华大芯片HC32F460/HC32F4A0系列芯片IAP升级Demo
04-12
为了实现这些功能，开发者需要对HC32F460/HC32F4A0的寄存器配置、中断系统、以及Flash编程接口有深入理解。同时，上位机软件的开发可能涉及串口通信协议（如UART）、USB通信协议或者网络协议，根据实际需求选择合适...
华大单片机HC32F4例程
01-19
HC32F4拥有众多内置外设，如ADC（模数转换器）、DMA（直接存储器访问）、SPI（串行外围接口）、I2C（仪表总线）、UART（通用异步收发传输器）等。例程通常会提供这些外设的驱动代码，使开发者能够轻松地读写数据、...
5-HC32F460(华大单片机)-串口(基本使用) - 杨奉武 - 博客园1
08-04
1. 选择合适的串口通道：HC32F460可能有多路串口，选择合适的通道进行配置。 2. 设置波特率：通过编程设置UART控制器的时钟分频因子，以达到所需的波特率。 3. 配置数据格式：包括数据位、停止位和校验位。 4. 配置...
基于HC32F460一个简单的BootLoader例程框架.zip
03-27
HC32F460系列芯片集成了ARM Cortex-M4内核，具有浮点单元（FPU）、数字信号处理（DSP）指令，支持高速外设接口如SPI、I2C、UART、CAN等，并且内置了丰富的定时器和PWM模块，适用于各种实时控制需求。 3. **...
华大芯片HC32F4A0实现RS485通讯DMA收发
jjjjjj0000的博客
06-21 2496
华大芯片HC32F4A0实现RS485通讯DMA收发
HC32F460 华大芯片 串口调试 官方工具 printf 重定义
hotter23的博客
08-22 2382
参数（M4_USART1/M4_USART2/M4_USART3 , 波特率 （115200），引脚初始化的函数指针）官方提供的 driver 中，有一个 hc32f460_utility.c，就是官方提供的工具类。首先找到 ddl_config.h 的64 行 使能 print，默认是 off 状态。使用起来 很简单，用 DDL_PrintfInit 先初始化 串口。非常简单，用来做串口格式化输出，串口打印调试，都非常方便。可以在任意的代码位置加上printf 语句了。...
十、stm32-ESP8266（串口透传、MCU透传、控制LED亮灭）
洛尘的博客
08-18 5775
十、stm32-ESP8266（串口透传、MCU透传、控制LED亮灭）
单片机串口接收发生溢出中断错误
hongprove的博客
12-30 4960
最近在写国产华大单片机HC32F4A0的串口超时中断加DMA接收数据过程中发现一个问题，在我串口收到数据进入串口超时中断后，正常情况下，如果数据量没超过DMA设定的发送次数最大情况，是能接收数据的，但是一旦接收超过最大发送次数后，DMA就一直接收不到数据了，经过各种尝试，最后发现串口一直会进入溢出中断中，清除了中断标志位也没用，后来猜测可能是串口最后的数据DMA没有接收成功，导致UART接收数据寄存器没有被处理，所以一直进入溢出中断，后来在UART超时中断中最后加上读取UART接收数据寄存器，这样就能解决这
生信初学者教程（二十八）：单细胞数据标准化
最新发布
专注生信领域
10-11 92
生信初学者教程（二十八）：单细胞数据标准化
LingedList＜T＞，自定义泛型
m0_69089705的博客
10-08 674
/查找，第一个节点会存储在LinkedList类中的LinkedListNode First属性，最后一个节点会存储在LinkedList类中的LinkedListNode Last属性。链表（LinkedList）：分为单链表和双链表，单链表的对象存储的是自己的value和下一个对象的address。//上述先创建了第一个节点Value是Mike，又创建了第二个节点Value是Jason，第一个节点指向第二而节点，第二个节点又指向第一个节点。泛型的声明可以有多个，多个泛型使用一个<>，用逗号隔开。
日志分析删除
面朝大海，春暖花开
10-08 271
运维嫌弃生产环境打印日志过多，而且日志存储需要费用，让我们减少打印日志大小，所以需要分析日志在哪里打印的过多。读取生产日志文件，统计分析打印日志的地方，最后删除代码中打印日志的地方。
Cpp::STL—list类的模拟实现(上)(13)
tan180°的博客
10-09 1072
注意本篇难度偏高，其主要体现在迭代器类的实现！什么，list类的迭代器还要单独封装成类！？还真是，毕竟它的元素存储在物理意义上不是连续的正文开始！本篇暂时就先介绍两个类，剩下最后一个list类我们下篇再介绍铠甲要合体了！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值