一个自己写的协程系统

最新推荐文章于 2024-07-17 17:29:57 发布
最新推荐文章于 2024-07-17 17:29:57 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： 系统 文章标签： 协程 系统 stc stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35223473/article/details/91876259
版权

一、为什么要要自己写一个协程系统
1.ucos ，freertos 这些真正有线程调度能力的系统，需要的资源比较大，stc ，stm32f030 这些价格比较好资源比较少的单片机还是用不了。多线程操作系统确实实时性好，用起来方便，但是对内存的要求相对高。所以本系统是针对那些资源比较小的单片机。

2.其实我们顺序运行的程序影响实时性的主要有两个问题，
一个是，频繁代用delay函数会 阻塞程序运行，一旦调用了 delay函数，所有程序都停止。
另一个是，程序的函数没有优先级排列。
比如下图，
在这里插入图片描述
如果我按下按键的时候程序刚好运行到deal_lcd(),如果每个函数都运行20ms，那么程序就要一百多毫秒以后才运行到deal_key()去处理按键消息，再显示出来就更慢，如果while（1）里的函数更多，延时就更长。这样给人的视觉上就是实时性很差，但是在平时，mcu的使用率其实没有超过10%。如果我把每个函数排了优先级以后，把deal_key()和deal_lcd()的优先级排在最高，那么，就算按下按键的那一刻程序在运行其他的函数，但是运行完哪一个函数后，会马上deal_key()这个函数，那么如果一个函数的运行时间只是20ms的话，延时最多就20ms，人基本上感受不到。这样的延时在一般的小产品已经够用了，当然，大产品也用不了省mcu的几块钱了。

3.协程其实是个单线程任务，只是给函数排列优先级，让下一个要运行的程序是优先级最高的，也就是最急迫要运行的，这样没有给每个线程分配堆栈的概念。所以对内存的要求很小。而且复杂性低。

二，我程序的原理
其实很简单，程序中有8个waiting队列，表示8个不同优先级的等待运行队列，主函数的每一个循环都会从优先级最高的队列中从上往下查找，找到一个优先级最高的函数运行。这样就确保了优先级最好的函数可以最快运行。运行完后的函数都会被推到sleep队列中，等待下一个运行周期到了再推进waiting队列中。
另外有个1ms定时器中断函数，用来计算sleep队列中的函数哪一个到了运行时间周期，然后将其推送到相应优先级的waiting队列中。
在这里插入图片描述

三，运行测试
以下是我在stm32f030f4t6的测试结果，本os的文件只有一个，myos.c。可以观察一下运行结果
在这里插入图片描述
在这里插入图片描述
四，源代码
、、、、、、、、、、、、、、、、、、、、
myos.c
、、、、、、、、、、、、、、、、、、、、、
#include “myos.h”
#include “stdlib.h”
#include “string.h”
#include “debug.h”
#include “tim.h”
static unsigned int sys_clock=0;
typedef enum
{
false =0,
true,
}bool;
static TASK_QUEUE sleep_queue={NULL,NULL};
static TASK_QUEUE waiting_queue[8]={{NULL,NULL}};
void idle_callback(void);

static unsigned short task_cnt=0;
static void init_queue(PTASK_QUEUE pQueue)
{
pQueue->head=pQueue->tail=(PTASK_HANDLE)malloc(sizeof(TASK_HANDLE));
pQueue->head->next=NULL;
pQueue->head->name=“head”;
}
static bool IsEmptyQueue(PTASK_QUEUE pQueue)
{
if (pQueue->head == pQueue->tail)
{
return true;
}
else
{
return false;
}
}

static TASK_HANDLE* get_element_from_queue_head(PTASK_QUEUE pQueue)
{
TASK_HANDLE* tmp;
LOCK();
if(IsEmptyQueue(pQueue))
{
tmp=NULL;
}
else
{
tmp=pQueue->head->next;
pQueue->head->next=tmp->next;
if(pQueue->tail==tmp)
{
pQueue->tail=pQueue->head;
pQueue->tail->next=NULL;
}
}
UNLOCK();
return tmp;
}
static void put_element_to_queue_tail(PTASK_QUEUE pQueue,TASK_HANDLE* element)
{
LOCK();
pQueue->tail->next=element;
pQueue->tail=pQueue->tail->next;
pQueue->tail->next=NULL;
// prt(“put_element_to_queue_tail:%s\r\n”,element->name);
UNLOCK();
}

static void task_switch_deal(unsigned char priority)
{
// prt(“enter task_switch_deal\r\n”);
if(true==IsEmptyQueue(&waiting_queue[priority]))return;
TASK_HANDLE* tmp=get_element_from_queue_head(&waiting_queue[priority]);
if(tmp->taskFun!=NULL)
{
// prt(“run task :%s \n\r”,tmp->name);
tmp->taskFun((void*)tmp);
}
put_element_to_queue_tail(&sleep_queue,tmp);
}
void init_os()
{
prt(“OS init\r\n”);
init_queue(&sleep_queue);
init_queue(&waiting_queue[0]);
init_queue(&waiting_queue[1]);
init_queue(&waiting_queue[2]);
init_queue(&waiting_queue[3]);
init_queue(&waiting_queue[4]);
init_queue(&waiting_queue[5]);
init_queue(&waiting_queue[6]);
init_queue(&waiting_queue[7]);

}
void os_loop()
{
prt(“OS start\r\n”);
START_OS_TEMER;
while(1)
{

	if(false==IsEmptyQueue(&waiting_queue[PRIORITY7]))
	{			
		task_switch_deal(PRIORITY7);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY6]))
	{			
		task_switch_deal(PRIORITY6);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY5]))
	{			
		task_switch_deal(PRIORITY5);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY4]))
	{			
		task_switch_deal(PRIORITY4);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY3]))
	{			
		task_switch_deal(PRIORITY3);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY2]))
	{			
		task_switch_deal(PRIORITY2);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY1]))
	{			
		task_switch_deal(PRIORITY1);
		
	}
	else if(false==IsEmptyQueue(&waiting_queue[PRIORITY0]))
	{			
		task_switch_deal(PRIORITY0);
		
	}
	else 
	{
		 idle_callback();
	}
}

}

void timer_1ms_interrupt()
{
sys_clock++;
TASK_HANDLE *tmp_sleep_element;
TASK_HANDLE *tmp_sleep_element_last=sleep_queue.head;
// TASK_HANDLE *tmp_sleep_element_next=NULL;

while(sleep_queue.head!=sleep_queue.tail&&tmp_sleep_element_last->next!=NULL)
{
	tmp_sleep_element=tmp_sleep_element_last->next;
//	prt("timer_1ms_interrupt tmp_sleep_element name :%s\r\n",tmp_sleep_element->name);
	if(tmp_sleep_element->next_call_time<=sys_clock)
	{
		tmp_sleep_element->next_call_time=sys_clock+tmp_sleep_element->recycle_period;
		if(tmp_sleep_element==sleep_queue.tail)
		{
				sleep_queue.tail=tmp_sleep_element_last;
				sleep_queue.tail->next=NULL;
			//	break;
		}
		else
		{
				tmp_sleep_element_last->next=tmp_sleep_element->next;
		}
		put_element_to_queue_tail(&waiting_queue[tmp_sleep_element->priority],tmp_sleep_element);
	//	prt("put element %s to waiting queue\r\n",tmp_sleep_element->name);
	}
	else
	{
			tmp_sleep_element_last=tmp_sleep_element_last->next;
	}
}

}

TASK_HANDLE * add_task(char* name,FUN taskfun,void* parameter,unsigned short recycle_period,unsigned char priority)
{
LOCK();
TASK_HANDLE* task=(TASK_HANDLE*)malloc(sizeof(TASK_HANDLE));
if(task==NULL) return NULL;
memset(task,0,sizeof(TASK_HANDLE));
task->next=NULL;
task->name=name;
task->taskFun=taskfun;
task->parameter=parameter;
task->recycle_period=recycle_period;
task->priority=priority;
put_element_to_queue_tail(&sleep_queue,task);
task_cnt++;
UNLOCK();
return task;
}

void task_resume(TASK_HANDLE *task)
{
task->next_call_time=0;
}

void delete_task()//ÒѾ­ÔÚwaitingµÄº¯Êý²»ÄÜɾ³ý
{

}

void idle_callback()
{
//prt(".");

}

define timer
#ifdef USE_TIMER
static TIMER timer_handle[TIMER_CNT_MAX]={0};
void add_timer(unsigned char timer_number,char* timer_name,unsigned int x100ms_delay,unsigned char is_static,TIMER_FUN fun )
{
timer_handle[timer_number].delay_x100ms=x100ms_delay;
timer_handle[timer_number].fun=fun;
timer_handle[timer_number].is_static=is_static;
strcpy(timer_handle[timer_number].name,timer_name);
timer_handle[timer_number].be_used=1;
}

void delete_timer(unsigned char task_number)
{

memset(&timer_handle[task_number],0,sizeof(TIMER));

}
char get_empty_timer_number(unsigned char *timer_number)
{
unsigned char i=0;
for(;i<TIMER_CNT_MAX;i++)
{
if(timer_handle[i].is_static1) continue;
if(timer_handle[i].be_used1)continue;
*timer_number=i;
return 1;
}
return 0;
}

void deal_timer(void *peram)
{
unsigned char index=0;
for(;index<TIMER_CNT_MAX;index++)
{
if(timer_handle[index].be_used1)
{
if(timer_handle[index].delay_x100ms>0)
{
timer_handle[index].delay_x100ms–;
}
else
{
timer_handle[index].be_used=0;
if(timer_handle[index].fun!=NULL)
{
timer_handle[index].fun();
}
if(timer_handle[index].is_static0)
{
memset(&timer_handle[index],0,sizeof(TIMER));
}
}
}
}
}
void init_timer()
{
TASK_HANDLE *timer_task_handle = add_task(“timer task”,deal_timer,NULL,100,PRIORITY2);
}

#endif
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
myos.h
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#ifndef MYOS_H
#define MYOS_H
//#define USE_TIMER
typedef void (*FUN)(void *this_task_handle);
#ifndef NULL
#define NULL (void )0
#endif
typedef struct Node
{
char name;
FUN taskFun;
void *parameter;
unsigned int next_call_time;//
int recycle_period:14;//16x1024ms
int task_state:1;//sleep,waitingrun
int task_stop:1;
int priority:3;//0 is low, 3 is high
struct Node *next;
}TASK_HANDLE,*PTASK_HANDLE;
#define TASK_WAITING 1
#define TASK_SLEEP 0
typedef struct QNode{
PTASK_HANDLE head;
PTASK_HANDLE tail;
}TASK_QUEUE,*PTASK_QUEUE;

#define PRIORITY0 0
#define PRIORITY1 1
#define PRIORITY2 2
#define PRIORITY3 3
#define PRIORITY4 4
#define PRIORITY5 5
#define PRIORITY6 6
#define PRIORITY7 7

extern void os_loop(void);//add to main
extern void timer_1ms_interrupt(void);//add to 1ms timer interrupt
extern TASK_HANDLE * add_task(char* name,FUN taskfun,void* parameter,unsigned short recycle_period,unsigned char priority);
extern void task_resume(TASK_HANDLE *task);
extern void task_delete(TASK_HANDLE *task);
define timer /
#ifdef USE_TIMER
#define TIMER_CNT_MAX 16
typedef void (*TIMER_FUN)(void);
typedef struct
{
char *name;
TIMER_FUN fun;
unsigned short delay_x100ms:14;//max 6553 s
unsigned char be_used:1;
unsigned char is_static:1;//if the plan is static ,it can be cover

}TIMER;
void init_timer(void);
char get_empty_timer_number(unsigned char timer_number);
void add_timer(unsigned char timer_number,char timer_name,unsigned int x100ms_delay,unsigned char is_static,TIMER_FUN fun );
#endif

#define LOCK() LL_TIM_DisableIT_UPDATE(TIM1)
#define UNLOCK() LL_TIM_EnableIT_UPDATE(TIM1)
#define START_OS_TEMER do{LL_TIM_EnableIT_UPDATE(TIM1);LL_TIM_EnableCounter(TIM1);}while(0)//for os
#endif
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
test.c
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#include “myos.h”
#include “tim.h”
#include “debug.h”
void task1_fun(void * parma)
{
TASK_HANDLE* this_task=parma;
prt(“This is %s\r\n”,this_task->name);
}
void task2_fun(void * parma)
{
TASK_HANDLE* this_task=parma;
prt(“This is %s\r\n”,this_task->name);
}
void task3_fun(void * parma)
{
TASK_HANDLE* this_task=parma;
prt(“This is %s\r\n”,this_task->name);
}
void task4_fun(void * parma)
{
TASK_HANDLE* this_task=parma;
prt(“This is %s\r\n”,this_task->name);
}
void task5_fun(void * parma)
{
TASK_HANDLE* this_task=parma;
prt(“This is %s\r\n”,this_task->name);
}

void test()
{
LL_TIM_ClearFlag_UPDATE(TIM1);
LL_TIM_DisableIT_UPDATE(TIM1);
LL_TIM_DisableCounter(TIM1);

//prt(“sfsdfasdfsda\r\n”);
init_os();

TASK_HANDLE *task_h1=add_task("task1 ",task1_fun,NULL,5000,7);
TASK_HANDLE *task_h2=add_task("task2 ",task2_fun,NULL,4000,6);
TASK_HANDLE *task_h3=add_task("task3 ",task3_fun,NULL,3000,5);
TASK_HANDLE *task_h4=add_task("task4 ",task4_fun,NULL,2000,4);
TASK_HANDLE *task_h5=add_task("task5 ",task5_fun,NULL,1000,3);
os_loop();

}

五，源代码及测试程序
这是我的源代码及测试程序，在stm32f030f4p6上实现的，移植起来会非常简单，当然代码还没有完善，但是后续会不断改进，也会跟进在微博上，在stc上的版本或者优化的版本， 有需求和问题的请留言
链接：https://pan.baidu.com/s/1ltJgToZAknALL6EM4N4pJw
提取码：or0s
如果百度云找不到可以去我的csdn微博上下载。

qq_35223473
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
51单片机可用的多线程调度示例程序
06-17
基于Protothreads思路实现的一个可用于STC15系列单片的一个多线程及消息队列应用示例。可以在资源极少的单片上实现多线程调度。
c语言协程[1]_基础协程实现
libertyzx的博客
08-05 843
协程的的实现,本质是利用程序语言语法来实现逻辑上的多任务的编程;
STM32G0系列 IO模拟UART通信
weixin_42401119的博客
12-30 1753
本文用stm32G0的GPIO模拟串口通信，使用定时器和外部中断，不用延时等待，用完定时器中断立刻失能，拒绝浪费CPU资源。 使用资源：一个定时器，一个普通IO口(TX)，一个带外部中断的IO口(RX)。
高性能分布式网络服务器--协程调度器
虎小黑的博客
11-10 369
高性能分布式网络服务器--协程调度器模块
自己写的可用的协程系统
06-13
这个是一个自己写的协程系统，已经用在我做的项目上了，针对小资源mcu，移植非常简单，移植性非常好。可以用来试试。测试代码是stm32f030f4p6。用不了或者有问题联系我，可能针对项目也需要一点点改进
一种协程的 C/C++ 实现
01-21
因为我可以使用一个线程来实现一个类似多线程的程序，如果使用协程来替代线程，可以省去很多原子操作和内存栅栏的麻烦，大大减少与线程同步相关的系统调用。因为我只有一个线程，而且协程之间的切换是可以由函数自己...
libhcoroutine:最近看了一下libgo的源码自己写了一个linux下的简易版协程
04-29
【标题】中的“libhcoroutine”是一个个人项目，它基于对“libgo”源码的研究，创建了一个针对Linux操作系统的简易版协程库。在深入探讨libhcoroutine的知识点之前，我们先来理解一下协程（Coroutine）的基本概念。 ...
plainCms异步协程内容管理系统 v1.0.zip
04-05
"plainCms异步协程内容管理系统 v1.0.zip" 是一个专为管理网站内容设计的软件工具，其核心特点在于使用了异步协程技术。在IT领域，异步编程是解决高并发和高性能问题的重要手段，而协程则是实现异步编程的一种轻量级...
基于STM32 F1的携程式操作系统(类似于FreeRTOS)程序可以用于STM32 F4
07-06
自创的协程式操作系统，像FreeRTOS那样可以创建、删除、挂起、恢复任务等许多操作，每个任务有自己的独立堆栈空间，底层使用内联汇编方式实现任务切换。自创了简单的消息队列。STM32 F1与F4的CPU寄存器相同所以可以用于F4系列，但不可以直接用于F0。特点：使用SysTick作为任务切换的时钟源，降低功耗。该程序占用空间小，非常适合小容量芯片。
socket-io:基于Hyperf微服务协程框架开发的sokcet-io分布式系统
03-11
即将发布的系统的业务逻辑从的逻辑使用hyperf改写，第一版本寻求重新运行业务架构，第二版本会议重新整理业务架构，代码进行更优化。并更加符合PHP规范化。发行日期：2012年11月。发行日期：2012年1月。发行日期：...
协程（四）原理
自由的天空
09-30 2233
出处：http://www.cnblogs.com/takeaction/archive/2015/03/25/4365422.html 协程，又称微线程和纤程等，据说源于 Simula 和 Modula-2 语言（我没有深究，有错请指正），现代编程语言基本上都有支持，比如 Lua、ruby 和最新的 Google Go，当然也还有最近很让我惊艳的 falcon。协程是用户空间线程，
c语言 异步,GitHub - xiaoliang314/libatask: 纯C语言高性能异步多任务多事件驱动的协程库| Pure C language high-performance async...
weixin_36106506的博客
05-21 447
libatasklibatask(Asynchronous multitasking library)是一个由纯C语言编写的基于事件循环由多事件驱动的高性能协程库。它将事件与协程进行了结合，还原了协程最本质的用途。libatask性能高且资源占用极低，仅需56B的RAM，以及不到1K的CODE，不仅仅是PC环境，连最苛刻单片机环境中也能完美运行。事件与事件循环libatask是一个完全由事件驱动运...
c++ 协程_关于协程的实现与原理，多年程序员深度总结，瞬间感觉线程跟进程弱爆了。...
weixin_39724004的博客
11-27 558
协程的实现与原理剖析前言协程这个概念很久了，好多程序员是实现过这个组件的，网上关于协程的文章，博客，论坛都是汗牛充栋，在知乎，github上面也有很多大牛写了关于协程的心得体会。突发奇想，我也来实现一个这样的组件，并测试了一下性能。借鉴了很多大牛的思想，阅读了很多大牛的代码。于是把整个思考过程写下来。实现代码https://github.com/wangbojing/NtyCo代码简单易读，如果在...
协程（一）协程的定义与分类
larryliuqing的专栏-xxx
03-20 1388
由于协程所带来的便利，以及使用时产生的疑惑，我深入了解了一番这个概念。回头来看，目前网上能查到的关于协程的资料实在不多，而且多数都会造成一些迷惑和误解（主要是下文提到的概念模糊问题）。于是我决定写个系列来详细介绍这个概念，一方面加深自己的理解，一方面培养点开放共享的精神，同时也期待大牛的指正。 协程的定义 协程的概念最早由Melvin Conway在1963年提出并实现，用于简化COBOL编译
LL库实现STM32使用定时器主从模式输出指定数量脉冲
初心不辜的博客
03-21 3000
这里我使用的是定时器1发送脉冲，定时器4记录脉冲个数，所以定时器1工作在主模式，定时器4工作在从模式。 定时器1主要是设置输出的触发事件，这里我们选择OC1REF 这里需要注意一下，配置的时候定时器的arr不能设置为0，不然无法输出脉冲。 先上定时器1配置图 然后就是定时器4了 因为使用的是从模式，所以在这里我们选择“外部时钟模式1” 还要选触发源，这里我们选择“ITR0”，...
Unity的Coroutine
化石
05-27 3408
对于Coroutine，编译器需要产生一些代码，在每次的大循环中，Unity的Update()返回后，保证是yield后的代码被正确调用，这样就形成了我们看到的一个function能分段执行的机制。
协程
范高伦的博客
10-01 1805
1. 协程的概念 程序之间的切换叫 协程 协程，又称微线程，纤程。英文名Coroutine。 线程是系统级别的它们由操作系统调度，而协程则是程序级别的由程序根据需要自己调度。在一个线程中会有很多函数，我们把这些函数称为子程序，在子程序执行过程中可以中断去执行别的子程序，而别的子程序也可以中断回来继续执行之前的子程序，这个过程就称为 协程。 def a(): for i in range(100):...
STM32判断休眠
最新发布
道亦无名
07-17 816
STM32是否进入休眠模式（或称为睡眠模式）的判断主要基于其功耗状态、内部时钟的关闭情况以及唤醒后的行为。判断STM32是否进入休眠模式可以通过观察其功耗状态、时钟关闭情况、唤醒后的行为以及使用特定函数或指令等方法来实现。同时，还可以利用调试工具进行实时验证。
STM32智能农业灌溉系统教程
2401_84204806的博客
07-17 947
本教程详细介绍了如何在STM32嵌入式系统中实现智能农业灌溉系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能农业灌溉系统。
写一个unity 锻造系统的代码
05-02
以下是一个简单的Unity锻造系统的代码示例： ```csharp using UnityEngine; using System.Collections; public class ForgeSystem : MonoBehaviour { public GameObject itemPrefab; // 锻造物品预制体 public Transform spawnPoint; // 物品生成点 public float forgeTime = 3f; // 锻造时间 public void ForgeItem() { StartCoroutine(Forging()); } IEnumerator Forging() { yield return new WaitForSeconds(forgeTime); // 锻造完成，生成物品 GameObject item = Instantiate(itemPrefab, spawnPoint.position, Quaternion.identity) as GameObject; item.transform.SetParent(spawnPoint); Debug.Log("锻造完成！"); } } ``` 以上代码包含一个 `ForgeSystem` 类，其中包含一个 `ForgeItem()` 方法，用于触发锻造流程。 `ForgeItem()` 方法会启动一个协程 `Forging()`，在一段时间后生成物品。 这里我们使用 `itemPrefab` 预制体和 `spawnPoint` 生成点，根据需要可以替换为你自己的对象。 锻造时间可以通过 `forgeTime` 参数进行设置。 在你的场景中，你可以将 `ForgeSystem` 脚本挂载到一个按钮或其他交互元素上，让玩家点击来锻造物品。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值