RT-Thread初识学习-03

RTT的源码使用面向对象思想并且代码框架很好，有空可以研究研究RTT的代码框架--但这是一个痛苦的事情 

线程控制块 

在FreeRTOS的多任务就是以任务描述，而在RTT中是以线程名称描述，应用的时候可以把它当作FreeRTOS的任务使用

线程管理 

线程管理特点 

我们操作的就是用户线程，就是相当于FreeRTOS动态创建一个任务一样，至于系统线程，可以理解为管理用户线程的线程，不需要我们操心，我们只需要将用户线程创建并且使用好即可 

 

 线程控制块

输入代码跳转至控制块源码中，以后我们可以这样快速找到源码并且进行分析 

 

/**
 * Thread structure
 */
//部分代码展示
struct rt_thread
{
    /* rt object */
    char        name[RT_NAME_MAX];                      /**< the name of thread */
    rt_uint8_t  type;                                   /**< type of object */
    rt_uint8_t  flags;                                  /**< thread's flags */
    void (*cleanup)(struct rt_thread *tid);             /**< cleanup function when thread exit */

thread */
};
typedef struct rt_thread *rt_thread_t;

在FreeRTOS中的空闲任务的作用之一，就是回收删除的任务资源并且释放 

 

 初学时不必要理解控制块，等之后会应用RTT再来分析

线程属性

FreeRTOS的每一个任务都有独立的栈空间，FreeRTOS的状态不存在初始，因为它一旦创建了任务该任务就是就绪态，并且FreeRTOS只有四种状态，而RTT却有5种状态

---

 线程优先级

与FreeRTOS不同的是：FreeRTOS的任务优先级值越低，其优先级越低，而RTT与其相反

 注意

 线程状态切换

在FreeRTOS中任务的状态切换就是使用API函数进行切换，同样对于RTT也是如此

 线程动态创建与删除

线程相关操作

这里的创建和初始化，指的是动态创建线程和静态创建线程（初始化），因此存在两个函数，而静态创建和动态创建的运行和删除线程使用的API函数是不同的，这个需要注意一下，后面会对API函数进行讲解

 线程动态创建函数

与FreeRTOS相似，创建一个任务是FR中的重点，同样线程的动态创建也是重点，创建的方法就是使用API函数

/**
 * This function will create a thread object and allocate thread object memory
 * and stack.
 *
 * @param name the name of thread, which shall be unique
 * @param entry the entry function of thread
 * @param parameter the parameter of thread enter function
 * @param stack_size the size of thread stack
 * @param priority the priority of thread
 * @param tick the time slice if there are same priority thread
 *
 * @return the created thread object
 */
rt_thread_t rt_thread_create(const char *name,
                             void (*entry)(void *parameter),
                             void       *parameter,
                             rt_uint32_t stack_size,
                             rt_uint8_t  priority,
                             rt_uint32_t tick)  //这个是任务运行的时间片选择，你想要这个任务运行几个时间片，FreeRTOS是运行一个时间片
{
    struct rt_thread *thread;
    void *stack_start;

    thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread,
                                                    name);
    if (thread == RT_NULL)
        return RT_NULL;

    stack_start = (void *)RT_KERNEL_MALLOC(stack_size);
    if (stack_start == RT_NULL)
    {
        /* allocate stack failure */
        rt_object_delete((rt_object_t)thread);

        return RT_NULL;
    }

    _rt_thread_init(thread,
                    name,
                    entry,
                    parameter,
                    stack_start,
                    stack_size,
                    priority,
                    tick);

    return thread;
}

 注意点：rt_uint32_t tick) ---这个是任务运行的时间片选择，你想要这个任务运行几个时间片，FreeRTOS是运行一个时间片，因此初学的时候你可以选择一个时间片
 

 动态创建线程与启动线程实例

新创建的线程不是就绪态，因此需要使用 rt_thread_startup(LED0_Ret);

并且在写代码的时候，使用了FreeRTOS的方式定义栈大小和优先级

#define LED0_THREAD_STACKSIZE   1280  //这个需要足够大，不然程序运行不了，我写128的时候，不能运行
#define LED0_THREAD_PRIORITY   20

rt_thread_t  LED0_Ret = NULL;

void LED_entry(void *parameter)
{
    while(1)
    {
        rt_pin_write(LED0_PIN, PIN_HIGH);
        rt_thread_mdelay(200);
        rt_pin_write(LED0_PIN, PIN_LOW);
        rt_thread_mdelay(200);
    }
}

int main(void)
{

    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);

    LED0_Ret = rt_thread_create("LED0_Thread",
                          LED_entry,
                            NULL,
                            (rt_uint32_t) LED0_THREAD_STACKSIZE,
            (rt_uint8_t)  LED0_THREAD_PRIORITY,
            1);
    if(LED0_Ret != RT_NULL)
    {
        rt_kprintf("SUCCESS\r\n");
    }
    else {
        rt_kprintf("fail,,,\r\n");
    }

    rt_thread_startup(LED0_Ret);




    return RT_EOK;
}

#define     LED_STACK_SIZE     256
#define     LED_PRIORITY       20
#define     LED_TICK            1

rt_thread_t LED_Thread_Handle = NULL;
void LE0_Thread_entry(void *parameter);

void Thread_Base_Funcation()
{
    
    /*
    *   创建线程
    */
    
    LED_Thread_Handle = rt_thread_create("LED0_THREAD",LE0_Thread_entry,NULL,LED_STACK_SIZE,LED_PRIORITY,LED_TICK); //创建线程
    if(LED_Thread_Handle == RT_NULL )
        rt_kprintf("LED0 is fail\r\n");
    else
        rt_kprintf("LED0 is success\r\n");
    
    /*
    *   开启线程
    */
    if ( rt_thread_startup(LED_Thread_Handle) == RT_EOK )    //刚创建的线程需要启动，不像FreeRTOS一开始就是启动的
        rt_kprintf("LED0 is start sucess\r\n");
    else
        rt_kprintf("LED0 is start fail\r\n");
    
    /*
    *   延时线程
    */
    rt_thread_mdelay(300);//延时300ms
    
    /*
    *  挂起线程和恢复线程 ---通常不应该使用这两个函数
    */
    
    //rt_thread_suspend();----挂起
    //rt_thread_resume()；----恢复
                                       
}


void LE0_Thread_entry(void *parameter)
{
    while(1)
    {
        
    }
    
    
}


rt_timer_t timer1 = NULL;
void timeout1(void *parameter);
void Timer_Create(void)
{
     /*
    *   创建定时器
    */
    timer1 = rt_timer_create("timer1",timeout1,RT_NULL,10,RT_TIMER_FLAG_PERIODIC);  //创建定时器，RT_TIMER_FLAG_ONE_SHOT--单次
    
    /*
    *   打开定时器
    */
    if(timer1 != RT_NULL)  
        rt_timer_start(timer1);    //默认新建的定时器需要打开
    
    /*
    *   删除定时器
    */
    rt_timer_delete(timer1);
    
     /*
    *   关闭定时器
    */
    rt_timer_stop(timer1);
    
}

 /*
    *   定时器timeout1回调函数
    */
void timeout1(void *parameter)
{
    
}