HRTOS 应用示例

1

邮箱类

包含公用邮箱与私有邮箱的基本发送、查询和删除示例。

案例1：公用邮箱1

#include<HRTOS.H>
#include<reg52.h>
#define HRTOS_LED P0				//数据显示
sbit	HRT_K=P3^2;					//键盘
void main()
{
	u8 i;
	i=os_news_send1(1,15); 			//发送数据
	if(!i)				   			//正确发送
	{
		i=os_news_query1(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	i=os_news_delete1(1);			//清除邮箱数据
	while(HRT_K);
	if(!i)				   			//正确发送
	{
		i=os_news_query1(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	while(1);
}

案例2：公用邮箱2

#include<HRTOS.H>
#include<reg52.h>
#define HRTOS_LED P0				//数据显示
sbit	HRT_K=P3^2;					//键盘
void main()
{
	u16 i;
	i=os_news_send2(1,15); 			//发送数据
	if(!i)				   			//正确发送
	{
		i=os_news_query2(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	i=os_news_delete2(1);			//清除邮箱数据
	while(HRT_K);
	if(!i)				   			//正确发送
	{
		i=os_news_query2(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	while(1);
}

案例3：私有邮箱

#include<HRTOS.H>
#include<reg52.h>
#define HRTOS_LED P0				//数据显示
sbit	HRT_K=P3^2;					//键盘
void main()
{
	u8 i;
	i=os_news_send(1,15); 			//发送数据
	if(!i)				   			//正确发送
	{
		i=os_news_query(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	i=os_news_delete(1);			//清除邮箱数据
	while(HRT_K);
	if(!i)				   			//正确发送
	{
		i=os_news_query(1);	  	//读取数据
		HRTOS_LED=i;			  	//发光LED显示数据，判断功能的正确性
	}
	else{}							//异常处理
	while(1);
}

2

优先级类

展示优先级查询与动态修改的典型调用方式。

案例1：优先级查询

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0

void task()
{
	char i;
	 while(1)
	{
		i=os_priority_query(12);
		HRTOS_LED=i; ;
	}
}
void os_slab_ov(){}
void hrtos_main()
{
	os_task(task,12,6,2);
	while(1);
}

案例2：优先级修改

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
sbit HRTOS_K2=P3^4;
char i1;
void task1()
{
	while(1)
	{
		  HRTOS_LED=2;
	}
}
void task2()
{
	while(1)
	{
		HRTOS_LED=4;
	}
}
void task()
{
	 while(1)
	{
		i1=os_priority_query(16);			//读取任务的优先级
		HRTOS_LED=i1;					//LED显示判断
		while(HRTOS_K);					//等待按键
		EA=0;	
		i1=os_priority_modify(16,2);		//优先级修改
		HRTOS_LED=i1;
		while(HRTOS_K1);				//等待按键
		i1=os_priority_query(i1);			//读取任务的优先级
		HRTOS_LED=i1;
							//LED显示判断
		EA=1;
		while(1)
		{
		P0=0X1;
		}
	}
}
void os_slab_ov(){}						//溢出处理
void hrtos_main()
{									   
	os_task(task,16,8,2);			   //注册任务
	os_task(task1,2,2,2);			   //注册任务
	os_task(task2,3,2,2);			   //注册任务
	while(1);
}

3

任务类

包括任务删除、同步、退出、指定运行和状态控制等示例。

案例1：任务删除

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
sbit HRTOS_K2=P3^4;
extern char os_task_sp(u8 id);
extern unsigned char xdata OS_MEMORY[4];
void os_slab_ov(){}
void task1()
{
	while(1);
}
void task2()
{
	while(1)P0=0;
}
void task3()
{
	while(1);
}
void task5()
{
	while(1);
}

void task4()
{
	u8 i;
	EA=0;
	i=os_task_sp(1);
	HRTOS_LED=i;
	while(HRTOS_K);
	os_task_delete(1);
	os_task(task1,16,8,1);
	os_task(task5,5,2,2);
	i=os_task_sp(16);
	HRTOS_LED=i;
	while(1);
}

void hrtos_main()
{
	EA=0;
	os_task(task2,1,1,1);
	os_task(task4,3,2,2);
	os_task(task3,17,8,2);
	os_task_hang(17);
	os_task_hang(16);
	EA=1;
	while(1);
}

案例2：同步

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
sbit HRTOS_K2=P3^4;
void os_slab_ov(){}
void task2()
{
	while(HRTOS_K);
	os_semaphore(2);
	while(1)
	{
		HRTOS_LED=1;
	}
}
void task3()
{
	while(HRTOS_K1);
	os_semaphore(2);
	while(1)
	{
		HRTOS_LED=2;
	}
}
void task4()
{
	os_semaphore_control(2,3);
	while(HRTOS_K2);
	os_semaphore(2);
	while(1)
	{
		HRTOS_LED=4;
	}
}

void hrtos_main()
{
	os_task(task4,4,2,2);
	os_task(task2,2,2,2);
	os_task(task3,3,2,2);
	while(1);
}

案例3：推出任务

#include<hrtos.h>
#include<hrtos_NEIBU.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
void os_slab_ov(){}
void task2()
{
	while(1)
	{
		HRTOS_LED=1;
	}
}
void task3()
{
	while(1)
	{
		HRTOS_LED=2;
	}
}
void task4()
{
	while(1)
	{
		HRTOS_LED=4;
	}
}

void hrtos_main()
{
	EA=0;
	os_task(task2,2,2,0);
	os_task(task3,3,2,0);
	os_task(task4,4,2,0);
	EA=1;
	os_task_exit();
	EA=0;
	while(1);
}

案例4：指定任务运行

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
void os_slab_ov(){}
void task1()
{
	while(1)
	{
		HRTOS_LED=15;
		while(!HRTOS_K)
		{
			os_task_function(3);
			break;
		}
	}
}
void task2()
{
	while(1)
	{
		HRTOS_LED=2;
	}
}
void task3()
{
	while(1)
	{
		HRTOS_LED=1;
	}
}

void hrtos_main()
{
	os_task(task1,1,8,2);
	os_task(task2,2,5,2);
	os_task(task3,3,2,2);
	while(1);
}

案例5：指定任务运行

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
sbit HRTOS_K2=P3^4;
sbit HRTOS_K3=P3^5;
sbit HRTOS_K4=P3^6;
void os_slab_ov(){}
void task2()
{
	u8 i;
	i=os_task_state(1);//0删除 1	运行 2就绪 3	挂起 4	超时
	HRTOS_LED=i;
	while(1)
	{
		EA=0;
		while(HRTOS_K1);
		
		os_task_hang(1);//挂起
		i=os_task_state(1);//0删除 1运行 2就绪 3挂起 4超时
		HRTOS_LED=i;
		EA=1;
	}
}
void task3()
{
	u8 i;
	i=os_task_state(3);//0删除 1运行 2就绪 3挂起 4超时
	HRTOS_LED=i;
	EA=0;
	while(HRTOS_K);
	EA=1;
	while(HRTOS_K3);
	os_task_delete(1);
	while(1);
}
void task4()
{
	u8 i;
	i=os_task_state(1);//0删除 1运行 2就绪 3挂起 4超时
	HRTOS_LED=i;
	while(1)
	{
		EA=0;
		while(HRTOS_K2);
		os_task_ready(1);
		i=os_task_state(1);//0删除 1运行 2就绪 3挂起 4超时
		HRTOS_LED=i;
		while(HRTOS_K4);
		EA=1;
	}
}

void hrtos_main()
{
	os_task(task2,2,2,2);
	os_task(task3,1,2,2);
	os_task(task4,4,2,2);
	while(1);
}

4

时间类

包括 wait、wait1、wait2 和 nop 延迟的示范代码。

案例1：延时wait

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
void os_slab_ov(){}
void task1()
{
	os_wait(K_IVL,2);//等待一个切换
	while(1)
	{
		HRTOS_LED=254;
	}
}
void task2()
{
	os_wait(K_SIG,1);//等待一个信号
	while(1)
	{
		HRTOS_LED=253;
	}
}
void task3()
{
	os_wait(K_SIG|K_TMO,1);//等待一个信号或者一个超时
	while(1)
	{
		HRTOS_LED=251;
	}
}
void task4()
{
	os_wait((K_SIG&K_TMO),1);//等待信号和超时
	while(1)
	{
		HRTOS_LED=247;
	}
}
void task5()
{
	os_wait((K_SIG&K_IVL),1);//等待一个信号和切换
	while(1)
	{
		HRTOS_LED=239;
	}
}
void task6()
{
	os_wait((K_SIG|K_IVL),1);//等待一个信号或者一个切换
	while(1)
	{
		HRTOS_LED=223;
	}
}
void task7()
{
	while(HRTOS_K);
	os_wait(K_TMO,1);//等待超时
	os_event_out(2);//向任务2发送一个信号
	os_event_out(4);
	os_event_out(5);
	while(1)
	{
		HRTOS_LED=191;
	}
}

void hrtos_main()	   //16136
{
	EA=0;
	os_task(task1,1,2,2);
	os_task(task2,2,2,2);
	os_task(task3,3,2,2);
	os_task(task4,4,2,2);
	os_task(task5,5,2,2);
	os_task(task6,6,2,2);
	os_task(task7,7,2,2);
	os_timer_length(20,65532);
	EA=1;
	while(1);
}

案例2：延时wait1

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
void os_slab_ov(){}
void task2()
{
	os_wait1(100);//
	while(1)
	{
		HRTOS_LED=0;
	}
}
void task3()
{
	while(1)
	{
		HRTOS_LED=254;
	}
}
void task4()
{
	while(1)
	{
		HRTOS_LED=253;
	}
}

void hrtos_main()
{
	os_task(task2,2,2,2);
	os_task(task3,3,2,2);
	os_task(task4,4,2,2);
	while(1);
}

案例3：延时wait2

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
void main()
{
	HRTOS_LED=0;
	while(1)
	{
		TR0=1;
		os_wait2(1000);
		HRTOS_LED++;
	}
	
}

案例4：延迟一个nop

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
void main()
{
	u16 i;
	HRTOS_LED=0;
	while(1)
	{
		i=65500;
		while(i--)
		{
			os_nop();//延时1个NOP
		}
		HRTOS_LED++;
	}
}

5

进程锁类

演示任务间争用同一把锁时的获取与释放流程。

案例1：进程锁

#include<hrtos.h>
#include<reg52.h>
#define HRTOS_LED P0
sbit HRTOS_K=P3^2;
sbit HRTOS_K1=P3^3;
void os_slab_ov(){}//内存溢出处理函数
void task2()
{
	os_priority_modify(2,2);//将任务2，即本任务的优先级修改为2
	os_lock(1);//取得锁1
	while(HRTOS_K)
	{
		HRTOS_LED=1;
	}
	os_lock_release(1);//释放锁1
	while(1)
	{
		HRTOS_LED=1;
	}
}							
void task3()
{
	os_lock(1);//试图取得锁1
	while(HRTOS_K1)
	{
		HRTOS_LED=2;
	}
	os_lock_release(1);//释放锁1
	while(1)
	{
		HRTOS_LED=2;
	}
}
void task4()
{
	os_lock(1);//
	while(1)
	{
		HRTOS_LED=4;
	}
}

void hrtos_main()
{
	EA=0;
	os_task(task2,2,6,2);
	os_task(task3,3,6,2);
	os_task(task4,4,6,2);
	os_lock_init();//锁的初始化
	EA=1;
	while(1);
}

6

内核测试类

这一组包含 HRT 主函数、自建调度策略以及 TASK 模拟用户程序。

HRT主函数

HRT主函数：

#include<myos.h>
#include<reg52.h>
void my_hrtos()
{
	u8 i;
	ET0=1;
	if(1)i=10;
	ET0=0;
}

MyOS自建调度策略

MyOS自建调度策略：

#include<myos.h>
#include<reg52.h>
u16 my_inter[10];//中断地址
void os_slab_ov(){}
volatile void my_os()
{
	U8 i;
	i=os_inter(); //中断号
	if(i==1)//t0	内核
	{		
		TF0=0;
		TH0=0;
		TL0=0;
		i=os_task_id();//运行编号
		os_task_protect(i);//保护现在的任务
		i=os_select(i);//选择下一个运行的任务
		os_task_release(i);//释放下一个任务
	}
	else   //中断
	{
		if(i)//如果不是INT0中断则减一，因为定时器T0中断为1
		{i--;}
		os_operate(my_inter[i]);
	}
}
void hrtos_main()
{
	EA=0;
	os_task(my_os,15,9,0);//将MyOS注册到HRTOS的中断服务函数处
	os_task(my_main,1,1,2);//启动MyOS的初始化函数
	EA=1;
	while(1);
}

TASK模拟用户程序

TASK模拟用户程序：

#include<myos.h>
#include<reg52.h>
void my_task(u16 addr,u8 id)   //id:0-13任务；14-24对应中断偏移地址，例如14对应外部中断0,15对应定时器0。但是定时器0被系统使用，故15为非法编号。
{
	if(id>24)//错误
	{}
	else 
	{
		if(id<14)//任务
		{
			id+=2;
			os_task(addr,id,2,2);//默认嵌套层数2
		}
		else if(id!=15)//中断
		{
			id-=14;
			if(id)
				id--;
			my_inter[id]=addr;
		}
	}
}