《RT-Thread内核实现与应用开发实战指南》读书笔记-RT-THREAD启动
1 J% @: t. ~* g; |& @( y% H搞硬件的就是这么不放心，第一点必须要搞清楚CPU怎么开始动起来的，然后操作系统又是怎么开发跑起来的。
  \6 W  h" ?$ _, [. z% R% p于是就跳过了N章，直接到第16章RT-THREAD启动流程 （前面的章节主要讲概念，慢慢理解，不急）。
这里只有书本内容，但我们看书也可以变通一下。调用一个例子对照。
比如官网的rtthread_simulator_v0.1.0例子。或者本书配套的17，线程管理例子。这样就比较好理解，也印象深刻一点。16章的开始就给我们介绍了两种风格的初始硬件和操作系统创建线程的操作系统方法。
9 j% M4 N" T% T  n一种是万事俱备，只欠东风
& V$ C% o- [/ n' F9 U2 o

1. int main(void)
   : A$ Y+ z1 b$ n
2. {
   : s7 m' y" Z5 K
3.     /*硬件初始化*/
   ( i" A4 b0 y9 h. g6 z
4.    HardWare_Init();
   % h# V. q& m% C, N
5.     /*RTOS 系统初始化*/
   5 d2 }3 f% P0 B# n& Q, x! c( t: @
6.    RT_Init();
   
7.    /*创建线程*/
   1 ?( y9 p( N$ A
8.    RTOS_ThreadCreate(Task1);
   $ b" p8 ~* |3 g. H  i' Q- e
9.    RTOS_ThreadCreate(Task1);
   8 {2 t! b# V5 L4 A# F7 [
10.    //...
    3 }. M  g: K" {
11.   RTOS_Start();
    ) G- N. }8 H; c. J9 |( L% f+ i
12. }

复制代码

2 _: |4 T. i+ V: C; a6 b+ {
, y. {2 F5 y9 u# L第二种是小心翼翼，十分谨慎

1. int main(void)
   
2. {
   " S2 f% ?" }1 v) h! V; v: \, `+ v2 V6 X
3. /*硬件初始化*/
   
4. HardWare_Init();
   * z8 ~$ b% u4 f9 i, n1 {4 U, ~
5. /*RTOS 系统初始化*/
   
6. RT_Init();
   : i9 Q/ q& K9 @4 b' F' a8 a
7. /*创建线程*/
   ' @; u+ y  A% \& o& {# [% ?
8. RTOS_ThreadCreate(AppThreadStart);
   
9. //启动RTOS，开始调度
   ; y" H; K: B8 g: q# }0 f+ O
10. RTOS_Start();
    ; e% F. g8 N; }0 Q/ R9 ?
11. }
    9 g9 H& C0 O$ F6 e6 [1 C
12. //AppThreadStart线程再创建线程，然后删除自己
    2 h7 o( l. I# m: Z+ C
13. void AppThreadStart(void *arg)

复制代码

5 n9 B" Z  ^4 v  T/ J# a/ A很有意思，还介绍了它们的优缺点，并介绍 UCOS freertos rt-thread是 怎么用的。
, m4 r4 Z6 Q4 L% P. \! d然后开始介绍RT-THREAD的启动流程
start-stm32xxxxxx.s:
, D% M) ], {% j+ J9 K: |: j) X' F

1. ; Reset handler
   : X6 s8 o& l3 u8 E3 D
2. Reset_Handler    PROC
   " m3 n9 P' e+ i2 o9 ?2 v
3.                  EXPORT  Reset_Handler             [WEAK]
   
4.         IMPORT  SystemInit
   2 a: g; S5 G* S2 m! `
5.         IMPORT  __main
   
6. 
   
7.                  LDR     R0, =SystemInit
   
8.                  BLX     R0
   & g6 U# C( }  I
9.                  LDR     R0, =__main
   
10.                  BX      R0
    # ]9 x7 h/ z6 M9 q
11.                  ENDP

复制代码

书中给我们介绍了这里执行后会跳到commponet.c中的$Sub$$main函数：因为编译器使用$Sub$$或$Super$$扩展main函数。$Sub$$main函数可以在
1 N: H0 G+ }% k9 \: S$ o9 Smain函数前面做些事情。那我们就到commponet.c去看一下（记得前面说的还是搞个工程对照好，可以加深印象）。
7 \3 Y  c' \# E5 I5 z# B

1. int $Sub$main(void)
   9 u. r  q0 v) }5 `
2. {
   
3.     rt_hw_interrupt_disable();
   0 f6 W+ W+ ]( Z9 w- f5 B
4.     rtthread_startup();
   % q" `  E3 X: x% U; @( n
5.     return 0;
   / z- a2 `& Z4 h4 y+ I+ i
6. }

复制代码

关中断，然后启动RT-THREAD！！！
6 M' g) p; _/ V% T: ?: ]- D我们也可以跳到rtthread_startup();看看它干了些什么！！！
4 Z/ w( v$ Y5 R1 }

1. int rtthread_startup(void)
   3 I5 X* r1 ]4 N1 @, H3 G( m. p) h
2. {
   # m. a6 L. w2 W
3.     rt_hw_interrupt_disable();
   6 \1 `; g* n/ h2 Y* Z
4. 
   
5.     /* board level initalization
   
6.      * NOTE: please initialize heap inside board initialization.
   2 U" t% }, _: u
7.      */
   
8.     rt_hw_board_init();
   
9. 
   ! _) J- E& }$ k' m- ?
10.     /* show RT-Thread version */
    
11.     rt_show_version();
    
12. 
    
13.     /* timer system initialization */
    / n5 N7 M4 ?& ]; i" g( ?
14.     rt_system_timer_init();
    
15. 
    
16.     /* scheduler system initialization */
    . l9 p7 r+ o0 P: L# b
17.     rt_system_scheduler_init();
    
18. 
    5 Y4 p* j& V) h( c2 p9 g
19. #ifdef RT_USING_SIGNALS
    9 V8 f6 d- p6 G, D9 s
20.     /* signal system initialization */
    
21.     rt_system_signal_init();
    " p* Y6 e9 Z3 r! U  |
22. #endif
      ~4 t7 d1 U5 K) R/ ?5 J
23. 
    9 v' Y- l8 S) R1 W* g$ P/ `
24.     /* create init_thread */
    6 z7 i" w2 R2 |
25.     rt_application_init();
    4 [: m9 M( \4 N# a! A
26. 
    
27.     /* timer thread initialization */
    5 i5 B" X4 \4 H7 n
28.     rt_system_timer_thread_init();
    5 t- k2 Q0 R8 G
29. 
    8 D0 D' N" i3 g2 h- N% s
30.     /* idle thread initialization */
    
31.     rt_thread_idle_init();
    # i5 n" t1 N) J$ L6 e7 @: `
32. 
    3 |* B8 b5 I. u- {3 a
33.     /* start scheduler */
    
34.     rt_system_scheduler_start();
    
35. 
    ! H5 x* K- T8 }+ E9 R- l
36.     /* never reach here */
      M# u' ]* \6 ^2 c8 m$ S2 c
37.     return 0;
    
38. }

复制代码

其实这里我们也可以运行一个例子如：rtthread_simulator_v0.1.0，看看启动的时候有没有和上面一样
9 D! Q8 Z0 I5 s/ d! _最后 我们看看本书配套的17，线程管理例子看看int main()函数

1. 
   

复制代码

1. int main(void)
     }) w6 W# ?% q* t% B7 j
2. {        
   7 t+ D- Z. [( Z) @: c% T) M
3.     /*
   * B4 @* r3 N  N- Z- L6 M
4.          * 开发板硬件初始化，RTT系统初始化已经在main函数之前完成，
   8 Y: z$ E* u8 ?% s5 M2 b
5.          * 即在component.c文件中的rtthread_startup()函数中完成了。
     ~& i% D$ D5 j- M
6.          * 所以在main函数中，只需要创建线程和启动线程即可。
   
7.          */
   ' R; M8 g6 G8 R& B/ @
8.    rt_kprintf("这是一个[野火]-STM32F767-挑战者RTT线程管理实验！\n\n");
   7 x! b$ ^) `4 a6 q
9.    rt_kprintf("按下K1挂起线程，按下K2恢复线程\n");
   
10.         led1_thread =                          /* 线程控制块指针 */
    2 ]$ s- U3 q% Z/ N4 x. c
11.     rt_thread_create( "led1",              /* 线程名字 */
    : C6 A" y& d/ a
12.                       led1_thread_entry,   /* 线程入口函数 */
    
13.                       RT_NULL,             /* 线程入口函数参数 */
    
14.                       512,                 /* 线程栈大小 */
    
15.                       3,                   /* 线程的优先级 */
    ; Z0 F" v2 K: n! C. E
16.                       20);                 /* 线程时间片 */
    
17.                   
    % w% d* ?2 o( ^# g: Z
18.     /* 启动线程，开启调度 */
    4 c( t4 o. a0 D, L% c) ^
19.     if (led1_thread != RT_NULL)
    
20.         rt_thread_startup(led1_thread);
    
21.     else
    
22.         return -1;
    
23.    
    
24.     key_thread =                          /* 线程控制块指针 */
    
25.     rt_thread_create( "key",              /* 线程名字 */
    
26.                       key_thread_entry,   /* 线程入口函数 */
    ' f7 R9 u# @$ b# k$ k, G
27.                       RT_NULL,             /* 线程入口函数参数 */
    
28.                       512,                 /* 线程栈大小 */
    ( M7 L" K6 E. r' r- X; T
29.                       2,                   /* 线程的优先级 */
    
30.                       20);                 /* 线程时间片 */
    
31.                   
    5 u* s( {" a) h+ [1 d% \+ e- [, O
32.     /* 启动线程，开启调度 */
    
33.    if (key_thread != RT_NULL)
    
34.         rt_thread_startup(key_thread);
    + U- r: w  B1 y% K
35.     else
    / F$ |5 j# v* ?  Y
36.         return -1;
    
37. }

复制代码

这样读书&看代码。就熟悉了RT-THREAD的启动流程。先写到这里。谢谢。 火哥的书通俗易懂！！！
: Y: j$ d- j# z( M; C) H
" D* [! _$ k  \

andeyqi 发表于 2018-12-4 12:08
顶一个

3 {/ u$ J7 v2 P. p+ Y1 ~3 x4 t谢谢 支持！！！
8 y5 A: d( {3 i& e" n

支持~