stm32裸機RT—thread開始創(chuàng)建線程詳解

在裸機系統(tǒng) 中，他們統(tǒng)統(tǒng)放在一個叫棧的地方，棧是單片機RAM里面一段連續(xù)的內(nèi)存空間，棧的大小一般在啟動文件或者鏈接腳 本里面指定，最后由C庫函數(shù)_main進行初始化。

在多線程系統(tǒng)中，每個線程都是獨立的，互不干擾的，所以要為每個線程都分配獨立的?？臻g，這個?？臻g通常是一個預(yù)先定義好的全局?jǐn)?shù)組，也可以是動態(tài)分配的一段內(nèi)存空間，但它們都存在于RAM中。

創(chuàng)建線程棧，需要幾個線程創(chuàng)建幾個線程棧，這里線程棧實際上就是全局變量，大小為512，這里創(chuàng)建兩個工作線程，如下：

ALIGN(RT_ALIGN_SIZE)//
/* 定義線程棧*/
rt_uint8_t rt_flag1_thread_stack[512];
rt_uint8_t rt_flag2_thread_stack[512];

ALIGN是一個 帶參宏，在rtdef.h中定義，設(shè)置變量需要多少個字節(jié)對齊，對在它下面的變量起作用。RT_ALIGN_SIZE是一個在rtconfig.h（rtconfig.h第一次使用需要在User文件夾下面新建然后添加到工程user這個組文件）中定義 的宏，默認(rèn)為4，表示4個字節(jié)對齊。

#ifndef __RTTHREAD_CFG_H__
#define __RTTHREAD_CFG_H__

#define RT_THREAD_PRIORITY_MAX  32     /* 最大優(yōu)先級 */
#define RT_ALIGN_SIZE           4      /* 多少個字節(jié)對齊 */

#endif /* __RTTHREAD_CFG_H__ */

下一步，定義線程函數(shù)：

這里我們建立線程函數(shù)，并給函數(shù)命名flag1_thread_entry，flag2_thread_entry兩個函數(shù) ，分別代表著兩個無限循環(huán)不返回的線程

/* 軟件延時 */
void delay (uint32_t count)
{
    for(; count!====0; count--);
}
/* 線程1 */
void flag1_thread_entry( void *p_arg )//   (1)
{
    for( ;; )
    {
        flag1 ==== 1;
        delay( 100 );
        flag1 ==== 0;
        delay( 100 );

        /* 線程切換，這里是手動切換 */
        rt_schedule();
    }
}
/* 線程2 */
void flag2_thread_entry( void *p_arg )//   (2)
{
    for( ;; )
    {
        flag2 ==== 1;
        delay( 100 );
        flag2 ==== 0;
        delay( 100 );

        /* 線程切換，這里是手動切換 */
        rt_schedule();
    }
}

下一步定義線程控制塊

在裸機系統(tǒng)中，程序的主體是CPU按照順序執(zhí)行的。而在多線程系統(tǒng)中，線程的執(zhí)行是由系統(tǒng)調(diào)度的。系統(tǒng)為了順利的調(diào)度線程，為每個線程都額外定義了一個線程控制塊，這個線程控制塊就相當(dāng)于線程的身份證，里面存有線程的所有信息，比如線程的棧指針，線程名稱，線程的形參等。有了這個線程控制塊之后，以后系統(tǒng)對線程的全部操作都可以通過這個線程控制塊來實現(xiàn)。定義一個線程控制塊需要一個新的數(shù)據(jù)類型，該數(shù)據(jù)類型在rtdef.h這個頭 文件中聲明，使用它可以為每個線程都定義一個線程控制塊實體。下面來看一下，此結(jié)構(gòu)體定義函數(shù)及內(nèi)容：

struct rt_thread
{
    void        *sp;                    /* 線程棧指針 */
    void        *entry;              /* 線程入口地址 */
    void        *parameter;       /* 線程形參 */
    void        *stack_addr;      /* 線程起始地址 */
    rt_uint32_t stack_size;       /* 線程棧大小，單位為字節(jié) */

    rt_list_t   tlist;            /* 線程鏈表節(jié)點 */
};
typedef struct rt_thread *rt_thread_t;// 

我們在main.c文件中為兩個線程定義的線程控制塊。

/* 定義線程控制塊 */
struct rt_thread rt_flag1_thread;
struct rt_thread rt_flag2_thread;

下一步，創(chuàng)建線程實現(xiàn)函數(shù)

線程的棧，線程的函數(shù)實體，線程的控制塊最終需要聯(lián)系起來才能由系統(tǒng)進行統(tǒng)一調(diào)度。那么這個聯(lián)系的工作就由線 程初始化函數(shù)rt_thread_init()來實現(xiàn)，該函數(shù)在thread.c（thread.c第一次使用需要自行在文件夾rtthread/3.0.3/src中新建并添加到工程的rtt/source組）中定義，在rtthread.h中聲明，所有跟線程相關(guān)的函數(shù)都在這個文件定義。rt_thread_init()函數(shù)的實現(xiàn)如下 ：

rt_err_t rt_thread_init(struct rt_thread *thread,//          (1)
                        void (*entry)(void *parameter),//    (2)
                        void             *parameter,//       (3)
                        void             *stack_start,//     (4)
                        rt_uint32_t       stack_size)//      (5)
{
    rt_list_init(&(thread->tlist));//                         (6)

    thread->entry ==== (void *)entry;//                       (7)
    thread->parameter ==== parameter;//                       (8)

    thread->stack_addr ==== stack_start;//                    (9)
    thread->stack_size ==== stack_size;//                     (10)

    /* 初始化線程棧，并返回線程棧指針 */ //                      (11)
    thread->sp ==== (void *)rt_hw_stack_init( thread->entry,
                                        thread->parameter,
                                    (void *)((char *)thread->stack_addr + thread->stack_size - 4) );

    return RT_EOK;//                                          (12)
}

(1) ：thread是線程控制塊指針。

(2) ：entry 是線程函數(shù)名， 表示線程的入口。

(3) ：parameter是線程形參，用于傳遞線程參數(shù)。

(4) ：stack_start 用于指向線程棧的起始地址。

(5) ：stack_size表示線程棧的大小，單位為字節(jié)。

(7) ：將線程入口保存到線程控制塊的entry成員中。

(8) ：將線程入口形參保存到線程控制塊的parameter成員中。

(9) ：將線程棧起始地址保存到線程控制塊的stack_start成員中。

(10) ：將線程棧起大小保存到線程控制塊的stack_size成員中。

(11) ：初始化線程棧，并返回線程棧頂指針。

rt_hw_stack_init()用來初始化線程棧， 當(dāng)線程第一次運行的時候，加載到CPU寄存器的參數(shù)就放在線程棧里面，該函數(shù)在cpuport.c中實現(xiàn)。cpuport.c第一次使用需要自行 在rtthread/3.0.3/ libcpu/arm/cortex-m3(cortex-m4或cortex-m7)文件夾下新建，然后添加到工程 的rtt/ports組中。

下一步，定義鏈表節(jié)點數(shù)據(jù)類型：

struct rt_list_node
{
   struct rt_list_node *next;              /* 指向后一個節(jié)點 */
   struct rt_list_node *prev;              /* 指向前一個節(jié)點 */
};
typedef struct rt_list_node rt_list_t;

rt_list_t 類型的節(jié)點里面有兩個rt_list_t類型的節(jié)點指針next和prev，分別用來指向鏈表中的下一個節(jié)點和上一個節(jié)點。

雙向鏈表的相關(guān)操作，這些函數(shù)均在rtservice.h中實現(xiàn)，rtservice.h第一次使用需要自行在rtthread/3.0.3/include文件夾下新建，然后添加到工程的rtt/source組中。下面從鏈表操作逐步實現(xiàn)。

鏈表節(jié)點初始化：

rt_inline void rt_list_init(rt_list_t *l)
{
    l->next ==== l->prev ==== l;
}

實際上進行了如下操作：

下面在鏈表頭部和尾部分別插入一個鏈表節(jié)點：

表頭后面插入一個節(jié)點

/* 在雙向鏈表頭部插入一個節(jié)點*/
rt_inline void rt_list_insert_after(rt_list_t *l, rt_list_t *n)
{
    l->next->prev ==== n; /* 第 1 步*/
    n->next ==== l->next; /* 第 2 步*/
    l->next ==== n; /* 第 3 步*/
    n->prev ==== l; /* 第 4 步*/
}

表頭前邊插入一個節(jié)點

rt_inline void rt_list_insert_before(rt_list_t *l, rt_list_t *n)
{
    l->prev->next ==== n; /* 第 1 步*/
    n->prev ==== l->prev; /* 第 2 步*/
    l->prev ==== n; /* 第 3 步*/
    n->next ==== l; /* 第 4 步*/
}

從雙向鏈表刪除一個節(jié)點

rt_inline void rt_list_remove(rt_list_t *n)
{
    n->next->prev ==== n->prev; /* 第 1 步*/
    n->prev->next ==== n->next; /* 第 2 步*/
    n->next ==== n->prev ==== n; /* 第 3 步*/
}

創(chuàng)建線程初始化函數(shù)

/* 線程棧初始化 */
rt_uint8_t *rt_hw_stack_init(void       *tentry,//                  (1)
                            void       *parameter,//                 (2)
                            rt_uint8_t *stack_addr)// 線程棧頂?shù)刂?4，在該函數(shù)調(diào)用的時候傳進來的是線程棧的棧頂?shù)刂?4
{

    struct stack_frame *stack_frame;//                               (4)
    rt_uint8_t         *stk;
    unsigned long       i;

    /* 獲取棧頂指針
    rt_hw_stack_init 在調(diào)用的時候，傳給stack_addr的是(棧頂指針)*/
    stk  ==== stack_addr + sizeof(rt_uint32_t);//                       (5)

    /* 讓stk指針向下8字節(jié)對齊 */
    stk  ==== (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8);//       (6)

    /* stk指針繼續(xù)向下移動sizeof(struct stack_frame)個偏移 */
    stk -==== sizeof(struct stack_frame);//                             (7)

    /* 將stk指針強制轉(zhuǎn)化為stack_frame類型后存到stack_frame */
    stack_frame ==== (struct stack_frame *)stk;//                       (8)

    /* 以stack_frame為起始地址，將?？臻g里面的sizeof(struct stack_frame)
    個內(nèi)存初始化為0xdeadbeef */
    for (i ==== 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)//   (9)
    {
            ((rt_uint32_t *)stack_frame)[i] ==== 0xdeadbeef;
    }

    /* 初始化異常發(fā)生時自動保存的寄存器 *///                            (10)
    stack_frame->exception_stack_frame.r0  ==== (unsigned long)parameter; /* r0 : argument */
    stack_frame->exception_stack_frame.r1  ==== 0;                        /* r1 */
    stack_frame->exception_stack_frame.r2  ==== 0;                        /* r2 */
    stack_frame->exception_stack_frame.r3  ==== 0;                        /* r3 */
    stack_frame->exception_stack_frame.r12 ==== 0;                        /* r12 */
    stack_frame->exception_stack_frame.lr  ==== 0;                        /* lr */
    stack_frame->exception_stack_frame.pc  ==== (unsigned long)tentry;    /* entry point, pc */
    stack_frame->exception_stack_frame.psr ==== 0x01000000L;              /* PSR */

    /* 返回線程棧指針 */
    return stk;//                                                    (11)
}

(5) ：獲取棧頂指針，將棧頂指針傳給指針stk。rt_hw_stack_init()函數(shù) 在rt_thread_init ()函數(shù)中調(diào)用的時候傳給形參stack_addr的值是棧頂指針減去4，所以現(xiàn)在 加上sizeof(rt_uint32_t)剛好與減掉的4相互抵消，即傳遞給stk的是棧頂指針。

(6) ：讓stk這個指針向下8個字節(jié)對齊，確保stk是8字節(jié)對齊的地址。 在Cortex-M3（Cortex-M4或Cortex-M7）內(nèi)核的單片機中，因為總線寬度是32位的，通常只要棧保持4字節(jié)對齊就 行，可這樣為啥要8字節(jié)？難道有哪些操作是64位的？確實有，那就是浮 點運算，所以要8字節(jié)對齊（但是目前我們都還沒有涉及到浮點運算，只是為了后續(xù)兼容浮點運行的考慮）。 如果棧頂指針是8字節(jié)對齊的，在進行向下8字節(jié)對齊的時候，指針不會移動，如果不是8字節(jié)對齊的， 在做向下8字節(jié)對齊的時候，就會空出幾個字節(jié)，不會使用，比如當(dāng)stk是33，明顯不能整除8， 進行向下8字節(jié)對齊就是32，那么就會空出一個字節(jié)不使用。

(7) ：stk指針繼續(xù)向下移動sizeof(struct stack_frame) 個偏移，即16個字的大小。

ok?。。。。。。?/strong>

/* 初始化線程 */
rt_thread_init(&rt_flag1_thread,                 /* 線程控制塊 */
                flag1_thread_entry,               /* 線程入口地址 */
                RT_NULL,                          /* 線程形參 */
                &rt_flag1_thread_stack[0],        /* 線程棧起始地址 */
                sizeof(rt_flag1_thread_stack) );  /* 線程棧大小，單位為字節(jié) */
/* 將線程插入到就緒列表 */

/* 初始化線程 */
rt_thread_init(&rt_flag2_thread,                 /* 線程控制塊 */
                flag2_thread_entry,               /* 線程入口地址 */
                RT_NULL,                          /* 線程形參 */
                &rt_flag2_thread_stack[0],        /* 線程棧起始地址 */
                sizeof(rt_flag2_thread_stack) );  /* 線程棧大小，單位為字節(jié) */