STM32F103C8T6移植uCOS(标准库)

STM32F103C8T6移植uCOS(标准库)


文章目录


任务简介
将ucos其移植到stm32F103上,构建3个任务(task):其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制;另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境!”。
实验工具:
(1)软件

(2)硬件

  • STM32F103C8T6的最小核心板
  • LED小灯
  • USB转TTL模块

一.准备工作

①.建好一个标准库项目

这里不用很麻烦,项目能跑就行,后面要以这个项目为基础移植。

②.下载ucOSⅢ源码

  • ucosⅢ源码:百度网盘链接:提取码:1234(STM32-F107对应版本)
    也可以去官网下载:链接,这里就不介绍官网下载的方法了,可以自行搜索。
  • 下载完后文件结构是这样的
    在这里插入图片描述

③.建好对应文件夹

  • 在我们第一步建立的标准库项目中的USER文件夹下新建如下几个文件夹
    在这里插入图片描述

二.开始移植

①.复制文件

1.转移APP文件夹文件
  • 把我们下载好的源码中对应地址下的这几个文件复制到我们准备好的APP文件夹下。
    在这里插入图片描述
    在这里插入图片描述
2.转移BSP文件夹文件
  • 把我们下载好的源码中对应地址下的这几个文件复制到我们准备好的BSP文件夹下。
    在这里插入图片描述
    在这里插入图片描述
3.转移uc-CPU文件夹

在这里插入图片描述

4.转移uc-LIB文件夹

在这里插入图片描述

5.转移uCOS-Ⅲ文件夹

在这里插入图片描述

②.工程中添加文件分组

1.在keil里也创建五个文件夹来对应我们USER文件夹里创建的文件

在这里插入图片描述

2.向“APP”分组添加“User/APP”文件夹下的所有文件

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
添加结果:
在这里插入图片描述

3.向“ BSP”分组添加“ \User\BSP”文件夹下的所有文件

在这里插入图片描述

4.向“ μC/CPU”分组添加“User\uC-CPU”文件夹下的所有文件和 “ \User\uC-CPU\ARM-Cortex-M3\RealView”文件夹下的所有文件

在这里插入图片描述

5.向“μC/LIB”分组添加“User\uC-LIB”文件夹下的所有文件和 “User\uC-LIB\Ports\ARM-Cortex-M3\1RealView”文件夹下的所有文件

在这里插入图片描述

6.向“ μC/OS-III Source”分组添加 “ \User\uCOS-III\Source”文件夹下的所有文件

在这里插入图片描述

7.向“μC/OS-III Port”分组添加 “User\uCOS-III\Ports\ARM-Cortex-M3\Generic\RealView”文件夹下的所有文件

在这里插入图片描述

③.添加头文路径到工程

源码已经添加到开发环境的组文件夹下面,编译的时候需要为这些源文件指定头文件的路径,不然编译会报错,此时我们先将头文件添加到我们的 工程中
在这里插入图片描述

④.具体的工程文件修改

添加完头文件路径后,我们可以编译一下整个工程,但肯定会有错误的, μC/OS-III 的移植尚未完毕,接下来需要对工程文件进行修改。 首先修改工程的启动文件“ startup_stm32f10x_hd.s”。 其中将PendSV_HandlerSysTick_Handler 分别改为OS_CPU_PendSVHandlerOS_CPU_SysTickHandler,共两处,因为μC/OS官方已经给我们处理好对应的中断函数,就无需我们自己处理与系统相关的中断了, 同时我们还需要将stm32f10x_it.c文件中的PendSV_HandlerSysTick_Handler函数注释掉(不注释也不会有问题)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

⑤.修改源码中的bsp.c与bsp.h文件

首先要知道,BSP (Board Support Package)是板级支持包,不同型号的板子对应的bsp文件是不一样的,但是里面的具体内容我们一般不去管,只有一个 BSP_Init()的初始化函数可以在里面实现一些例如电灯或者串口发送等的程序用来测试或者函数调用。这里给出bsp.c修改后的代码

  • bsp.c


#define  BSP_MODULE
#include <bsp.h>



CPU_INT32U  BSP_CPU_ClkFreq_MHz;



#define  DWT_CR      *(CPU_REG32 *)0xE0001000
#define  DWT_CYCCNT  *(CPU_REG32 *)0xE0001004
#define  DEM_CR      *(CPU_REG32 *)0xE000EDFC
#define  DBGMCU_CR   *(CPU_REG32 *)0xE0042004




#define  DBGMCU_CR_TRACE_IOEN_MASK       0x10
#define  DBGMCU_CR_TRACE_MODE_ASYNC      0x00
#define  DBGMCU_CR_TRACE_MODE_SYNC_01    0x40
#define  DBGMCU_CR_TRACE_MODE_SYNC_02    0x80
#define  DBGMCU_CR_TRACE_MODE_SYNC_04    0xC0
#define  DBGMCU_CR_TRACE_MODE_MASK       0xC0

#define  DEM_CR_TRCENA                   (1 << 24)

#define  DWT_CR_CYCCNTENA                (1 <<  0)




void  BSP_Init (void)
{
	//NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4);
	
	//LED_Init (); 
	
}



CPU_INT32U  BSP_CPU_ClkFreq (void)
{
    RCC_ClocksTypeDef  rcc_clocks;


    RCC_GetClocksFreq(&rcc_clocks);

    return ((CPU_INT32U)rcc_clocks.HCLK_Frequency);
}




#if ((APP_CFG_PROBE_OS_PLUGIN_EN == DEF_ENABLED) && \
     (OS_PROBE_HOOKS_EN          == 1))
void  OSProbe_TmrInit (void)
{
}
#endif




#if ((APP_CFG_PROBE_OS_PLUGIN_EN == DEF_ENABLED) && \
     (OS_PROBE_HOOKS_EN          == 1))
CPU_INT32U  OSProbe_TmrRd (void)
{
    return ((CPU_INT32U)DWT_CYCCNT);
}
#endif




#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
void  CPU_TS_TmrInit (void)
{
    CPU_INT32U  cpu_clk_freq_hz;


    DEM_CR         |= (CPU_INT32U)DEM_CR_TRCENA;                /* Enable Cortex-M3's DWT CYCCNT reg.                   */
    DWT_CYCCNT      = (CPU_INT32U)0u;
    DWT_CR         |= (CPU_INT32U)DWT_CR_CYCCNTENA;

    cpu_clk_freq_hz = BSP_CPU_ClkFreq();
    CPU_TS_TmrFreqSet(cpu_clk_freq_hz);
}
#endif



#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
CPU_TS_TMR  CPU_TS_TmrRd (void)
{
    return ((CPU_TS_TMR)DWT_CYCCNT);
}
#endif

  • bsp.h
#ifndef  BSP_PRESENT
#define  BSP_PRESENT




#ifdef   BSP_MODULE
#define  BSP_EXT
#else
#define  BSP_EXT  extern
#endif




#include  <stdarg.h>
#include  <stdio.h>

#include  <cpu.h>
#include  <cpu_core.h>

#include  <lib_ascii.h>
#include  <lib_def.h>
#include  <lib_mem.h>
#include  <lib_str.h>

#include "stm32f10x.h"         

#include  <app_cfg.h>

void         BSP_Init                    (void);

CPU_INT32U   BSP_CPU_ClkFreq             (void);



#endif                                                          /* End of module include.                               */

⑥.修改os_cfg.h(在APP目录下)

#ifndef OS_CFG_H
#define OS_CFG_H


/* --- 其他配置 --- */
#define OS_CFG_APP_HOOKS_EN             1u/* 是否使用钩子函数     */
#define OS_CFG_ARG_CHK_EN               1u/* 是否使用参数检查     */
#define OS_CFG_CALLED_FROM_ISR_CHK_EN   1u/* 是否使用中断调用检查 */
#define OS_CFG_DBG_EN                   1u/* 是否使用debug        */
#define OS_CFG_ISR_POST_DEFERRED_EN     1u/* 是否使用中断延迟post操作*/
#define OS_CFG_OBJ_TYPE_CHK_EN          1u/* 是否使用对象类型检查   */
#define OS_CFG_TS_EN                    1u/*是否使用时间戳     */

#define OS_CFG_PEND_MULTI_EN            1u/*是否使用支持多个任务pend操作*/

#define OS_CFG_PRIO_MAX                32u/*定义任务的最大优先级 */

#define OS_CFG_SCHED_LOCK_TIME_MEAS_EN  1u/*是否使用支持测量调度器锁定时间 */
#define OS_CFG_SCHED_ROUND_ROBIN_EN     1u/* 是否支持循环调度         */
#define OS_CFG_STK_SIZE_MIN            64u/* 最小的任务栈大小        */


/* ---------- 事件标志位---------- */
#define OS_CFG_FLAG_EN                  1u/*是否使用事件标志位    */
#define OS_CFG_FLAG_DEL_EN                  1u/*是否包含OSFlagDel()的代码 */
#define OS_CFG_FLAG_MODE_CLR_EN         1u/*是否包含清除事件标志位的代码*/
#define OS_CFG_FLAG_PEND_ABORT_EN       1u/*是否包含OSFlagPendAbort()的代码*/


/* --------- 内存管理 --- */
#define OS_CFG_MEM_EN                   1u/* 是否使用内存管理         */


/* -------- 互斥量 ----- */
#define OS_CFG_MUTEX_EN                 1u/*是否使用互斥量 */
#define OS_CFG_MUTEX_DEL_EN             1u/*是否包含OSMutexDel()的代码*/
#define OS_CFG_MUTEX_PEND_ABORT_EN      1u/*是否包含OSMutexPendAbort()的代码*/


/* ------- 消息队列--------------- */
#define OS_CFG_Q_EN                     1u/* 是否使用消息队列       */
#define OS_CFG_Q_DEL_EN                 1u/* 是否包含OSQDel()的代码 */
#define OS_CFG_Q_FLUSH_EN               1u/* 是否包含OSQFlush()的代码 */
#define OS_CFG_Q_PEND_ABORT_EN          1u/* 是否包含OSQPendAbort()的代码*/


/* -------------- 信号量 --------- */
#define OS_CFG_SEM_EN                   1u/*是否使用信号量  */
#define OS_CFG_SEM_DEL_EN               1u/*是否包含OSSemDel()的代码*/
#define OS_CFG_SEM_PEND_ABORT_EN        1u/*是否包含OSSemPendAbort()的代码*/
#define OS_CFG_SEM_SET_EN               1u/*是否包含OSSemSet()的代码  */


/* ----------- 任务管理 -------------- */
#define OS_CFG_STAT_TASK_EN             1u/* 是否使用任务统计功能 */
#define OS_CFG_STAT_TASK_STK_CHK_EN     1u/* 从统计任务中检查任务栈 */

#define OS_CFG_TASK_CHANGE_PRIO_EN      1u/* 是否包含OSTaskChangePrio()的代码*/
#define OS_CFG_TASK_DEL_EN              1u/* 是否包含OSTaskDel()的代码*/
#define OS_CFG_TASK_Q_EN                1u/*是否包含OSTaskQXXXX()的代码*/
#define OS_CFG_TASK_Q_PEND_ABORT_EN     1u/* 是否包含OSTaskQPendAbort()的代码 */
#define OS_CFG_TASK_PROFILE_EN          1u/* 是否在OS_TCB中包含变量以进行性能分析 */
#define OS_CFG_TASK_REG_TBL_SIZE     1u/*任务特定寄存器的数量  */
#define OS_CFG_TASK_SEM_PEND_ABORT_EN   1u/* 是否包含OSTaskSemPendAbort()的代码 */
#define OS_CFG_TASK_SUSPEND_EN       1u/*是否包含OSTaskSuspend()和
                        OSTaskResume()的代码*/

/* ------- 时间管理 ------- */
#define OS_CFG_TIME_DLY_HMSM_EN      1u/*是否包含OSTimeDlyHMSM()的代码*/
#define OS_CFG_TIME_DLY_RESUME_EN   1u/*是否包含OSTimeDlyResume()的代码*/


/* ---------- 定时器管理 ------- */
#define OS_CFG_TMR_EN                   1u/* 是否使用定时器        */
#define OS_CFG_TMR_DEL_EN               1u/* 是否支持OSTmrDel()  */

#endif

⑦.修改cpu_cfg.h(在APP目录下)


#ifndef  CPU_CFG_MODULE_PRESENT
#define  CPU_CFG_MODULE_PRESENT




                                                                /* Configure CPU host name feature (see Note #1) :      */
#define  CPU_CFG_NAME_EN                        DEF_ENABLED
                                                                /*   DEF_DISABLED  CPU host name DISABLED               */
                                                                /*   DEF_ENABLED   CPU host name ENABLED                */

                                                                /* Configure CPU host name ASCII string size ...        */
#define  CPU_CFG_NAME_SIZE                                16u   /* ... (see Note #2).                                   

                                                                /* Configure CPU timestamp features (see Note #1) :     */
#define  CPU_CFG_TS_32_EN                       DEF_ENABLED          // Modified by fire (原是 DEF_DISABLED)
#define  CPU_CFG_TS_64_EN                       DEF_DISABLED
                                                                /*   DEF_DISABLED  CPU timestamps DISABLED              */
                                                                /*   DEF_ENABLED   CPU timestamps ENABLED               */

                                                                /* Configure CPU timestamp timer word size ...          */
                                                                /* ... (see Note #2) :                                  */
#define  CPU_CFG_TS_TMR_SIZE                    CPU_WORD_SIZE_32



#if 1          // Modified by fire (原是 0)                    /* Configure CPU interrupts disabled time ...           */
#define  CPU_CFG_INT_DIS_MEAS_EN                                /* ... measurements feature (see Note #1a).             */
#endif

                                                                /* Configure number of interrupts disabled overhead ... */
#define  CPU_CFG_INT_DIS_MEAS_OVRHD_NBR                    1u   /* ... time measurements (see Note #1b).                */



#if 1                                                           /* Configure CPU count leading zeros bits ...           */
#define  CPU_CFG_LEAD_ZEROS_ASM_PRESENT                         /* ... assembly-version (see Note #1).                  */
#endif


/*$PAGE*/


#endif                                                          /* End of CPU cfg module include.                       */


⑧.修改os_cfg_app.h(在APP目录下)

#ifndef OS_CFG_APP_H
#define OS_CFG_APP_H


/* --------------------- MISCELLANEOUS ------------------ */
#define  OS_CFG_MSG_POOL_SIZE            100u/* 支持的最大消息数量 */
#define  OS_CFG_ISR_STK_SIZE             128u/*ISR栈的大小 */
#define  OS_CFG_TASK_STK_LIMIT_PCT_EMPTY  10u/*检查栈的剩余大小(百分百形式,
                        此处是10%)*/


/* ---------------------- 空闲任务 --------------------- */
#define  OS_CFG_IDLE_TASK_STK_SIZE       128u/* 空闲任务栈大小    */


/* ------------------ 中断处理任务------------------ */
#define  OS_CFG_INT_Q_SIZE                10u/*中断处理任务队列大小  */
#define  OS_CFG_INT_Q_TASK_STK_SIZE      128u/* 中断处理任务的栈大小*/


/* ------------------- 统计任务------------------- */
#define  OS_CFG_STAT_TASK_PRIO            11u/* 统计任务的优先级  */
#define  OS_CFG_STAT_TASK_RATE_HZ         10u/* 统计任务的指向频率(10HZ)*/
#define  OS_CFG_STAT_TASK_STK_SIZE       128u/*统计任务的栈大小*/


/* ------------------------ 时钟节拍任务 ----------------------- */
#define  OS_CFG_TICK_RATE_HZ       1000u/*系统的时钟节拍(一般为10 到 1000 Hz) */
#define  OS_CFG_TICK_TASK_PRIO            1u/*时钟节拍任务的优先级    */
#define  OS_CFG_TICK_TASK_STK_SIZE       128u/* 时钟节拍任务的栈大小*/
#define  OS_CFG_TICK_WHEEL_SIZE           17u/* 时钟节拍任务的列表大小 */


/* ----------------------- 定时器任务 ----------------------- */
#define  OS_CFG_TMR_TASK_PRIO          11u/*定时器任务的优先级  */
#define  OS_CFG_TMR_TASK_RATE_HZ        10u/* 定时器频率(10 Hz是典型值) */
#define  OS_CFG_TMR_TASK_STK_SIZE      128u/* 定时器任务的栈大小    */
#define  OS_CFG_TMR_WHEEL_SIZE          17u/*定时器任务的列表大小  */

#endif

⑧.修改app.c(在APP目录下)

  • app.c里是用来创建以及执行任务,以及实现任务的具体内容。
  • 把原来app.c里的文件全部删除 加一个主函数,并且删掉原来创建项目时的主函数,否则会因为两个主函数报错
#include <includes.h>  
int main(void)
{
    /*暂时没有在main里面创建任务应用任务 */
}

三.任务实现

1.添加初始化文件

由于我们的任务是用三个任务实行不同频率的点灯和串口发送,所以我们需要添加两个文件来分别初始化LEDUSART串口,最好在bsp文件目录下加,作为板载文件。这里初始化PA0,PA1用来点灯,串口PA9和PA10。
在这里插入图片描述

  • 这里Serial串口初始化的文件其实最好也建在BSP里面,作为板载文件。

  • LED.c

#include "stm32f10x.h"                  // Device header

void LED1_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_SetBits(GPIOA, GPIO_Pin_1 | GPIO_Pin_2);
}

void LED1_ON(void)
{
	GPIO_ResetBits(GPIOA, GPIO_Pin_1);
}

void LED1_OFF(void)
{
	GPIO_SetBits(GPIOA, GPIO_Pin_1);
}

void LED1_Turn(void)
{
	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_1) == 0)
	{
		GPIO_SetBits(GPIOA, GPIO_Pin_1);
	}
	else
	{
		GPIO_ResetBits(GPIOA, GPIO_Pin_1);
	}
}

void LED2_ON(void)
{
	GPIO_ResetBits(GPIOA, GPIO_Pin_2);
}

void LED2_OFF(void)
{
	GPIO_SetBits(GPIOA, GPIO_Pin_2);
}

void LED2_Turn(void)
{
	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_2) == 0)
	{
		GPIO_SetBits(GPIOA, GPIO_Pin_2);
	}
	else
	{
		GPIO_ResetBits(GPIOA, GPIO_Pin_2);
	}
}

  • LED.h
#ifndef __LED_H
#define __LED_H

void LED_Init(void);
void LED1_ON(void);
void LED1_OFF(void);
void LED1_Turn(void);
void LED2_ON(void);
void LED2_OFF(void);
void LED2_Turn(void);

#endif

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

void Serial_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Tx;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_Init(USART1, &USART_InitStructure);
	
	USART_Cmd(USART1, ENABLE);
}

void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Array[i]);
	}
}

void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --)
	{
		Result *= X;
	}
	return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

void Serial_Printf(char *format, ...)
{
	char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	Serial_SendString(String);
}

  • Serial.h
#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

//void Serial_Init(void);
//void Serial_SendByte(uint8_t Byte);
//void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
//void Serial_SendNumber(uint32_t Number, uint8_t Length);
//void Serial_Printf(char *format, ...);

#endif

  • 并且要在bsp.h里把LED.h和Serial.h的头文件都加进去
#include "LED.h"
#include "Serial.h"

2.任务模块介绍

①.定义任务栈

定义一个栈, 目前我们使用的是静态内存,所以任务栈是一个独立的全局变量。任务的栈占用的是MCU内部的RAM,当任务越多的时候, 需要使用的栈空间就越大,即需要使用的RAM空间就越多。

#define  APP_TASK_START_STK_SIZE                    128 

static  CPU_STK  AppTaskStartStk[APP_TASK_START_STK_SIZE];
②.定义任务控制块

定义好任务函数和任务栈之后,我们还需要为任务定义一个任务控制块,通常我们称这个任务控制块为任务的身份证。在C代码上,任务控制块就是一个结构体, 里面有非常多的成员,这些成员共同描述了任务的全部信息

static OS_TCB AppTaskStartTCB;
③.定义任务主体函数

任务实际上就是一个无限循环且不带返回值的C函数。这里,我们创建一个这样的任务作为例子, 让开发板上面的LED灯以500ms的频率闪烁,

static voidLED_Task (void* parameter)
{
    while (1)                                  
    {
        LED1_ON;
        OSTimeDly (500,OS_OPT_TIME_DLY,&err);/* 延时500个tick */

        LED1_OFF;
        OSTimeDly (500,OS_OPT_TIME_DLY,&err);/* 延时500个tick */

    }
}
④.创建任务

一个任务的三要素是任务主体函数任务栈任务控制块,那么怎么样把这三个要素联合在一起?μC/OS里面有一个叫任务创建函数OSTaskCreate(), 它就是干这个活的。它将任务主体函数,任务栈和任务控制块这三者联系在一起,让任务在创建之后可以随时被系统启动与调度

OSTaskCreate((OS_TCB     *)&AppTaskStartTCB,                       
            (CPU_CHAR   *)"App Task Start",               
            (OS_TASK_PTR ) AppTaskStart,                  
            (void       *) 0,                                    
            (OS_PRIO     ) APP_TASK_START_PRIO,          
            (CPU_STK    *)&AppTaskStartStk[0],                 
            (CPU_STK_SIZE) APP_TASK_START_STK_SIZE / 10,   
            (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,        
            (OS_MSG_QTY  ) 5u,                            
            (OS_TICK     ) 0u,                          
            (void       *) 0,                                 
            (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), 
            (OS_ERR     *)&err);                                   
⑤.启动任务
/* 启动任务,开启调度 */
OSStart(&err);

3.任务具体实现(APP.c文件)

  • 创建多任务只需要按照创建单任务的套路依葫芦画瓢即可,接下来我们创建四个任务,分别是起始任务(用来开启其他任务)LED1 任务LED2 任务USART3任务。 任务1让一个LED灯闪烁,任务2让另外一个LED闪烁,两个LED闪烁的频率不一样,任务3让串口发送字符串。三个任务的优先级不一样。
  • 主函数运行时创建起始任务起始任务运行时进行创建两个LED 灯的任务一个串口发送任务和删除自身,之后就运行三个任务。两个 LED 灯的任务优先级不一样, LED1任务为 LED1 每隔 1秒切换一次亮灭状态, LED2 任务为 LED2 每隔 3 秒切换一次亮灭状态, USART3 任务以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境!”.
①首先在“ app_cfg.h”里,增加定义三个任务的优先级和栈空间大小

在这里插入图片描述

②.修改app.c


#include <includes.h>



//任务控制块
static  OS_TCB   AppTaskStartTCB;
static  OS_TCB   AppTaskLed1TCB;
static  OS_TCB   AppTaskLed2TCB;
static  OS_TCB   AppTaskUSART3TCB;



//定义任务栈
static  CPU_STK  AppTaskStartStk[APP_TASK_START_STK_SIZE];
static  CPU_STK  AppTaskLed1Stk [ APP_TASK_LED1_STK_SIZE ];
static  CPU_STK  AppTaskLed2Stk [ APP_TASK_LED2_STK_SIZE ];
static  CPU_STK  AppTaskUSART3Stk [ APP_TASK_USART3_STK_SIZE ];


static  void  AppTaskStart  (void *p_arg);
static  void  AppTaskLed1  ( void * p_arg );
static  void  AppTaskLed2  ( void * p_arg );
static  void  AppTaskUSART3  ( void * p_arg );


int  main (void)
{
    OS_ERR  err;


    OSInit(&err);                                               /* Init uC/OS-III.                                      */

    OSTaskCreate((OS_TCB     *)&AppTaskStartTCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"App Task Start",
                 (OS_TASK_PTR ) AppTaskStart,
                 (void       *) 0,
                 (OS_PRIO     ) APP_TASK_START_PRIO,
                 (CPU_STK    *)&AppTaskStartStk[0],
                 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE / 10,
                 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
                 (OS_MSG_QTY  ) 5u,
                 (OS_TICK     ) 0u,
                 (void       *) 0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)&err);

    OSStart(&err);                                              /* Start multitasking (i.e. give control to uC/OS-III). */
		
		
}




//定义任务函数

static  void  AppTaskStart (void *p_arg)
{
    CPU_INT32U  cpu_clk_freq;
    CPU_INT32U  cnts;
    OS_ERR      err;

  LED1_Init();
   (void)p_arg;

    //BSP_Init();                                                 /* Initialize BSP functions                             */
    CPU_Init();

    cpu_clk_freq = BSP_CPU_ClkFreq();                           /* Determine SysTick reference freq.                    */
    cnts = cpu_clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz;        /* Determine nbr SysTick increments                     */
    OS_CPU_SysTickInit(cnts);                                   /* Init uC/OS periodic time src (SysTick).              */

    Mem_Init();                                                 /* Initialize Memory Management Module                  */

#if OS_CFG_STAT_TASK_EN > 0u
    OSStatTaskCPUUsageInit(&err);                               /* Compute CPU capacity with no task running            */
#endif

    CPU_IntDisMeasMaxCurReset();
	
	//任务1
	 OSTaskCreate((OS_TCB     *)&AppTaskLed1TCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"App Task Led1",
                 (OS_TASK_PTR ) AppTaskLed1,
                 (void       *) 0,
                 (OS_PRIO     ) APP_TASK_LED1_PRIO,
                 (CPU_STK    *)&AppTaskLed1Stk[0],
                 (CPU_STK_SIZE) APP_TASK_LED1_STK_SIZE / 10,
                 (CPU_STK_SIZE) APP_TASK_LED1_STK_SIZE,
                 (OS_MSG_QTY  ) 5u,
                 (OS_TICK     ) 0u,
                 (void       *) 0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)&err);
	
	
	//任务2
	OSTaskCreate((OS_TCB     *)&AppTaskLed2TCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"App Task Led2",
                 (OS_TASK_PTR ) AppTaskLed2,
                 (void       *) 0,
                 (OS_PRIO     ) APP_TASK_LED2_PRIO,
                 (CPU_STK    *)&AppTaskLed2Stk[0],
                 (CPU_STK_SIZE) APP_TASK_LED2_STK_SIZE / 10,
                 (CPU_STK_SIZE) APP_TASK_LED2_STK_SIZE,
                 (OS_MSG_QTY  ) 5u,
                 (OS_TICK     ) 0u,
                 (void       *) 0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)&err);
	
	//任务3
				 //任务2
	OSTaskCreate((OS_TCB     *)&AppTaskUSART3TCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"App Task USART3",
                 (OS_TASK_PTR ) AppTaskUSART3,
                 (void       *) 0,
                 (OS_PRIO     ) APP_TASK_USART3_PRIO,
                 (CPU_STK    *)&AppTaskUSART3Stk[0],
                 (CPU_STK_SIZE) APP_TASK_USART3_STK_SIZE / 10,
                 (CPU_STK_SIZE) APP_TASK_USART3_STK_SIZE,
                 (OS_MSG_QTY  ) 5u,
                 (OS_TICK     ) 0u,
                 (void       *) 0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)&err);
	
				 //创建三个任务成功,删除起始任务
	OSTaskDel ( & AppTaskStartTCB, & err );	
		
}


//任务1具体实现
static  void  AppTaskLed1 ( void * p_arg )
{
    OS_ERR      err;

    (void)p_arg;

    while (DEF_TRUE) {                                          /* Task body, always written as an infinite loop.       */
			LED1_ON();
			OSTimeDly ( 3, OS_OPT_TIME_DLY, & err );
		    LED1_OFF();
		    OSTimeDly ( 3000, OS_OPT_TIME_DLY, & err );
    }
}

//任务2具体实现
static  void  AppTaskLed2 ( void * p_arg )
{
    OS_ERR      err;


    (void)p_arg;
	
	 //LED1_Init();

    while (DEF_TRUE) {                                          /* Task body, always written as an infinite loop.       */
			LED2_ON();
			OSTimeDly ( 1, OS_OPT_TIME_DLY, & err );
		    LED2_OFF();
		    OSTimeDly ( 1000, OS_OPT_TIME_DLY, & err );
    }


}

//任务3具体实现
static  void  AppTaskUSART3 ( void * p_arg )
{
    OS_ERR      err;
    (void)p_arg;
	
	 Serial_Init();

    while (DEF_TRUE) {                                          /* Task body, always written as an infinite loop.       */
			Serial_SendString("hello uc/OS! 欢迎来到RTOS多任务环境!\r\n");
		OSTimeDly ( 2000, OS_OPT_TIME_DLY, & err );
    }


}



四.实验结果

请添加图片描述

请添加图片描述

  • 6
    点赞
  • 39
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
您好!感谢您的提问。要在STM32F103C8T6上移植uC/OS-II操作系统,您可以按照以下步骤进行操作: 1. 准备工作: - 下载uC/OS-II源代码,并将其加入您的工程中。您可以从Micrium官方网站获取源代码。 - 确保您已经熟悉STM32F103C8T6的硬件配置,并且已经完成了基本的初始化工作。 2. 配置uC/OS-II: - 打开uC-CPU目录下的"cpu_cfg.h"文件,根据您的硬件平台配置相关选项,如时钟频率、堆栈大小等。 - 打开OS_CFG目录下的"os_cfg.h"文件,配置uC/OS-II的一些参数,如任务数量、时钟节拍等。 3. 硬件驱动支持: - 根据您的需求,编写或添加适当的设备驱动程序。 - 确保uC/OS-II能够与硬件平台协同工作,例如定时器、中断等。 4. 创建任务: - 在main函数中使用OSTaskCreate函数创建您的任务。您可以根据自己的需求创建多个任务。 - 每个任务都应该有一个入口函数,您可以在这里编写任务的逻辑。 5. 启动uC/OS-II: - 在main函数中调用OSStart函数启动uC/OS-II内核。这会启动任务调度器并开始执行任务。 这些是移植uC/OS-II到STM32F103C8T6的基本步骤。请注意,移植过程可能会因为您的具体需求和硬件平台的差异而有所不同。为了成功移植,您可能需要进一步了解uC/OS-II的使用文档和STM32F103C8T6的技术参考手册。 希望这些信息对您有所帮助!如有任何疑问,请随时提问。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值