rtthread空闲线程与阻塞延时的实现

最新推荐文章于 2024-04-05 20:57:31 发布
最新推荐文章于 2024-04-05 20:57:31 发布
阅读量3.1k 收藏
点赞数
分类专栏： 记录 STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzw508170827/article/details/111347908
版权
记录 同时被 2 个专栏收录
82 篇文章 7 订阅
订阅专栏
STM32
31 篇文章 4 订阅
订阅专栏

title: rtthread空闲线程与阻塞延时的实现
date: 2020-10-22 17:04:45
tags: rtthread

RTOS 中的延时叫阻塞延时，即线程需要延时的时候，线程会放弃 CPU 的使用权，CPU 可以去干其它的事情，当线程延时时间到，重新获取 CPU 使用权，线程继续运行，这样就充分地利用了 CPU 的资源，而不是干等着。如果没有其它线程可以运行，RTOS 都会为 CPU 创建一个空闲线程，这个时候 CPU 就运行空闲线程，且空闲线程的优先级最低。

空闲线程

在idle.c文件下

  1. 定义空闲线程栈
  2. 定义空闲线程控制块
  3. 定义空闲线程函数
  4. 空闲线程初始化

idle.c

#define IDLE_THREAD_STACK_SIZE      512 

ALIGN(RT_ALIGN_SIZE)
static rt_uint8_t rt_thread_stack[IDLE_THREAD_STACK_SIZE];

struct rt_thread idle;

rt_ubase_t  rt_idletask_ctr = 0;

void rt_thread_idle_entry(void *parameter)
{
    parameter = parameter;
    while (1)
    {
        rt_idletask_ctr ++;
    }
}

/**
 * @ingroup SystemInit
 *
 * 初始化空闲线程，启动空闲线程
 *
 * @note 当系统初始化的时候该函数必须被调用
 */
void rt_thread_idle_init(void)
{
    
    /* 初始化线程 */
    rt_thread_init(&idle,
                   "idle",
                   rt_thread_idle_entry,
                   RT_NULL,
                   &rt_thread_stack[0],
                   sizeof(rt_thread_stack));
    
	/* 将线程插入到就绪列表 */
    rt_list_insert_before( &(rt_thread_priority_table[RT_THREAD_PRIORITY_MAX-1]),&(idle.tlist) );
}

阻塞延时

阻塞延时函数

thread.c

void rt_thread_delay(rt_tick_t tick)
{
    struct rt_thread *thread;    
    
    /* 获取当前线程的线程控制块 */    
    thread = rt_current_thread;
    
    /* 设置延时时间 */
    thread->remaining_tick = tick;
	
	/* 进行系统调度 */
	rt_schedule();
}

remaining_tick 是线程控制块的一个成员，用于记录线程需要延时的时间，单位为 SysTick 的中断周期。比如我们本书当中 SysTick 的中断周期为 10ms，调用 rt_thread_delay(2)则完成 2*10ms 的延时。

remaining_tick 定义

/*
*************************************************************************
*                               线程结构体
*************************************************************************
*/
struct rt_thread
{
    /* rt 对象 */
    char        name[RT_NAME_MAX];    /* 对象的名字 */
    rt_uint8_t  type;                 /* 对象类型 */
    rt_uint8_t  flags;                /* 对象的状态 */
    rt_list_t   list;                 /* 对象的列表节点 */
    
	rt_list_t   tlist;                /* 线程链表节点 */
    
	void        *sp;	              /* 线程栈指针 */
	void        *entry;	              /* 线程入口地址 */
	void        *parameter;	          /* 线程形参 */	
	void        *stack_addr;          /* 线程起始地址 */
	rt_uint32_t stack_size;           /* 线程栈大小，单位为字节 */
	
    rt_ubase_t  remaining_tick;      /* 用于实现阻塞延时 */
};
typedef struct rt_thread *rt_thread_t;

系统调度

/* 系统调度 */
void rt_schedule(void)
{
	struct rt_thread *to_thread;
	struct rt_thread *from_thread;
    
#if 0
	/* 两个线程轮流切换 */
	if( rt_current_thread == rt_list_entry( rt_thread_priority_table[0].next,
											struct rt_thread,
											tlist) )
	{
		from_thread = rt_current_thread;
		to_thread = rt_list_entry( rt_thread_priority_table[1].next,
								   struct rt_thread,
								   tlist);
	  rt_current_thread = to_thread;
	}
	else
	{
		from_thread = rt_current_thread;
		to_thread = rt_list_entry( rt_thread_priority_table[0].next,
								   struct rt_thread,
								   tlist);
	  rt_current_thread = to_thread;																		 
	}    
#else    

                                 
	/* 如果当前线程是空闲线程，那么就去尝试执行线程1或者线程2，
       看看他们的延时时间是否结束，如果线程的延时时间均没有到期，
       那就返回继续执行空闲线程 */
	if( rt_current_thread == &idle )
	{
		if(rt_flag1_thread.remaining_tick == 0)
		{            
            from_thread = rt_current_thread;
            to_thread = &rt_flag1_thread;
            rt_current_thread = to_thread;
		}
		else if(rt_flag2_thread.remaining_tick == 0)
		{
            from_thread = rt_current_thread;
            to_thread = &rt_flag2_thread;
            rt_current_thread = to_thread;
		}
		else
		{
			return;		/* 线程延时均没有到期则返回，继续执行空闲线程 */
		} 
	}
	else
	{
		/*如果当前线程是线程1或者线程2的话，检查下另外一个线程,如果另外的线程不在延时中，就切换到该线程
        否则，判断下当前线程是否应该进入延时状态，如果是的话，就切换到空闲线程。否则就不进行任何切换 */
		if(rt_current_thread == &rt_flag1_thread)
		{
			if(rt_flag2_thread.remaining_tick == 0)
			{
                from_thread = rt_current_thread;
                to_thread = &rt_flag2_thread;
                rt_current_thread = to_thread;
			}
			else if(rt_current_thread->remaining_tick != 0)
			{
                from_thread = rt_current_thread;
                to_thread = &idle;
                rt_current_thread = to_thread;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
		else if(rt_current_thread == &rt_flag2_thread)
		{
			if(rt_flag1_thread.remaining_tick == 0)
			{
                from_thread = rt_current_thread;
                to_thread = &rt_flag1_thread;
                rt_current_thread = to_thread;
			}
			else if(rt_current_thread->remaining_tick != 0)
			{
                from_thread = rt_current_thread;
                to_thread = &idle;
                rt_current_thread = to_thread;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
	}
#endif	
	/* 产生上下文切换 */
	rt_hw_context_switch((rt_uint32_t)&from_thread->sp,(rt_uint32_t)&to_thread->sp);	
}

SysTick_Handler 中断服务函数

/* 关中断 */
rt_hw_interrupt_disable();

/* SysTick中断频率设置 */
SysTick_Config( SystemCoreClock / RT_TICK_PER_SECOND );

void SysTick_Handler(void)
{
    /* 进入中断 */
    rt_interrupt_enter();

    rt_tick_increase();

    /* 离开中断 */
    rt_interrupt_leave();
}

clock.c

static rt_tick_t rt_tick = 0;

void rt_tick_increase(void)
{
    rt_ubase_t i;
    struct rt_thread *thread;
    rt_tick ++;

	/* 扫描就绪列表中所有线程的remaining_tick，如果不为0，则减1 */
	for(i=0; i<RT_THREAD_PRIORITY_MAX; i++)
	{
        thread = rt_list_entry( rt_thread_priority_table[i].next,
								 struct rt_thread,
							     tlist);
		if(thread->remaining_tick > 0)
		{
			thread->remaining_tick --;
		}
	}
    
    /* 系统调度 */
	rt_schedule();
}

irq.c

/* 中断计数器 */
volatile rt_uint8_t rt_interrupt_nest;

/**
 * 当BSP文件的中断服务函数进入时会调用该函数
 * 
 * @note 请不要在应用程序中调用该函数
 *
 * @see rt_interrupt_leave
 */
void rt_interrupt_enter(void)
{
    rt_base_t level;
    
    
    /* 关中断 */
    level = rt_hw_interrupt_disable();
    
    /* 中断计数器++ */
    rt_interrupt_nest ++;
    
    /* 开中断 */
    rt_hw_interrupt_enable(level);
}


/**
 * 当BSP文件的中断服务函数离开时会调用该函数
 *
 * @note 请不要在应用程序中调用该函数
 *
 * @see rt_interrupt_enter
 */
void rt_interrupt_leave(void)
{
    rt_base_t level;
    
    
    /* 关中断 */
    level = rt_hw_interrupt_disable();
    
    /* 中断计数器-- */
    rt_interrupt_nest --;

    /* 开中断 */
    rt_hw_interrupt_enable(level);
}

rt_interrupt_nest中断计数器，是一个全局变量，用了记录中断嵌套次数。当 BSP 文件的中断服务函数进入时会调用该函数，应用程序不能调用，切记。

main函数

/*
*************************************************************************
*                              全局变量
*************************************************************************
*/
rt_uint8_t flag1;
rt_uint8_t flag2;

extern rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];

/*
*************************************************************************
*                      线程控制块 & STACK & 线程声明
*************************************************************************
*/


/* 定义线程控制块 */
struct rt_thread rt_flag1_thread;
struct rt_thread rt_flag2_thread;

ALIGN(RT_ALIGN_SIZE)
/* 定义线程栈 */
rt_uint8_t rt_flag1_thread_stack[512];
rt_uint8_t rt_flag2_thread_stack[512];

/* 线程声明 */
void flag1_thread_entry(void *p_arg);
void flag2_thread_entry(void *p_arg);

/*
*************************************************************************
*                               函数声明
*************************************************************************
*/
void delay(uint32_t count);

/************************************************************************
  * @brief  main函数
  * @param  无
  * @retval 无
  *
  * @attention
  *********************************************************************** 
  */
int main(void)
{	
	/* 硬件初始化 */
	/* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */
	
    /* 关中断 */
    rt_hw_interrupt_disable();
    
    /* SysTick中断频率设置 */
    SysTick_Config( SystemCoreClock / RT_TICK_PER_SECOND );
	
	/* 调度器初始化 */
	rt_system_scheduler_init();

    /* 初始化空闲线程 */    
    rt_thread_idle_init();	
	
	/* 初始化线程 */
	rt_thread_init( &rt_flag1_thread,                 /* 线程控制块 */
                    "rt_flag1_thread",                /* 线程名字，字符串形式 */
	                flag1_thread_entry,               /* 线程入口地址 */
	                RT_NULL,                          /* 线程形参 */
	                &rt_flag1_thread_stack[0],        /* 线程栈起始地址 */
	                sizeof(rt_flag1_thread_stack) );  /* 线程栈大小，单位为字节 */
	/* 将线程插入到就绪列表 */
	rt_list_insert_before( &(rt_thread_priority_table[0]),&(rt_flag1_thread.tlist) );
	
	/* 初始化线程 */
	rt_thread_init( &rt_flag2_thread,                 /* 线程控制块 */
                    "rt_flag2_thread",                /* 线程名字，字符串形式 */
	                flag2_thread_entry,               /* 线程入口地址 */
	                RT_NULL,                          /* 线程形参 */
	                &rt_flag2_thread_stack[0],        /* 线程栈起始地址 */
	                sizeof(rt_flag2_thread_stack) );  /* 线程栈大小，单位为字节 */
	/* 将线程插入到就绪列表 */
	rt_list_insert_before( &(rt_thread_priority_table[1]),&(rt_flag2_thread.tlist) );
	
	/* 启动系统调度器 */
	rt_system_scheduler_start(); 
}

/*
*************************************************************************
*                               函数实现
*************************************************************************
*/
/* 软件延时 */
void delay (uint32_t count)
{
	for(; count!=0; count--);
}

/* 线程1 */
void flag1_thread_entry( void *p_arg )
{
	for( ;; )
	{
#if 0
		flag1 = 1;
		delay( 100 );		
		flag1 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */		
		rt_schedule();
#else
        flag1 = 1;
        rt_thread_delay(2); 		
		flag1 = 0;
        rt_thread_delay(2);
#endif        
	}
}

/* 线程2 */
void flag2_thread_entry( void *p_arg )
{
	for( ;; )
	{
#if 0
		flag2 = 1;
		delay( 100 );		
		flag2 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */
		rt_schedule();
#else
        flag2 = 1;
        rt_thread_delay(2); 		
		flag2 = 0;
        rt_thread_delay(2);
#endif        
	}
}


void SysTick_Handler(void)
{
    /* 进入中断 */
    rt_interrupt_enter();

    rt_tick_increase();

    /* 离开中断 */
    rt_interrupt_leave();
}
橘长_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hutool中的threadutil_Hutool工具包：使用ThreadUtil创建并使用线程池的简单案例
weixin_39568133的博客
12-18 7468
需求：模拟一个含有100个元素的集合，同时开启5个线程进行遍历。代码：packagecom.provy.jiagou;importcn.hutool.core.thread.ThreadUtil;importcn.hutool.db.Db;importcn.hutool.db.Entity;importjava.sql.SQLException;importjava.util.List...
多线程中的Join
柯基的博客
09-16 2552
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
主线程等待子线程结束代码
10-14
我在工作的过程中遇到一个问题,需要主线程等等所有子线程执行完后再做某件事情,在网上找了很多代码,都没有真正解决这个问题. 现在我解决了这个问题,把代码共享出来供大家参考. 代码中有注释和注意事项,相信大家看过后就会觉得非常简单.
RT-Thread内核介绍
qq_43643506的博客
02-13 2957
内核基础 介绍 RT-Thread 内核基础，包括：内核简介、系统的启动流程及内核配置的部分内容。 RT-Thread 内核的简单介绍，从软件架构入手讲解实时内核的组成与实现，这部分给初学者引入一些 RT-Thread 内核相关的概念与基础知识，让初学者对内核有初步的了解。学完本章，读者将会对 RT-Thread 内核有基本的了解，知道内核的组成部分、系统如何启动、内存分布情况以及内核配置方法。 ...
【RT-Thread基础教程】Delay函数与空闲线程及其钩子函数_rtthread空闲任务钩子
最新发布
2401_84009300的博客
04-05 386
你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！Vip1104z获取！！！（备注：嵌入式）**你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！更多资料点击此处获qu！！
Qt线程QThread详解
北极星的技术笔记
02-20 6493
在程序中使用线程可以提高程序的性能、并发性、响应性和稳定性，使得程序设计更加灵活和简单。但是，线程编程也有一些挑战，如线程安全性和死锁等问题需要格外注意。我们使用QT框架编程时，可以用框架提供的线程类QThread来管理线程。本文将介绍使用QThread编程时的两种方式，并给出一个数据同步的示例。在介绍QThread之前先复习下线程的定义，线程是操作系统中的基本执行单元，是一个独立的执行路径。每个线程都有自己的栈空间，用于存储本地变量和函数调用的上下文。
python 多线程 join用法 简介
whatday的专栏
04-20 3595
目录 概念说明 Python多线程的默认情况 设置守护线程 join的作用 python多线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例 概念说明 知识点一： 当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下（其实就是setDaemon(False)），主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束，例子见下面一。 知识点二：
Qt之QThread介绍(常用接口及实现、自动释放内存、关闭窗口时停止线程运行、同步互斥)
热门推荐
yky的博客
08-09 1万+
在程序设计中，为了不影响主程序的执行，常常把耗时操作放到一个单独的线程中执行。Qt对多线程操作有着完整的支持，Qt中通过继承QThread并重写run()方法的方式实现多线程代码的编写。针对线程之间的同步与互斥问题，Qt还提供了QMutex、QReadWriteLock、QwaitCondition、QSemaphore等多个类来实现。 本篇博客将针对以下几个方面进行讲解 [1]QThread...
QThread的用法
顺其自然~专栏
07-07 8660
QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。QThread的使用方法有如下两种：下面通过具体的方法描述和例子来介绍两种方法。 首先新建一个worker类，该类重点在于其doWork槽
最详细的Qt多线程的三种方法之一QThread
zy1024的博客
07-30 4712
一、多线程目的 QThread类提供了一个与平台无关的管理线程的方法。 在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，比如大量运算，复制大文件，网络传输等。 二、Qt多线程使用方法 使用Qt框架开发应用程序时，使用QThread类可以方便快捷地创建管理多线程。 而多线程之间的通信也可使用Qt特有的“信号-槽”机制实现。 QThread的使用方法有如下两种： 1. 继承QThread类 2. QObject::moveToThread() 2.1 继承QThread方法 第一种方法很简
Qt之QThread（深入理解）
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-02 9514
简述 为了让程序尽快响应用户操作，在开发应用程序时经常会使用到线程。对于耗时操作如果不使用线程，UI界面将会长时间处于停滞状态，这种情况是用户非常不愿意看到的，我们可以用线程来解决这个问题。 前面，已经介绍了QThread常用的两种方式： Worker-Object 子类化QThread 下面，我们来看看子类化QThread在日常中的应用。 简述 子类化QThread 线程休眠...
NXP i.MX RT1052 RT-Thread实战：空闲线程与阻塞延时的实现【基于Cortex-M7】
12-01
NXP i.MX RT1052 RT-Thread实战。NXP i.MX RT1052驱动程序。资源代码可直接编译、运行。
NXP i.MX RT1052 RT-Thread实战：空闲线程与阻塞延时的实现【基于Cortex-M4】
12-01
NXP i.MX RT1052 RT-Thread实战。NXP i.MX RT1052驱动程序。资源代码可直接编译、运行。
NXP i.MX RT1052 RT-Thread实战：空闲线程与阻塞延时的实现【基于Cortex-M3】
12-01
NXP i.MX RT1052 RT-Thread实战。NXP i.MX RT1052驱动程序。资源代码可直接编译、运行。
NXP i.MX RT1052 FreeRTOS实战：空闲任务与阻塞延时的实现
12-01
NXP i.MX RT1052 FreeRTOS实战。NXP i.MX RT1052驱动程序。资源代码可直接编译、运行。
空闲任务与阻塞延时（1）.zip
06-28
这是配合我的一篇文章的代码，配合使用效果更佳。欢迎下载学习！如有错误，欢迎批评指正！欢迎交流学习！您的鼓励是我创作的动力！
RT-Thread学习笔记三——空闲线程钩子函数的使用
Reasally的博客
09-28 882
RT-Thread中利用延时进入空闲线程钩子函数示例
RT-Thread源码-5-空闲线程分析
qq_36535265的博客
05-05 629
前言 空闲线程是系统中优先级最低的线程，且永远不会被挂起，当系统无其他线程轮转调度时，调度器将调度到空闲线程。 初始化 空闲线程初始化于函数rtthread_startup函数中，在调度器启动前执行，具体看RT-Thread西东启动流程分析。函数名为rt_thread_idle_init，具体实现为： /** * @ingroup SystemInit * * This function will initialize idle thread, then start it. * * @no
从0到1写RT-Thread内核——空闲线程与阻塞延时的实现
qq_37659294的博客
09-08 1236
在之前写的另外一篇文章——<从0到1写RT-Thread内核——线程定义及切换的实现>中线程体内的延时使用的是软件延时，即还是让CPU空等来达到延时的效果。RTOS中的延时叫阻塞延时，即线程需要延时的时候，线程会放弃CPU的使用权，CPU可以去干其他的事情，当线程延时时间到，重新获取CPU使用权，线程继续运行，这样就充分利用了CPU的资源，而不是干等着。 ...
rtthread空闲中断
09-02
RT-Thread是一个开源的实时操作系统，可以适用于多种嵌入式平台。在STM32上使用RT-Thread时，使用串口的DMA空闲中断可以实现接收不定长数据。 具体的开发环境和工程配置可以参考博文https://blog.csdn.net/coderdd/article/details/108264369 ，该博文提供了详细的步骤和代码示例。 在RT-Thread Studio v2.1.0开发环境中，使用STM32F407VG芯片，可以按照以下步骤进行配置： 1. 打开RT-Thread Studio v2.1.0，创建一个新的工程。 2. 在工程配置中选择STM32F407VG芯片作为目标芯片。 3. 添加相应的代码，并进行测试。 4. 可以通过配置串口的DMA空闲中断来实现接收不定长数据。 通过以上步骤，可以在RT-Thread中实现rtthread空闲中断的功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [rt-thread+stm32 使用串口dma空闲中断接收不定长数据](https://blog.csdn.net/gyzw_mx/article/details/115899755)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值