RT-Thread文档读书笔记 - 内核

RT-Thread文档读书笔记

  • 内核框图

1.内核库是为了保证内核能够独立运行的一套小型的类似 C 库的函数实现子集。

  • 线程调度

1.在系统中除了中断处理函数、调度器上锁部分的代码和禁止中断的代码是不可抢占的之外，系统的其他部分都是可以抢占的，包括线程调度器自身。

2.最低优先级留给空闲线程使用。

3.调度器在寻找那些处于就绪状态的具有最高优先级的线程时，所经历的时间是恒定的。

  • 时钟管理

1.根据超时函数执行时所处的上下文环境，RT-Thread 的定时器可以设置为 HARD_TIMER 模式或者 SOFT_TIMER 模式。

2.使用定时器定时回调函数（即超时函数），完成定时服务。

  • 线程间通信

1.消息队列能够接收不固定长度的消息，并把消息缓存在自己的内存空间中。

2.邮箱和消息队列的发送动作可安全用于中断服务例程中。因为消息队列空间不属于任何线程，归系统所有。

  • 设备管理

RT-Thread 将 PIN、I2C、SPI、USB、UART 等作为外设设备，统一通过设备注册完成。实现了按名称访问的设备管理子系统，可按照统一的 API 界面访问硬件设备。在设备驱动接口上，根据嵌入式系统的特点，对不同的设备可以挂接相应的事件。当设备事件触发时，由驱动程序通知给上层的应用程序。

  • 系统启动

1.启动流程图

2.MCU外设硬件初始化，在调度器运行之前$Sub$$main()中初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void rt_hw_board_init(void)
{
....
#ifdef RT_USING_HEAP
    rt_system_heap_init((void *)NRF_HEAP_BEGIN, (void *)CHIP_HEAP_END); // 系统堆初始化
    rt_kprintf("beagin:0x%x\r\n", NRF_HEAP_BEGIN);
#endif

#ifdef RT_USING_COMPONENTS_INIT
    rt_components_board_init();  // MCU外设硬件初始化
#endif

#if defined(RT_USING_CONSOLE) && defined(RT_USING_DEVICE)
    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
#endif
....
}

/**
 * RT-Thread Components Initialization for board
 */
void rt_components_board_init(void)
{
    volatile const init_fn_t *fn_ptr;

    for (fn_ptr = &__rt_init_rti_board_start; fn_ptr <= &__rt_init_rti_board_end; fn_ptr++)
    {
        (*fn_ptr)();
    }
}


3.系统或自己实现的模块初始化，在调度器开始后，在mian线程入口main_thread_entry()中初始化

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * RT-Thread Components Initialization
 */
void rt_components_init(void)
{
    volatile const init_fn_t *fn_ptr;
    rt_kprintf("__rt_init_rti_board_end:0x%x __rt_init_rti_end: 0x%x\n", &__rt_init_rti_board_end,&__rt_init_rti_end);
    for (fn_ptr = &__rt_init_rti_board_end; fn_ptr <= &__rt_init_rti_end; fn_ptr ++)
    {
        (*fn_ptr)();
    }
}

int value = 555;

!!value二次取反：第一次!将value转换成bool值false，第一次!将bool value = false转换成true，确保value的值一定是bool值，只有两个值true/false。

  • 内核对象模型

静态内核对象：存放在RW/ZI段中，在系统启动时对象被自动初始化。

动态内核对象：程序运行时在堆中创建，然后手工初始化。

静态对象会占用RAM空间，不依赖与内存管理器，内存分配时间确定。

动态对象则依赖内存管理器，分配对象时根据系统当时的内存情况决定分配的时间长短，分配好后可再被删除。

  • 内核对象管理框架

内核对象管理系统管理所有的内核对象，不管是静态内核对象还是动态内核对象统一动过管理器由对象名字来访问内核对象。

内核对象容器（数组的元素，即内核对象链表头）：

内核对象：

此类可作为基类被包含在其它对象中，从而扩展自己的属性，我们可以通过构建一个类（通常是一个device）继承该类，实例化后挂载到内核里面，内核就可以通过名字来找到我们自己创建的对象了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 初始化一个静态的内核对象，要求对象已经存在空间
void rt_object_init(struct rt_object         *object,
                    enum rt_object_class_type type,
                    const char               *name);
// 脱离一个静态对象，把它从内核链表中移除，空间并不会被释放因为是静态对象
void rt_object_detach(rt_object_t object);

// 分配一个对象，返回一个指向该对象的指针
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);
// 删除一个对象
void rt_object_delete(rt_object_t object);

// 判断一个对象是静态对象还是动态对象
rt_bool_t rt_object_is_systemobject(rt_object_t object);

只要是位于静态空间的对象都会被rt_object_init()初始化为：RT_Object_Class_Static 对象类型，由此用于区分是否是静态对象或者动态对象。

  • 常见宏定义
1
2
3
4
5
6
7
#define RT_WEAK                     __attribute__((weak))
#define rt_inline                   static __inline
#define RT_UNUSED                   __attribute__((unused))
#define RT_USED                     __attribute__((used))
#define PRAGMA(x)                   _Pragma(#x)
#define ALIGN(n)                    __attribute__((aligned(n)))
#define RT_ALIGN(size, align)           (((size) + (align) - 1) & ~((align) - 1))

线程管理

  • 线程

线程包括：线程控制块、线程栈、线程入口函数

线程初始化_rt_thread_init()时默认：

  • 优先级

0为最高优先级，一般设置0-31，共32级，idle优先级设置为最低31，用户线程一般不设置优先级为31，设置0-30。

僵尸链表，线程退出是会自动调用rt_thread_exit()应该是放在函数入口lr寄存器，把当前线程假如到僵尸链表，杂空闲任务里面检测该链表并删除线程。

  • 线程状态图

  • 空闲任务钩子函数

钩子函数可以钩入功耗管理、喂狗等工作，因为必须保证空闲线程要一直处于就绪态，钩子函数里面不能出现任何会使线程挂起的操作。

时钟

  • 定时器

硬件定时器：上下文是中断中，在定时器外设中断检查定时器是否超时，超时则执行超时函数。

软件定时器：上下文是线程中，创建一个线程专门检查软件定时器是否超时，超时则执行超时函数。

在硬件定时超时函数不应去挂起、等到等操作，不应去申请释放动态内存。

RT_TIMER_SKIP_LIST_LEVEL定时器跳表层数，默认跳表是一层，相当于不使用跳表算法。

  • 硬件定时器链表和软件定时器链表

1
2
3
4
5
// 硬件定时器初始化：初始化硬件定时器链表
void rt_system_timer_init(void);

// 软件定时器初始化：初始化软件定时器链表和创建软件定时器线程
void rt_system_timer_thread_init(void)；

单次定时器会在定时器超时后被从定时器链表中移除，而周期定时器会被从定时器移除后，再次按照定时器的超时键先后顺序重新插入定时器链表。

  • 只支持小于 1 OS Tick的超短时间延时

两种进入临界区的方式：

1
2
3
4
5
void rt_enter_critical(void); // 锁调度器方式，防止线程调度
void rt_exit_critical(void);

void rt_hw_interrupt_enable(rt_base_t level); // 屏蔽中断方式
rt_base_t rt_hw_interrupt_disable(void);

线程间同步和互斥

  • 信号量

信号量进行P操作释放一个信号量的时候，唤醒该信号量挂起链表上的第一个线程。

  • 计数信号量

计数信号量适用于工作处理速度不匹配的场合，一般计数信号量也应配合互斥量混合使用对资源加锁访问。

  • 互斥锁

线程与线程之间的互斥采用互斥锁，而中断与线程之间只能采用开关中断的方式进行互斥。IPC对象的内部实现时需要资源保护也使用开关中断的方式。

互斥锁的特点：

1.所有权：互斥量有所有权只能由同一个线程对互斥量加锁解锁，互斥量会被线程持有，所有权归于此线程，只有这个线程可以对互斥锁解锁，其它线程不可以。

2.递归性：互斥量可以多次获取（需多次释放），二值信号量不能多次获取否则线程会被死锁。

3.继承性：互斥量的持有线程会继承，尝试获取该互斥量比自己高优先级的线性的优先级。

持有互斥量的线程应尽快释放互斥量，且不能在持有互斥量期间手动改变线程的优先级，切记互斥量不能在中断服务函数中使用，因为互斥量只能属于某个线程。中断中若要进行资源保护就使用开关中断的方式。

  • 事件集

1.特定事件唤醒线程。

2.任意事件唤醒线程。类似于linux的select()集合，可实现io多路复用。

3.多个事件发生时唤醒线程。

一对多：一个线程对应多个事件。

多对多：多个线程对应多个事件。

逻辑或：线程与任意事件发生同步。

逻辑与：线程与若干事件都发生同步。

事件无排队性：多次向同一线程发送相同事件效果和发送一次一样。

线程间通信

  • 邮箱

非阻塞方式的邮件发送可用于中断，邮件的接收通常是以阻塞的方式接收所以不能用于中断。

suspend_sender_thread：发送邮箱的挂起等待线程链表。

邮箱创建时需动态分配一段空间用来存放邮件。

邮箱的使用场景：

1.一次只能发送小于等于4字节内容的情况。

2.发送一个缓冲区信息结构体的指针。

1
2
3
4
5
6
7
8
9
10
11
// 缓存区信息结构体
struct msg
{
    char *pdata; // 指向缓存区
    int data_size; // 缓冲区的长度
};


struct msg *msg_ptr = (struct msg *)malloc(sizeof(struct msg));
msg_ptr->pdata = ...;
msg_ptr->data_size = ...;
  • 消息队列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct rt_messagequeue
{
    struct rt_ipc_object parent;

    void* msg_pool;                     /* 指向存放消息的缓冲区的指针 */

    rt_uint16_t msg_size;               /* 每个消息的长度 */
    rt_uint16_t max_msgs;               /* 最大能够容纳的消息数 */

    rt_uint16_t entry;                  /* 队列中已有的消息数 */

    void* msg_queue_head;               /* 消息链表头 */
    void* msg_queue_tail;               /* 消息链表尾 */
    void* msg_queue_free;               /* 空闲消息链表 */

    rt_list_t suspend_sender_thread;    /* 发送线程的挂起等待队列 */
};
typedef struct rt_messagequeue* rt_mq_t;

struct rt_mq_message
{
    struct rt_mq_message *next;  // 消息体指针
};

消息队列可用于线程与线程、中断与线程之间通信，中断中发送消息必须为非阻塞方式。

消息队列维护着两条链表：已有消息链表（msg_queue_head 到 msg_queue_free）、空闲消息链表（msg_queue_free 到 msg_queue_tail），最开始msg_queue_head和msg_queue_tail都等于NULL，msg_queue_free包含这个内存池空间，每次入队从msg_queue_free取一个节点填充数据然后插入到msg_queue_tai位置。有第一条新消息时msg_queue_head = new_msg，以后就是msg_queue_head和msg_queue_tail不变，msg_queue_free移动。

1
2
3
4
rt_err_t rt_mq_recv(rt_mq_t    mq,
                    void      *buffer,
                    rt_size_t  size,  // 最大不能大于每条消息的最大长度msg_size
                    rt_int32_t timeout);

同步消息场景：一个线程发送消息给另一个线程，另一个线程收到消息后要给线程发送一个ACK这个ACK可以使用邮箱或信号量。【消息队列 + 信号量或邮箱】

1
2
3
4
5
6
struct msg
{
    /* 消息内容 */
    ....
    struct rt_mailbox ack; // 消息中带有一个邮箱，让接收者接收到这条消息后会一个邮件，发送者发送完消息后要阻塞等待接收者回的邮件（状态码）
}
  • 信号

信号和信号量等的最大区别是信号是异步通信方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
struct rt_thread
{
    #if defined(RT_USING_SIGNALS)
    rt_sigset_t     sig_pending;                        /**< the pending signals */
    rt_sigset_t     sig_mask;                           /**< the mask bits of signal */

#ifndef RT_USING_SMP
    void            *sig_ret;                           /**< the return stack pointer from signal */
#endif
    rt_sighandler_t *sig_vectors;                       /**< 信号执行函数表 */
    void            *si_list;                           /**< the signal infor list */
#endif
};

1.信号是在软件层次上对中断的一种模拟，线程收到信号 –> 执行创建信号时绑定好的回调函数

线程信号线的三种处理：1.类似中断执行指定的处理函数， 2.忽略信号，不做任何处理， 3.对信号处理保留系统的默认值，系统默认的处理方式。

2.当信号被传递给线程时，如果线程被挂起，线程改为就绪去处理对应信号。当线程正在运行收到信号，那么它会在当前线程栈的基础上建立新栈空间（类似与中断和线程的空间都是独立的）去处理对应的信号。使用的线程栈大小也会相应增加。

1
2
3
4
5
rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler)； // 安装信号，在线程给信号绑定一个回调函数

void rt_signal_mask(int signo);  // 信号阻塞：相当于屏蔽信号，信号将不会窗体给安装次信号的线程

void rt_signal_unmask(int signo);  // 解除信号阻塞：使线程结束到该信号后有效

等待信号和信号量等没有区别，都是同步阻塞等待。

1
2
3
4
// set: 指定等待的信号
// si：指向储存等到信号信息的指针
// timeout：等待时间
int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout);

本章小结：

1.不可以在中断中接收邮件，不可以在中断中以等待方式发送邮件。

2.不可以在中断中接收消息队列的消息。

3.邮箱的邮件必须使用全局、静态、动态申请形式，邮箱内容直接发送邮内容的指针。

4.消息队列消息内容可以使用局部形式，消息会被复制进消息队列的空间。

5.消息队列是一种异步通信方式，如接收方需告诉发送方已经接收到消息，可以通过邮箱或信号量的方式。

内存管理

实时操作系统内存管理的特定和要求：

1.分配内存块事件必须确定。

2.可自动处理内存碎片的产生，不能重启。

3.嵌入式系统需针对不同的硬件内存大小给出不同的内存管理算法。

小内存算法：针对内存小于2M

memheap内存算法：多内存池的算法，可将多个内存堆合并在一起用。

slab内存算法：多内存池的通用算法。

因为内存算法需考虑多线程间的互斥问题，所以不能在中断中分配或释放内存，否则可能引起当前线程被挂起等待。

  • RT-Thread 将 “ZI 段结尾处” 到内存尾部的空间用作内存堆

1
2
3
4
5
6
7
// __CC_ARM编译器（kile）， ZI 段结尾处表示
extern int Image$$RW_IRAM1$$ZI$$Limit;
#define HEAP_BEGIN      ((void *)&Image$$RW_IRAM1$$ZI$$Limit)

// IAR_ARM编译器，ZI 段结尾处表示
extern int __bss_end__;
#define HEAP_BEGIN   (&__bss_end__)
  • 小内存算法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define HEAP_MAGIC 0x1ea0
struct heap_mem
{
    /* magic and used flag */
    rt_uint16_t magic;
    rt_uint16_t used;
    rt_size_t next, prev;
    rt_uint8_t thread[4];   /* thread name */
};

/** pointer to the heap: for alignment, heap_ptr is now a pointer instead of an array */
static rt_uint8_t *heap_ptr;

/** the last entry, always unused! */
static struct heap_mem *heap_end;

mem.c 对应小内存分配算法，memheap.c对应有多个内存堆的算法。

  • 内存池

1.malloc一块大内存，把这块内存分成指定数量的若干小块内存并用链表管理，空闲链表和使用的链表。

2.宏观来看内存池和消息队列类似，消息队列是对内存池的进一步封装。

1
2
3
4
5
6
rt_mp_t rt_mp_create(const char *name,
                     rt_size_t   block_count,
                     rt_size_t   block_size);
rt_err_t rt_mp_delete(rt_mp_t mp);
void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);
void rt_mp_free(void *block);

本章小结：

1.内存池可以极大的加快内存分配的速度，不用去遍历mem链表寻找合适大小的内存块。

2.从内存池分配的内存块大小是固定的。

中断

  • Cortex-M 系列 CPU寄存器

Cortex-M 有两个运行级别，分别为特权级和用户级，线程模式可以工作在特权级或者用户级，而处理模式总工作在特权级，可通过 CONTROL 特殊寄存器控制。工作模式状态切换情况如上图所示。

Cortex-M 的堆栈寄存器 SP 对应两个物理寄存器 MSP 和 PSP，MSP 为主堆栈，PSP 为进程堆栈，处理模式总是使用 MSP 作为堆栈，线程模式可以选择使用 MSP 或 PSP 作为堆栈，同样通过 CONTROL 特殊寄存器控制。复位后，Cortex-M 默认进入线程模式、特权级、使用 MSP 堆栈

中断前导程序

中断前导程序主要工作如下：

1）保存 CPU 中断现场，这部分跟 CPU 架构相关，不同 CPU 架构的实现方式有差异。

对于 Cortex-M 来说，该工作由硬件自动完成。当一个中断触发并且系统进行响应时，处理器硬件会将当前运行部分的上下文寄存器自动压入中断栈中，这部分的寄存器包括 PSR、PC、LR、R12、R3-R0 寄存器。

2）通知内核进入中断状态，调用 rt_interrupt_enter() 函数，作用是把全局变量 rt_interrupt_nest 加 1，用它来记录中断嵌套的层数，代码如下所示。

1
2
3
4
5
6
7
8
void rt_interrupt_enter(void)  // 通知内核进入中断状态,把全局变量 rt_interrupt_nest 加 1
{
    rt_base_t level;

    level = rt_hw_interrupt_disable();
    rt_interrupt_nest ++;
    rt_hw_interrupt_enable(level);
}

中断后续程序

中断后续程序主要完成的工作是:

1 通知内核离开中断状态，通过调用 rt_interrupt_leave() 函数，将全局变量 rt_interrupt_nest 减 1，代码如下所示。

1
2
3
4
5
6
7
8
void rt_interrupt_leave(void) // 通知内核离开中断状态,将全局变量 rt_interrupt_nest 减 1
{
    rt_base_t level;

    level = rt_hw_interrupt_disable();
    rt_interrupt_nest --;
    rt_hw_interrupt_enable(level);
}
  • 中断栈

1.在中断处理过程中，在系统响应中断前，软件代码（或处理器）需要把当前线程的上下文保存下来（通常保存在当前线程的线程栈中），再调用中断服务程序进行中断响应、处理。

2.中断处理函数中很可能会有自己的局部变量，这些都需要相应的栈空间来保存，所以中断响应依然需要一个栈空间来做为上下文，运行中断处理函数。

3.中断栈可以保存在打断线程的栈中，当从中断中退出时，返回相应的线程继续执行。

4.中断栈也可以与线程栈完全分离开来，即每次进入中断时，在保存完打断线程上下文后，切换到新的中断栈中独立运行。

RT-Thread 采用的方式是提供独立的中断栈，即中断发生时，中断的前期处理程序会将用户的栈指针更换到系统事先留出的中断栈空间中，等中断退出时再恢复用户的栈指针。这样中断就不会占用线程的栈空间，从而提高了内存空间的利用率，且随着线程的增加，这种减少内存占用的效果也越明显。

  • 中断分步处理

1.中段上半步：在中断中执行，负责取得硬件状态和数据，做好一些软件上的标记或者发送信号量、消息等，用来启动中断的下半部操作。

2.中断下半步：在线程中执行，线程收到中断发来的信号量、消息，进行具体的解析业务操作，此部分比较耗时。

  • 全局中断开关

全局中断开关也称为中断锁，是禁止多线程访问临界区最简单的一种方式，即通过关闭中断的方式，来保证当前线程不会被其他事件打断（因为整个系统已经不再响应那些可以触发线程重新调度的外部事件），也就是当前线程不会被抢占，除非这个线程主动放弃了处理器控制权。当需要关闭整个系统的中断时，可调用下面的函数接口：

1
2
rt_base_t rt_hw_interrupt_disable(void); // 关中断
void rt_hw_interrupt_enable(rt_base_t level); // 开中断

使用中断锁来操作临界区的方法可以应用于任何场合，且其他几类同步方式都是依赖于中断锁而实现的，可以说中断锁是最强大的和最高效的同步方法。只是使用中断锁最主要的问题在于，在中断关闭期间系统将不再响应任何中断，也就不能响应外部的事件。所以中断锁对系统的实时性影响非常巨大，当使用不当的时候会导致系统完全无实时性可言（可能导致系统完全偏离要求的时间需求）；而使用得当，则会变成一种快速、高效的同步方式。

例如，为了保证一行代码（例如赋值）的互斥运行，最快速的方法是使用中断锁而不是信号量或互斥量：

1
2
3
4
5
/* 关闭中断 */
level = rt_hw_interrupt_disable();
a = a + value;
/* 恢复中断 */
rt_hw_interrupt_enable(level);复制错误复制成功

在使用中断锁时，需要确保关闭中断的时间非常短，例如上面代码中的 a = a + value; 也可换成另外一种方式，例如使用信号量：

1
2
3
4
5
/* 获得信号量锁 */
rt_sem_take(sem_lock, RT_WAITING_FOREVER);
a = a + value;
/* 释放信号量锁 */
rt_sem_release(sem_lock);复制错误复制成功

这段代码在 rt_sem_take 、rt_sem_release 的实现中，已经存在使用中断锁保护信号量内部变量的行为，所以对于简单如 a = a + value; 的操作，使用中断锁将更为简洁快速。

简单嵌套中断使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <rthw.h>

void global_interrupt_demo(void)
{
    rt_base_t level0;
    rt_base_t level1;

    /* 第一次关闭全局中断，关闭之前的全局中断状态可能是打开的，也可能是关闭的 */
    level0 = rt_hw_interrupt_disable();
    /* 第二次关闭全局中断，关闭之前的全局中断是关闭的，关闭之后全局中断还是关闭的 */
    level1 = rt_hw_interrupt_disable();

    do_something();

    /* 恢复全局中断到第二次关闭之前的状态，所以本次 enable 之后全局中断还是关闭的 */
    rt_hw_interrupt_enable(level1);
    /* 恢复全局中断到第一次关闭之前的状态，这时候的全局中断状态可能是打开的，也可能是关闭的 */
    rt_hw_interrupt_enable(level0);
}

使用 rt_interrupt_enter/leave() 的作用是，在中断服务程序中，如果调用了内核相关的函数（如释放信号量等操作），则可以通过判断当前中断状态，让内核及时调整相应的行为。例如：在中断中释放了一个信号量，唤醒了某线程，但通过判断发现当前系统处于中断上下文环境中，那么在进行线程切换时应该采取中断中线程切换的策略，而不是立即进行切换。

1
2
void rt_interrupt_enter(void);  // rt_interrupt_nest++
void rt_interrupt_leave(void);  // rt_interrupt_nest--

但如果中断服务程序不会调用内核相关的函数（释放信号量等操作），这个时候，也可以不调用 rt_interrupt_enter/leave() 函数。

补充：

FreeRTOS是将各种IPC函数区分为在中断中使用和在线程中使用的两种（显式方式），而不是通过告诉内核处于中断还是线程状态让内核自动执行对应的线程切换方法的隐式方式。

中断与轮询

当驱动外设工作时，其编程模式到底采用中断模式触发还是轮询模式触发往往是驱动开发人员首先要考虑的问题，并且这个问题在实时操作系统与分时操作系统中差异还非常大。因为轮询模式本身采用顺序执行的方式：查询到相应的事件然后进行对应的处理。所以轮询模式从实现上来说，相对简单清晰。例如往串口中写入数据，仅当串口控制器写完一个数据时，程序代码才写入下一个数据（否则这个数据丢弃掉）。相应的代码可以是这样的：

1
2
3
4
5
6
7
8
9
10
/* 轮询模式向串口写入数据 */
    while (size)
    {
        /* 判断 UART 外设中数据是否发送完毕 */
        while (!(uart->uart_device->SR & USART_FLAG_TXE));
        /* 当所有数据发送完毕后，才发送下一个数据 */
        uart->uart_device->DR = (*ptr & 0x1FF);

        ++ptr; --size;
    }复制错误复制成功

在实时系统中轮询模式可能会出现非常大问题，因为在实时操作系统中，当一个程序持续地执行时（轮询时），它所在的线程会一直运行，比它优先级低的线程都不会得到运行。而分时系统中，这点恰恰相反，几乎没有优先级之分，可以在一个时间片运行这个程序，然后在另外一段时间片上运行另外一段程序。

所以通常情况下，实时系统中更多采用的是中断模式来驱动外设。当数据达到时，由中断唤醒相关的处理线程，再继续进行后续的动作。例如一些携带 FIFO（包含一定数据量的先进先出队列）的串口外设，其写入过程可以是这样的，如下图所示：

中断模式驱动外设

线程先向串口的 FIFO 中写入数据，当 FIFO 满时，线程主动挂起。串口控制器持续地从 FIFO 中取出数据并以配置的波特率（例如 115200bps）发送出去。当 FIFO 中所有数据都发送完成时，将向处理器触发一个中断；当中断服务程序得到执行时，可以唤醒这个线程。这里举例的是 FIFO 类型的设备，在现实中也有 DMA 类型的设备，原理类似。

对于低速设备来说，运用这种模式非常好，因为在串口外设把 FIFO 中的数据发送出去前，处理器可以运行其他的线程，这样就提高了系统的整体运行效率（甚至对于分时系统来说，这样的设计也是非常必要）。但是对于一些高速设备，例如传输速度达到 10Mbps 的时候，假设一次发送的数据量是 32 字节，我们可以计算出发送这样一段数据量需要的时间是：(32 X 8) X 1/10Mbps = 25us。当数据需要持续传输时，系统将在 25us 后触发一个中断以唤醒上层线程继续下次传递。假设系统的线程切换时间是 8us（通常实时操作系统的线程上下文切换时间只有几个 us），那么当整个系统运行时，对于数据带宽利用率将只有 25/(25+8) =75.8%。但是采用轮询模式，数据带宽的利用率则可能达到 100%。这个也是大家普遍认为实时系统中数据吞吐量不足的缘故，系统开销消耗在了线程切换上（有些实时系统甚至会如本章前面说的，采用底半处理，分级的中断处理方式，相当于又拉长中断到发送线程的时间开销，效率会更进一步下降）。

通过上述的计算过程，我们可以看出其中的一些关键因素：发送数据量越小，发送速度越快，对于数据吞吐量的影响也将越大。归根结底，取决于系统中产生中断的频度如何。当一个实时系统想要提升数据吞吐量时，可以考虑的几种方式：

1）增加每次数据量发送的长度，每次尽量让外设尽量多地发送数据；

2）必要情况下更改中断模式为轮询模式。同时为了解决轮询方式一直抢占处理机，其他低优先级线程得不到运行的情况，可以把轮询线程的优先级适当降低。

注：由于关闭全局中断会导致整个系统不能响应中断，所以在使用关闭全局中断做为互斥访问临界区的手段时，必须需要保证关闭全局中断的时间非常短，例如运行数条机器指令的时间。

本章小结：

1.中断服务程序应该尽可能精简。

2.对于是否使用中断下半部处理，需要考虑中断服务下半部的的处理时间是否大于发送信号量的时间。

3.建议实时系统尽量使用中断的模式驱动外设，配合DMA缓冲使用，一次发送尽可能多的数据，然后尝试一次中断和线程切换8us，如需使用轮询应设置轮询线程较低的优先级，保证其他线程的运行时间。

展开全文 >>

RT-Thread文档读书笔记 - 内核移植

内核移植

CPU架构移植

移植分成CPU架构移植和BSP(Board Support Package，板级支持包)两部分。

  • 实现cpulib抽象：

主要文件：cpuport.c context_rvds.S

主要接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/************** context_rvds.S 实现 ***************/
// 关全局中断
rt_base_t rt_hw_interrupt_disable();
// 开全局中断
void rt_hw_interrupt_enable(rt_base_t level);
// 从from线程切换到to线程
void rt_hw_context_switch(rt_uint32 from, rt_uint32 to);
// 第一次线程切换，没有from线程
void rt_hw_context_switch_to(rt_uint32 to);
{
    	.....
        LDR     r0, =NVIC_INT_CTRL              ; 触发PendSV异常
        .....
}
// 中断中从from线程切换到to线程
void rt_hw_context_switch_interrupt(rt_uint32 from, rt_uint32 to);
// pendsv中断服务函数
void PendSV_Handler(void)


/************** cpuport.c 实现 ***************/
// 在线程进行上下文切换时，用来保存from和头线程
rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
// 表示需要在中断里进行线程切换的标志
rt_uint32_t rt_thread_switch_interrupt_flag;
    
// 线程栈初始化，内核在线程创建时调用，会手动构建一个上下文内容，作为每个线程第一次执行的初始值   
rt_uint8_t *rt_hw_stack_init(void       *tentry,
                             void       *parameter,
                             rt_uint8_t *stack_addr,
                             void       *texit)

在中断服务函数中进程线程切换需要等到中断结束后才能进行切换，在线程中进行线程切换是马上进行切换。

在中断程序处理完事务之后，中断退出之前，检查 rt_thread_switch_interrupt_flag 变量（调用 rt_hw_context_switch_interrupt 函数时会标记该变量和设置from、to线程等待中断处理完成进行线性切换）如果为1，就根据 rt_interrupt_from_thread, rt_interrupt_to_thread 变量，进程一次上下文切换。

向上对内核提供一套统一的函数接口，包括全局中断开关函数、线程栈的初始化函数、上下文切换函数、时钟节拍配置和中断函数。

  • 线程栈的初始化

僵尸线程：已经被系统删除，线程不属于任何ipc量，对调度器不可见但是它的资源还未被释放的线程叫僵尸线程。

僵尸线程链表：rt_thread_defunct。

  • 线程栈图示

在线程创建时通过 rt_hw_stack_init 函数手动构建一个上下文内容，作为每个线程第一次执行的初始值 ，如下图：

Cortex-M处理器在线程上下文切换过程中，pendsv发生后，r0-psr 由硬件自动压栈/出栈，r4-r11需程序手动压栈/出栈（由 rt_hw_context_switch 函数完成）。

  • PSR特殊功能寄存器组包括：

特殊功能寄存器是按位来表示的。

  • 实现时钟节拍

开启一个定时器中断，可以是systick也可以是rtc，但需要保证这个定时器无论什么时候都在运行就算设备休眠进入低功耗。

1
2
3
4
5
6
7
8
9
10
11
void SysTick_Handler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();

    HAL_IncTick();
    rt_tick_increase(); // 主要对系统时间加加，对当前线程的时间片减减，检查硬件定时器链表是否有定时器时间已到，到了要执行定时器回调函数

    /* leave interrupt */
    rt_interrupt_leave();
}

BSP移植

板卡移植：CPU架构移植已经实现CPU芯片相关的移植，但还需要使RAM、GPIO、UART等外设工作才能建立操作系统运行的基本环境。

传统意义上的嵌入式计算机CPU和RAM是毫无关系的，不同的CPU可以配不同的RAM，只是MCU把CPU和RAM集成在了一个芯片，所以CPU架构移植不包括RAM的部分。

主要工作：

1.初始化CPU内部寄存器，设定RAM工作时序。

2.实现时钟驱动及中断控制器驱动，完善中断管理。

3.实现串口和GPIO驱动。

4.初始化动态内存堆，实现动态内存堆管理。

  • 建立rtthread工程

1.拷贝rt-thread文件夹到工程文件夹，添加内核源码、cpulib层、board.c相关文件到工程，添加相关头文件目录。

  • 实现时钟管理

1.在boar.c初始化滴答定时器配置中断，在中断函数中添加rt_rt_tick_increase();

  • 实现控制台

1.初始化串口。

2.实现rt_hw_console_output()函数。

  • 实现动态内存管理

1.在rt_hw_board_init()函数调用rt_system_heap_init()初始化系统堆内存。

最后运行结果：

本章小结：
1.CPU架构移植主要要移植cpulib层包括：cpuport.c context_rvds.S，全局中断相关、上下文相关的API以及时钟节拍的实现。
2.BSP移植主要需实现：实时时钟管理，动态堆内存管理，控制台输出。

展开全文 >>

Env辅助开发工具、FinSH控制台

Env辅助开发环境

  • 支持使用不同编译器，如GCC、ARM_CC等

  • 搭建项目工程

在BSP工程目录下使用：scons –dist命令在BSP目录下生成dist目录，这边是一个新羡慕的工程框架。其中包含rttread源码，不相关的BSP文件夹及libcpu都会被移除。

  • 生成工程命令
1
2
3
4
5
6
7
socons --target=mdk5 # 生成mdk5工程
socons --target=iar # 生成iar工程
socons --target=makefile # 生成makefile文件
scons -s # 和scons相比会会打印具体内部命令
scons -c # 清除编译目标，清除编译产生的临时文件和目标文件
scons -jN # 多核线程编译
sons --verbose # 编译时显示编译参数

-c选项相当于，make clean，socons –target=mdk5也可以在后面加 -s、-c选项

  • 和SConstruct同目录下的SConscript，总的最外层的工程构建脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# for module compiling
import os  # 导入python系统编程os模块，相当于包含头文件
Import('rtconfig') # 导入rtconfig对象，其他python模块文件定义的对象，rtconfig.CROSS_TOOL 定义在这个 rtconfig 模块
from building import * # 把 building 模块的所有内容全部导入到当前模块，DefineGroup 定义在这个模块。

cwd = GetCurrentDir() # 获得当前路径并保存在字符变量 cwd 中
objs = [] # 定义一个空的list型变量
list = os.listdir(cwd) # 得到当前目录下的所有子目录并保存到list变量中

for d in list: # 一个for循环，循环遍历list变量中的（保存的是子目录）子目录的 SConscript文件，并把它们都加入到源码编译列表 objs 中
    path = os.path.join(cwd, d)
    if os.path.isfile(os.path.join(path, 'SConscript')):
        objs = objs + SConscript(os.path.join(d, 'SConscript'))

Return('objs') # 返回源码编译列表 objs

  • 子目录下的SConscript构建脚本，和源文件 .c文件在同一目录
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Import('rtconfig')
from building import *

cwd     = GetCurrentDir()
src     = Split(''' 
shell.c
cmd.c
''')  # Split(str):将字符串str分割成一个列表

fsh_src = Split('''
finsh_compiler.c
finsh_error.c
finsh_heap.c
finsh_init.c
finsh_node.c
finsh_ops.c
finsh_parser.c
finsh_var.c
finsh_vm.c
finsh_token.c
''')

msh_src = Glob('msh.c') # 获取 msh.c 文件到msh_src变量

if GetDepend('RT_USING_DFS'):  # 根据 RT_USING_DFS 依赖决定是否在 msh_src 变量追加 .c文件
    msh_src += ['msh_file.c']

if not GetDepend('FINSH_USING_SYMTAB'):
    src += ['symbol.c']
if GetDepend('FINSH_USING_MSH'):
	src = src + msh_src
if not GetDepend('FINSH_USING_MSH_ONLY'):
    src = src + fsh_src

CPPPATH = [cwd] # 将当前路径保存到一个变量 CPPPATH，CPPPATH：全局的变量，整个工程的源文件都会保存到里面

group = DefineGroup('finsh', src, depend = ['RT_USING_FINSH'], CPPPATH = CPPPATH) # 创建一个组（keil工程里的组），src：源文件，depend：依赖的宏，
# CPPPATH = CPPPATH：将当前路径添加到系统的头文件路径，左边的CPPPATH：是DefineGroup中的内置参数，表示内置参数，右边的CPPPATH：是本文件上面一行定义的，
# 这样我们就可以在其他源码中引用finsh目录下的头文件

Return('group')

  • Kconfig：图形界面配置文件

  • rtconfig.py编译选项配置文件，编译器配置、cpu架构配置

  • 根据生成的 makefile 直接使用 arm_gcc 编译器编译

1
socons # 需arm平台的芯片
  • 图形化系统配置

menuconfig是一种基于Kconfig的图形化配置工具。通过图形配置最终生成rtconfig.h配置文件，对系统进行配置、裁剪。

每次通过menconfig图形配置界面配置删除或添加软件包后，需要使用 scons –update命令更新软件包。

  • 软件包管理
1
2
pkgs --upgrade # 同步git服务器上的软件包
pkgs --update # 更新软件包：下载或者删除软件包
  • 修改工程模板

如果要修改MCU型号，工程配置等，建议直接修改 template 工程，再使用 socons –target=mdk5 重新生成工程。可使用menuconfig -s 配置退出图形界面自动更新软件包和生成keil工程。

scons 是按照模板工程生成工程的。

FinSH控制台

  • 传统命令行模式（默认）

又称msh（module shell），类似与bash/dos。

  • C语言解释器模式（占用空间大）

又称C-style模式，此模式下控制台能解析并执行大部分C语言的表达式，并使用类似C语言的函数调用方式访问系统中的函数及全局变量，也能够通过命令行创建变量。

1
list_thread() # 打印系统中所有的线程，C-style模式命令必须携带括号
  • msh自定义命令导入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
MSH_CMD_EXPORT(name, desc);

void hello(void)// 不带参数的命令函数定义
{
    rt_printf("hello\n");
}

#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(hello, say hello);
#endif

void atcmd(int argc, char **argv) // 带参数的命令函数定义
{
    if (argc < 2)
    {
        rt_kprintf("please input 'atcmd <server|client>'\n");
        return; 
    }
    
    if (strcmp(argv[1], "server") == 0)
    { 
        rt_kprintf("AT server\n");
    }
    else if (strcmp(argv[1], "client") == 0)
    { 
        rt_kprintf("AT client\n");
    }
    else
    {
        rt_kprintf("please input 'atcmd <server|client>'\n");
    }
}

#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(atcmd, atcmd <server|client>);
#endif
  • C-style自定义命令导入
1
FINSH_FUNCTION_EXPORT(name, desc);
  • C-style自定义变量导出

展开全文 >>

IO设备管理

I/O设备管理

IO设备管理层框架从下往上一次共三层：设备驱动层 –> 设备驱动框架层 –> IO设备管理层

IO设备框架向下操作硬件，向上提供统一的一套接口给应用程序调用，使得应用程序不用关系具体的硬件操作，更换硬件执行修改设备驱动操作硬件相关的代码。

  • IO设备管理层

1.实现了对设备驱动程序的封装，使程序完全脱离了具体的硬件。

2.提供给应用程序的接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/************** device.c *******************/
// 1.通过名字查找设备，返回设备句柄
rt_device_t rt_device_find(const char *name);
// 2.通过设备句柄打开这个设备
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);
// 3.通过设备句柄，读设备数据
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);

rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size)
// 4.关闭设备
rt_err_t rt_device_close(rt_device_t dev);

3.提供给驱动程序实现的：

1
2
3
4
// 驱动程序实例化一个设备对象，并通过此接口注册到IO设备管理层
rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags);
  • 设备框架层

1.对同类硬件设备驱动做抽象：将不同厂家的同类硬件设备驱动中相同的部分抽取出来。

2.将不同的部分留出接口，由驱动程序实现。

3.负责创建和注册IO设备（就是设备框架层将不同部分留出的接口，设备驱动层需要去实现这些接口，注册给设备框架层使用）。

4.通过IO管理层提供的接口，注册一个串口设备到IO管理层：

5.设备驱动框架是对同类设备的抽象（这一层可以没有），例如：显示设备和ssd1306的关系，显示设备可以是ssd1306或者lcd显示屏，但它们都属于显示设备都能够显示一个字母、显示一个数字。

设备框架层就是对同类设备的抽象，同类设备的一些共性。

4.不同芯片厂家的串口操作方式是不一样的，但他们肯定都有putc、getc、config的这些功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*************** serial.c ******************/
// 1.提供给驱动层使用的，注册一个设备到IO管理层
rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
                               const char              *name,
                               rt_uint32_t              flag,
                               void                    *data)
{
    rt_err_t ret;
    struct rt_device *device; // 待封装的设备对象

    device = &(serial->parent);

    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

    device->ops         = &serial_ops;  

    /* register a character device */
    ret = rt_device_register(device, name, flag); // 注册封装好的设备对象到IO管理层

....
    return ret;
}

struct serial_ops // 设备对象方法
{
    .config = stm32_configure,
    .putc = stm32_putc,
    .getc = stm32_getc
}

对于逻辑操作简单的设备，可以跳过设备框架层，直接注册到IO设备管理层，将设备框架层必要的东西直接在设备驱动层实现。

  • 设备驱动层

通常是直接调用厂家提供的操作硬件寄存器函数

1.是一组直接驱使硬件工作的程序，实现访问硬件提供的功能。

2.设备框架层提供的接口，注册一个串口设备到设备框架层。

硬件相关的：配置具体的外设、读、写等，硬件的功能实现函数。

这些硬件相关的操作函数都将被，驱动层使用注意不是调用（在驱动层封装成硬件设备对象的方法，再由驱动层注册到IO设备层），所以IO设备驱动层对设备对象的操作相当于直接调用了这些函数。

以上的这些层都是为应用程序服务的，宏观上这些层都可以叫做驱动，驱动只提供方法不会操作硬件，只有应用程序里面才会调用这些设备对象的方法操作硬件，可能进行设备初始化、打开、关闭、读、写，根据设备提供的方法不一样不一定所有的设备都有这些方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/******************** drv_uart.c **************************/
// 初始化串口设备
static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg) 
{
.....
    if (HAL_UART_Init(&uart->handle) != HAL_OK)
    {
        return -RT_ERROR;
    }

    return RT_EOK;
}

// 向串口设备写一个字符
static int stm32_putc(struct rt_serial_device *serial, char c) 
{
...
    uart->handle.Instance->DR = c;
    while (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) == RESET);
    return 1;
}

// 从串口设备读一个字符
static int stm32_getc(struct rt_serial_device *serial) 
{
...
    ch = uart->handle.Instance->DR & 0xff;
    return ch;
}

// 注册一个设备到设备框架层，在系统启动时调用，会注册设备到IO管理层，也可以封装成设备对象方法，在应用程序需要的时候调用初始化设备
int rt_hw_usart_init(void)
{
    rt_size_t obj_num = sizeof(uart_obj) / sizeof(struct stm32_uart);
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
    rt_err_t result = 0;

    stm32_uart_get_dma_config();

    for (int i = 0; i < obj_num; i++)
    {
        /* init UART object */
        uart_obj[i].config = &uart_config[i];
        uart_obj[i].serial.ops    = &stm32_uart_ops;
        uart_obj[i].serial.config = config;

        /* register UART device */
        result = rt_hw_serial_register(&uart_obj[i].serial, uart_obj[i].config->name,
                                       RT_DEVICE_FLAG_RDWR
                                       | RT_DEVICE_FLAG_INT_RX
                                       | RT_DEVICE_FLAG_INT_TX
                                       | uart_obj[i].uart_dma_flag
                                       , NULL);
        RT_ASSERT(result == RT_EOK);
    }

    return result;
}

  • 应用程序

例如shell.c是一个应用程序，它和用户直接交互

应用程序：实现产品具体功能的代码，与用户交互的、显示用的、一个触摸的键盘，分别获取用户的输入做出反应、输出信息给用户看、得到用户的输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/******************** shell.c ****************************/
// 通过名字设置一个设备给finsh用
void finsh_set_device(const char *device_name)
{
   ...
    /* open this device and set the new device in finsh shell */
    if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | \  // 打开一个设备里面会调用设备提供的open函数
                       RT_DEVICE_FLAG_STREAM) == RT_EOK)
    {
        if (shell->device != RT_NULL)
        {
            /* close old finsh device */
            rt_device_close(shell->device);  // 关闭设备里面会调用设备提供的close函数
            rt_device_set_rx_indicate(shell->device, RT_NULL);
        }
    }

     ...
}

从上面的代码可以看出，只有应用程序才会去操作硬件，驱动程序只提供操作硬件的方法。

小结：

分层思想的原则：

1.确定本层的职责，搞清承上启下的对象是谁。

2.实现本层职责时，提供好给上层调用的接口和对象。

3.如果超出本层职责（操作过于细节），那么提供注册函数给自己的下层调用，让下层提供一个实现具体细节的方法给自己使用。

4.一般方法和信息都是通过对象的形式在层与层之间传递。

  • I/O设备对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 设备类型
enum rt_device_class_type
{
    RT_Device_Class_Char = 0,                           /**< 字符设备 */
    RT_Device_Class_Block,                              /**< 块设备 */
    RT_Device_Class_NetIf,                              /**< 网络接口设备 */
    RT_Device_Class_MTD,                                /**< 内存设备 */
    RT_Device_Class_CAN,                                /**< can设备 */
    RT_Device_Class_RTC,                                /**< RTC设备 */
    RT_Device_Class_Sound,                              /**< 声音设备 */
    RT_Device_Class_Graphic,                            /**< 图形设备 */
    RT_Device_Class_I2CBUS,                             /**< I2C总线设备 */
    RT_Device_Class_USBDevice,                          /**< USB从设备 */
    RT_Device_Class_USBHost,                            /**< USB主设备 */
    RT_Device_Class_SPIBUS,                             /**< SPI总线 */
    RT_Device_Class_SPIDevice,                          /**< SPI设备 */
    RT_Device_Class_SDIO,                               /**< SDIO总线设备 */
    RT_Device_Class_PM,                                 /**< PM伪设备 */
    RT_Device_Class_Pipe,                               /**< 管道设备 */
    RT_Device_Class_Portal,                             /**< 门户设备 */
    RT_Device_Class_Timer,                              /**< 计时器设备 */
    RT_Device_Class_Miscellaneous,                      /**< 其他设备 */
    RT_Device_Class_Sensor,                             /**< 传感器设备 */
    RT_Device_Class_Touch,                              /**< 触摸设备 */
    RT_Device_Class_PHY,                                /**< 物理设备 */
    RT_Device_Class_Unknown                             /**< 未知设备 */
};

/**
 * 设备对象
 */
struct rt_device
{
    struct rt_object          parent;                   /**< 内核对象基类 */

    enum rt_device_class_type type;                     /**< 设备类型 */
    rt_uint16_t               flag;                     /**< 设备参数 */
    rt_uint16_t               open_flag;                /**< 设备打开标志 */

    rt_uint8_t                ref_count;                /**< 设备被引用次数 */
    rt_uint8_t                device_id;                /**< 设备id：0 - 255 */

    /* 数据收发回调 */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
    
    const struct rt_device_ops *ops;


    void                     *user_data;                /**< 设备私有数据 */
};
typedef struct rt_device *rt_device_t;

常见设备：字符设备：允许非结构数据传输，串行传输一次一个字节，块设备：每次传输一个数据块，如512byte，数据块是硬件强制性的，通常情况下操作，先读一个块数据，改变之中的一部分数据然后再写回去。

  • 访问IO设备

设备的多种打开方式：

1
2
3
4
5
6
7
8
9
10
11
#define RT_DEVICE_FLAG_INT_RX           0x100           /**< INT mode on Rx */
#define RT_DEVICE_FLAG_DMA_RX           0x200           /**< DMA mode on Rx */
#define RT_DEVICE_FLAG_INT_TX           0x400           /**< INT mode on Tx */
#define RT_DEVICE_FLAG_DMA_TX           0x800           /**< DMA mode on Tx */

#define RT_DEVICE_OFLAG_CLOSE           0x000           /**< device is closed */
#define RT_DEVICE_OFLAG_RDONLY          0x001           /**< read only access */
#define RT_DEVICE_OFLAG_WRONLY          0x002           /**< write only access */
#define RT_DEVICE_OFLAG_RDWR            0x003           /**< read and write */
#define RT_DEVICE_OFLAG_OPEN            0x008           /**< device is opened */
#define RT_DEVICE_OFLAG_MASK            0xf0f           /**< mask of open flag */

如果上层应用程序需要设置设备的接收回调函数，则必须以 RT_DEVICE_FLAG_INT_TX 或者 RT_DEVICE_FLAG_DMA_RX 的方式打开设备，否则不会回调函数。

  • 打开IO设备
1
2
// 该函数主要执行 dev->open();
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);

rt_device_open() 和 rt_device_close() 需成对使用。

  • 控制设备
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 该函数主要执行 dev->control();
rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg);

/**
 * general device commands
 */
#define RT_DEVICE_CTRL_RESUME           0x01            /**< resume device */
#define RT_DEVICE_CTRL_SUSPEND          0x02            /**< suspend device */
#define RT_DEVICE_CTRL_CONFIG           0x03            /**< configure device */
#define RT_DEVICE_CTRL_CLOSE            0x04            /**< close device */

#define RT_DEVICE_CTRL_SET_INT          0x10            /**< set interrupt */
#define RT_DEVICE_CTRL_CLR_INT          0x11            /**< clear interrupt */
#define RT_DEVICE_CTRL_GET_INT          0x12            /**< get interrupt status */
  • 设备读写
1
2
3
4
5
6
7
8
9
10
// pos:根据设备的不同有不同的意义，读串口设备底层会忽略这个参数，pos参数没有一样
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);
// pos：写入数据在 buffer 的偏移量
rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size);
  • 数据收发回调

接收回调：

1
2
3
4
5
6
7
8
9
// 设置接收数据回调：设置一个回调函数，当硬件设备接收到数据时，
// 会回调这个函数，并把数据长度放在size中，上层应用线程收到指示后，立刻从设备中读取数据
rt_err_t rt_device_set_rx_indicate(rt_device_t dev,
                          rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size))
{
    dev->rx_indicate = rx_ind; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

发送回调：

1
2
3
4
5
6
7
8
9
// 设置发送完数据回调：当硬件设备发送完数据，驱动程序回调这个函数并把发送完成的数据块地址buffer作为参数传递给上层应用，
// 上层应用线程收到指示后会根据buffer的情况，释放buffer内存或将其作为下一个写数据的缓存。
rt_err_t rt_device_set_tx_complete(rt_device_t dev,
                          rt_err_t (*tx_done)(rt_device_t dev, void *buffer))
{
    dev->tx_complete = tx_done; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

上面两个函数都是应用程序注册给底层硬件驱动回调用的，相当于是底层驱动异步通知应用程序执行的操作结果。是一种层与层之间的沟通方式，和底层注册到上层类似。

本章小结：

1.没有提供驱动的设备，或者自己另外需要添加的设备，需要根据驱动框架自己实现设备的方法。
2.动态创建的设备销毁时要记得释放设备控制块占用的内存。
3.IO设备在应用程序的写使用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int xxx_writedata(uint8_t* buffer, size_t buff_size)
{
    ....
    device = rt_device_find("spi1");
    if (!device)
    {
        rt_kprintf("find spi1 failed!\n");
        return RT_ERROR;
    }
    err = rt_device_open(device, RT_DEVICE_OFLAG_WRONLY);
    if (err < 0)
    {
        rt_kprintf("open spi1 failed!\n");
        return RT_ERROR;
    }

    rt_device_write(device, 0, (const void *)buffer, buff_size);
    rt_device_close(device);
    ....
}

展开全文 >>

线性表

数据结构

线性表

线性：说的是数据在逻辑上的排列结构。除了线性还有树形、点状、集合等逻辑结构。

储存结构区分：

1.顺序存储结构的线性表叫顺序表，线性表中的元素储存是一个挨着一个按顺序储存的。

2.链式存储结构的线性表叫链表，线性表中的元素可以储存在任意位置，通过地址来建立元素与元素之间的逻辑关系。

顺序、链式：说的是数据在物理空间（如RAM、FALSH等）的储存结构，数组就是典型的顺序存储结构，一个数据元素在物理空间上挨着另一个数据元素。链式存储就像一条链子一样，一个关联一个，一个数据元素扣一个数据元素的存储。

我们通常说的单链表、双链表、顺序表都是说的数据的物理储存结构，但是他们都是属于线性表。

线性表表示方法：

  • 单链表结构：

1.将线性表L = （a0,a1,…..an-1）中的元素分布在储存器的不同存储块，称为节点。

2.节点与节点之间建立关系，一般通过一个节点保存另一个节点的首地址的方式建立节点之间的关系。

  • 节点包括数据域和指针域

a(i+1)节点叫做a(i)节点的后继节点。

数据与用来保存该节点携带的数据，指针域用来保存与该节点逻辑上相邻的节点的地址。例如 a(i) 节点指针域保存 a(i+1)节点的地址

  • 头结点

1.头结点是链表逻辑上第一个节点，它的数据域通常不用来保存数据，而是用来保存该链表当前的一些信息，比如：链表中当前节点的个数、链表头地址、链表尾地址等链表相关的信息。

2.我们通过头结点就可以很方便的找到整个链表。

3.头结点是恒存在的，不能被删除，空链表中只存在一个头结点，没有其它保存数据用的节点。

4.头结点的类型可以和其他节点的类型可以不一样，设计如下节点类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 链表
struct list
{
    struct list *next;
};
typedef struct list *list_t;

// 用于保存数据的节点类型
struct _node
{
    list_t list;
    struct node_data; // 节点的数据域 struct node_data 自由设计一个数据类型
};
typedef struct _node *_node_t
    
// 头结点类型
struct head_node
{
    list_t list;
    struct _node *head;
    struct _node *tail;
    int node_count;
};
typedef struct head_node *head_node_t;

单链表倒置：

方法一：

1.将 l->next = NULL; p1 = l->next; p2 = l->next->next;

2.tmp = p2->next; (p2下次往前移到到这个tmp保存下)

3.p2 -> next = p1; (p2反方向指，指向p1)

4.p1 = p2; p2 = tmp; (p1、p2分别往前移到一个位置)

5.循环 234步骤，直到 p2 == NULL；跳出。

6.l->next = p1;(头结点指向新的第一个节点)

方法二：

1.p1 = l->next;(p1保存下老链表的第一个节点)，l->next = NULL；置空链表得到一个空链表和一个以p1为头的孤立链表。

2.p2 = p1;(保存下p1的位置之后将这个节点插入到空链表) ，p1 = p1->next；(p1往后移到)

3.p2->next = l->next; l->next = p2;(p2节点插入到空链表)

4.重复23步骤直到p1==NULL移到到老孤立链表的最后。

单链表排序：

1.将要排序的链表拆成两个链表，不带head节点的链表：p = l->next->next，带head节点的链表（链表只有一个节点）：r = l;

2.从不带头结点的链表取节点，tmp = p;

3.把上面取到的节点插入带head的链表的正确位置：首先要遍历带head节点的链表，找到合适位置插入tmp；

4.p指针往下走，从不带头结点的链表取第二个节点，执行3步骤插入操作。

5.循环234步骤，直到p == NULL，到达不带head节点链表尾部。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 链表排序的条件可以提供一个方法用来比较的，里面的内容可以自己实现，增加排序灵活性
int pkt_list_by_data_order_with_fun(pkt_node_t l, int (*cmp)(pkt_node_t l1, pkt_node_t l2))
{
    PKT_ASSERT(l);
    if (!l->next || !l->next->next)
    {
        printf("this list node <= 1, no need order\n");
        return -1;
    }
    pkt_node_t p = l->next->next; /* the other list do not have head node */
    pkt_node_t r = l;
    l->next->next = NULL;  /* new list have one node */
    pkt_node_t tmp;

    while (p->next) /* 不带head节点的链表，从头一个一个的取node插入到带head节点的链表 */
    {
        tmp = p;  /* get a node */
        p = p->next; /* move to next node */
        
        /* 寻找满足cmp条件的l链表的正确位置，如果到了最后也没有就把q插到最后位置 */
        r = l;
        while (r->next && !cmp(r->next, tmp))  /* r->next是新拆分带头head节点的那个，q是不带head节点的那个 */
        {
            r = r->next;
        }
        tmp->next = r->next;
        r->next = tmp;
    }

    return 0;
}

// 这个函数可以控制按什么规则来排序
int rule(pkt_node_t l1, pkt_node_t l2)
{
    if (l2->data > l1->data)
    {
        return 0;
    }
    return 1;
}

/* 调用排序函数 */
pkt_list_by_data_order_with_fun(l, rule);

单项循环链表：

循环链表的优点：可以通过遍历找到节点的前驱节点，单项非循环链表只能找自己的后继节点。

两个单向循环链表合并步骤：

1.P = B->next; 保存被合并链表的head节点

2.B->next = A->next; B链表尾指向A链表头

3.A->next = P->next; A链表尾指向B链表第一个节点（除去head节点）

4.free（P）；释放B链表的head节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 循环链表创建
list_node_t pkt_creat_loop_list(void)
{
    list_node_t n;

    n = (list_node_t)malloc(sizeof(struct list_node));
    n->next = n;
    return n;
}

// 合并循环单向链表
int pkt_merge_loop_list(list_node_t des, list_node_t src)
{
    PKT_ASSERT(des);
    PKT_ASSERT(src);
    if (!des->next || !src->next)
    {
        printf("is a empty list!\n");
        return -1;
    }
    list_node_t p = des;
    list_node_t q = src;

    while (p->next != des) // 移到p指针变量到des链表尾
    {
        p = p->next;
    }

    while (q->next != src) // 移到q指针变量到src链表尾
    {
        q = q->next;
    }

    q->next = p->next; // 将src链表尾指向des链表的头部
    p->next = src->next; // 将des链表的尾巴指向src链表的头部（除去head节点）
    free(src); // 释放src的head节点
    return 0;
}

循环链表：

双向循环链表插入操作：

关于双向链表的插入步骤原则：1.先处理新要插入的节点的prev、next指向，再处理p1前一个节点的next指向，再处理p1节点prev的指向。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 创建双向循环链表
dlist_node_t pkt_creat_loop_dlist(void) 
{
    dlist_node_t n;
    n = (dlist_node_t)malloc(sizeof(struct dlist_node));
    n->next = n->prev = n;
    return n;
}

// 向双向循环链表插入一个节点数据
int pkt_insert_loop_dlist(dlist_node_t l, data_type data)
{
    PKT_ASSERT(l);

    dlist_node_t n = (dlist_node_t)malloc(sizeof(struct dlist_node)); // @2
    if (!n)
    {
        printf("malloc failed!\n");
        return -1;
    }
    n->data = data;
    dlist_node_t p = l->next; // @1

    n->next = p; // @3
    n->prev = p->prev; // @4
    p->prev->next = n; // @5
    p->prev = n; // @6
    return 0;
}

// 按数据删除一个双向循环链表的节点
int pkt_remove_loop_dlist(dlist_node_t l, data_type data)
{
    PKT_ASSERT(l);
    dlist_node_t p = l->next;

    while (p->next != l && p->data != data)
    {
        p = p->next;
    }

    if (p->next == l)
    {
        printf("did not find the node\n");
        return -1;
    }

    p->prev->next = p->next; // 删除的时候先处理p前一个节点的next
    p->next->prev = p->prev; // 在处理p后一个节点的prev

    free(p); // p释放虽然它的指next和pre都和原来一样， 但已经没有一个节点指向它了（脱离了链表）
    return 0;
}

1.双向循环链表相比非循环单链表很容易实现头插和尾插：dlist_node_t p = l->next; 头插，在第一个节点前插入，dlist_node_t p = l；尾插，在head节点前插入。

2.如果是非循环单链表和循环单链表都需要先遍历链表，时工作指针移动带链表尾，才可以实现尾部插入节点。

3.循环链表之所以可以很方便实现尾插模式，是因为每个节点都有一个point指向前驱节点。而head节点的前驱节点就是链表的尾节点。

代码仓库：http://gitea.880755.xyz/private/list.git

补充知识：
ringbuffer和message_queue
ringbuffer：一般使用数组通过顺序表实现，用于字节流的储存，储存单元是byte，读取通过read指针和write指针，以及提供要读写的大小，记录位置。
message_queue：通过链表实现，配合动态内存分配，创建时固定每条消息容量，队列多大储存消息数量。最小的储存单元是消息，读队列就是从队列头取一条消息，写队列就是从队列尾写一条消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// ringbuffer 类型声明
typedef struct __CBUF_STRUCT
{
    cbuf_size_t __head;  // read ponit
    cbuf_size_t __tail;  // wirte ponit
    cbuf_unit_t *  __buf_room;   // mem pool start addr
    cbuf_size_t __buf_size; // mem pool size
}CBUF_STRUCT;

// message_queue 类型声明
struct rt_messagequeue
{
    struct rt_ipc_object parent;                        /**< inherit from ipc_object */

    void                *msg_pool;                      /**< start address of message queue */

    rt_uint16_t          msg_size;                      /**< message size of each message */
    rt_uint16_t          max_msgs;                      /**< max number of messages */

    rt_uint16_t          entry;                         /**< index of messages in the queue */

    void                *msg_queue_head;                /**< list head */
    void                *msg_queue_tail;                /**< list tail */
    void                *msg_queue_free;                /**< pointer indicated the free node of queue */

    rt_list_t            suspend_sender_thread;         /**< sender thread suspended on this message queue */
};
typedef struct rt_messagequeue *rt_mq_t;

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发