第九周 嵌入式RTOS编程

一、任务目的

​1. 使用TIM3和TIM4，分别输出一个PWM波形，PWM的占空比随时间变化，去驱动你外接的一个LED以及最小开发板上已焊接的LED（固定接在 PC13 GPIO端口），实现2个 LED呼吸灯的效果。

2. 学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。记录详细的移植过程。

二、任务一

1.PWM定义

PWM是一种对模拟信号电平进行数字编码的方法。通过高分辨率计数器的使用，方波的占空比被调制用来对一个具体模拟信号的电平进行编码。PWM信号仍然是数字的，因为在给定的任何时刻，满幅值的直流供电要么完全有（ON），要么完全无（OFF）。电压或电流源是以一种通（ON）或断（OFF）的重复脉冲序列被加到模拟负载上去的。通的时候即是直流供电被加到负载上的时候，断的时候即是供电被断开的时候。只要带宽足够，任何模拟值都可以使用PWM进行编码。

脉宽调制（PWM，Pulse Width Modulation）是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术，广泛应用在从测量、通信到功率控制与变换的许多领域中。

2.PWM参数

pwm的频率：是指1秒钟内信号从高电平到低电平再回到高电平的次数(一个周期)；也就是说一秒钟PWM有多少个周期

单位： Hz

表示方式： 50Hz 100Hz

pwm的周期：T=1/f（周期=1/频率），例如50Hz = 20ms 一个周期

如果频率为50Hz ，也就是说一个周期是20ms 那么一秒钟就有 50次PWM周期

占空比：是一个脉冲周期内，高电平的时间与整个周期时间的比例

单位： % (0%-100%)

表示方式：20%

脉宽时间占总周期时间的比例，就是占空比

3.基本原理

PWM就是对逆变电路开关器件的通断进行控制，使输出端得到一系列幅值相等的脉冲，用这些脉冲来代替正弦波或所需要的波形。

也可以这样理解，PWM是一种对模拟信号电平进行数字编码的方法。通过高分辨率计数器的使用，方波的占空比被调制用来对一个具体模拟信号的电平进行编码。PWM信号仍然是数字的，因为在给定的任何时刻，满幅值的直流供电要么完全有(ON)，要么完全无(OFF)。电压或电流源是以一种通(ON)或断(OFF)的重复脉冲序列被加到模拟负载上去的。只要带宽足够，任何模拟值都可以使用 PWM 进行编码。

PWM就是在合适的信号频率下，通过一个周期里改变占空比的方式来改变输出的有效电压；PWM频率越大，相应越快。

在PWM输出模式下，除了CNT（计数器当前值）、ARR（自动重装载值）之外，还多了一个值CCRx（捕获/比较寄存器值）；

当CNT小于CCRx时，TIMx_CHx通道输出低电平；

当CNT等于或大于CCRx时，TIMx_CHx通道输出高电平；

这个时候就可以对其下一个准确的定义了：所谓脉冲宽度调制模式（PWM模式），就是可以产生一个由TIMx_ARR寄存器确定频率，由TIMx_CCRx寄存器确定占空比的信号。它是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术

4.PWM输出模式的区别

PWM模式1：在向上计数时，一旦TIMx_CNT\u003CTIMx_CCR1时通道1为有效电平，否则为无效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为无效电平(OC1REF=0)，否则为有效电平(OC1REF=1)

PWM模式2：在向上计数时，一旦TIMx_CNT\u003CTIMx_CCR1时通道1为无效电平，否则为有效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为有效电平，否则为无效电平

注意：PWM的模式只是区别什么时候是有效电平，但并没有确定是高电平有效还是低电平有效。这需要结合CCER寄存器的CCxP位的值来确定。

例如：若PWM模式1，且CCER寄存器的CCxP位为0，则当TIMx_CNT\u003CTIMx_CCR1时，输出高电平；同样的，若PWM模式1，且CCER寄存器的CCxP位为2，则当TIMx_CNT\u003CTIMx_CCR1时，输出低电平。

5.PWM产生

通过STM32控制板，有两种方式能产生PWM，第一是利用普通IO口输出PWM，第二种是利用定时器的PWM的IO口或复用IO口。

STM32的定时器除了TIM6和7，其他的定时器都可以用来产生PWM输出。

其中高级定时器TIM1和TIM8可以同时产生多达 7 路的 PWM 输出。而通用定时器也能同时产生多达 4路的 PWM 输出，这样，STM32 最多可以同时产生 30 路 PWM 输出。

一般能够输出PWM的端口都会在主要功能那一栏出现CHx的标志，而普通定时器没有出现这种标志。

6.PWM的计数模式

向上计数模式：当TIMx_CR1 寄存器中的DIR位为低的时候执行向上计数

下面是一个PWM模式1的例子。当TIMx_CNT\u003CTIMx_CCRx时PWM信号参考OCxREF为高，否则为低。如果TIMx_CCRx中的比较值大于自动重装载值(TIMx_ARR)，则OCxREF保持为’1’。如果比较值为0，则OCxREF保持为’0：

 

向下计数模式：当TIMx_CR1 寄存器的DIR位为高时执行向下计数。

在 PWM 模式 1，当 TIMx_CNT>TIMx_CCRx 时 OCxREF 为低，否则为高。如果

TIMx_CCRx 中的比较值大于 TIMx_ARR 中的自动重装载值，则 OCxREF 保持为

“1＂。该模式下不能产生 0％的 PWM 波形。

中央对齐模式：当TIMx_CR1 寄存器中的CMS位不为 00 时为中央对齐模式(所有其他的配置对

OCxREF/OCx信号都有相同的作用)。

根据不同的CMS位的设置，比较标志可能在计数器向上计数时被置 1、在计数器向下计数时被置 1、或在计数器向上和向下计数时被置 1。。TIMx_CR1 寄存器中的计数方向位(DIR)由硬件更新，不要用软件修改它。

图中给出了一些中央对齐的PWM波形的例子 TIMx_ARR=8 PWM 模式 1 TIMx_CR1 寄存器中的 CMS=01，在中央对齐模式1 时，当计数器向下计 数时标志被设置

 

7.PWM相关配置寄存器

7.1 捕获/比较模式寄存器（TIMx_CCMR1）

作用：在PWM输出模式下，确定PWM的模式、使能相应的预装载寄存器等操作

 

7.2 捕获/比较使能寄存器（TIMx_CCER）

作用：在PWM输出模式下，确定PWM的输出极性和输出使能

 

7.3 捕获/比较寄存器（TIMx_CCR1）

作用：在PWM输出模式下，确定比较的值

8.STM32CubeMx创建工程

选择STMF103c8t6芯片的基础上

配置RCC和SYS

 

 

9.配置定时器TIM

勾选Internal Clock（内部时钟）

通道1选择：PWM Generation CH1（PWM输出通道1）

Prtscaler (定时器分频系数) : 71

Counter Mode(计数模式)：Up(向上计数模式)

CounterPeriod(自动重装载值) : 500

CKD(时钟分频因子) ：No Division （不分频 ）

 

由于需要两个TIMER所以再配置TIM4，配置方法如上

10.配置时钟

 

11.代码编写

定义变量

在main.c文件中定义一个全局变量

 

打开PWM通道 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); 

    HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_1); 

 

12.在while循环中写入调用代码

while (pwm< 500)

   {

    pwm++;

    __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_1, pwm);  

    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_1, pwm);     

    HAL_Delay(1);

   }

   while (pwm)

   {

    pwm--;

    __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_1, pwm);    

       __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_1, pwm);  

   

    HAL_Delay(1);

   }

   HAL_Delay(200);

13.烧录

 

 

三、任务二

1.获取uC/OS-III源码

官方下载：http://micrium.com/downloadcenter/

2.建立stm32 hal库工程

打开stm32 cubeMX，选择芯片stm32f103c8，配置系统时钟为72M，将与LED相连的两个端口PB0，PC13配置为GPIO_Output，我们还需要串口输出，所以还需配置串口，我配置的串口1。

 

时钟配置

 

3.复制uC/OS-III文件到工程文件夹

在生成的keil工程文件夹f103c8_uCOSIII_1_test中新建一个 UCOSIII 的文件夹，将我们下载的源代码中三个文件夹： Uc-CPU、 uC-LIB、 Ucos-III 复制到我们新建的文件夹中

4.在Src文件夹下新建一个OS文件夹

5.将刚才下载源码打开，将路径：\\EvalBoards\\Micrium\\uC-Eval-STM32F107\\uCOS-III 下的文件：\napp.c 、 app_cfg.h 、 cpu_cfg.h 、 includes.h 、 lib_cfg.h 、 os_app_hooks.c 、os_app_hook.h、os_cfg.h、os_cfg_app.h复制到上一步建立的OS文件夹中，同时新建三个空白文件： bsp.c、bsp.h、app.h

 

6.添加工程组件和头文件路径

添加工程分组

打开f103c8_uCOSIII_1_test工程， 按照如图所示添加六个新的组： bsp、uCOSIII_CPU、 uCOSIII_LIB、 uCOSIII_Ports、 uCOSIII_Source、 OS_cfg

 

7.添加文件到分组

文件目录是： Src/OS，将其中 bsp.c 和 bsp.h文件添加至 bsp 组中，将 app.c 添加进 Application/User 组中\nuCOSIII_CPU 组件， 点击 Add Files…按钮，将文件目录跳转至： UCOSIII/uC-CPU， 选择 ALL files 文件类型，将其中的三个文件点击 Add 添加， 然后再打开： ARM-Cortex-M3\\RealView， 同样选择 ALL files 文件类型，将三个文件添加进 uCOSIII_CPU 组

添加 uCOSIII_LIB 组件文件：选择 uCOSIII_LIB 组，点击 Add Files…按钮， 将文件目录跳转至： UCOSIII/uCLIB，选择 ALL files 文件类型，将其中的九个文件添加进 uCOSIII_LIB 组；然后继续打开： Ports/ARM-Cortex-M3/Realview， 添加 lib_mem_a.asm 文件

选择 uCOSIII_Ports 组，点击 Add Files…按钮， 将文件目录调整至： UCOSIII/UcosIII/Ports/RAM-Cortex-M3/Generic/RealView。选择 ALL files 文件类型， 将其中三个文件添加进 uCOSIII_Ports 组

选择uCOSIII_Sourc组，点击Add Files…按钮， 将文件目录调整至： UCOSIII/UcosIII/Source。选择 ALL files 文件类型， 将其中二十个文件添加进 uCOSIII_Sourc 组。

选择 OS_cfg 组，点击 Add Files…按钮， 将文件目录调整至： Src/OS。选择 ALLfiles 文件类型， 将图中的八个文件添加进 uCOSIII_Sourc 组

最后点OK。

全部组件文件添加完成以后的工程文件结构：

 

 

 

 

8.添加头文件路径

 

 

9.修改文件内容

启动文件 startup_stm32f103xb.s

 

 

app_cfg.h

第一处修改：

修改前

#define APP_CFG_SERIAL_EN DEF_ENABLED

修改后

#define APP_CFG_SERIAL_EN DEF_DISABLED

第二处修改：

修改前

#define APP_TRACE BSP_Ser_Printf

修改后

#define APP_TRACE (void)

includes.h

第一处修改： 添加相关头文件

修改前

#include

改后

#include

#include "gpio.h"

#include "app_cfg.h"

#include "app.h"

第二处修改： 添加HAL 库

修改前

#include

改后

#include "stm32f1xx_hal.h"

bsp.c和bsp.h

// bsp.c

#include "includes.h"

 

#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 DEM_CR_TRCENA (1 << 24)

#define DWT_CR_CYCCNTENA (1 << 0)

 

CPU_INT32U BSP_CPU_ClkFreq (void)

{

    return HAL_RCC_GetHCLKFreq();

}

 

void BSP_Tick_Init(void)

{

 CPU_INT32U cpu_clk_freq;

 CPU_INT32U cnts;

 cpu_clk_freq = BSP_CPU_ClkFreq();

 

 #if(OS_VERSION>=3000u)

  cnts = cpu_clk_freq/(CPU_INT32U)OSCfg_TickRate_Hz;

 #else

  cnts = cpu_clk_freq/(CPU_INT32U)OS_TICKS_PER_SEC;

 #endif

 OS_CPU_SysTickInit(cnts);

}

 

 

 

void BSP_Init(void)

{

 BSP_Tick_Init();

 MX_GPIO_Init();

}

 

 

#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

 

 

#if (CPU_CFG_TS_32_EN == DEF_ENABLED)

CPU_INT64U CPU_TS32_to_uSec (CPU_TS32 ts_cnts)

{

 CPU_INT64U ts_us;

  CPU_INT64U fclk_freq;

 

 

  fclk_freq = BSP_CPU_ClkFreq();

  ts_us = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);

 

  return (ts_us);

}

#endif

 

 

#if (CPU_CFG_TS_64_EN == DEF_ENABLED)

CPU_INT64U CPU_TS64_to_uSec (CPU_TS64 ts_cnts)

{

 CPU_INT64U ts_us;

 CPU_INT64U fclk_freq;

 

 

  fclk_freq = BSP_CPU_ClkFreq();

  ts_us = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);

 

  return (ts_us);

}

#endif

// bsp.h

#ifndef __BSP_H__

#define __BSP_H__

 

#include "stm32f1xx_hal.h"

 

void BSP_Init(void);

 

#endif

 

10.代码

/* Includes ------------------------------------------------------------------*/

#include "main.h"

#include "usart.h"

#include "gpio.h"

 

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include

#include "stdio.h"

/* USER CODE END Includes */

 

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

int fputc(int ch,FILE *f){

 uint8_t temp[1]={ch};

 HAL_UART_Transmit(&huart1,temp,1,2);

 return ch;

}

 

/* USER CODE END PTD */

 

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

#define APP_TASK_LED1_PRIO 3 #任务优先级

#define APP_TASK_LED2_PRIO 4

#define APP_TASK_USART_PRIO 5

 

#define APP_TASK_LED1_STK_SIZE 64 #分配栈堆大小

#define APP_TASK_LED2_STK_SIZE 64

#define APP_TASK_USART_STK_SIZE 64

/* USER CODE END PD */

 

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

 

/* USER CODE END PM */

 

/* Private variables ---------------------------------------------------------*/

 

/* USER CODE BEGIN PV */

 

 

 

//任务控制块

static OS_TCB AppTaskStartTCB;

static OS_TCB AppTaskLED1TCB; //定义任务控制块LED1

static OS_TCB AppTaskLED2TCB; //定义任务控制块LED2

static OS_TCB AppTaskLUSARTTCB; //定义任务控制块USART

 

//任务堆栈

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 AppTaskUSARTSTK[APP_TASK_USART_STK_SIZE];

 

 

/* 私有函数原形 --------------------------------------------------------------*/

static void AppTaskCreate(void);

static void AppObjCreate(void);

static void AppTaskStart(void *p_arg);

 

static void AppTaskLED1(void *p_arg);

static void AppTaskLED2(void *p_arg);

static void AppTaskUSART(void *p_arg);

/* USER CODE END PV */

 

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);

/* USER CODE BEGIN PFP */

 

/* USER CODE END PFP */

 

/* Private user code ---------------------------------------------------------*/

/* USER CODE BEGIN 0 */

/**

  * @brief System Clock Configuration

  * @retval None

  */

void SystemClock_Config(void)

{

  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 

  /**Initializes the CPU, AHB and APB busses clocks 

  */

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  RCC_OscInitStruct.HSEState = RCC_HSE_ON;

  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;

  RCC_OscInitStruct.HSIState = RCC_HSI_ON;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;

  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

  {

    Error_Handler();

  }

  /**Initializes the CPU, AHB and APB busses clocks 

  */

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

 

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)

  {

    Error_Handler();

  }

}

 

/* USER CODE END 0 */

 

/**

  * @brief The application entry point.

  * @retval int

  */

int main(void)

{

  /* USER CODE BEGIN 1 */

 OS_ERR err;

  /* USER CODE END 1 */

 

  /* MCU Configuration--------------------------------------------------------*/

 

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */

  HAL_Init();

 

  /* USER CODE BEGIN Init */

 

  /* USER CODE END Init */

 

  /* Configure the system clock */

  SystemClock_Config();

 

  /* USER CODE BEGIN SysInit */

 OSInit(&err);    

  /* USER CODE END SysInit */

 

  /* Initialize all configured peripherals */

  MX_GPIO_Init();

  MX_USART1_UART_Init();

  /* USER CODE BEGIN 2 */

 

  /* USER CODE END 2 */

 

  /* Infinite loop */

  /* USER CODE BEGIN WHILE */

                                                                                 

 /* 创建任务 */

 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 ) 0,

     (OS_TICK ) 0,

     (void *) 0,

     (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

     (OS_ERR *)&err);

 /* 启动多任务系统，控制权交给uC/OS-III */

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

               

}

 

 

/**

  * 函数功能: 启动任务函数体。

  * 输入参数: p_arg 是在创建该任务时传递的形参

  * 返 回 值: 无

  * 说 明：无

  */

static void AppTaskStart (void *p_arg)

{

  OS_ERR err;

 

  (void)p_arg;

 

  BSP_Init(); /* Initialize BSP functions */

  CPU_Init();

 

  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();

 

  AppTaskCreate(); /* Create Application Tasks */

 

  AppObjCreate(); /* Create Application Objects */

 

 OSTaskCreate( (OS_TCB *)&AppTaskLED1TCB,/* Create the Led1 task */

                 (CPU_CHAR *)"AppTaskLED1",

                 (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 ) 0,

                 (OS_TICK ) 0,

                 (void *) 0,

                 (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

                 (OS_ERR *)&err);         

 

 /*Task LED2*/

 OSTaskCreate( (OS_TCB *)&AppTaskLED2TCB,/* Create the Led1 task */

                 (CPU_CHAR *)"AppTaskLED2",

                 (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 ) 0,

                 (OS_TICK ) 0,

                 (void *) 0,

                 (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

                 (OS_ERR *)&err);

 /*Task LED3*/         

 OSTaskCreate( (OS_TCB *)&AppTaskLUSARTTCB,/* Create the Led1 task*/

                 (CPU_CHAR *)"AppTaskUSART",

                 (OS_TASK_PTR ) AppTaskUSART,

                 (void *) 0,

                 (OS_PRIO ) APP_TASK_USART_PRIO,

                 (CPU_STK *)&AppTaskUSARTSTK[0],

                 (CPU_STK_SIZE) APP_TASK_USART_STK_SIZE / 10,

                 (CPU_STK_SIZE) APP_TASK_USART_STK_SIZE,

                 (OS_MSG_QTY ) 0,

                 (OS_TICK ) 0,

                 (void *) 0,

                 (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

                 (OS_ERR *)&err);

     OS_TaskSuspend((OS_TCB*)&AppTaskStartTCB,&err);

    /* USER CODE END WHILE */

 

    /* USER CODE BEGIN 3 */

  

  /* USER CODE END 3 */

}

 

 

 

/* USER CODE BEGIN 4 */

/**

  * 函数功能: 创建应用任务

  * 输入参数: p_arg 是在创建该任务时传递的形参

  * 返 回 值: 无

  * 说 明：无

  */

static void AppTaskCreate (void)

{

  

}

 

 

/**

  * 函数功能: uCOSIII内核对象创建

  * 输入参数: 无

  * 返 回 值: 无

  * 说 明：无

  */

static void AppObjCreate (void)

{

 

}

/*Task LED1*/

static void AppTaskLED1(void *p_arg)

{

 OS_ERR err;

 (void )p_arg;

 BSP_Init(); /* Initialize BSP functions */

  CPU_Init();

 

  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();

 

  AppTaskCreate(); /* Create Application Tasks */

 

  AppObjCreate(); 

  while (DEF_TRUE)

  {

  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);

  //HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1, GPIO_PIN_SET);

  OSTimeDlyHMSM(0, 0, 1, 0,

                  OS_OPT_TIME_HMSM_STRICT,

                  &err);

 }

 

}

 

/*Task LED2*/

static void AppTaskLED2(void *p_arg)

{

  OS_ERR err;

 (void )p_arg;

 BSP_Init(); /* Initialize BSP functions */

  CPU_Init();

 

  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();

 

  AppTaskCreate(); /* Create Application Tasks */

 

  AppObjCreate(); 

  while (DEF_TRUE)

  {

  HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_13);

  //HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1, GPIO_PIN_SET);

  OSTimeDlyHMSM(0, 0, 3, 0,

                  OS_OPT_TIME_HMSM_STRICT,

                  &err);

 }

}

/*Task LED3*/

static void AppTaskUSART(void *p_arg)

{

  OS_ERR err;

 (void )p_arg;

 BSP_Init(); /* Initialize BSP functions */

  CPU_Init();

 

  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();

 

  AppTaskCreate(); /* Create Application Tasks */

 

  AppObjCreate();

 while (DEF_TRUE)

  {

  printf("hello uc/OS! 欢迎来到RTOS多任务环境！");

  //HAL_GPIO_Write"Pin(GPIOB,GPIO_PIN_1, GPIO_PIN_SET);

  OSTimeDlyHMSM(0, 0, 2, 0,

                  OS_OPT_TIME_HMSM_STRICT,

                  &err);

 }

}

/* USER CODE END 4 */

 

/**

  * @brief This function is executed in case of error occurrence.

  * @retval None

  */

void Error_Handler(void)

{

  /* USER CODE BEGIN Error_Handler_Debug */

  /* User can add his own implementation to report the HAL error return state */

 

  /* USER CODE END Error_Handler_Debug */

}

 

#ifdef USE_FULL_ASSERT

/**

  * @brief Reports the name of the source file and the source line number

  * where the assert_param error has occurred.

  * @param file: pointer to the source file name

  * @param line: assert_param error line source number

  * @retval None

  */

void assert_failed(uint8_t *file, uint32_t line)

{

  /* USER CODE BEGIN 6 */

  /* User can add his own implementation to report the file name and line number,

     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* USER CODE END 6 */

}

#endif /* USE_FULL_ASSERT */

 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

11.效果

 

 

四、总结

通过查阅资料，对于PWM的知识有了个大概的了解，并使用定时器的TIM3和TIM4，分别输出了一个PWM波形，实现2个 LED呼吸灯的效果。