ucos:ucos 应用编程大全

最新推荐文章于 2024-09-28 09:32:00 发布
最新推荐文章于 2024-09-28 09:32:00 发布
阅读量3.3k 收藏 5
点赞数
分类专栏： linux-基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiyuan19840208/article/details/11614385
版权

0：ucos for linux port 代码
     ucos for linux port代码可以在： 我的资源中下载。

1：说明

主要对ucos中的task创建，消息队列，消息邮箱，信号量，互斥量的使用进行了举例说明。
对不同的模块的测试：可以通过不同的宏定义来实现。
#define UCOS_BASIC_TASK_TEST   0  //基本任务的创建
#define UCOS_MSG_QUEUE_TASK_TEST 0  //消息队列
#define UCOS_MAIL_B0X_TASK_TEST 0 //消息邮箱
#define UCOS_MEM_TASK_TEST          0 //内存管理
#define UCOS_SEM_TASK_TEST          0 //信号量
#define UCOS_MUTEX_TASK_TEST        1 //互斥量

对不同的模块的测试：可以通过不同的宏定义来实现。
#define UCOS_BASIC_TASK_TEST  0//基本任务的创建
#define UCOS_MSG_QUEUE_TASK_TEST0//消息队列
#define UCOS_MAIL_B0X_TASK_TEST0//消息邮箱
#define UCOS_MEM_TASK_TEST         0//内存管理
#define UCOS_SEM_TASK_TEST         0//信号量
#define UCOS_MUTEX_TASK_TEST       1//互斥量

2：示例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ucos_ii.h"

typedef unsigned char uint8 ;
typedef unsigned short uint16;
struct msgbuf {
    uint8  option;                 /* Message type */
    uint8  msgID;
    uint16 msgData;
};
struct msgType {
	long mtype;
	struct msgbuf mdata;
};
#define  TASK_STK_SIZE    128
#define  BUFFER_SIZE  	  3


struct storage_data
{
	INT16U input;
	INT16U output;
	INT16U buffer[BUFFER_SIZE];
};
OS_STK        AppStk_send_one[TASK_STK_SIZE];
OS_STK        AppStk_send_two[TASK_STK_SIZE];
OS_STK        AppStk_recv[TASK_STK_SIZE];
OS_STK        qsmBox_AppStk_send[TASK_STK_SIZE];
OS_STK        qsmBox_AppStk_recv[TASK_STK_SIZE];
OS_STK        mem_AppStk_one[TASK_STK_SIZE];
OS_STK        mem_AppStk_two[TASK_STK_SIZE];
OS_STK        sem_AppStk_producer[TASK_STK_SIZE];
OS_STK        sem_AppStk_customer[TASK_STK_SIZE];
OS_STK        mutex_Stack1[TASK_STK_SIZE];
OS_STK        mutex_Stack2[TASK_STK_SIZE];
OS_MEM *mem_p;
OS_EVENT  *pmsgqueue;
OS_EVENT  *pmailbox;
OS_EVENT  *sem_custom;
OS_EVENT  *sem_produce;
OS_EVENT  *ResourceMutex;
void *ptr;
void *msgqueue[10];
struct storage_data *storage;
static int g_counter=0;

unsigned long long monotonic_us(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	return tv.tv_sec * 1000000ULL + tv.tv_usec;
}
void printf_task_info(uint8 i)
{
	if(OSTCBPrioTbl[i]==NULL)
	{
		printf("the prio=%u task is no exit\n",i);
		return ;
	}
	else

	{
		OS_Printf("the prio=%u task information as follow\n",i);
		OS_Printf("the prio=%u task delay time is %u\n",i,OSTCBPrioTbl[i]->OSTCBDly);
		OS_Printf("the prio=%u task status is 0x%x\n",i,OSTCBPrioTbl[i]->OSTCBStat);
		OS_Printf("the prio=%u task name is %s\n",i,OSTCBPrioTbl[i]->OSTCBTaskName);
		OS_Printf("OSTCBCur->OSTCBStkPtr=%p\n",OSTCBCur->OSTCBStkPtr);
		OS_Printf("current task prio=%u\n",OSPrioCur);
		return ;
	}
}
void MyTask( void *p_arg )
{
	char* sTaskName = (char*)p_arg;
	while(1)
	{
		/* printf uses mutex to get terminal access, therefore must enter critical section */
		OS_Printf("%s\t%s: line: %d Name: %s\n", __FILE__,__func__, __LINE__, sTaskName );
		/* Delay so other tasks may execute. */
		OSTimeDlyHMSM(0, 0,0 , 50);

	}/* while */

}

void App_send_one(void *p_arg)
{
	INT8U  err;
	struct msgType sendMsg;
  struct msgType *recvdMsg;
	memset(&sendMsg,0,sizeof(sendMsg));
	p_arg = p_arg;
	OSTaskNameSet(OSPrioCur,"App_send_one",&err);
   while(1)                            
	{ 
		srand(monotonic_us());
		sendMsg.mtype=0x01;
		sendMsg.mdata.option=0x01;
		sendMsg.mdata.msgID=0x01;
		sendMsg.mdata.msgData=rand();
		recvdMsg =&sendMsg;
		if((err=OSQPost(pmsgqueue,(void *)&sendMsg))==OS_NO_ERR)
		{
			OS_Printf("App_send_one: mtype:%d option:%d msgID:%d msgData:%d\n",recvdMsg->mtype,recvdMsg->mdata.option ,recvdMsg->mdata.msgID, recvdMsg->mdata.msgData);
		}
		else if(err==OS_Q_FULL)
		{
			OS_Printf("this is senderone the msg_q is full\n");
		}
		else
		{
			OS_Printf("other err\n");
		}

        OSTimeDlyHMSM(0, 0, 0, 20);
	//	printf_task_info(OSPrioCur);
    }
}


void App_send_two(void *p_arg)
{
	INT8U err;
	p_arg = p_arg;
	struct msgType sendMsg;
  struct msgType *recvdMsg;
	memset(&sendMsg,0,sizeof(sendMsg));
	OSTaskNameSet(OSPrioCur,"App_send_two",&err);
    while(1)                           
	{ 
		srand(monotonic_us());
		sendMsg.mtype=0x02;
		sendMsg.mdata.option=0x02;
		sendMsg.mdata.msgID=0x02;
		sendMsg.mdata.msgData=rand();
		recvdMsg =&sendMsg;

		if((err=OSQPost(pmsgqueue,&sendMsg))==OS_NO_ERR)
		{
			OS_Printf("App_send_two: mtype:%d option:%d msgID:%d msgData:%d\n",recvdMsg->mtype,recvdMsg->mdata.option ,recvdMsg->mdata.msgID, recvdMsg->mdata.msgData);
		}
		else if(err==OS_Q_FULL)
		{
			OS_Printf("this is sendertwo\nthe msg_q is full\n");
		}
		else
		{
			OS_Printf("other err\n");
		}
    OSTimeDlyHMSM(0, 0, 2, 0);
		sendMsg.mtype=0x03;
		sendMsg.mdata.option=0x03;
		sendMsg.mdata.msgID=0x03;
		sendMsg.mdata.msgData=rand();
		recvdMsg =&sendMsg;
		if((err=OSQPostFront(pmsgqueue,&sendMsg))==OS_NO_ERR)
		{
			OS_Printf("App_send_two: mtype:%d option:%d msgID:%d msgData:%d\n",recvdMsg->mtype,recvdMsg->mdata.option ,recvdMsg->mdata.msgID, recvdMsg->mdata.msgData);
		}
		else if(err==OS_Q_FULL)
		{
			OS_Printf("this is sendertwo the msg_q is full\n");
		}
		else
		{
			OS_Printf("other err\n");
		}
        OSTimeDlyHMSM(0, 0, 0, 10);
		//printf_task_info(OSPrioCur);
    }
}

void App_recv(void *p_arg)
{
	INT8U err;
	INT16U timeout=100;
	struct msgType *recvdMsg;
	p_arg = p_arg;
	OS_Printf("when create:\n");
	pmsgqueue=OSQCreate(msgqueue,10);
	for (;;)
	{
		recvdMsg=OSQPend(pmsgqueue,timeout,&err);
		if(err==OS_NO_ERR)
		{
			OS_Printf("recver data is: mtype:%d option:%d msgID:%d msgData:%d\n",recvdMsg->mtype,recvdMsg->mdata.option ,recvdMsg->mdata.msgID, recvdMsg->mdata.msgData);
		}
		else if(err==OS_TIMEOUT)
		{
			OS_Printf("timeout\n");
			break;
		}
		else if(err==OS_ERR_EVENT_TYPE)
		{	
			OS_Printf("this is recver err is OS_ERR_EVENT_TYP\n");
			break;
		}
		else
		{
			break;
		}
        OSTimeDlyHMSM(0, 0, 0, 1);
	}
	OSQDel(pmsgqueue,OS_DEL_NO_PEND, &err);
	if(err==OS_ERR_TASK_WAITING)
	{
		OS_Printf("some task wait for this Mailbox\n");
	}
}
void qsmBox_App_send(void *p_arg)
{
	INT8U i;
	INT8U err;
	INT8U *buffer[3];
	buffer[0]="test01\n";
	buffer[1]="test02\n";
	buffer[2]="test03\n";
	p_arg = p_arg;
	pmailbox=OSMboxCreate(NULL);
	while(1)
	{
	    for (i=0;i<=2;)
		{
			if((err=OSMboxPost(pmailbox,buffer[i]))==OS_NO_ERR)
			{
				OS_Printf("qsmBox_App_send,data is: %s\n",buffer[i]);
				i++;
			}
			else if(err==OS_MBOX_FULL)
			{
				OS_Printf("this is sender\nthe Mailbox has data,data is: %s\n",pmailbox->OSEventPtr);
			}
			else
			{
				OS_Printf("other err\n");
			}
	       OSTimeDlyHMSM(0, 0, 0, 25);
	    }
	}

	OSTimeDlyHMSM(0, 0, 5, 0);
	OSMboxDel (pmailbox,OS_DEL_NO_PEND, &err);
	if(err==OS_ERR_TASK_WAITING)
	{
		OS_Printf("some task wait for this Mailbox\n");
	}
}



void qsmBox_App_recv(void *p_arg)
{
	INT8U err;
	INT16U timeout=100;
	INT8U *buffer;
	p_arg = p_arg;

    for (;;)
		{
				buffer=OSMboxPend(pmailbox,timeout,&err);
				if(err==OS_NO_ERR)
				{
					OS_Printf("qsmBox_App_recv data is: %s\n",buffer);
				}
				else if(err==OS_TIMEOUT)
				{
					OS_Printf("timeout\n");
				}
				else if(err==OS_ERR_EVENT_TYPE)
				{
					OS_Printf("this is recver\nerr is OS_ERR_EVENT_TYP\n");
					break;
				}
				else
				{
					break;
				}
		        OSTimeDlyHMSM(0, 0, 0, 10);
    }
}
void mem_App_one(void *p_arg)
{
	INT8U err;
	INT8U *string="test memory";
	p_arg = p_arg;
	ptr=malloc(10*1024);
	mem_p=OSMemCreate (ptr, 10, 1024, &err);
	OSMemNameSet (mem_p, string, &err);
	output("after create:",mem_p);

	OSTimeDlyHMSM(0, 0, 2, 0);
	output("\nafter get twice:",mem_p);

	OSTimeDlyHMSM(0, 0, 2, 0);
	output("\nafter release one:",mem_p);
}

void mem_App_two(void *p_arg)
{

	INT8U err;
	void *ptr[10];
	p_arg = p_arg;

	printf("\nfirst get:\n");
	ptr[0]=OSMemGet (mem_p, &err);
	printf("ptr[0]=%p\n",ptr[0]);

	printf("second get:\n");
	ptr[1]=OSMemGet (mem_p, &err);
	printf("ptr[1]=%p\n",ptr[1]);

	OSTimeDlyHMSM(0, 0, 3, 0);
	OSMemPut (mem_p, ptr[1]);
}

void output(char *info,OS_MEM *p)
{
	printf("%s\n",info);
	printf("OSMemAddr=%p\n",p->OSMemAddr);
	printf("OSMemFreeList=%p\n",p->OSMemFreeList);
	printf("OSMemBlkSize=%d\n",p->OSMemBlkSize);
	printf("OSMemName=%s\n",p->OSMemName);
	printf("OSMemNFree=%d\n",p->OSMemNFree);
	printf("OSMemNBlks=%d\n",p->OSMemNBlks);
}
void sem_App_producer(void *p_arg)
{
	INT16U i;
	INT16U timeout;
	INT8U err;
	timeout=30000;
	storage=malloc(sizeof(struct storage_data));
	sem_produce=OSSemCreate(BUFFER_SIZE);
	sem_custom=OSSemCreate(0);
	sem_init();
	for(i=1;;)
	{
		OSSemPend (sem_produce, timeout, &err);
		if(err==OS_NO_ERR)
		{
			storage->buffer[storage->input]=i;
			storage->input++;
			i++;
		    if (storage->input >= BUFFER_SIZE)
		    {
				storage->input = 0;
		    }
		  sem_info();
			OSSemPost(sem_custom);
		}
		else if(err==OS_TIMEOUT)
		{
			continue;
		}
		else
		{
			printf("other error %d\n",err);
			break;
		}
		OSTimeDlyHMSM(0, 0, 0, 10);
	}
}




void sem_App_customer(void *p_arg)
{

	INT16U i;
	INT16U data;
	INT16U timeout;
	INT8U err;
	timeout=30000;
	for(i=1;;)
	{
		OSSemPend (sem_custom, timeout, &err);
		if(err==OS_NO_ERR)
		{
			data=storage->buffer[storage->output];
			storage->buffer[storage->output]=0;
			printf("consume data %d\n",data);
			storage->output++;
			i++;
			  if(storage->output >= BUFFER_SIZE)
			  {
					storage->output = 0;
			  }
		   sem_info();
		  OSSemPost(sem_produce);

		}
		else if(err==OS_TIMEOUT)
		{
				continue;	
		}
		else
		{
			printf("other error abc\n");
			break;
		}
		OSTimeDlyHMSM(0, 0, 3, 10);
	}
}

void sem_init()
{
	int j;
	storage->input=0;
	storage->output=0;

	for(j=0;j<BUFFER_SIZE;j++)
	{
		storage->buffer[j]=0;
	}
}


void sem_info()
{
	int j;
	for(j=0;j<BUFFER_SIZE;j++)
	{
		printf("buffer[%d]=%u\t",j,storage->buffer[j]);

	}
	printf("storage->input=%u\t",storage->input);
	printf("storage->output=%u\n",storage->output);
}

static void mutex_Task1(void *p_arg)
{
 
 	uint8  err;
  p_arg=p_arg;
#if OS_CRITICAL_METHOD == 3
		OS_CPU_SR  cpu_sr;
#endif
  ResourceMutex= OSMutexCreate(9,&err);  
	while(1)
	{
		OSMutexPend(ResourceMutex,0,&err);
    OS_ENTER_CRITICAL();

		g_counter++;

		OS_EXIT_CRITICAL();  
	  OSMutexPost(ResourceMutex);

		OSTimeDly(OS_TICKS_PER_SEC*2);
		OS_Printf("g_counter:%ld\n",g_counter);
	}
}

static void mutex_Task2(void *p_arg)
{   
	uint8  err;
	p_arg=p_arg;
#if OS_CRITICAL_METHOD == 3
		OS_CPU_SR  cpu_sr;
#endif
	while(1)
	{

		OSMutexPend(ResourceMutex,0,&err);
		OS_ENTER_CRITICAL();
		g_counter++;
		OS_EXIT_CRITICAL(); 
	  OSMutexPost(ResourceMutex);
	  
		OSTimeDly(OS_TICKS_PER_SEC);
		OS_Printf("g_counter:%ld\n",g_counter);
	}
}
#define UCOS_BASIC_TASK_TEST  			0
#define UCOS_MSG_QUEUE_TASK_TEST		0
#define UCOS_MAIL_B0X_TASK_TEST			0
#define UCOS_MEM_TASK_TEST          0
#define UCOS_SEM_TASK_TEST          0
#define UCOS_MUTEX_TASK_TEST        1
int main (void)
{
	uint8 Stk1[TASK_STK_SIZE];
	uint8 Stk2[TASK_STK_SIZE];
	char sTask1[] = "Task 1";
	char sTask2[] = "Task 2";
  OSInit();
#if UCOS_BASIC_TASK_TEST
	OSTaskCreate(App_recv,NULL,(OS_STK *)&AppStk_recv[TASK_STK_SIZE-1],(INT8U)4);
	OSTaskCreate( MyTask, sTask2, (OS_STK *)&Stk2[TASK_STK_SIZE-1], 5 );
#endif	
	
#if UCOS_MSG_QUEUE_TASK_TEST0		
	OSTaskCreate(App_send_one,NULL,(OS_STK *)&AppStk_send_one[TASK_STK_SIZE-1],(INT8U)11);
	OSTaskCreate(App_send_two,NULL,(OS_STK *)&AppStk_send_two[TASK_STK_SIZE-1],(INT8U)12);
	OSTaskCreate(MyTask, sTask1, (OS_STK *)&Stk1[TASK_STK_SIZE-1], 13);
#endif	

#if UCOS_MAIL_B0X_TASK_TEST	
	OSTaskCreate(qsmBox_App_send,NULL,(OS_STK *)&qsmBox_AppStk_send[TASK_STK_SIZE-1],(INT8U)14);
	OSTaskCreate(qsmBox_App_recv,NULL,(OS_STK *)&qsmBox_AppStk_recv[TASK_STK_SIZE-1],(INT8U)35);
#endif

#if UCOS_MEM_TASK_TEST
	OSTaskCreate(mem_App_one,NULL,(OS_STK *)&mem_AppStk_one[TASK_STK_SIZE-1],(INT8U)16);
	OSTaskCreate(mem_App_two,NULL,(OS_STK *)&mem_AppStk_two[TASK_STK_SIZE-1],(INT8U)17);
#endif

#if UCOS_SEM_TASK_TEST
	OSTaskCreate(sem_App_producer,NULL,(OS_STK *)&sem_AppStk_producer[TASK_STK_SIZE-1],(INT8U)18);
	OSTaskCreate(sem_App_customer,NULL,(OS_STK *)&sem_AppStk_customer[TASK_STK_SIZE-1],(INT8U)19);
#endif

#if UCOS_MUTEX_TASK_TEST
	OSTaskCreate(mutex_Task1,NULL,(OS_STK *)&mutex_Stack1[TASK_STK_SIZE-1],(INT8U)20);
	OSTaskCreate(mutex_Task2,NULL,(OS_STK *)&mutex_Stack2[TASK_STK_SIZE-1],(INT8U)21);
#endif

  OSStart();
  return 0;
}


家有工程师
关注
专栏目录
uCOS-II多任务编程设计
02-14
uCOS-II 任务 编程 详细描述了在uCOS-II环境下，任务设计的步骤。全文分为任务函数和数据结构设计，并通过一个实例，说明了设计的具体过程
介绍uCOS-II应用举例
12-17
介绍uCOS-II应用举例 介绍uCOS-II应用举例
ucos 编程
one shot,one kill.
12-17 992
开启辅助访问 jenney |我的 |设置 |消息 |提醒 |退出 积分: 16 |用户组: 新手上路 快捷导航 首页 全部帖汇总 技术帖汇总 非飞思汇总 非技术帖子 阿莫电子邮购   帖子 搜索 热搜:净化器雕刻机阿莫邮购
uCOS超小型实时操作系统源代码剖析
最新发布
weixin_32535825的博客
09-28 1252
本文还有配套的精品资源，点击获取 简介：uCOS，也称为uC/OS，是一款专为微控制器设计的实时操作系统，以小型、高效率和良好的可移植性著称。文章详细解析了uCOS的核心部分，重点讨论了其在蓝牙4.0设备中的应用。uCOS源代码包括CPU初始化、核心功能实现以及API接口定义，支持任务管理、内存管理和时间管理。它还适用于低功耗蓝牙4.0设备，能够支持多任务环境并优化功耗。通...
UCOS应用 | 数据通信
qq_44678204的博客
08-08 268
全局变量 不能实现任务之间的相互关联，时效性较差。 当没有行为同步的要求时，传输数据不大，采用全局变量配合关中断的资源同步时一种经济有效的方法。（并且对共享内容的读写不是非常频繁，否则需要考虑大量的数据保护手段） 内存数据块 一般配合消息队列使用，动态内存管理的办法，管理消息内容数组。 消息邮箱 具有行为同步功能的通信手段，此类数据通信一般要求接收消息的任务总是在等待消息，一有消息就能在下一个消息产生之前处理完毕。如果双方的执行频度相同，也比较适合。同时操作系统对消息已经进行过互斥处理，双方在时序上互不打扰
uCOS学习笔记以及编程接口
张鹏军的技术之旅
11-09 545
实时操作系统 uCOS是一个实时操作系统(RTOS)，在这里我对实时的理解是每个任务的有不同的优先级，当高优先级任务就绪时可以不用等待低优先级的任务执行完成，就可以立马调度执行，响应时间基本是固定的. 任务管理 主要包括任务的创建，删除，挂起和恢复 时间管理 主要是实现任务的延时，延时的单位可以节拍，毫秒，秒，分，小时。一般调用延时函数后，当前的任务会从运行状态变为睡眠状态.时间到后会把该任务变为就绪态. 任务间通讯及同步 uCOS使用信号量，邮箱，队列实现任务间的同步。邮箱相对于信号量，可以传递一个消息指
uCOS-II源码中文译注.rar_ucos_ucos2_嵌入式_编程_翻译
09-21
10. **实践应用**：除了理论知识，译注还可能包含一些实际案例，展示如何在具体项目中应用uCOS-II，以提高读者的实践能力。 通过《uCOS-II源码中文译注》的学习，读者不仅能掌握 ucOS-II 的基本操作，还能深入了解...
实验3：UCOSIII-多任务创建_多任务编程_STM32F103_
10-01
本实验“实验3：UCOSIII-多任务创建”专注于如何在UCOSIII（μC/OS-III）这个实时操作系统上实现多任务编程，这对于提升系统的并发性和效率至关重要。UCOSIII是Micrium公司推出的一款高效、可移植的实时内核，特别...
UCOSII.rar_ucos点灯_应用ucos-ii实验
09-20
UCOS-II，全称μC/OS-II，是一款实时操作系统（RTOS），专为微控制器设计。这个基础点灯实验是学习和理解UCOS-II操作系统的一个典型入门实践，它旨在帮助初学者掌握如何在UCOS-II环境下进行任务调度、中断处理以及...
STM32F103VET6单片机UCOS实验例程源代码zigbee通信例程 ucos ucgui.rar
11-07
在STM32F103VET6上运行UCOS，可以实现复杂的应用程序结构，比如同时处理多个并发任务，提高系统的响应速度和实时性。 Zigbee是一种基于IEEE 802.15.4标准的低功耗、短距离无线通信技术，常用于物联网设备之间的通信...
uCOS-II.rar_ucos 应用_ucosⅡ代码举例
09-23
标题"uCOS-II.rar_ucos 应用_ucosⅡ代码举例"揭示了这个压缩包的内容主要是关于uCOS-II操作系统在ARM7处理器上的移植和应用实例。uCOS-II是一款嵌入式实时操作系统（RTOS），它提供了一种在微控制器上实现多任务调度...
uCOS-II操作系统的驱动开发应用开发实例
02-24
uCOS-II操作系统的驱动开发应用开发实例
uCOS-II原理及应用
11-19
嵌入式实时系统中最常用也是入门级的操作系统。是我最开始接触系统的入门途径，这本书我觉得写的很不错。
基于ucos-ii的程序设计实例
11-19
基于ucos-ii的程序设计实例
ucosii应用例子
06-01
ucosii的一些应用例子，很不错的学习资料
UCOS应用 | 任务的设计
qq_44678204的博客
06-26 2839
任务函数的结构 单次执行的任务 含义：此类任务只执行一次，执行结束后即自行删除。通常用于“启动任务”。单次执行的任务采用“创建任务函数”来启动。 用处：每当需要执行该任务时，就将该任务创建一次，由键盘操作启动你的任务通常采用这种结构。 注意：采用此种方式来启动一个任务，除了实时性差意外，还可能有一些后遗症： 占用共享资源未释放 积压信号量或者消息 可能留下未删除干净的废弃变量 适合采用“创建任务”的方式来启动的任务，通常时孤立任务，他们不和其他任务进行通信，只使用共享资源来获取信息和输出信息。 周期性执
ucOS应用程序(任务)编写
weixin_34194087的博客
03-25 148
编写用户任务： 转载于:https://www.cnblogs.com/markmin214/archive/2013/03/25/2987979.html
ucos-iii学习之单任务应用程序
思想的苇草
09-10 312
其中BSP_InitDisAll(),STM32并没有定义。然后是任务函数内容其中（2）（4）（5）（7）是需要自己编写的。
ucos应用例子收集
abc
02-20 3337
[stm32][ucos] 1、基于ucos操作系统的LED闪烁、串口通信简单例程 http://www.cnblogs.com/zjutlitao/p/3917638.html 本例程操作系统采用ucos2.86a版本， 建立了5个任务 任务名 优先级 APP_TASK_START_PRIO ...
UCOS-II操作系统编程关键函数解析
"UCOS-II编程要点讲解.pdf" UCOS-II是一种实时嵌入式...理解并熟练运用这些知识点，对于编写高效且稳定的UCOS-II应用程序至关重要。在实际开发中，开发者还需要关注错误处理、调试技巧以及特定硬件平台的适配等问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

家有工程师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值