使用 FreeRTOS 和 HAL 库的 STM32 例程，多个任务例程

#include "main.h"

#include "cmsis_os.h"

#include <stdio.h>

 

// 定义全局变量

TIM_HandleTypeDef htim2;

UART_HandleTypeDef huart2;

osThreadId defaultTaskHandle, uartTaskHandle, buttonTaskHandle;

uint8_t uart_buf[16];

osSemaphoreId uart_sem;

 

// 声明函数原型

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_TIM2_Init(void);

static void MX_USART2_UART_Init(void);

void StartDefaultTask(void const * argument);

void UartSendTask(void const * argument);

void ButtonCheckTask(void const * argument);

 

int main(void)

{

  // 初始化 HAL 库和 RTOS 内核

  HAL_Init();

  SystemClock_Config();

  MX_GPIO_Init();

  MX_TIM2_Init();

  MX_USART2_UART_Init();

 

  // 创建默认任务

  osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);

  defaultTaskHandle = osThreadCreate(osThread(defaultTask));

 

  // 创建串口发送任务

  osThreadDef(uartTask, UartSendTask, osPriorityNormal, 0, 128);

  uartTaskHandle = osThreadCreate(osThread(uartTask));

 

  // 创建按键检测任务

  osThreadDef(buttonTask, ButtonCheckTask, osPriorityNormal, 0, 128);

  buttonTaskHandle = osThreadCreate(osThread(buttonTask));

 

  // 创建信号量

  osSemaphoreDef(uartSem);

  uart_sem = osSemaphoreCreate(osSemaphore(uartSem), 1);

 

  // 启动 RTOS 内核

  osKernelStart();

 

  while (1) {}

}

 

// 默认任务的入口函数

void StartDefaultTask(void const * argument)

{

  for (;;) {

    HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);  // 切换 LED 状态

    osDelay(500);                                // 延迟 500ms

  }

}

 

// 串口发送任务的入口函数

void UartSendTask(void const * argument)

{

  uint32_t tick_count;

  sprintf((char *)uart_buf, "Hello, world!\r\n");

  for (;;) {

    osSemaphoreWait(uart_sem, osWaitForever);  // 等待信号量

    tick_count = osKernelSysTick();

    HAL_UART_Transmit(&huart2, uart_buf, strlen((char*)uart_buf), 1000);

    tick_count = osKernelSysTick() - tick_count;

    printf("UART send time: %ld\r\n", tick_count);  // 打印发送时间

  }

}

 

// 按键检测任务的入口函数

void ButtonCheckTask(void const * argument)

{

  GPIO_PinState button_state = GPIO_PIN_SET;

  GPIO_PinState last_state = GPIO_PIN_SET;

  for (;;) {

    button_state = HAL_GPIO_ReadPin(BUTTON_GPIO_Port, BUTTON_Pin);

    if (button_state != last_state) {

      sprintf((char *)uart_buf, "Button state: %d\r\n", button_state);

      osSemaphoreRelease(uart_sem);  // 发送数据

      last_state = button_state;

    }

    osDelay(10);  // 延迟一段时间

  }

}

 

// 定时器中断回调函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

  if (htim->Instance == TIM2) {

    HAL_IncTick();  // 增加 HAL 的滴答计数器

    osSystickHandler();  // 调用 RTOS 的 SysTick 处理函数

  }

}

 

// 配置系统时钟源和频率

void SystemClock_Config(void)

{

  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 

  __HAL_RCC_PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

 

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;

  RCC_OscInitStruct.HSIState = RCC_HSI_ON;

  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

  {

    Error_Handler();

  }

 

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

 

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

  {

    Error_Handler();

  }

}

 

// 配置 GPIO 和 TIM2

static void MX_GPIO_Init(void)

{

  GPIO_InitTypeDef GPIO_InitStruct = {0};

 

  __HAL_RCC_GPIOA_CLK_ENABLE();

  __HAL_RCC_GPIOC_CLK_ENABLE();

 

  GPIO_InitStruct.Pin = LED_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

  HAL_GPIO_Init(LED_GPIO_Port, &GPIO_InitStruct);

 

  GPIO_InitStruct.Pin = BUTTON_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

  GPIO_InitStruct.Pull = GPIO_PULLUP;

  HAL_GPIO_Init(BUTTON_GPIO_Port, &GPIO_InitStruct);

}

 

static void MX_TIM2_Init(void)

{

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};

  TIM_MasterConfigTypeDef sMasterConfig = {0};

 

  __HAL_RCC_TIM2_CLK_ENABLE();

 

  htim2.Instance = TIM2;

  htim2.Init.Prescaler = 7999;

  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim2.Init.Period = 999;

  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

  {

    Error_Handler();

  }

 

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)

  {

    Error_Handler();

  }

 

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

  {

    Error_Handler();

  }

}

 

static void MX_USART2_UART_Init(void)

{

  huart2.Instance = USART2;

  huart2.Init.BaudRate = 115200;

  huart2.Init.WordLength = UART_WORDLENGTH_8B;

  huart2.Init.StopBits = UART_STOPBITS_1;

  huart2.Init.Parity = UART_PARITY_NONE;

  huart2.Init.Mode = UART_MODE_TX_RX;

  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;

  huart2.Init.OverSampling = UART_OVERSAMPLING_16;

  if (HAL_UART_Init(&huart2) != HAL_OK)

  {

    Error_Handler();

  }

}

 

// 错误处理函数

void Error_Handler(void)

{

  while(1) {}

}