RT-Thread-新手学RTT提问：为啥线程不运行？欢迎老师围观RT-Thread问答社区

新手学RTT提问：为啥线程不运行？欢迎老师围观

发布于 2019-07-09 08:25:32 浏览：3153 订阅该版

为了检测串口的收发数据，写了下面的代码，奇怪的是串口收发都很正常，但是作为运行指示的LED不会闪烁:L
如果只是运行一个LED线程和随便一个串口的线程，那LED就可以正常闪烁，串口也还是可以工作，是什么原因啊？
本人脸皮厚，不怕高手喷，欢迎围观。:$ 
```
/*
*************************************************************************
* 包含的头文件
*************************************************************************
*/
#include "board.h"
#include "rtthread.h"
#include <string.h>

/************************* 全局变量声明 ****************************/

/* 相关宏定义 */
extern char DEBUG_Usart_Rx_Buf[DEBUG_USART_RBUFF_SIZE];

/*
******************************************************************
*                               变量
******************************************************************
*/
/* 定义线程控制块 */
static rt_thread_t usart1_rx_thread = RT_NULL;
//static rt_thread_t usart2_rx_thread = RT_NULL;
//static rt_thread_t usart3_rx_thread = RT_NULL;
static rt_thread_t led1_thread = RT_NULL;

static rt_thread_t usart3_tx_thread1 = RT_NULL;
static rt_thread_t usart3_tx_thread2 = RT_NULL;
static rt_thread_t usart3_tx_thread3 = RT_NULL;

/* 定义信号量控制块 */
extern rt_sem_t usart1_rx_sem;
extern rt_sem_t usart2_rx_sem;
extern rt_sem_t usart3_rx_sem;

/*
*************************************************************************
*                             函数声明
*************************************************************************
*/
static void usart1_rx_thread_entry(void* parameter);
//static void usart2_rx_thread_entry(void* parameter);
//static void usart3_rx_thread_entry(void* parameter);
static void led1_thread_entry(void* parameter);

static void usart3_tx_thread1_entry(void* parameter);
static void usart3_tx_thread2_entry(void* parameter);
static void usart3_tx_thread3_entry(void* parameter);

/*
*************************************************************************
*                             main 函数
*************************************************************************
*/
/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{

/* 为USART1接收完成创建一个信号量 */
 usart1_rx_sem = rt_sem_create("usart1_rx_sem",/* 消息队列名字 */
 0, /* 信号量初始值，默认有一个信号量 */
 RT_IPC_FLAG_FIFO); /* 信号量模式 FIFO(0x00)*/
 if (usart1_rx_sem != RT_NULL)
 rt_kprintf("usart1信号量usart1_rx_sem创建成功！ ");
//==============================================================================
 /* 为USART2接收完成创建一个信号量 */
 usart2_rx_sem = rt_sem_create("usart2_rx_sem",0, RT_IPC_FLAG_FIFO); //消息队列名字||信号量初始值，默认有一个信号量||信号量模式 FIFO(0x00)
 if (usart2_rx_sem != RT_NULL)
 rt_kprintf("usart2信号量usart2_rx_sem创建成功！ ");
//============================================================================
 /* 为USART3接收完成创建一个信号量 */
 usart3_rx_sem = rt_sem_create("usart3_rx_sem",0, RT_IPC_FLAG_FIFO); 
 if (usart3_rx_sem != RT_NULL)
 rt_kprintf("usart3信号量usart3_rx_sem创建成功！ ");	
//================================================================================	
 usart1_rx_thread = /* 线程控制块指针 */
 rt_thread_create( "usart1", /* 线程名字 */
 usart1_rx_thread_entry, /* 线程入口函数 */
 RT_NULL, /* 线程入口函数参数 */
 512, /* 线程栈大小 */
 2, /* 线程的优先级 */
 20); /* 线程时间片 */

/* 启动线程，开启调度 */
    if (usart1_rx_thread != RT_NULL)
        rt_thread_startup(usart1_rx_thread);
    else
        return -1;
//=============================================================================	
	    usart3_tx_thread1 =                          /* 线程控制块指针 */
        rt_thread_create( "usart3_tx_thread1",              /* 线程名字 */
                          usart3_tx_thread1_entry,   /* 线程入口函数 */
                          RT_NULL,             /* 线程入口函数参数 */
                          512,                 /* 线程栈大小 */
                          1,                   /* 线程的优先级 */
                          20);                 /* 线程时间片 */

/* 启动线程，开启调度 */
    if (usart3_tx_thread1 != RT_NULL)
        rt_thread_startup(usart3_tx_thread1);
    else
        return -1;

usart3_tx_thread2 =                          /* 线程控制块指针 */
        rt_thread_create( "usart3_tx_thread2",              /* 线程名字 */
                          usart3_tx_thread2_entry,   /* 线程入口函数 */
                          RT_NULL,             /* 线程入口函数参数 */
                          512,                 /* 线程栈大小 */
                          2,                   /* 线程的优先级 */
                          20);                 /* 线程时间片 */

/* 启动线程，开启调度 */
    if (usart3_tx_thread2 != RT_NULL)
        rt_thread_startup(usart3_tx_thread2);
    else
        return -1;
	
	    usart3_tx_thread3 =                          /* 线程控制块指针 */
        rt_thread_create( "usart3_tx_thread3",              /* 线程名字 */
                          usart3_tx_thread3_entry,   /* 线程入口函数 */
                          RT_NULL,             /* 线程入口函数参数 */
                          512,                 /* 线程栈大小 */
                          1,                   /* 线程的优先级 */
                          20);                 /* 线程时间片 */

/* 启动线程，开启调度 */
    if (usart3_tx_thread3 != RT_NULL)
        rt_thread_startup(usart3_tx_thread3);
    else
        return -1;

//================================================================================
	led1_thread =                          /* 线程控制块指针 */
    rt_thread_create( "led1",              /* 线程名字 */
                      led1_thread_entry,   /* 线程入口函数 */
                      RT_NULL,             /* 线程入口函数参数 */
                      512,                 /* 线程栈大小 */
                      3,                   /* 线程的优先级 */
                      20);                 /* 线程时间片 */
                   
    /* 启动线程，开启调度 */
   if (led1_thread != RT_NULL)
        rt_thread_startup(led1_thread);
    else
        return -1;

}

/*
*************************************************************************
* 线程定义
*************************************************************************
*/
static void usart1_rx_thread_entry(void* parameter)
{
 rt_err_t uwRet = RT_EOK;
 /* 任务都是一个无限循环，不能返回 */
 while (1)
 {
 uwRet = rt_sem_take(usart1_rx_sem,	0); 	 /* 等待时间：0 */
		
 if(RT_EOK == uwRet)
 {
 rt_kprintf("收到数据:%s ", DEBUG_Usart_Rx_Buf);
 //memset(DEBUG_Usart_Rx_Buf, 0, DEBUG_USART_RBUFF_SIZE); /* 清零 */
 }
		rt_thread_delay(20);
 }
}

/*
*************************************************************************
* 线程定义
*************************************************************************
*/
static void led1_thread_entry(void* parameter)
{	
 while (1)
 {
 LED1_ON;
		LED2_ON;
 rt_thread_delay(500); /* 延时500个tick */
 rt_kprintf("led1_thread running,LED1_ON ");
 
 LED1_OFF; 
		LED2_OFF; 
 rt_thread_delay(500); /* 延时500个tick */		 		
 rt_kprintf("led1_thread running,LED1_OFF ");
 }
}
/*
*************************************************************************
* 线程定义
*************************************************************************
*/
static void usart3_tx_thread1_entry(void* parameter)
{
 rt_err_t uwRet = RT_EOK;
 char *data;
 uint16_t len;
 /* 任务都是一个无限循环，不能返回 */
 while (1)
 {
		
 uwRet = rt_sem_take(usart3_rx_sem, 0); 	 // 获取串口中断的信号量 , 等待时间：0
 if(RT_EOK == uwRet)
 {
 data = Uasrt3_ReadDMA_DataLength(&len);
 //rt_kprintf("收到数据:%s ", data);
			Usart3_Puts(data);
 memset(data, 0, WIFI_USART_RBUFF_SIZE); /* 清零 */
 }
		rt_thread_delay(10);
 }
}
/*
*************************************************************************
* 线程定义
*************************************************************************
*/
static void usart3_tx_thread2_entry(void* parameter)
{

while (1)
    {

Usart3_Puts("串口3定时发送任务，线程2 ");
		rt_thread_delay(220);
 }
}
/*
*************************************************************************
* 线程定义
*************************************************************************
*/
static void usart3_tx_thread3_entry(void* parameter)
{
	
 while (1)
 {

Usart3_Puts("串口3定时发送任务线程3 ");
		rt_thread_delay(330);
 }
}
/********************************END OF FILE****************************/
```