快速入门
可以去官方有相关文档说明
首先将KEIL下载下来，官网上有相关例程
# R, A1 D7 K0 t  @9 x. j% q
, z" J1 @2 T9 s# t! [工程说明

. M$ y" {$ L1 l: z  \& j
6 [" o$ n: `2 T7 z, |
: k- `0 [7 K" ^; X! M

7 D* A- r# R; r5 a5 Y7 z" F0 Y3 T& c  x

调试命令
打开调试公共点击运行（F5）代码，打开串口UART#1，点击Tab键或者help+回车，查看系统支持的命令。
/ z% `8 a0 ]1 e; p1 |! B

* R+ H% W% |) e3 ?; P
, t$ }) f7 P  s6 F, C3 J: C

系统启动步骤
         以 MDK-ARM 为例，MDK-ARM 的用户程序入口为 main() 函数，位于 main.c 文件中。系统启动后先从汇编代码 startup_stm32f103xe.s 开始运行，然后跳转到 C 代码，进行 RT-Thread 系统功能初始化，最后进入用户程序入口 main()。
% l5 `8 u: y2 p8 \

* P* Y7 R3 T1 `7 W
如果使用到了ARM内核则重新定义启动当时，最终跳到了rtthread_startup(); 是RT-Thread规定的统一启动入口。 启动程序函数初始化如下图所示：



启动代码分为四部分：


3 _- l2 T: U! ?4 ~. F
! E! `  R0 O$ g$ r* E. r用户入口代码
! A) A& Y  r8 {" a" H        为了在进入 main 程序之前，完成系统功能初始化，可以使用 $sub$$ 和 $super$$ 函数标识符在进入主程序之前调用另外一个例程，这样可以让用户不用去管 main() 之前的系统初始化操作。

7 M. ~% ]* j- g4 z3 v# t6 G0 t, n内核基础
内核的组成部分、系统如何启动、内存分布情况以及内核配置方法。
: I" }  x% x7 {" t

6 i' f7 m: x5 O" {4 _! Y
实时内核的实现包括：对象管理、线程管理及调度器、线程间通信管理、时钟管理及内存管理等等，内核最小的资源占用情况是 3KB ROM，1.2KB RAM。


线程调度
        线程是 RT-Thread 操作系统中最小的调度单位，线程调度算法是基于优先级的全抢占式多线程调度算法，即在系统中除了中断处理函数、调度器上锁部分的代码和禁止中断的代码是不可抢占的之外，系统的其他部分都是可以抢占的，包括线程调度器自身。


时钟管理
        RT-Thread 的时钟管理以时钟节拍为基础，时钟节拍（滴答始终）是 RT-Thread 操作系统中最小的时钟单位。RT-Thread 的定时器提供两类定时器机制：第一类是单次触发定时器，这类定时器在启动后只会触发一次定时器事件，然后定时器自动停止。第二类是周期触发定时器，这类定时器会周期性的触发定时器事件，直到用户手动的停止定时器否则将永远持续执行下去。

0 X& B/ j" R% B另外，根据超时函数执行时所处的上下文环境，RT-Thread 的定时器可以设置为 HARD_TIMER 模式或者 SOFT_TIMER 模式。
3 F( T+ O5 \% S( Z  U7 q8 d
) c3 F& v% Z, V% w  c# d; c  ?通常使用定时器定时回调函数（即超时函数），完成定时服务。用户根据自己对定时处理的实时性要求选择合适类型的定时器。


线程间同步
/ L3 A: Q9 L* w+ Q1 S        RT-Thread 采用信号量、互斥量与事件集实现线程间同步。线程通过对信号量、互斥量的获取与释放进行同步；互斥量采用优先级继承的方式解决了实时系统常见的优先级翻转问题，信号量会导致线程阻塞即当低优先级持有信号量时，高优先级无法获取信号量。
3 |1 c! r6 @6 _3 A+ P) o0 J) N
( D$ u% K' u- E) `- T2 U

, A, m  l& J  b: z# m, ~( I2 m
. L- f0 h5 f! a1 }: O线程间通信
         RT-Thread 支持邮箱和消息队列等通信机制。邮箱中一封邮件的长度固定为 4 字节大小；消息队列能够接收不固定长度的消息，并把消息缓存在自己的内存空间中。邮箱效率较消息队列更为高效。邮箱和消息队列的发送动作可安全用于中断服务例程中。通信机制支持线程按优先级等待或按先进先出方式获取。
* \1 _3 J# M$ E+ X
* T: M1 F; o( F. E/ f+ K) t6 S8 p
. g! `  h! r5 _6 {/ \* z内存管理
        RT-Thread 支持静态内存池管理及动态内存堆管理。当静态内存池具有可用内存时，系统对内存块分配的时间将是恒定的；当静态内存池为空时，系统将申请内存块的线程挂起或阻塞掉 (即线程等待一段时间后仍未获得内存块就放弃申请并返回，或者立刻返回。等待的时间取决于申请内存块时设置的等待时间参数)，当其他线程释放内存块到内存池时，如果有挂起的待分配内存块的线程存在的话，则系统会将这个线程唤醒。
! @1 z/ K! Z* \% ^6 t
动态内存堆管理模块在系统资源不同的情况下，分别提供了面向小内存系统的内存管理算法及面向大内存系统的 SLAB 内存管理算法。

, A  @/ p" x2 Q还有一种动态内存堆管理叫做 memheap，适用于系统含有多个地址且不连续的内存堆。使用 memheap 可以将多个内存堆 “粘贴” 在一起，让用户操作起来像是在操作一个内存堆。
5 I( e% i9 d& v) m7 p$ T$ n/ {
4 j, _4 r8 A0 D0 m" M- ]" _
I/O设备管理
6 k$ w9 _6 A" t5 ~        RT-Thread 将 PIN、I2C、SPI、USB、UART 等作为外设设备，统一通过设备注册完成。实现了按名称访问的设备管理子系统，可按照统一的 API 界面访问硬件设备。在设备驱动接口上，根据嵌入式系统的特点，对不同的设备可以挂接相应的事件。当设备事件触发时，由驱动程序通知给上层的应用程序。
" x, O/ B! ~; G$ B% E

程序内存分布
( p0 B3 w, `. k. p6 ~5 Z4 }( d( ?$ f7 c一般MCU包含的存储空间有：片内Flash（硬盘）与片内RAM（内存）。编译器会将一个程序分类为好几个部分，分别存储在 MCU 不同的存储区。
' M4 d5 X' s+ S" b) y5 P2 O  H
% E+ i" q* p$ l1 Z) x9 T" ^Keil工程在编译完成后，会相应的程序提示占用空间

2 t2 k" k, p2 J5 B" u

4 i3 n' ~. e" V! V. e2 }1.Code：代码段，存放程序的代码部分；
/ H( v2 X8 x* |, Z2.RO-data：只读数据段，存放程序中定义的常量；
3.RW-data：读写数据段，存放初始化为非 0 值的全局变量；
4.ZI-data：0 数据段，存放未初始化的全局变量及初始化为 0 的变量；
/ t( I& U9 f; d  ?. C; c6 C
9 k. {' y; @3 v( G编译完后工程会生成一个.map文件，说明了各个函数占用的吃尺寸和地址，在文件最后几行与场面的关系。

& d' u' }" l1 z( z

7 I, i/ t0 n5 |1 g0 X8 ~: E+ L1.RO Size 包含了 Code 及 RO-data，表示程序占用 Flash 空间的大小；
9 D3 A( x8 A. A( k6 X2.RW Size 包含了 RW-data 及 ZI-data，表示运行时占用的 RAM 的大小；
3.ROM Size 包含了 Code、RO-data 以及 RW-data，表示烧写程序所占用的 Flash 空间的大小；


6 v$ R4 A- J& @STM32 在上电启动之后默认从 Flash 启动，启动之后会将 RW 段中的 RW-data（初始化的全局变量）搬运到 RAM 中，但不会搬运 RO 段，即 CPU 的执行代码从 Flash 中读取，另外根据编译器给出的 ZI 地址和大小分配出 ZI 段，并将这块 RAM 区域清零。


4 N1 k4 J+ v7 i1 Q* I
动态内存的申请：msg_ptr 指针指向的 128 字节内存空间位于动态内存堆空间中。



而一些全局变量则是存放于 RW 段和 ZI 段中，RW 段存放的是具有初始值的全局变量（而常量形式的全局变量则放置在 RO 段中，是只读属性的），ZI 段存放的系统未初始化的全局变量。
% y& ~& A+ x) n

$ P  l2 d2 O+ |8 i" S& i自动初始化机制
; F" f( F  i& ?" C3 v2 i, `自动初始化机制是指初始化函数不需要被显式调用，只需要在函数定义处通过宏定义的方式进行申明，就会在系统启动过程中被执行。

! O0 d5 P+ ~- ^  Q2 y
( H* K4 {( t! [/ Y6 C1 P+ p
& r  J$ @# s/ b
. p5 U4 Z5 ~  X. @$ {  h

$ }& }6 X, V$ f5 @$ ~* p内核对象模型
! J) {/ U* Q9 L. B+ Q% e6 o5 H静态与动态对象
静态内核对象通常放在 RW 段和 ZI 段中，在系统启动后在程序中初始化；
5 W8 n4 M2 }4 C" E  S, L: s8 I- D
$ g* b9 G! s) f+ x8 X& o动态内核对象则是从内存堆中创建的，而后手工做初始化，最后需要释放。

4 x: A, ]; x1 q$ b  s1 @静态对象会占用 RAM 空间，不依赖于内存堆管理器，内存分配时间确定。动态对象则依赖于内存堆管理器，运行时申请 RAM 空间，当对象被删除后，占用的 RAM 空间被释放。这两种方式各有利弊，可以根据实际环境需求选择具体使用方式。

- a8 P* |) x  ]/ `4 Q3 D内核对象管理架构
静态对象会占用 RAM 空间，不依赖于内存堆管理器，内存分配时间确定。动态对象则依赖于内存堆管理器，运行时申请 RAM 空间，当对象被删除后，占用的 RAM 空间被释放。这两种方式各有利弊，可以根据实际环境需求选择具体使用方式。
. |8 ?5 M% g" R: L  m$ o

% p2 s/ h; W7 Q4 `$ a. Y% t


; v4 `: A$ G! A) p
; I, i2 k$ H- J9 {( q0 x 对象控制块
1 ~6 @2 o- k$ E1 a) ?4 v$ F! Q( ?

1. struct rt_object
   
2. {
   " \3 k! d  m" w1 _
3.      /* 内核对象名称     */
   
4.      char      name[RT_NAME_MAX];
   , @6 J9 a$ I& ]1 Y- |+ w& N
5.      /* 内核对象类型     */
   
6.      rt_uint8_t  type;
   8 [' J: L) [- E8 D* ~. |0 j) o
7.      /* 内核对象的参数   */
   3 c, W3 b# b/ M8 N4 L" n% P/ b
8.      rt_uint8_t  flag;
   8 y! A, K. f/ v# v5 c. E7 [
9.      /* 内核对象管理链表 */
   0 G2 {1 r, ^' A9 j5 U
10.      rt_list_t   list;
    
11. };

复制代码

1. struct rt_object_information
   9 l. ~' `6 T# _
2. {
   
3.      /* 对象类型 */
   4 W# Y9 I" _5 B3 O
4.      enum rt_object_class_type type;
   & z7 r. z4 b" Z& T- {$ g% G
5.      /* 对象链表 */
   + V2 _6 b5 m' f4 Y. K! q! ~
6.      rt_list_t object_list;
   ) v7 h' H5 G& e& F  C3 ^
7.      /* 对象大小 */
   0 n* d& g, A1 l/ y
8.      rt_size_t object_size;
   6 g" X4 F8 i, p9 k
9. };

复制代码

遍历内核对象

1. rt_thread_t thread = RT_NULL;
   
2. struct rt_list_node *node = RT_NULL;
   ! S9 p, l6 r% z" d( |: v
3. struct rt_object_information *information = RT_NULL;
   
4. 
   / l: X0 {" K% U+ Y  E% |0 G, O
5. information = rt_object_get_information(RT_Object_Class_Thread);
   * a3 j# W  @' A, O
6. 
   
7. rt_list_for_each(node, &(information->object_list))
   
8. {
   
9.     thread = (rt_thread_t)rt_list_entry(node, struct rt_object, list);
   
10.     /* 比如打印所有thread的名字 */
    
11.     rt_kprintf("name:%s\n", thread->name);
    
12. }

复制代码

2 @9 ~4 h& s8 ]6 h1 R2 \" I

1. rt_mutex_t mutex = RT_NULL;
   
2. struct rt_list_node *node = RT_NULL;
   & I, i' D! z9 t' c' Z4 l
3. struct rt_object_information *information = RT_NULL;
   
4. 
   
5. information = rt_object_get_information(RT_Object_Class_Mutex);
   ' X2 E/ O" x! R: m3 \
6. 
   * z5 w9 v; _8 l
7. rt_list_for_each(node, &(information->object_list))
   : R& F7 s) O1 R
8. {
   
9.     mutex = (rt_mutex_t)rt_list_entry(node, struct rt_object, list);
   ) a- z6 w7 d. H4 o8 S7 D& V
10.     /* 比如打印所有mutex的名字 */
    1 y; z; W; P: W
11.     rt_kprintf("name:%s\n", mutex->parent.parent.name);
    8 r% E2 \9 B) B3 p" a# s
12. }

复制代码

$ {- \/ x' y* \7 s
内核配置与裁剪
. Z3 z' i( Q2 [配置主要是通过修改工程目录下的 rtconfig.h 文件来进行，用户可以通过打开 / 关闭该文件中的宏定义来对代码进行条件编译，最终达到系统配置和裁剪的目的

: `% A4 e+ Q9 u. h注：在实际应用中，系统配置文件 rtconfig.h 是由配置工具自动生成的，无需手动更改。

& V/ G& s( ?6 R6 o1 }; I
第8章 线程的定义与线程的切换
定义线程栈：
% p' K# Z& V  Q" ?9 O- _

/ D# A3 a: N9 `( q- G* L  ^
rt_uint8_t
        这些经过重定义的数据类型放在rtdef.h（rtdef.h 第一次使用需要在 include 文件夹下面新建然后添加到工程 rtt/source 这个组文件）这个头文件。

ALIGN
# s( c" w: y, u  d( G$ B        是一个带参宏，也在rtdef.h中定义



* a  O9 w3 Q5 E/ q RT_ALIGN_SIZE
是一个在 rtconfifig.h （ rtconfifig.h 第一次使用需要在 User 文件夹下面新建然后添加到工程 user
这个组文件）中定义的宏


* u9 V. G; k% ^7 k' c: m. @
2 x) G9 ^5 I  o* \7 E, l
+ d- a' }5 ]# P  
遵循 RT-Thread 中的函数命名规则，以小写的 rt 开头，表示这是一个外部函数，可以由用户调用，以 _rt 开头的函数表示内部函数，只能由 RT-Thread 内部使用。紧接着是文件名，表示该函数放在哪个文件，最后是函数功能名称。
thread 是线程控制块指针。
# T+ e$ g. i( Bentry 是线程函数名，表示线程的入口。
parameter 是线程形参，用于传递线程参数。
- m9 E) i- q& x! a3 {( r9 M  kstack_start 用于指向线程栈的起始地址。
stack_size 表示线程栈的大小，单位为字节。

链表
1 j4 I+ P+ E' n0 x5 f  W



7 h6 V; ]" G0 U; u- P. p/ j6 l
这些函数均在 rtservice.h 中实现，rtservice.h 第一次使用需要自行在 rtthread/3.0.3/include 文件夹下新建，然后添加到工程的 rtt/source 组中。

7 N& H- V3 P; f
初始化链表节点
, O7 U1 X" U$ K- S! V1 y
/ N$ j) Q" s  m1 w1 c2 m6 T. M& r

; N; n' w% _5 C 双向链表表头后面插入一个节点



7 q( [: q5 a6 K+ t3 t/ Q# O. }
1 F3 v/ E0 k; G3 _6 ^) p7 W
双向链表表头前面插入一个节点



* f& _9 }# t8 B& {

双向链表删除一个节点
/ J2 a, U$ E- N; S! o

" u. I7 D6 M7 Q( z0 |% c
2 P( b) ^9 t* e$ r! N) J
4 H4 l3 W5 Y  ]/ c1 }. F4 ^线程栈初始化：rt_hw_stack_init() 函数
& N+ h! J$ q5 b' _8 X/* 获取栈顶指针 rt_hw_stack_init 在调用的时候，传给 stack_addr 的是 ( 栈顶指针 )*
3 g; J& Q0 d3 [0 `1 B6 sstk = stack_addr + sizeof (rt_uint32_t);


% M  K3 Z, ^* S1 p  Q- |
stk = (rt_uint8_t * )RT_ALIGN_DOWN((rt_uint32_t)stk, 8 );
" I5 d, P, D' y: ]让 stk 这个指针向下 8 个字节对齐，确保 stk 是 8 字节对齐的地址。在 Cortex-M3 （ Cortex-M4 或 Cortex-M7 ）内核的单片机中，因为总线宽度是 32 位的，通常只要栈保持 4 字节对齐就行，可这样为啥要 8 字节？难道有哪些操作是 64 位的？ 确实有，那就是浮点运算，所以要 8 字节对齐（但是目前我们都还没有涉及到浮点运算，只是为了后续兼容浮点运行的考虑） 。如果栈顶指针是 8 字节对齐的，在进行向下 8 字节对齐的时候，指针不会移动，如果不是 8 字节对齐的，在做向下 8 字节对齐的时候，就会空出几个字节，不会使用，比如当 stk 是 33 ，明显不能整除 8 ，进行向下 8 字节对齐就是 32，那么就会空出一个字节不使用。
( w1 u4 e! t* t2 o; d1 u

  r+ b3 m- j" u& B8 ~
线程第一次运行的时候，加载到 CPU 寄存器的环境参数我们要预先初始化好。从栈顶开始，初始化的顺序固定，首先是异常发生时自动保存的 8 个寄存器，即 xPSR 、 R15 、 R14 、 R12 、 R3 、 R2 、 R1 和 R0 。 其中 xPSR 寄存器的位 24 必须是1，R15 PC 指针必须存的是线程的入口地址，R0 必须是线程形参，剩下的 R14、R12、R3、R2 和 R1 我们初始化为 0。
; K1 ^4 K8 z. y

# G/ g* B3 a3 Y3 K: X! f
8 n  k; l2 I3 `8 @" j将线程插入到双向就绪列表       
' G/ H2 b& i! y. E9 f# f7 y         线程创建好之后，我们需要把线程添加到就绪列表里面，表示线程已经就绪，系统随时可以调度。就绪列表在 scheduler.c 中定义（scheduler.c 第一次使用需要在 rtthread3.0.3src 目录下新建，然后添加到工程的 rtt/source 组中）。
: n7 V7 V* ?2 s, S% c6 j





实现调度器
; o/ v3 C9 w& X7 g2 O* M$ i        调度器是操作系统的核心，其主要功能就是实现线程的切换，即从就绪列表里面找到优先级最高的线程，然后去执行该线程。从代码上来看，调度器无非也就是由几个全局变量和一些可以实现线程切换的函数组成，全部都在 scheduler.c 文件中实现。
5 r$ d, Z6 T4 ]$ B1 L
& I; X4 i# J* ^( @0 E  i! O
" R) G: T1 u6 Y
定义一个局部变量，用 C 语言关键词 register 修饰，防止被编译器优化。我们把调度器初始化放在硬件初始化之后，线程创建之前
调度器启动由函数 rt_system_scheduler_start() 来完成

. g" a; n' l/ D8 N4 p系统调度
- I# F+ I7 w3 j* [8 r8 I: {系统调度就是在就绪列表中寻找优先级最高的就绪线程，然后去执行该线程。但是目前我们还不 支持优先级，仅实现两个线程轮流切换，系统调度函数 rt_schedule。
+ T& e. X/ H7 q9 l4 y
main函数
5 V  U/ l( {% L4 A7 P线程的创建，就绪列表的实现，调度器的实现均已经讲完，现在我们把全部的测试代码都放到 main.c 里面

$ g( G6 E0 B, C* l) M. r* t7 T" H

4 o" j8 P5 Z! q5 S1 j; r* ~6 m第9章 临界段的保护
        临界段用一句话概括就是一段在执行的时候 不能被中断的代码段 。在 RT-Thread 里面，这个临界段最常出现的就是对全局变量的操作。
        那么什么情况下临界段会被打断？一个是系统调度，还有一个就是外部中断。在 RT-Thread，系统调度，最终也是产生 PendSV 中断，在 PendSV Handler 里面实现线程的切换，所以还是可以归结为中断。既然这样， RT-Thread 对临界段的保护就处理的很干脆了，直接把中断全部关了，NMIFAULT 和硬 FAULT 除外。


) j5 y7 a: q; S" X9 |


" N" @2 y# K+ S
0 v+ N: R+ r7 e; Z& [$ g% U" Y+ p2 O第10章  对象容器的实现
4 Y' A: M3 s) V1 q! |% x0 z在 RT-Thread 中，所有的数据结构都称之为对象。
6 N  G' P% e% Z


1 A" q6 I0 y1 M  p; S8 l

0 p# ^5 g) ]7 D* C2 `在 RT-Thread 中，每个对象都会有对应的一个结构体，这个结构体叫做该对象的控制块。
0 c# \9 z, f0 f7 Z


. h. h5 T! k0 z2 r  P' t
: R* Q* t# N* \在 rtt 中，每当用户创建一个对象，如线程，就会将这个对象放到一个叫做容器的地方。

那什么是容器，从代码上看，容器就是一个数组，是一个全局变量，数据类型为 struct
2 A! d; p" d8 g  `rt_object_information ，在 object.c 中定义
) |8 l' C0 a$ H+ l3 ]
9 ]/ I7 l& S7 h; o9 h2 u  J( b
# H( V' F1 D7 J$ ~" m& |
; K4 T, x2 o+ L* L' c! q
& f# {, x0 w7 p  ]3 c& Y
! ]" K! ?: X7 Q
————————————————
9 E7 k7 k, R' w# K( n版权声明：追逐者-桥
% U" }4 A* I% q* E% `" p7 \' y如有侵权请联系删除