 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
iData MC80使用说明书
下载积分：650
内容提示：iData MC80使用说明书
文档格式：DOC|
浏览次数：390|
上传日期： 17:34:51|
文档星级：
全文阅读已结束，如果下载本文需要使用
 650 积分
下载此文档
该用户还上传了这些文档
iData MC80使用说明书
官方公共微信带信号量和抢占式的中断调度的mini操作系统(基于8051)
单片机&嵌入式
单片机应用
嵌入式操作系统
学习工具&教程
学习和开发单片机的必备工具
(有问必答)
(带你轻松入门)
电子元件&电路模块
当前位置： >>
>> 浏览文章
带信号量和抢占式的中断调度的mini操作系统(基于8051)
做了7个文件,分别是
os_core.h&&&&&& //核心文件的参数定义&&&
os_core.c&&&&&& //核心文件,包含进程的6种操作,系统级别的操作
task_switch.h //任务切换函数的定义
task_switch.c //任务切换函数的实现,采用抢占式中断调用(T2自动重载)
sem.h&&&&&&&&&&& //信号量的定义,其实也就是3个函数,创建信号量,发送一个信号量,接收信号量,在教材里面讲得那么复杂,差点把人搞晕了,实现起来不要太简单
sem.c&&&&&&&&&&& //信号量实现
main.c&&&&&&&&&& //任务以及它的操作和主函数包括在这里
//---------------------------------------------------os_core.h---------------------------------------------------------------//
#ifndef __OS_CORE_H__
#define __OS_CORE_H__
#include &reg52.h&
typedef signed char int8s;
typedef unsigned char int8u;
typedef signed int int16s;
typedef unsigned int int16u;
typedef signed long int32s;
typedef unsigned long int32u;
//任务的5种状态
#define TASK_STATUS_CREATE 0x00
#define TASK_STATUS_RDY 0x01
#define TASK_STATUS_SUSPEND 0x02
#define TASK_STATUS_ENDED0x04
#define TASK_STATUS_SEM0x08
//任务控制块
typedef struct {
int8u task_//任务状态
int8u task_//任务的优先级
int8u task_stack_//任务栈顶地址(保存任务栈顶的地址)
int8u task_wait_//任务延时等待次数
#define MAX_TASKS 4//最大的任务数量
//任务的优先级从小到大一次排列，数值越小，优先级越高
#define TASK_STACK_DEPTH 17//最大任务堆栈深度（2字节程序地址+13字节寄存器数据+2字节中断过程保存字节）
#define NUM_RESISTER_PUSHED 13//人工堆栈中需要被保存的寄存器数量（这里因为是8051，所以有13字节）
extern idata volatile OS_TCB os_tcb[MAX_TASKS];//任务控制块列表
extern volatile int8u task_running_//正在运行任务的标号
extern volatile int8u os_res_//系统资源表，表示哪些资源是否被占用（最大为8个）
extern volatile int8u idata task_stack[MAX_TASKS][TASK_STACK_DEPTH];//每个任务的任务栈
extern volatile int8u task_int_//任务中断标记（最大为8个）
extern volatile int8u int_//进入中断次数
extern volatile int8u os_en_cr_//进入临界区次数
#define os_enter_critical() {EA=0;os_en_cr_count++;} //进入临界区
#define os_exit_critical() {if(os_en_cr_count&0){os_en_cr_count--;if(os_en_cr_count==0){EA=1;}}}//退出临界区
//任务的六种操作
void task_create(void (*task)(void),int8u task_priority);
void task_delete(int8u task_id);
void task_sleep();
void task_wake();
void task_suspend(int8u task_id);
void task_resume(int8u task_id);
//系统操作
void os_init();//初始化系统
void os_start();//开始系统
void os_delay(int8u tick);//任务延时
void os_task_idle();//空任务，具有最低优先级
//---------------------------------------------------os_core.c---------------------------------------------------------------//
#include &os_core.h&
#include &task_switch.h&
idata volatile OS_TCB os_tcb[MAX_TASKS];//任务控制块列表
volatile int8u task_running_//正在运行任务的标号
volatile int8u os_res_//系统资源表，表示哪些资源是否被占用（最大为8个）
volatile int8u idata task_stack[MAX_TASKS][TASK_STACK_DEPTH];//每个任务的任务栈
volatile int8u task_int_//任务中断标记（最大为8个）
volatile int8u int_//进入中断次数
volatile int8u os_en_cr_//进入临界区次数
********************************************************************************************************
********************************************************************************************************
void task_create(void (*task)(void),int8u task_priority) {
static int8
static int8u task_
static int8u *stack_
for(i=0; i&MAX_TASKS;i++) {//为任务分配id和资源（注意，task的id和资源的分配是自动的）
if((os_res_list&(0x01&&i))==0) {//如果是空的话，那么会从第0个开始分配，即第一个任务的ID号肯定是0，也就是空闲任务ID肯定是0
os_res_list|=0x01&&i;
os_tcb[task_id].task_status = TASK_STATUS_CREATE;//将任务置于创建态
//为任务分配堆栈空间
stack_point = task_stack[task_id];
for(i=0; i&TASK_STACK_DEPTH; i++) {//先清除堆栈
*(stack_point+i) = 0;
*stack_point = (int16u) //任务低8位给task_stack[task_id][0]
stack_point++;
*stack_point = (int16u)task&&8; //任务高8位给task_stack[task_id][1]
stack_point += NUM_RESISTER_PUSHED; //将13个寄存器位置保存起来
//为任务添加属性
os_tcb[task_id].task_stack_top = (int8u)stack_
os_tcb[task_id].task_priority = task_
os_tcb[task_id].task_wait_tick = 0;
os_tcb[task_id].task_status = TASK_STATUS_RDY;//将任务置于就绪态
void task_suspend(int8u task_id) { //挂起一个任务
os_enter_critical();
os_tcb[task_id].task_status = TASK_STATUS_SEM;//将该任务的状态置于被挂起的状态(由于信号量）
os_exit_critical();
if(task_id == task_running_id) {
os_task_switch(); //调用一下任务切换，切换到其它任务
void task_resume(int8u task_id) {
os_enter_critical();
if(os_res_list&(0x01&&task_id) != 0) { //如果要恢复的任务存在
os_tcb[task_id].task_status = TASK_STATUS_RDY;//将任务状态置于就绪态
os_exit_critical();
if(os_tcb[task_id].task_priority & os_tcb[task_running_id].task_priority) {
os_task_switch(); //调用一下任务切换，切换到优先级更高的任务
void task_delete(int8u task_id) { //删除一个任务
os_enter_critical();
if(os_res_list&(0x01&&task_id) != 0) { //如果要删除的任务存在
os_tcb[task_id].task_status = TASK_STATUS_ENDED; //将任务状态置于结束态
os_res_list &= ~(0x01&&task_id); //释放任务使用的堆栈等资源
os_tcb[task_id].task_wait_tick = 0;
os_exit_critical();
os_task_switch();
********************************************************************************************************
********************************************************************************************************
void os_init(){ //初始化系统
EA = 0;//关闭总中断
ET2 = 1;//开启定时器2中断
T2CON = 0x00;//自动重载
//T2MOD = 0x00;
RCAP2H = 0xD8; //晶振使用12MHZ，定时时间10ms
RCAP2L = 0xF0;
os_res_list = 0x00; //资源全部置空
os_en_cr_count = 0; //进入临阶段0次
task_create(&(os_task_idle),MAX_TASKS-1);//创建空闲进程，优先级为MAX_TASKS-1
void os_start(){//开始系统
task_running_id = 0;//指示task_idle 为第一个运行的任务
os_tcb[task_running_id].task_stack_top -= NUM_RESISTER_PUSHED;//去掉寄存器的堆栈，以免在调用的时候出现堆栈溢出
SP = os_tcb[task_running_id].task_stack_ //将空闲任务置于运行态
TR2 = 1;//开启定时器2中断
EA = 1;//开启总中断
//while(1);//等待定时器中断的调用
void os_delay(int8u tick){//任务延时
os_enter_critical();
os_tcb[task_running_id].task_wait_tick =//设置延时节拍数
os_tcb[task_running_id].task_status = TASK_STATUS_SUSPEND;//将置于处于挂起态，等待延时
os_exit_critical();
os_task_switch();
os_exit_critical();
void os_task_idle() {//空任务，具有最低优先级
//static int8
while(1) {
//os_enter_critical();
//os_exit_critical();
//---------------------------------------------------task_switch.h---------------------------------------------------------------//
#ifndef __TASK_SWITCH_H__
#define __TASK_SWITCH_H__
#include &os_core.h&
void os_task_switch();//任务调度
//---------------------------------------------------task_switch.c---------------------------------------------------------------//
#include &task_switch.h&
void os_task_switch(){//任务调度
static int8
__asm PUSH ACC//保存寄存器
__asm PUSH B
__asm PUSH PSW
__asm PUSH DPH
__asm PUSH DPL
__asm MOV A,R0
__asm PUSH ACC
__asm MOV A,R1
__asm PUSH ACC
__asm MOV A,R2
__asm PUSH ACC
__asm MOV A,R3
__asm PUSH ACC
__asm MOV A,R4
__asm PUSH ACC
__asm MOV A,R5
__asm PUSH ACC
__asm MOV A,R6
__asm PUSH ACC
__asm MOV A,R7
__asm PUSH ACC
os_tcb[task_running_id].task_stack_top = SP;//保存当前的堆栈指针
//os_tcb[task_running_id].task_status = TASK_STATUS_RDY;//不用在这里修改当前任务的状态，已经在任务函数中修改过了
task_running_id = 0;
for(i=0; i&MAX_TASKS; i++) {
if((os_res_list&(0x01&&i)) != 0) {//判断任务的资源是否还在使用，即任务是否还存在
if(os_tcb[i].task_status == TASK_STATUS_RDY) {
if(os_tcb[i].task_priority&os_tcb[task_running_id].task_priority) {
task_running_id = //找到优先级最高的，而且处于就绪状态的任务，将它置位当前要运行的任务
SP = os_tcb[task_running_id].task_stack_
__asm POP ACC//恢复寄存器
__asm MOV R7,A
__asm POP ACC
__asm MOV R6,A
__asm POP ACC
__asm MOV R5,A
__asm POP ACC
__asm MOV R4,A
__asm POP ACC
__asm MOV R3,A
__asm POP ACC
__asm MOV R2,A
__asm POP ACC
__asm MOV R1,A
__asm POP ACC
__asm MOV R0,A
__asm POP DPL
__asm POP DPH
__asm POP PSW
__asm POP B
__asm POP ACC
void timer2_isr(void) interrupt 5 using 1 {
__asm MOV A,R0
__asm PUSH ACC
__asm MOV A,R1
__asm PUSH ACC
__asm MOV A,R2
__asm PUSH ACC
__asm MOV A,R3
__asm PUSH ACC
__asm MOV A,R4
__asm PUSH ACC
__asm MOV A,R5
__asm PUSH ACC
__asm MOV A,R6
__asm PUSH ACC
__asm MOV A,R7
__asm PUSH ACC
os_tcb[task_running_id].task_stack_top = SP;
task_running_id = 0;
for(i=0; i&MAX_TASKS; i++) {
if((os_res_list&(0x01&&i)) != 0) {//判断任务的资源是否还在使用，即任务是否还存在
if(os_tcb[i].task_status == TASK_STATUS_SUSPEND) { //只有被挂起的任务才能时间减少
if(os_tcb[i].task_wait_tick != 0) {
os_tcb[i].task_wait_tick--;
if(os_tcb[i].task_wait_tick == 0) {
os_tcb[i].task_status = TASK_STATUS_RDY;
if(os_tcb[i].task_status == TASK_STATUS_RDY) {
if(os_tcb[i].task_priority&os_tcb[task_running_id].task_priority) {
task_running_id = //找到优先级最高的，而且处于就绪状态的任务，将它置位当前要运行的任务
SP = os_tcb[task_running_id].task_stack_
__asm POP ACC//恢复寄存器
__asm MOV R7,A
__asm POP ACC
__asm MOV R6,A
__asm POP ACC
__asm MOV R5,A
__asm POP ACC
__asm MOV R4,A
__asm POP ACC
__asm MOV R3,A
__asm POP ACC
__asm MOV R2,A
__asm POP ACC
__asm MOV R1,A
__asm POP ACC
__asm MOV R0,A
//---------------------------------------------------sem.h---------------------------------------------------------------//
#ifndef __SEM_H__
#define __SEM_H__
#include &os_core.h&
#define MAX_SEMS 2
typedef struct {
int8u os_event_//0：不可用，1：可用
int8u os_task_pend_//等待信号量的任务列表
}OS_EVENT;
extern volatile OS_EVENT os_sem[MAX_SEMS];
void os_task_sem_pend(int8u index);
void os_task_sem_post(int8u index);
void os_sem_create(int8u index,int8u state);
#define os_sem_clean(index) os_sem[index].os_event_state = 0
//---------------------------------------------------sem.c---------------------------------------------------------------//
#include &sem.h&
volatile OS_EVENT os_sem[MAX_SEMS];
void os_task_sem_pend(int8u index) {
os_enter_critical();
if(index& MAX_SEMS) {
if(os_sem[index].os_event_state!=0) {//信号量可用
os_sem[index].os_event_state--;
os_sem[index].os_task_pend_tbl |= (0x01&&task_running_id);
task_suspend(task_running_id);
os_exit_critical();
void os_task_sem_post(int8u index) {
os_enter_critical();
if(index&MAX_SEMS) {
for(i=0; i&MAX_TASKS; i++) { //找到的i是优先级最高且处于等待状态的任务
if((os_sem[index].os_task_pend_tbl&(0x01&&i)) != 0) {//如果要恢复的任务存在
if(i & MAX_TASKS) {
os_sem[index].os_task_pend_tbl &= ~(0x01&&i);
task_resume(i);
os_sem[index].os_event_state++;
os_exit_critical();
void os_sem_create(int8u index,int8u state) { //初始化信号量
if(index & MAX_SEMS) {
os_sem[index].os_task_pend_tbl = 0;
os_sem[index].os_event_state =
//---------------------------------------------------main.c---------------------------------------------------------------//
#include &os_core.h&
#include &task_switch.h&
#include &sem.h&
void task_1(void) {
static int8
while(1) {
os_task_sem_pend(1);
P1 = 0x01&&(i%8);
os_delay(100);
os_task_sem_post(1);
sbit led = P2^1;
void task_2(void) {
while(1) {
os_task_sem_pend(0);
os_task_sem_pend(1);
os_delay(10);
os_delay(10);
os_task_sem_post(0);
os_task_sem_post(1);
void task_3(void) {
static int8
while(1) {
os_task_sem_pend(0);
P3 = 0x01&&(j%8);
os_delay(100);
os_task_sem_post(0);
int main(void) {
os_init();
os_sem_create(0,1);
os_sem_create(1,1);
task_create(&(task_2),0);
task_create(&(task_1),1);
task_create(&(task_3),2);
os_start();
在51单片机上实现操作系统是我们不常讨论的话题，其实操作系统还是有蛮大的用处的，&上次我写了一篇文章：一个简单的51单片机操作系统的实现，连接是：&，这篇其实是对上篇文章的补充.实现更多的一些功能，希望大家多多指点啊.
& 实现了任务的互斥，使得两个任务之间能够互斥运行，但是不能是两个以上，因为系统采用的是抢占式的中断调度，所以两个以上任务公用一个信号量，会出现优先级较低的那个任务出现饥饿的情况。
任务的实时性是很有保障的，因为内部函数比较简单，所以不存在嵌套中断的说法。
计算一下程序使用的RAM，一共使用大概101字节，剩余107字节可用，感觉还不错.
现在已经成功地实现信号量的功能。
剩下的还有邮箱、事件、内存等等了，不过由于8051RAM空间还是小了些，如果能扩充到4KB以上，发展潜力倒是会有很大的提高，不过外置RAM肯定速度上比不了内置的。
自己动手做51操作系统现在暂时告一段落，操作系统还是在片上资源丰富的系统上用比较好，不过STC的那个最NB的STC90C516AD拥有4KB的RAM和62KB的ROM用起来也可以的。价格也不贵,有空再去尝试...
当任务多了的时候，任务的配置模块也很多，RAM里面84%以上的空间都是用于任务的各种属性的配置，包括任务堆栈和任务的互斥。
希望接下来的复习能够更加认真！！！现在算是了却了我内心中的一桩心愿吧，真正实现了自己的操作系统！！！（功能匮乏，只有进程调度和互斥实现)
现在我才知道链表的操作是多么地耗费内存.创建一个指针就要3个字节,如果搞个链表出来,包括结构体,在资源不那么丰富的8051上(操作系统中),简直是宰牛用杀鸡刀,完全吃不消.但是如果是AVR或者ARM等片上资源丰富的单片机,那就不存在了.
为什么手机的操作系统里面一个安装文件动不动就几MB的大小,为什么Android中的程序动不动就占用几MB的内存?
这就和操作系统有很大关系了,创建一个任务,给它定义进程控制块,堆栈,还要包括它的GUI,别看图形界面特别简单,实际上采用图形界面还是相当吃内存的.在进程切换中,保存堆栈和一些进程信息,这又得占用一部分内存.Android因为采用虚拟机的缘故,这虚拟机它也得吃内存啊,开个程序就有个虚拟机跟着,速度当然不如symbian了.可惜symbian内存和cpu的频率比较低...
所以内存占用和系统任务的个数是线性关系的.当某个程序比较大,它占用内存越多,而且可能会频繁地读取内存,这样就会造成其它程序速度变慢.这就是为什么在听歌的时候,上网有时会有点卡的原因之一.
系统启动的时候,会把程序加载进入内存中,当需要加载的程序数量过多时,自然就会比较卡.所以开机的时候会有一段延迟.
【】【】【】【】
上一篇:下一篇:
CopyRight @
单片机教程网
, All Rights Reserved下次自动登录
现在的位置:
& 综合 & 正文
存储过程和IDataReader取数据的性能
最近在做一些数据的统计运算功能的咚咚，发现存储过程并不像想象的性能那么好。
目前的表有记录5万条，550列。由于其中的运算比较复杂，所以只有采用遍历记录的方式其中又要做一些运算。
方式1：采用存储过程。使用Cursor遍历记录，将中间变量放在table变量中。初次运行约40s,反复运行在37s左右。
方式2：采用IDataReader遍历记录。在C#的后台模块中使用IDataReader（System.Data.OleDb)来遍历记录，将中间变量放在Hashtable中。运行时间20s左右。
其中中间变量的作用是，当遍历一条记录的时候查看某一个特定的项（例如aid)是否在中间变量中存在，如果不存在则新添加一个，否则就将记录中的某一部分
列的值做一些运算之后累加到已有的记录中。最后这些中间变量（aid)共有1000左右个值（即hashtable中有1000个key）。
不知道其中是游标的原因还是中间变量使用table变量和hashtable的差别，导致了如此的差距。
还是具体问题具体分析，采用不同的设计，不能盲从。
欢迎大家评论！提出更好的看法!
&&&&推荐文章:
【上篇】【下篇】我是普元顾问，欢迎与我在线交流。