RT-thread初学

最新推荐文章于 2024-09-05 23:36:05 发布
最新推荐文章于 2024-09-05 23:36:05 发布
阅读量235 收藏
点赞数
分类专栏： 单片机 文章标签： stm32 mcu 单片机 arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51183186/article/details/120489958
版权

RT-thread初学

线程

在这里插入图片描述

动态创建线程

/*任务回调函数*/
void rtt1_entry(void *parameter)
{
    for(int i = 0;i<5;i++)
    {
        rt_kprintf("run1:%d\n",i);
        rt_thread_delay(1000);
    }
}

	/*动态创建函数*/
    rtt1_ptr = rt_thread_create("rtt1",rtt1_entry,NULL,1024,1,5);
    if(rtt1_ptr == RT_NULL){
        LOG_E("Thread creation 1 failure\n");
    }
    else{
        LOG_D("Thread created 1 successfully\n");
        rt_thread_startup(rtt1_ptr);
    }

静态创建线程

/*简要：任务2回调函数*/
void rtt2_entry(void *parameter)
{
    for(int i = 0;i<5;i++)
    {
        rt_kprintf("run2:%d\n",i);
        rt_thread_delay(1000);
    }
    //rt_thread_delete(rtt1_ptr);
}

	/*静态创建函数*/
    int ret = rt_thread_init(&rtt2_ptr,"rtt2",rtt2_entry,NULL,rtt2_stack,sizeof(rtt2_stack),2,5);
    if(ret == 0){
        LOG_D("Thread created 2 successfully\n");
        rt_thread_startup(&rtt2_ptr);
    }
    else {
        LOG_E("Thread creation 2 failure\n");
    }

钩子函数

在整个系统的运行时，系统都处于线程运行、中断触发 - 响应中断、切换到其他线程，甚至是线程间的切换过程中，或者说系统的上下文切换是系统中最普遍的事件。有时用户可能会想知道在一个时刻发生了什么样的线程切换，可以通过调用下面的函数接口设置一个相应的钩子函数。在系统线程切换时，这个钩子函数将被调用

/*简要：钩子函数*/
void scheduler_hook(struct rt_thread *from, struct rt_thread *to)
{
    //rt_kprintf("from:%s ---> to:%s\n",from->name,to->name);
}

rt_scheduler_sethook(scheduler_hook);

定时器

RT-Thread 的定时器提供两类定时器机制：第一类是单次触发定时器，这类定时器在启动后只会触发一次定时器事件，然后定时器自动停止。第二类是周期触发定时器，这类定时器会周期性的触发定时器事件，直到用户手动的停止，否则将永远持续执行下去。

获取系统时间

int main(void)
{
    for(int i = 0;i<10;i++)
    {
        /*获取系统时间*/
        rt_tick_t num = rt_tick_get();
        rt_kprintf("tick : %u\n",num);
        rt_thread_mdelay(500);
    }
    return 0;
}

动态创建定时器

/*
 * 简要：动态定时器的回调函数
 */
void tim1_demo(void *parameter)
{
    rt_kprintf("tim1 run\n");
}

	rt_timer_t tim_1 = NULL;
	
    /*动态创建定时器(周期)*/
    tim_1 = rt_timer_create("tim1",tim1_demo,RT_NULL,3000,RT_TIMER_FLAG_PERIODIC);

    /*启动定时器*/
    if(tim_1 != RT_NULL)rt_timer_start(tim_1);

静态创建定时器

/*
 * 简要：静态定时器的回调函数
 */
void tim2_demo(void *parameter)
{
    rt_kprintf("tim2 run\n");
}

	struct rt_timer tim_2;
	
    /*静态创建定时器(单次)*/
    rt_timer_init(&tim_2,"tim2",tim2_demo,RT_NULL,3000,RT_TIMER_FLAG_ONE_SHOT);

    /*启动定时器*/
    rt_timer_start(&tim_2);

信号量

以生活中的停车场为例来理解信号量的概念：

①当停车场空的时候，停车场的管理员发现有很多空车位，此时会让外面的车陆续进入停车场获得停车位；

②当停车场的车位满的时候，管理员发现已经没有空车位，将禁止外面的车进入停车场，车辆在外排队等候；

③当停车场内有车离开时，管理员发现有空的车位让出，允许外面的车进入停车场；待空车位填满后，又禁止外部车辆进入。

在此例子中，管理员就相当于信号量，管理员手中空车位的个数就是信号量的值（非负数，动态变化）；停车位相当于公共资源（临界区），车辆相当于线程。车辆通过获得管理员的允许取得停车位，就类似于线程通过获得信号量访问公共资源。

静态创建与动态创建信号量

rt_sem_t rs1 = NULL;
struct rt_semaphore rs2;
int main(void)
{
    /*动态创建信号量*/
    rs1 = rt_sem_create("dsem",0,RT_IPC_FLAG_PRIO);
    if(rs1 == RT_NULL)
    {
        LOG_E("dsem no\n");
        return -1;
    }
    else
    {
        LOG_D("dsem yes\n");
    }
    /*静态创建信号量*/
    rt_sem_init(&rs2,"dsem2",0,RT_IPC_FLAG_PRIO);

    return RT_EOK;
}

信号量实例

/*全局变量*/
rt_sem_t rs1 = NULL;
rt_sem_t rs2 = NULL;
rt_thread_t rm1 = NULL;
rt_thread_t rm2 = NULL;
int num = 0;

/*任务1*/
void dome1_task(void *parameter)
{
    while(1)
    {
        rt_sem_take(rs1,RT_WAITING_FOREVER);
        num++;
        rt_kprintf("[num: %d]dome1_task run\n",num);
        if(num == 100)
        {
           num = 0;
        }
        rt_sem_release(rs2);
        rt_thread_mdelay(1000);
    }
}

/*任务2*/
void dome2_task(void *parameter)
{
    while(1)
    {
        rt_sem_take(rs2,RT_WAITING_FOREVER);
        if(num > 0)
        {
            num--;
            rt_kprintf("[num: %d]dome2_task run\n",num);
        }
        rt_sem_release(rs1);
        rt_thread_mdelay(3000);
    }
}

/*主函数*/
int main(void)
{
    /*创建信号量1*/
    rs1 = rt_sem_create("dsem1",1,RT_IPC_FLAG_PRIO);
    if(rs1 == RT_NULL)
    {
        LOG_E("dsem1 no\n");
        return -1;
    }
    else
    {
        LOG_D("dsem1 yes\n");
    }

    /*创建信号量2*/
    rs2 = rt_sem_create("dsem2",0,RT_IPC_FLAG_PRIO);
    if(rs2 == RT_NULL)
    {
        LOG_E("dsem2 no\n");
        return -1;
    }
    else
    {
        LOG_D("dsem2 yes\n");
    }

    /*创建线程1*/
    rm1 = rt_thread_create("dome1",dome1_task,NULL,512,20,5);
    if(rm1 == RT_NULL)
    {
        LOG_E("dome1 rt_thread_create NO\n");
        return -1;
    }
    else
    {
        LOG_D("dome1 rt_thread_create YES\n");
        rt_thread_startup(rm1);
    }

    /*创建线程2*/
    rm2 = rt_thread_create("dome2",dome2_task,NULL,512,20,5);
    if(rm2 == RT_NULL)
    {
        LOG_E("dome2 rt_thread_create NO\n");
        return -1;
    }
    else
    {
        LOG_D("dome2 rt_thread_create YES\n");
        rt_thread_startup(rm2);
    }

    return -1;
}

互斥量（互斥锁）

在这里插入图片描述

互斥量又叫相互排斥的信号量，是一种特殊的二值信号量。互斥量类似于只有一个车位的停车场：当有一辆车进入的时候，将停车场大门锁住，其他车辆在外面等候。当里面的车出来时，将停车场大门打开，下一辆车才可以进入。

动态创建互斥量

	rt_mutex_t Motor = NULL;
    /*动态创建互斥锁*/
    Motor = rt_mutex_create("Motor",0);
    if (Motor == RT_NULL)
    {
        rt_kprintf("Motor rt_mutex_create NO");
        return -1;
    }

互斥量实例

/*全局变量*/
rt_thread_t t1 = NULL;
rt_thread_t t2 = NULL;
rt_mutex_t Motor = NULL;
int num1 = 0,num2 = 0;

/*线程1回调函数*/
void task1_main(void *parameter)
{
    while(1)
    {
        rt_mutex_take(Motor,RT_WAITING_FOREVER);
        num1++;
        rt_thread_mdelay(500);
        num2++;
        rt_mutex_release(Motor);
    }
}

/*线程2回调函数*/
void task2_main(void *parameter)
{
    while(1)
    {
        rt_mutex_take(Motor,RT_WAITING_FOREVER);
        if(num1 != num2){
            rt_kprintf("num1:%d != num2:%d\n",num1,num2);
        }
        else {
            rt_kprintf("num1:%d == num2:%d\n",num1,num2);
        }
        rt_thread_mdelay(500);
        rt_mutex_release(Motor);

        if(num1>58)
        {
            return;
        }
    }
}

int main(void)
{
    /*动态创建互斥锁*/
    Motor = rt_mutex_create("Motor",0);
    if (Motor == RT_NULL)
    {
        rt_kprintf("Motor rt_mutex_create NO");
        return -1;
    }

    /*动态创建线程1*/
    t1 = rt_thread_create("task1",task1_main,RT_NULL,512,15,500);
    if(t1 != RT_NULL){
        LOG_D("task1 rt_thread_create YES");
        rt_thread_startup(t1);
    }
    else {
        LOG_E("task1 rt_thread_create NO");
        return -1;
    }

    /*动态创建线程2*/
    t2 = rt_thread_create("task2",task2_main,RT_NULL,512,17,500);
    if(t2 != RT_NULL){
        LOG_D("task2 rt_thread_create YES");
        rt_thread_startup(t2);
    }
    else {
        LOG_E("task2 rt_thread_create NO");
        return -1;
    }
    return RT_EOK;
}

注意

  • 线程任务执行完，线程不是挂起，而是删除了
  • 在获得互斥量后，请尽快释放互斥量，并且在持有互斥量的过程中，不得再行更改持有互斥量线程的优先级，否则可能人为引入无界优先级反转的问题。
  • 需要切记的是互斥量不能在中断服务例程中使用。
沈溪溪
关注
专栏目录
关于rt-thread调度器实现的底层代码分析
呆呆的根号三的博客
10-30 880
本文使用了rt-thread自带的钩子函数和显示函数进行了实验，从rt-thread自带的延时函数rt_thread_delay()函数入手，对rt-thread系统的调度器进行分析。主要参考资料是野火的rt-thread手册和rt-thread官方文档，汇编部分的指令是参考的cortex-M3权威参考手册，实验版本是rt-thread3.1.5 1、实验准备 使用三个线程，内部调用延时函数，每个线程内部延时1s。 使用系统自带的钩子函数，在调度器实现调度的时候打印线程状态...
rt_thread线程管理
RONG_YAO的博客
06-18 826
创建线程的时候，将线程的状态设定为初始态。此线程在就绪列表中，具备执行的能力，等待cpu此线程正在运行，占用处理器。此线程正在等待某个时序或者外部中断，改线不在就绪列表中，包含线程被 挂起、线程被延时、线程正在等待信号量、读写队列或者等待读写事件等。该线程运行结束，等待系统回收资源。...
rt-thread提高控制频率
最新发布
2301_79968250的博客
09-05 885
修改系统定时器节拍已实现线程执行频率的提高
RT-Thread的rt_thread_create函数介绍
SuGuolin的博客
03-07 9413
thread = rt_thread_create("T_RTU", Thread_RTU, RT_NULL, 2048, //分配堆栈大小 3, // 线程的优先级 20);//线程所分配的时间片 当一个线程的优先级独一无二的时候，它的时间片这个参数将失去作用，我们不要认为上面的两个线程运行完 20 个系统 ticks 后就会
RT-THREAD学习笔记
qq_41531368的博客
11-12 1549
2020年9月29日23:36:01 系统中总共存在两类线程，分别是系统线程和用户线程 RT-Thread 的线程调度器是抢占式的 静态创建的线程需要用到线程控制块 线程栈 RT-Thread 线程具有独立的栈，当进行线程切换时，会将当前线程的上下文存在栈中，当线程要恢复运行时，再从栈中读取上下文信息，进行恢复。 线程的优先级 RT-Thread 最大支持 256 个线程优先级 (0~255)，数值越小的优先级越高，0 为最高优先级。在一些资源比较紧张的系统中，可以根据实际情况选择只支持 8 个或 32 个
开启一个RT-thread线程，实现两个灯不同频率的闪烁
xiaodazi0723的博客
10-23 1859
编写控制一个灯的闪烁的函数。和正常函数区别就是多了void *parameter static void led1_entry(void *parameter) { while(1) { LED0 = 0; rt_thread_mdelay(300); LED0 = 1; rt_thread_mdelay(300); } } 利用rt_thread_create创建一个线程，led1_id是一个全局变量，用来接收线程创建成功后的句柄 static rt_thread_t led1_i
STM32+Nano版RT-thread+LWIP移植源码
05-23
STM32+Nano版RT-thread+LWIP移植源码是一个针对STM32微控制器的嵌入式系统开发项目，其核心目标是将轻量级的RTOS（实时操作系统）RT-thread的Nano版本与TCP/IP协议栈LWIP整合，以实现网络通信功能。下面将详细阐述这...
RT-Thread.pdf
03-26
RT-Thread对初学者而言，是一本入门级电子书教程，可以帮助初学者快速了解和掌握RTOS的基本概念和编程方法。 ### 核心组件和架构 1. **RT-Thread内核介绍**： - **线程调度**：决定了多个线程如何获得处理器的...
5，RT Thread操作系统教程及资料_rtthread_RT-Thread_
10-02
对于初学者，首先理解实时操作系统的基本概念，然后通过搭建环境和运行示例来熟悉RT Thread的基础操作。接着，可以深入学习API和开发工具，结合实例提升实践能力。最后，研究高级主题，提升系统设计和优化能力。 7...
rt-thread-v2.0.2.zip_RT-Thread_RT-thread-2_RT_Thread_V2 _rtthrea
09-24
RT-Thread是一个开源、免费的实时操作系统（RTOS），专为嵌入式系统设计。这个"rt-thread-v2.0.2.zip"压缩包包含了RT-Thread的2.0.2版本源码，它是一个功能强大且高度可定制的内核，广泛应用于物联网设备、智能家居...
rt-thread_0_3_0.zip_RT-THREAD 3.0_RT-Thread 0.3.0_RTGUI_rt-threa
09-24
示例项目有助于初学者快速入门，了解如何在实际项目中应用RT-Thread和RTGUI。 总的来说，"rt-thread_0_3_0.zip"包含了RT-Thread 3.0及其图形界面组件RTGUI的核心组件，为开发者提供了一个完整的嵌入式操作系统解决...
RT-Thread快速入门-线程管理(下)
一起学嵌入式
01-27 5789
首发，公众号【一起学嵌入式】 上一篇主要介绍了 RT-Thread 线程管理相关的理论知识： RT-Thread快速入门-线程管理 这篇重点介绍 RT-thread 提供的线程管理相关的接口函数，以及实战演示。 线程创建 在 RT-Thread 中，创建一个线程的方式有两种： 动态创建方式，线程的栈和线程控制块由系统从动态内存堆上分配。 静态创建方式，线程的栈和线程控制块由用户定义分配。 1. 动态创建线程 动态创建线程，用户不需要考虑线程栈和线程控制块空间分配的问题，全部由系统自动完成分配。用户只.
RT-Thread学习笔记
善若水，朝心流的博客
09-16 7194
RT-Thread学习之——静态线程和动态线程 RT-Thread中支持静态和动态两种定义方式。 用线程来举例的话，rt_thread_init对应静态定义方式，rt_thread_create对应动态定义方式。 使用静态定义方式时，必须先定义静态的线程控制块，并且定义好堆栈空间，然后调用rt_thread_init来完成线程的初始化工作。采用这种方式，线程控制块和堆栈占用的内存会放在RW段...
RT_Thread_线程的一些基本概念
人非生而知之者
04-10 1187
官方资料：线程管理 (rt-thread.org) 1、线程的分类 系统线程：rtt系统创建的线程：main、idle空闲线程； 用户线程：我们自己写的，由rt_thread_init和rt_thread_create创建的线程； 2、线程的五种状态和切换 注：RT-Thread 中，实际上线程并不存在运行状态，就绪状态和运行状态是等同的。 3、创建线程 补充一下下面创建线程时有关的宏定义，可以在rt_config.h里查看和修改； 3.1、静态线程 静态线程是指线..
【RT-Thread基础教程】线程的基本使用
m0_62599305的博客
02-23 3366
在嵌入式系统开发中，RTOS（Real-Time Operating System）扮演着至关重要的角色，而RT-Thread作为一款开源的实时操作系统，在嵌入式领域中备受欢迎。线程是RTOS中的基本执行单元，其良好的多任务处理能力使得嵌入式系统能够更有效地响应各种事件和任务。本文将着重介绍在RT-Thread中线程的基本使用方法，包括线程的创建、调度、挂起和删除等方面。通过深入理解线程的基本概念和操作，读者将能更好地利用RT-Thread构建稳定而高效的嵌入式系统。
RT-Thread内核
姜大大的博客
04-04 495
1. 嵌入式系统 嵌入式系统是一种完全嵌入在装置或设备内部，为满足特定需求而设计的计算机系统，生活中常见的嵌入式系统有：电视机机顶盒、路由器、电冰箱等等。 嵌入式操作系统是应用于嵌入式系统的软件，他用来对接嵌入式底层硬件与上层应用。嵌入式操作系统在多任务任务管理、任务间通信、内存管理、定时器管理、设备管理等方面，提供给了用户一套完整的机制，极大程度上便利了嵌入式应用程序的开发，管理和维护。 2. 认识RTT操作系统 RTT与其他RTOS（FreeRTOS、uC/OS）的主要区别是：RT-Thread自创建
RT-Thread快速入门-线程管理（上）
一起学嵌入式
01-25 4234
首发，公众号【一起学嵌入式】 在 RT-Thread 中，最基本的调度单位是线程，其他 RTOS 也叫任务。如果学习过或者了解过 RTOS，任务这种叫法是最为熟知的。 本篇文章来学习一下 RT-Thread 线程方面的内容。对于初学者来说，转换一下思维，建立多任务（线程）的编程思想。 引言 对于裸机编程，整个软件系统只有一个线程（任务）在执行，实现方式是通过一个大循环完成的。应用程序是一个无限循环，循环中调用各个功能模块的函数，完成相应的操作。 RTOS 是一个多任务系统，可以把总体功能划分为多个小模块.
[嵌入式系统-78]：RT-Thread：线程管理的基本原理与应用
文火冰糖（王文兵）的博客
05-14 2043
RT_Thread实时操作系统为空闲线程提供了一个钩子函数（钩子函数：用户提供的一段代码，在系统运行的某一路径上设置一个钩子，当系统经过这个位置时，转而执行这个钩子函数，然后再返回到它的正常路径上） ，可以让系统在空闲的时候执行一些特定的任务，例如系统运行指示灯闪烁，电源管理等，除了调用钩子函数，RT_Thread也把线程清理（rt_thread_cleanup）函数，真正的线程删除动作放到了空闲线程中（在删除线程时，仅改变线程的状态为关闭状态不在参与系统调度）。在系统线程切换时，这个钩子函数将被调用。
01_RT-thread笔记之内核基础
被狠狠嵌入了...
04-01 1016
内核库是为了保证内核能够独立运行的一套小型的类似 C 库（不同C库实现可能不同）的函数实现子集。仅提供内核用到的一小部分 C 库函数实现，为了避免与标准 C 库重名，在这些函数前都会添加上 rt_ 前缀RT-Thread 支持多种平台和多种编译器，而 rtthread_startup() 函数是 RT-Thread 规定的统一启动入口。
RT-Thread实时操作系统编程手册
本编程指南是针对RT-Thread初学者的一份详尽文档，旨在帮助读者理解如何在RT-Thread环境中进行有效的编程。 首先，RT-Thread的软件结构包括内核、组件和应用程序三个主要部分。内核提供了基本的实时调度、内存管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值