STM32F103C8T6移植uCOS基于HAL库

最新推荐文章于 2024-05-31 23:12:02 发布
最新推荐文章于 2024-05-31 23:12:02 发布
阅读量876 收藏 26
点赞数 24
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66160948/article/details/134721711
版权

一、CubeMX配置

配置RCC

配置SYS

设置PC13为GPIO_Output用于点亮LED灯

设置串口USART1

设置工程

点击生成代码，并在Keil中打开该工程。

在main函数中的while循环里添加语句

while (1)
  {
    /* USER CODE END WHILE */
​
    /* USER CODE BEGIN 3 */
        HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
        HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
        HAL_Delay(500);
  }
  /* USER CODE END 3 */

二、准备uCOSIII源码

进入官网下载：http://micrium.com/downloadcenter/

或链接：百度网盘 请输入提取码 提取码：1234

网盘下载，打开目录如下（文件夹uC-BSP和uC-CONFIG是自己新建的两个文件夹）

1.为uC-BSP文件夹新建bsp.c和bsp.h文件
2.给文件夹uC-CONFIG添加以下文件（从以下路径复制过来）

3.将uCOS相关文件复制到HAL工程的MDK-ARM文件夹下

三、移植

回到Keil打开的HAL工程

1.将uCOS文件添加到项目

点击Manage Project Items

为项目新建文件夹如下

分别给新增的文件夹添加文件

点击CPU–>Add Files…，选中以下文件，Add

点击LIB–>Add Files…，选中以下文件，Add

点击PORT–>Add Files…，选中以下文件，Add

点击SOURCE–>Add Files…，选中以下文件，Add

点击CONFIG–>Add Files…，选中以下文件，Add

点击BSP–>Add Files…，选中以下文件，Add

导入文件路径

从项目路径下寻找

2.为bsp.c和bsp.h添加代码

找到BSP下的bsp.c和bsp.h文件

bsp.h

// bsp.h
#ifndef  __BSP_H__
#define  __BSP_H__
​
#include "stm32f1xx_hal.h"
​
void BSP_Init(void);
​
#endif

bsp.c

// 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
3.修改main.c文件代码
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"
#include "usart.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <includes.h>
#include "stm32f1xx_hal.h"
/* USER CODE END Includes */
​
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
​
/* USER CODE END PTD */
​
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 任务优先级 */
#define START_TASK_PRIO     3
#define LED0_TASK_PRIO      4
#define MSG_TASK_PRIO       5
​
/* 任务堆栈大小   */
#define START_STK_SIZE      64
#define LED0_STK_SIZE       64
#define MSG_STK_SIZE        64//任务堆大小过大会报错，可以试着改小一点
​
/* 任务栈 */   
CPU_STK START_TASK_STK[START_STK_SIZE];
CPU_STK LED0_TASK_STK[LED0_STK_SIZE];
CPU_STK MSG_TASK_STK[MSG_STK_SIZE];
/* 任务控制块 */
OS_TCB StartTaskTCB;
OS_TCB Led0TaskTCB;
OS_TCB MsgTaskTCB;
/* USER CODE END PD */
​
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
​
/* USER CODE END PM */
​
/* Private variables ---------------------------------------------------------*/
​
/* USER CODE BEGIN PV */
​
/* 任务函数定义 */
void start_task(void *p_arg);
static  void  AppTaskCreate(void);
static  void  AppObjCreate(void);
static  void  led_pc13(void *p_arg);
static  void  send_msg(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)
{
    OS_ERR  err;
    OSInit(&err);
  HAL_Init();
    SystemClock_Config();
    //MX_GPIO_Init(); 这个在BSP的初始化里也会初始化
  MX_USART1_UART_Init();    
    /* 创建任务 */
    OSTaskCreate((OS_TCB     *)&StartTaskTCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"start task",
                 (OS_TASK_PTR ) start_task,
                 (void       *) 0,
                 (OS_PRIO     ) START_TASK_PRIO,
                 (CPU_STK    *)&START_TASK_STK[0],
                 (CPU_STK_SIZE) START_STK_SIZE/10,
                 (CPU_STK_SIZE) 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). */
               
}
​
​
void start_task(void *p_arg)
{
    OS_ERR err;
    CPU_SR_ALLOC();
    p_arg = p_arg;
    
    /* YangJie add 2021.05.20*/
  BSP_Init();                                                   /* Initialize BSP functions */
  //CPU_Init();
  //Mem_Init();                                                 /* Initialize Memory Management Module */
​
#if OS_CFG_STAT_TASK_EN > 0u
   OSStatTaskCPUUsageInit(&err);        //统计任务                
#endif
    
#ifdef CPU_CFG_INT_DIS_MEAS_EN          //如果使能了测量中断关闭时间
    CPU_IntDisMeasMaxCurReset();    
#endif
​
#if OS_CFG_SCHED_ROUND_ROBIN_EN         //当使用时间片轮转的时候
     //使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
    OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);  
#endif      
    
    OS_CRITICAL_ENTER();    //进入临界区
    /* 创建LED0任务 */
    OSTaskCreate((OS_TCB    * )&Led0TaskTCB,        
                 (CPU_CHAR  * )"led_pc13",      
                 (OS_TASK_PTR )led_pc13,            
                 (void      * )0,                   
                 (OS_PRIO     )LED0_TASK_PRIO,     
                 (CPU_STK   * )&LED0_TASK_STK[0],   
                 (CPU_STK_SIZE)LED0_STK_SIZE/10,    
                 (CPU_STK_SIZE)LED0_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);               
                 
    /* 创建LED1任务 */
    OSTaskCreate((OS_TCB    * )&MsgTaskTCB,     
                 (CPU_CHAR  * )"send_msg",      
                 (OS_TASK_PTR )send_msg,            
                 (void      * )0,                   
                 (OS_PRIO     )MSG_TASK_PRIO,       
                 (CPU_STK   * )&MSG_TASK_STK[0],    
                 (CPU_STK_SIZE)MSG_STK_SIZE/10, 
                 (CPU_STK_SIZE)MSG_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*)&StartTaskTCB,&err);        //挂起开始任务             
    OS_CRITICAL_EXIT(); //进入临界区
}
/**
  * 函数功能: 启动任务函数体。
  * 输入参数: p_arg 是在创建该任务时传递的形参
  * 返 回 值: 无
  * 说    明：无
  */
static  void  led_pc13 (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                           */
​
  while (DEF_TRUE)
  {
        HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
        OSTimeDlyHMSM(0, 0, 0, 500,OS_OPT_TIME_HMSM_STRICT,&err);
        HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
        OSTimeDlyHMSM(0, 0, 0, 500,OS_OPT_TIME_HMSM_STRICT,&err);
    /* USER CODE END WHILE */
​
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
static  void  send_msg (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                           */
​
  while (DEF_TRUE)
  {
            printf("hello world \r\n");
        OSTimeDlyHMSM(0, 0, 0, 500,OS_OPT_TIME_HMSM_STRICT,&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)
{
​
}
​
/* 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****/
4.修改其余文件部分代码

找到文件startup_…

在以下位置处将PendSV_Handler和SysTick_Handler改为OS_CPU_PendSVHandler和OS_CPU_SysTickHandler

找到文件app_cfg.h

找到文件includes.h

#include <bsp.h>处添加

找到lib_cfg.h

此处修改为5（该处宏定义设置堆空间的大小，STM32F103C8T6的RAM只有20K，所以要改小一点）

由于我们使用了printf函数，需要在usart.c文件中添加以下代码完成printf重定向

/* USER CODE BEGIN 1 */
int fputc(int ch,FILE *f){
    HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xffff);
    return ch;
}
/* USER CODE END 1 */
5.参数配置

四、实现三个任务

3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。 gpio.c中修改代码（添加初始化PA3）

void MX_GPIO_Init(void)
{
​
  GPIO_InitTypeDef GPIO_InitStruct = {0};
​
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
​
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
​
​
  /*Configure GPIO pin : PC13|PA3 */
  GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
​
}

修改main.c

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 任务优先级 */
#define START_TASK_PRIO     3
#define LED0_TASK_PRIO      4
#define MSG_TASK_PRIO       5
#define LED1_TASK_PRIO      6
​
/* 任务堆栈大小   */
#define START_STK_SIZE      96
#define LED0_STK_SIZE       64
#define MSG_STK_SIZE        64
#define LED1_STK_SIZE       64
​
/* 任务栈 */   
CPU_STK START_TASK_STK[START_STK_SIZE];
CPU_STK LED0_TASK_STK[LED0_STK_SIZE];
CPU_STK MSG_TASK_STK[MSG_STK_SIZE];
CPU_STK LED1_TASK_STK[LED1_STK_SIZE];
​
/* 任务控制块 */
OS_TCB StartTaskTCB;
OS_TCB Led0TaskTCB;
OS_TCB MsgTaskTCB;
OS_TCB Led1TaskTCB;
​
/* USER CODE END PD */
​
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
​
/* USER CODE END PM */
​
/* Private variables ---------------------------------------------------------*/
​
/* USER CODE BEGIN PV */
​
/* 任务函数定义 */
void start_task(void *p_arg);
static  void  AppTaskCreate(void);
static  void  AppObjCreate(void);
static  void  led_pc13(void *p_arg);
static  void  send_msg(void *p_arg);
static  void  led_pa3(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)
{
    OS_ERR  err;
    OSInit(&err);
  HAL_Init();
    SystemClock_Config();
    //MX_GPIO_Init(); 这个在BSP的初始化里也会初始化
  MX_USART1_UART_Init();    
    /* 创建任务 */
    OSTaskCreate((OS_TCB     *)&StartTaskTCB,                /* Create the start task                                */
                 (CPU_CHAR   *)"start task",
                 (OS_TASK_PTR ) start_task,
                 (void       *) 0,
                 (OS_PRIO     ) START_TASK_PRIO,
                 (CPU_STK    *)&START_TASK_STK[0],
                 (CPU_STK_SIZE) START_STK_SIZE/10,
                 (CPU_STK_SIZE) 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). */
               
}
​
​
void start_task(void *p_arg)
{
    OS_ERR err;
    CPU_SR_ALLOC();
    p_arg = p_arg;
    
    /* YangJie add 2021.05.20*/
  BSP_Init();                                                   /* Initialize BSP functions */
  //CPU_Init();
  //Mem_Init();                                                 /* Initialize Memory Management Module */
​
#if OS_CFG_STAT_TASK_EN > 0u
   OSStatTaskCPUUsageInit(&err);        //统计任务                
#endif
    
#ifdef CPU_CFG_INT_DIS_MEAS_EN          //如果使能了测量中断关闭时间
    CPU_IntDisMeasMaxCurReset();    
#endif
​
#if OS_CFG_SCHED_ROUND_ROBIN_EN         //当使用时间片轮转的时候
     //使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
    OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);  
#endif      
    
    OS_CRITICAL_ENTER();    //进入临界区
    /* 创建LED0任务 */
    OSTaskCreate((OS_TCB    * )&Led0TaskTCB,        
                 (CPU_CHAR  * )"led_pc13",      
                 (OS_TASK_PTR )led_pc13,            
                 (void      * )0,                   
                 (OS_PRIO     )LED0_TASK_PRIO,     
                 (CPU_STK   * )&LED0_TASK_STK[0],   
                 (CPU_STK_SIZE)LED0_STK_SIZE/10,    
                 (CPU_STK_SIZE)LED0_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);       
​
/* 创建LED1任务 */
    OSTaskCreate((OS_TCB    * )&Led1TaskTCB,        
                 (CPU_CHAR  * )"led_pa3",       
                 (OS_TASK_PTR )led_pa3,             
                 (void      * )0,                   
                 (OS_PRIO     )LED1_TASK_PRIO,     
                 (CPU_STK   * )&LED1_TASK_STK[0],   
                 (CPU_STK_SIZE)LED1_STK_SIZE/10,    
                 (CPU_STK_SIZE)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);                                        
                 
    /* 创建MSG任务 */
    OSTaskCreate((OS_TCB    * )&MsgTaskTCB,     
                 (CPU_CHAR  * )"send_msg",      
                 (OS_TASK_PTR )send_msg,            
                 (void      * )0,                   
                 (OS_PRIO     )MSG_TASK_PRIO,       
                 (CPU_STK   * )&MSG_TASK_STK[0],    
                 (CPU_STK_SIZE)MSG_STK_SIZE/10, 
                 (CPU_STK_SIZE)MSG_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*)&StartTaskTCB,&err);        //挂起开始任务             
    OS_CRITICAL_EXIT(); //进入临界区
}
/**
  * 函数功能: 启动任务函数体。
  * 输入参数: p_arg 是在创建该任务时传递的形参
  * 返 回 值: 无
  * 说    明：无
  */
static  void  led_pc13 (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                           */
​
  while (DEF_TRUE)
  {
        HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
        OSTimeDlyHMSM(0, 0, 1, 0,OS_OPT_TIME_HMSM_STRICT,&err);
        HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
        OSTimeDlyHMSM(0, 0, 1, 0,OS_OPT_TIME_HMSM_STRICT,&err);
    /* USER CODE END WHILE */
​
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
​
static  void  led_pa3 (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                           */
​
  while (DEF_TRUE)
  {
        HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_RESET);
        OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
        HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_SET);
        OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
    /* USER CODE END WHILE */
​
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
​
static  void  send_msg (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                           */
​
  while (DEF_TRUE)
  {
            printf("hello uc/OS \r\n");
        OSTimeDlyHMSM(0, 0, 2, 0,OS_OPT_TIME_HMSM_STRICT,&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)
{
​
}
​
/* 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****/

实现效果

庆尘118
关注
  • 24
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
电路设计之STM32F103C8T6开发板 CAN总线 RS485 RS232-电路方案
04-21
建议大家:如果想学习总线通讯，建议大家至少2块板子。这样可以直观感受多机通讯的效果。 1、基本例程-ADC操作 2、基本例程-CRC操作 3、基本例程-I0操作_LED流水灯 4、基本例程—SysTick（系统滴答定时器）操作 5、基本例程-TIM定时器操作 6、基本例程-USART收发 7、基本例程-按键（查询方式） 8、基本例程-按键(中断方式） 9、高级例程-基于MINI板的Free MODBUS协议例程 10、高级例程-基于MINI 板的UCOS 创建2个任务 11、高级例程-基于MINI板的 呼吸灯效果 采用TIM1的PWM实现 12、高级例程-基于STM32 USB 虚拟串口 采集ADC 13、高级例程-基于STM32 USB 虚拟串口 控制IO端口 14、高级例程-基于两个MINI板的CAN通讯 15、高级例程-基于两个MINI板的RS485通讯 16、高级例程-基于WEB的网页服务器例程（须另购买模块运行） 17、高级例程-基于NRF24L01模块的无线收发例程（须另购买模块运行） 18、高级例程-基于DS18B20的温度测量例程（须另购买模块运行） 19、高级例程-基于DHT11的温湿度测量例程（须另购买模块运行） 开发板购买链接:https://item.taobao.com/item.htm?spm=a1z10.5-c.w40... https://item.taobao.com/item.htm?spm=a1z10.5-c.w4002-13756981114.53.6cea55d0h6R3yz&id=555123831945
STM32F103C8T6程序例程.rar
02-18
包括基于MINI板的基本例程LED流水灯，滴答定时器，基本定时器的定时中断，USART收发，ADC和CRC操作，以及高级例程PWM输出和UCOS。
移植uCOS-II到STM32F103C8T6上.rar_stm32f103c8t6_ucos-ii_ucos移植
07-15
移植uCOS-II到STM32F103C8T6上
stm32f103c8移植UCOSIII单任务演示
02-23
stm32f103c8移植UCOSIII单任务演示，使用MDK（keil5）打开工程编译即可
基于STM32f103c8t6的UCOS 创建2个任务.7z
03-28
基于STM32f103c8t6的UCOS 创建2个任务
stm32f103c8t6基于hal库的uCOSIII-版本
02-01
stm32f103c8t6基于hal库的uCOSIII_版本，这是一个干净的版本，可以基于上面直接开发
STM32高级控制定时器应用之检测输入PWM周期和占空比
mftang的博客
05-29 1426
本文主要介绍STM32高级定时器的用法至输入捕获功能，该功能可用于捕捉外部输入信号的频率，并且计算出PWM的占空比。笔者通过详细的案例介绍这个功能，包括理论知识，实现原理，以及如何使用STM32Cube配置基本的参数，编写实用代码，实现捕捉频率当的功能。
STM32G030C8T6：EEPROM读写实验（I2C通信）--M24C64
最新发布
AnChenliang_1002的博客
05-31 525
本专栏记录STM32开发各个功能的详细过程，方便自己后续查看，当然也供正在入门STM32单片机的兄弟们参考；本小节的目标是，系统主频64 MHZ,采用高速外部晶振，实现PB11,PB10 引脚模拟I2C 时序，对M24C08 的EEPROM 进行读。原理：通过模拟I2C接(PB10:CLK,PB11:DTA)与M24C08 EEPROM进行读写实验。涉及到的知识：配置I2C通信，STM32CubeMX的使用。
蓝桥杯物联网竞赛_STM32L071_18_长短按键检测
Narnat的博客
05-28 326
【代码】蓝桥杯物联网竞赛_STM32L071_18_长短按键检测。
玩转STM32-通信协议SPI（详细-慢工出细活）
2301_81355360的博客
05-31 715
SPI系统可直接与各个厂家生产的多种标准外围器件接口，它只需4条线：串行时钟线（SCK）、主机输入/从机输出数据线（MISO）、主机输出/从机输入数据线（MOSI）和低电平有效的从机选择线（NSS）。（1）MISO：该引脚在从模式下发送数据，在主模式下接收数据。（2）MOSI：该引脚在主模式下发送数据，在从模式下接收数据。（3）SCK：串口时钟，作为主设备的输出，从设备的输入。（4）NSS：这个是一个可选的引脚，用来选择主/从设备。
stm32-DMA转运数据
m0_74246768的博客
05-28 893
在配置前要记得先定义一下DMA转运的源端数组和目标数组两个数组哦。接下来我们就开始准备配置吧。
[STM32+HAL]LD-1501MG舵机二次开发指南
共同进步！
05-28 324
一、准备材料 STM32F407ZGT6 LD-1501MG数字舵机 24路PWM舵机控制器
STM32建立工程问题汇总
2301_76776609的博客
05-28 360
工程内容如下：User文件夹中存放main.c文件，用户中断服务函数（stm32f1xx.it.c），用户配置文件（stm32f1xx_hal_conf.h）等用户程序文件，或者mdk启动程序。obj文件夹中存放hex或者mdk启动程序。类似于mdk5中的output文件夹CORE、Libraries、Obj、object、User等大部分工程内容都为系统文件（有的还有start文件夹也是是底层启动文件），可由对应芯片的固件包中获取，而需要移植或者编辑的文件都放在自己建立的文件夹里。
STM32—按键控制LED（定时器）
nownow_的博客
05-31 614
此笔记基于朗峰 STM32F103 系列的记录。STM32—按键控制LED（定时器）
STM32 入门教程（江科大教材）#笔记2
2301_79706774的博客
05-28 425
0.96寸OLED模块：小巧玲珑、占用接口少、简单易用，是电子设计中非常常见的显示屏模块。OLED（Organic Light Emitting Diode）：有机发光二极管。OLED显示屏：性能优异的新型显示屏，具有功耗低、相应速度快、宽视角、轻薄柔韧等特点。供电：3~5.5V，通信协议：I2C/SPI，分辨率：128*64。3-5光敏传感器控制蜂鸣器。4-1 OLED调试工具。3-4按键控制LED。
【STM32】定时器与PWM的LED控制
Pijiojio的博客
05-31 548
STM32F103一共有8个定时器TIM1~TIM8。STM32的定时器分为基本定时器、通用定时器和高等定时器。①TIM6TIM7（基本定时器）：基本定时器是只能向上计数的16位定时器，基本定时器只能有定时的功能，没有外部IO口，所以没有捕获和比较通道。②TIM2TIM3TIM4TIM5（通用定时器）：通用定时器是可以向上计数，也可以向下计数的16位定时器。通用定时器可以定时、输出比较、输入捕捉，每个通用定时器具有4个外部IO口。③TIM1TIM8。
stm32启动文件
m0_60503814的博客
05-27 615
stm32启动文件
【嵌入式硬件】DRV8874电机驱动
qq_39200110的博客
05-30 122
1）N沟道H桥电机驱动；2）驱动1个双向有刷直流电机；3）2个单向有刷直流电机；4）4.5V-37V工作电压范围；5）集成电流感测和调节；6）成比例电流输出（IPROPI）；7）可选电流调节（IMODE）:逐周期或固定关断时间；8）支持1.8、3V、5V逻辑输入；9）集成保护：欠压、电荷泵欠压、过流保护、输出关闭、热关断、自动故障恢复。
基于单片机的汽车防盗报警系统设计与实现
weixin_45905610的博客
05-31 661
为了有效保护车辆，防止车辆被盗，汽车防盗报警系统的设计成为研究的热点问题。基于 STC89C52 单片机设计了一套汽车防盗报警系统，该系统由硬件和软件两部分组成，通过高效集成电路形成完整的控制系统，电路结构简单、易于检测。介绍了各部件的结构及工作原理，利用实车试验对系统的性能进行了测试。试验结果表明，该系统对入侵信息反应灵敏并能够报警提示，可靠性与稳定性较高。
stm32f103c8t6移植ucosii
08-29
您好！感谢您的提问。要在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的技术参考手册。 希望这些信息对您有所帮助！如有任何疑问，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值