RT-Thread-再用ringbuffer方法移植Finsh的时候出现程序卡死RT-Thread问答社区

5 再用ringbuffer方法移植Finsh的时候出现程序卡死

发布于 2024-11-15 22:04:18 浏览：15 订阅该版

在跟着rtt官方用中断方式移植FinSH组件的时候在进入rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);的时候程序卡死，一旦这句话注释掉，程序正常运行，有大佬解答一下吗
这是串口的完整函数

```c
#include "bsp_usart.h"

#if USART1_EN == 1
	unsigned char   g_USART1_RxBuf[USART1_RX_BUF_SIZE];//串口接收缓冲区
	unsigned short int 	g_USART1_RecPos = 0;//存放当前串口接收数据存放的位置
#endif

#if USART2_EN == 1
	unsigned char   g_USART2_RxBuf[USART2_RX_BUF_SIZE];//串口接收缓冲区
	unsigned short int 	g_USART2_RecPos = 0;//存放当前串口接收数据存放的位置
#endif

#if USART3_EN == 1
	unsigned char   g_USART3_RxBuf[USART3_RX_BUF_SIZE];//串口接收缓冲区
	unsigned short int 	g_USART3_RecPos = 0;//存放当前串口接收数据存放的位置
#endif

rt_uint8_t uart_rx_buf[512] = {0};
struct rt_ringbuffer  uart_rxcb;         /* 定义一个 ringbuffer cb */

static struct rt_semaphore shell_rx_sem; /* 定义一个静态信号量 */

void UsartInit(void)
{
	
	GPIO_InitTypeDef  GPIO_InitStructure;
	USART_InitTypeDef  USART_InitStructure;
	NVIC_InitTypeDef   NVIC_InitStructure;
	
#if USART1_EN == 1
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_9 ;  //TX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_10 ;  //RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	USART_InitStructure.USART_BaudRate = USART1_BAUD;  
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity =  USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Rx |USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_Init(USART1, &USART_InitStructure);//初始化串口1
//#if 0 //由于FinSH中rt_hw_console_getchar使用查询方式实现，故串口1中断初始化需注释掉
	//串口1中断初始化
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
//#endif
	USART_Cmd(USART1, ENABLE);//使能串口1
	
  USART_ClearFlag(USART1, USART_FLAG_TC  );//清发送完成标志位
#endif

#if USART2_EN == 1
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_2 ;  //TX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_3 ;  //RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	USART_InitStructure.USART_BaudRate = USART2_BAUD;  
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity =  USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Rx |USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_Init(USART2, &USART_InitStructure);//初始化串口2
	
	//串口2中断初始化
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

USART_Cmd(USART2, ENABLE);//使能串口2
	
  USART_ClearFlag(USART2, USART_FLAG_TC  );//清发送完成标志位
#endif

#if USART3_EN == 1
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_10 ;  //TX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_11 ;  //RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	
	USART_InitStructure.USART_BaudRate = USART3_BAUD;  
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity =  USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Rx |USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_Init(USART3, &USART_InitStructure);//初始化串口3
	
	//串口3中断初始化
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);

USART_Cmd(USART3, ENABLE);//使能串口3
	
  USART_ClearFlag(USART3, USART_FLAG_TC  );//清发送完成标志位
#endif

}

//为能够调用printf函数从选定的串口打印输出，重定义fputc函数，本例子使用串口1
int fputc(int ch,FILE *f)
{
	
	USART_SendData(USART1, (unsigned char)ch);
	
	while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET);
	
	return (ch);

}

static void UsartSendByte(USART_TypeDef* USARTx,unsigned char ch)
{
	
	USART_SendData(USARTx, (unsigned char)ch);
	
	while(USART_GetFlagStatus(USARTx, USART_FLAG_TC)== RESET);
}

void UsartSendString(USART_TypeDef* USARTx,unsigned char *str)
{
	unsigned int pos = 0;
	while(*(str+pos)!='\0')
	{
		UsartSendByte(USARTx,*(str+pos));
		pos ++;
		
	}

}

//#if 0 //由于FinSH中rt_hw_console_getchar使用查询方式实现，故串口1中断回调需注释掉
//USART1_IRQHandler,串口1中断回调函数
void USART1_IRQHandler(void)
{
#if USART1_EN == 1 
	/*----------------------------------------------------------------------------------*/
    int ch = -1;
    /* enter interrupt */
    rt_interrupt_enter();          //在中断中一定要调用这对函数，进入中断
	/*----------------------------------------------------------------------------------*/
#endif
	if( USART_GetFlagStatus(USART1,USART_FLAG_RXNE)!=RESET )				// 串口接收数据 
	{		
#if USART1_EN == 1 
	/*----------------------------------------------------------------------------------	*/
        while (1)
        {
            ch = -1;
            if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE)!=RESET)
            {
                ch =  USART_ReceiveData(USART1);
            }else  ch = -1;
						
            if (ch == -1)
            {
                break;
            }
            /* 读取到数据，将数据存入 ringbuffer */
            rt_ringbuffer_putchar(&uart_rxcb, ch);
        }
        rt_sem_release(&shell_rx_sem);
				
	/*----------------------------------------------------------------------------------*/	
#endif
		USART_ClearFlag(USART1, USART_FLAG_RXNE);
	}
	if( USART_GetFlagStatus(USART1,USART_FLAG_ORE)==SET ) 				// 串口溢出错误
	{
			USART_ClearFlag(USART1, USART_FLAG_ORE);
	}
	
	  /* leave interrupt */
    rt_interrupt_leave();    //在中断中一定要调用这对函数，离开中断
}
//#endif

//USART2_IRQHandler,串口2中断回调函数
void USART2_IRQHandler(void)
{
	#if USART2_EN == 1 
		//用户代码
	#endif
	if( USART_GetFlagStatus(USART2,USART_FLAG_RXNE)!=RESET )				// 串口接收数据 
	{		
		#if USART2_EN == 1 
					 //用户代码
		#endif
		USART_ClearFlag(USART2, USART_FLAG_RXNE);
	}
	if( USART_GetFlagStatus(USART2,USART_FLAG_ORE)==SET ) 				// 串口溢出错误
	{
			USART_ClearFlag(USART2, USART_FLAG_ORE);
	}
}

//USART3_IRQHandler,串口3中断回调函数
void USART3_IRQHandler(void)
{
	#if USART3_EN == 1 
		//用户代码
	#endif

if( USART_GetFlagStatus(USART3,USART_FLAG_RXNE)!=RESET )				// 串口接收数据 
	{		
		#if USART3_EN == 1 
			//用户代码
		#endif
		
		USART_ClearFlag(USART3, USART_FLAG_RXNE);
	}
	if( USART_GetFlagStatus(USART3,USART_FLAG_ORE)==SET ) 				// 串口溢出错误
	{
			USART_ClearFlag(USART3, USART_FLAG_ORE);
	}
}

void rt_hw_console_output(const char *str)  //实现该函数，才能使用rt_kprintf
{

/* 进入临界段 */
  rt_enter_critical();
	
	while(*str !='\0')
	{
		 /* 换行 */
    if (*str == '\n')//RT-Thread 系统中已有的打印均以 \n 结尾，而并非 \r\n，所以在字符输出时，需要在输出 \n 之前输出 \r，完成回车与换行，否则系统打印出来的信息将只有换行
    {
       USART_SendData(USART1, '\r');
	
	     while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET);
    }

USART_SendData(USART1, *(str++));
	
	  while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET);
		
	}
	 /* 退出临界段 */
  rt_exit_critical();  //注意：使用进入临界段语句rt_enter_critical(); 一定要使用退出临界段语句 rt_exit_critical();否则调度器锁住，无法进行调度
	
}

//char rt_hw_console_getchar(void)//使用Finsh组件三步骤：1.实现该函数及rt_hw_console_output函数；2.rtconfig.h中开启RT_USING_FINSH宏;3.添加Finsh组件(cmd.c、msh.c、shell.c)，
//{  //查询方式实现，记得将Usart1初始化中的中断接收配置相关代码注释掉
//	   int ch = -1;
//	   /*等待串口1输入数据*/
//     if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) != RESET)
//		 {
//         ch = (int)USART_ReceiveData(USART1);
//			   USART_ClearFlag(USART1, USART_FLAG_RXNE);
//		 }
//		 else
//		 {
//			 
//         if(USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
//         {
//             USART_ClearFlag(USART1, USART_FLAG_ORE);
//         }
//         //rt_thread_mdelay(10);
//			 
//		 }

//     return ch;
//}

char rt_hw_console_getchar(void)
{
	char ch = 0;
	  /* 从 ringbuffer 中拿出数据 */
    while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    {
       rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    }
    return ch;

}

```

这是FInSH组件显示内容，求大佬解答
![1.png](https://oss-club.rt-thread.org/uploads/20241115/a9689f51d4461e69ab52e6aab004cade.png)

程序主要问题应该在这段程序

```c
char rt_hw_console_getchar(void)
{
    char ch = 0;
      /* 从 ringbuffer 中拿出数据 */
    while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    {
       rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    }
    return ch;
}
```
中的rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
注释掉程序运行良好。