当前位置： 首页 > article >正文

STM32CUBEIDE FreeRTOS操作教程（十三）：task api 任务访问函数

article 2025/2/25 23:03:24

STM32CUBEIDE FreeRTOS操作教程（十三）：task api 任务访问函数

STM32CUBE开发环境集成了STM32 HAL库进行FreeRTOS配置和开发的组件，不需要用户自己进行FreeRTOS的移植。这里介绍最简化的用户操作类应用教程。以STM32F401RCT6开发板为例，只用到USB，USART1极少的接口，体现FreeRTOS的各种操作过程。
在这里插入图片描述
操作教程（十三）配置FreeRTOS及相关环境，采用task api 任务访问函数获取任务状态参数，通过USB虚拟串口接收指令，根据指令执行相关的任务访问函数，并通过USB虚拟串口返回结果。常用的task api有如下一些：
在这里插入图片描述
FreeRTOS的教程较多，推荐参考正点原子所出的《STM32F407 FreeRTOS开发手册》了解相关知识。
在这里插入图片描述
在这里插入图片描述

STM32CUBEIDE工程配置

选择TIM1(也可以是其它TIM)作为FreeRTOS操作系统占用的时钟源：
在这里插入图片描述

在这里插入图片描述

配置时钟树包括USB的48MHz时钟：
在这里插入图片描述
配置PC13为低电平点灯的管脚：
在这里插入图片描述
配置USB串口:
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
配置UART1串口（但本例中不用到UART1):
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

FreeRTOS配置

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
保存并生成基础工程代码：
在这里插入图片描述
在生成代码的这个部分可以看到FreeRTOS代码部分：
在这里插入图片描述

任务实现

基于前述的配置，main.c代码里会加载Free-RTOS的配置，并启动几个任务的调度，当然，此时的任务都是什么也不干。实现LED闪灯，就在LED闪灯任务里加入代码即可：

void StartTask_TASK_LED_FLASH(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_LED_FLASH */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1000);
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  }
  /* USER CODE END StartTask_TASK_LED_FLASH */
}

也就实现了LED闪灯功能，其中osDelay(1000);实现1秒时间的操作系统调度延时，也就是1秒执行一次LED灯的亮灭。osDelay(1）；是最小的调度延时，为1毫秒。要实现更小的延时，则可以用微秒延时函数实现，参考《STM32 HAL us delay（微秒延时）的指令延时实现方式及优化》

在USB虚拟串口的接收数据回调函数里，接收指令信息：
在这里插入图片描述

static int8_t CDC_Receive_FS(uint8_t* Buf, uint32_t *Len)
{
  /* USER CODE BEGIN 6 */
	extern uint8_t USB_VCOM_BUFF[1024];
	extern uint32_t USB_VCOM_INDEX;

	extern osSemaphoreId_t USB_VCOM_BinarySem01Handle;
	extern BaseType_t USB_VCOM_pxHigherPriorityTaskWaken;

	memcpy(USB_VCOM_BUFF+USB_VCOM_INDEX, Buf, *Len);
	xSemaphoreGiveFromISR(USB_VCOM_BinarySem01Handle, &USB_VCOM_pxHigherPriorityTaskWaken);
	USB_VCOM_INDEX += *Len;


  USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
  USBD_CDC_ReceivePacket(&hUsbDeviceFS);
  return (USBD_OK);
  /* USER CODE END 6 */
}

在main.c的USB任务里，根据指令信息进行任务访问函数的调用和反馈：

void StartTask_TASK_USB_VCOM(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_USB_VCOM */
  BaseType_t err_stu = pdFALSE;

  UBaseType_t result = 0;

  /* Infinite loop */
  for(;;)
  {
    osDelay(10);
    USB_VCOM_xBlockTime = 0; //Block(waiting) time to get semaphore
    err_stu = xSemaphoreTake(USB_VCOM_BinarySem01Handle, USB_VCOM_xBlockTime);
    if(err_stu==pdTRUE)
    {

    	if(USB_VCOM_BUFF[0]==0x01) //Get task priority
    	{
    		result = uxTaskPriorityGet(TASK_LED_FLASHHandle);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "LED task's priority is %d\r\n", result);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x02) //Set task priority from current priority + 1
    	{
    		result = uxTaskPriorityGet(TASK_LED_FLASHHandle) + 1;
    		vTaskPrioritySet(TASK_LED_FLASHHandle, result);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "LED task's priority is set to %d\r\n", result);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x03) //Get all tasks' status and output LED task status
    	{
            uint32_t rt = 0;
    		TaskStatus_t * SB = pvPortMalloc(1024);
    		result = uxTaskGetSystemState(SB, 20, &rt);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Task number got is %d\r\n", result);
    		usbprintstring(TB);

    		for(uint32_t i=0; i<result;i++)
    		{
    			if(SB[i].xHandle == TASK_LED_FLASHHandle)
    			{
    	    		sprintf(TB, "LED task handle = %d\r\n", SB[i].xHandle);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task name = %s\r\n", SB[i].pcTaskName);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task status = %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", SB[i].eCurrentState);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task current priority = %d\r\n", SB[i].uxCurrentPriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task base priority = %d\r\n", SB[i].uxBasePriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task runtime counter = %d\r\n", SB[i].ulRunTimeCounter);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack base = 0x%.8x\r\n", SB[i].pxStackBase);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack high water mark = %d\r\n", SB[i].usStackHighWaterMark);
    	    		usbprintstring(TB);

    			  break;
    			}
    		}

    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x04) //Get and output LED task's status
    	{
            uint32_t rt = 0;
    		TaskStatus_t * SB = pvPortMalloc(1024);
    		vTaskGetInfo(TASK_LED_FLASHHandle, SB, pdTRUE, eInvalid);
    		char * TB = pvPortMalloc(1024);

    	    		sprintf(TB, "LED task handle = %d\r\n", (*SB).xHandle);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task name = %s\r\n", (*SB).pcTaskName);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task status = %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", (*SB).eCurrentState);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task current priority = %d\r\n", (*SB).uxCurrentPriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task base priority = %d\r\n", (*SB).uxBasePriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task runtime counter = %d\r\n", (*SB).ulRunTimeCounter);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack base = 0x%.8x\r\n", (*SB).pxStackBase);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack high water mark = %d\r\n", (*SB).usStackHighWaterMark);
    	    		usbprintstring(TB);


    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x05) //Set and get task Tag
    	{
    		TaskHookFunction_t TV = 0;
    		char * TB = pvPortMalloc(1024);

    		BaseType_t cbf( void * param )
    		{
    			return 100;
    		}

    		vTaskSetApplicationTaskTag( TASK_LED_FLASHHandle, ( void * ) 1 );
    		usbprintstring("LED task's TAG is set to digital\r\n");
    		TV = xTaskGetApplicationTaskTag( TASK_LED_FLASHHandle);

    		sprintf(TB, "LED task's TAG is %.8x (digital)\r\n", TV);
    		usbprintstring(TB);


    		vTaskSetApplicationTaskTag( TASK_LED_FLASHHandle, ( void * ) cbf );
    		usbprintstring("LED task's TAG is set to function\r\n");
    		TV = xTaskGetApplicationTaskTag( TASK_LED_FLASHHandle);
    		sprintf(TB, "LED task's TAG is %.8x (function address)\r\n", TV);
    		usbprintstring(TB);

    		BaseType_t (*fp)(void);
    		fp = TV;
    		BaseType_t rv = fp();
    		sprintf(TB, "Function return value is %d\r\n", rv);
    		usbprintstring(TB);

    		rv = xTaskCallApplicationTaskHook( TASK_LED_FLASHHandle, 0);
    		sprintf(TB, "Function return value is %d\r\n", rv);
    		usbprintstring(TB);

    		vPortFree(TB);

    	}

    	if(USB_VCOM_BUFF[0]==0x06) //Get current task handle
    	{
    		TaskHandle_t th = xTaskGetCurrentTaskHandle();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Current task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x07) //Get task handle from task name
    	{
    		TaskHandle_t th = xTaskGetHandle("TASK_LED_FLASH");

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "'TASK_LED_FLASH' task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x08) //Get idle task handle
    	{
    		TaskHandle_t th = xTaskGetIdleTaskHandle();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Idle task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x09) //Get task stack-high-water-mark
    	{
    		UBaseType_t tshwm = uxTaskGetStackHighWaterMark(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's stack-high-water-mark is %d\r\n", tshwm);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0A) //Get task running state
    	{
    		eTaskState ts = eTaskGetState(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's running state is %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", ts);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0B) //Get task name from task handle
    	{
    		char * tn = pcTaskGetName(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's name is %s\r\n", tn);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0C) //Get tick count
    	{
    		TickType_t tc = xTaskGetTickCount();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Tick count is %ld\r\n", tc);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0D) //Get scheduler state
    	{
    		BaseType_t ts = xTaskGetSchedulerState();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Scheduler state is %ld\r\n0:taskSCHEDULER_SUSPENDED;1:taskSCHEDULER_NOT_STARTED;2:taskSCHEDULER_RUNNING\r\n", ts);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0E) //Get task number
    	{
    		UBaseType_t tn = uxTaskGetNumberOfTasks();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Task number is %ld\r\n", tn);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0F) //Get all tasks' information
    	{
    		char * TB = pvPortMalloc(1024);
    		vTaskList(TB);

    		usbprintstring("Name       State   Priority   Stack   Number\r\n");
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x10) //Task's thread local storage pointer write and read
    	{
    		char * TB = pvPortMalloc(1024);
    		vTaskSetThreadLocalStoragePointer(TASK_LED_FLASHHandle, 0, TB);

    		void * ta = pvTaskGetThreadLocalStoragePointer(TASK_LED_FLASHHandle, 0);

    		sprintf(TB, "LED Task's storage index is 0x%.8X\r\n", ta);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	USB_VCOM_INDEX = 0;
    }
  }
  /* USER CODE END StartTask_TASK_USB_VCOM */
}

main.c文件的完整代码为：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
//Example 2: LED flash + USB VCOM with semaphore binary for task api enquiry
//Written by Pegasus Yu
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
#include "usb_device.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "semphr.h"
#include "task.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
__IO float usDelayBase = 7.63238716; //For STM32F401RCT6 working in 84MHz main clock

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_rx;

/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for TASK_LED_FLASH */
osThreadId_t TASK_LED_FLASHHandle;
const osThreadAttr_t TASK_LED_FLASH_attributes = {
  .name = "TASK_LED_FLASH",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for TASK_UART1 */
osThreadId_t TASK_UART1Handle;
const osThreadAttr_t TASK_UART1_attributes = {
  .name = "TASK_UART1",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for TASK_USB_VCOM */
osThreadId_t TASK_USB_VCOMHandle;
const osThreadAttr_t TASK_USB_VCOM_attributes = {
  .name = "TASK_USB_VCOM",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for USB_VCOM_BinarySem01 */
osSemaphoreId_t USB_VCOM_BinarySem01Handle;
const osSemaphoreAttr_t USB_VCOM_BinarySem01_attributes = {
  .name = "USB_VCOM_BinarySem01"
};
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART1_UART_Init(void);
void StartDefaultTask(void *argument);
void StartTask_TASK_LED_FLASH(void *argument);
void StartTask_TASK_UART1(void *argument);
void StartTask_TASK_USB_VCOM(void *argument);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len);
void usbprintstring(char * data)
{
	if(CDC_Transmit_FS((uint8_t *)data, strlen(data))==USBD_BUSY)
	{
		PY_Delay_us_t(1000000);
	    CDC_Transmit_FS((uint8_t *)data, strlen(data));
	}
}

void usbprintarray(uint8_t * data, uint16_t len)
{
	if(CDC_Transmit_FS(data, len)==USBD_BUSY)
	{
		PY_Delay_us_t(1000000);
		CDC_Transmit_FS(data, len);
	}
}

uint8_t USB_VCOM_BUFF[1024];
uint32_t USB_VCOM_INDEX = 0;

BaseType_t USB_VCOM_pxHigherPriorityTaskWaken;
TickType_t USB_VCOM_xBlockTime = 0;

BaseType_t testfun(void)
{
	return 0x55;
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* 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 */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Init scheduler */
  osKernelInitialize();

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* creation of USB_VCOM_BinarySem01 */
  USB_VCOM_BinarySem01Handle = osSemaphoreNew(1, 0, &USB_VCOM_BinarySem01_attributes);

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of TASK_LED_FLASH */
  TASK_LED_FLASHHandle = osThreadNew(StartTask_TASK_LED_FLASH, NULL, &TASK_LED_FLASH_attributes);

  /* creation of TASK_UART1 */
  TASK_UART1Handle = osThreadNew(StartTask_TASK_UART1, NULL, &TASK_UART1_attributes);

  /* creation of TASK_USB_VCOM */
  TASK_USB_VCOMHandle = osThreadNew(StartTask_TASK_USB_VCOM, NULL, &TASK_USB_VCOM_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

  /* Start scheduler */
  osKernelStart();

  /* We should never get here as control is now taken by the scheduler */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 25;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses 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();
  }
}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA2_Stream2_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : LED_Pin */
  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);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* init code for USB_DEVICE */
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN 5 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END 5 */
}

/* USER CODE BEGIN Header_StartTask_TASK_LED_FLASH */
/**
* @brief Function implementing the TASK_LED_FLASH thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_LED_FLASH */
void StartTask_TASK_LED_FLASH(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_LED_FLASH */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1000);
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  }
  /* USER CODE END StartTask_TASK_LED_FLASH */
}

/* USER CODE BEGIN Header_StartTask_TASK_UART1 */
/**
* @brief Function implementing the TASK_UART1 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_UART1 */
void StartTask_TASK_UART1(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_UART1 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask_TASK_UART1 */
}

/* USER CODE BEGIN Header_StartTask_TASK_USB_VCOM */
/**
* @brief Function implementing the TASK_USB_VCOM thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_USB_VCOM */
void StartTask_TASK_USB_VCOM(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_USB_VCOM */
  BaseType_t err_stu = pdFALSE;

  UBaseType_t result = 0;

  /* Infinite loop */
  for(;;)
  {
    osDelay(10);
    USB_VCOM_xBlockTime = 0; //Block(waiting) time to get semaphore
    err_stu = xSemaphoreTake(USB_VCOM_BinarySem01Handle, USB_VCOM_xBlockTime);
    if(err_stu==pdTRUE)
    {

    	if(USB_VCOM_BUFF[0]==0x01) //Get task priority
    	{
    		result = uxTaskPriorityGet(TASK_LED_FLASHHandle);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "LED task's priority is %d\r\n", result);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x02) //Set task priority from current priority + 1
    	{
    		result = uxTaskPriorityGet(TASK_LED_FLASHHandle) + 1;
    		vTaskPrioritySet(TASK_LED_FLASHHandle, result);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "LED task's priority is set to %d\r\n", result);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x03) //Get all tasks' status and output LED task status
    	{
            uint32_t rt = 0;
    		TaskStatus_t * SB = pvPortMalloc(1024);
    		result = uxTaskGetSystemState(SB, 20, &rt);
    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Task number got is %d\r\n", result);
    		usbprintstring(TB);

    		for(uint32_t i=0; i<result;i++)
    		{
    			if(SB[i].xHandle == TASK_LED_FLASHHandle)
    			{
    	    		sprintf(TB, "LED task handle = %d\r\n", SB[i].xHandle);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task name = %s\r\n", SB[i].pcTaskName);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task status = %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", SB[i].eCurrentState);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task current priority = %d\r\n", SB[i].uxCurrentPriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task base priority = %d\r\n", SB[i].uxBasePriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task runtime counter = %d\r\n", SB[i].ulRunTimeCounter);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack base = 0x%.8x\r\n", SB[i].pxStackBase);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack high water mark = %d\r\n", SB[i].usStackHighWaterMark);
    	    		usbprintstring(TB);

    			  break;
    			}
    		}

    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x04) //Get and output LED task's status
    	{
            uint32_t rt = 0;
    		TaskStatus_t * SB = pvPortMalloc(1024);
    		vTaskGetInfo(TASK_LED_FLASHHandle, SB, pdTRUE, eInvalid);
    		char * TB = pvPortMalloc(1024);

    	    		sprintf(TB, "LED task handle = %d\r\n", (*SB).xHandle);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task name = %s\r\n", (*SB).pcTaskName);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task status = %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", (*SB).eCurrentState);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task current priority = %d\r\n", (*SB).uxCurrentPriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task base priority = %d\r\n", (*SB).uxBasePriority);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task runtime counter = %d\r\n", (*SB).ulRunTimeCounter);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack base = 0x%.8x\r\n", (*SB).pxStackBase);
    	    		usbprintstring(TB);

    	    		sprintf(TB, "LED task stack high water mark = %d\r\n", (*SB).usStackHighWaterMark);
    	    		usbprintstring(TB);


    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x05) //Set and get task Tag
    	{
    		TaskHookFunction_t TV = 0;
    		char * TB = pvPortMalloc(1024);

    		BaseType_t cbf( void * param )
    		{
    			return 100;
    		}

    		vTaskSetApplicationTaskTag( TASK_LED_FLASHHandle, ( void * ) 1 );
    		usbprintstring("LED task's TAG is set to digital\r\n");
    		TV = xTaskGetApplicationTaskTag( TASK_LED_FLASHHandle);

    		sprintf(TB, "LED task's TAG is %.8x (digital)\r\n", TV);
    		usbprintstring(TB);


    		vTaskSetApplicationTaskTag( TASK_LED_FLASHHandle, ( void * ) cbf );
    		usbprintstring("LED task's TAG is set to function\r\n");
    		TV = xTaskGetApplicationTaskTag( TASK_LED_FLASHHandle);
    		sprintf(TB, "LED task's TAG is %.8x (function address)\r\n", TV);
    		usbprintstring(TB);

    		BaseType_t (*fp)(void);
    		fp = TV;
    		BaseType_t rv = fp();
    		sprintf(TB, "Function return value is %d\r\n", rv);
    		usbprintstring(TB);

    		rv = xTaskCallApplicationTaskHook( TASK_LED_FLASHHandle, 0);
    		sprintf(TB, "Function return value is %d\r\n", rv);
    		usbprintstring(TB);

    		vPortFree(TB);

    	}

    	if(USB_VCOM_BUFF[0]==0x06) //Get current task handle
    	{
    		TaskHandle_t th = xTaskGetCurrentTaskHandle();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Current task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x07) //Get task handle from task name
    	{
    		TaskHandle_t th = xTaskGetHandle("TASK_LED_FLASH");

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "'TASK_LED_FLASH' task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x08) //Get idle task handle
    	{
    		TaskHandle_t th = xTaskGetIdleTaskHandle();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Idle task's handle(pointer) is 0x%.8x\r\n", th);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x09) //Get task stack-high-water-mark
    	{
    		UBaseType_t tshwm = uxTaskGetStackHighWaterMark(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's stack-high-water-mark is %d\r\n", tshwm);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0A) //Get task running state
    	{
    		eTaskState ts = eTaskGetState(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's running state is %d\r\neRunning=0;eReady=1;eBlocked=2;eSuspended=3;eDeleted=4;eInvalid=5;\r\n", ts);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0B) //Get task name from task handle
    	{
    		char * tn = pcTaskGetName(TASK_LED_FLASHHandle);

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Led task's name is %s\r\n", tn);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0C) //Get tick count
    	{
    		TickType_t tc = xTaskGetTickCount();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Tick count is %ld\r\n", tc);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0D) //Get scheduler state
    	{
    		BaseType_t ts = xTaskGetSchedulerState();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Scheduler state is %ld\r\n0:taskSCHEDULER_SUSPENDED;1:taskSCHEDULER_NOT_STARTED;2:taskSCHEDULER_RUNNING\r\n", ts);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0E) //Get task number
    	{
    		UBaseType_t tn = uxTaskGetNumberOfTasks();

    		char * TB = pvPortMalloc(1024);
    		sprintf(TB, "Task number is %ld\r\n", tn);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x0F) //Get all tasks' information
    	{
    		char * TB = pvPortMalloc(1024);
    		vTaskList(TB);

    		usbprintstring("Name       State   Priority   Stack   Number\r\n");
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	if(USB_VCOM_BUFF[0]==0x10) //Task's thread local storage pointer write and read
    	{
    		char * TB = pvPortMalloc(1024);
    		vTaskSetThreadLocalStoragePointer(TASK_LED_FLASHHandle, 0, TB);

    		void * ta = pvTaskGetThreadLocalStoragePointer(TASK_LED_FLASHHandle, 0);

    		sprintf(TB, "LED Task's storage index is 0x%.8X\r\n", ta);
    		usbprintstring(TB);
    		vPortFree(TB);
    	}

    	USB_VCOM_INDEX = 0;
    }
  }
  /* USER CODE END StartTask_TASK_USB_VCOM */
}

/**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM1 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */

  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */

  /* USER CODE END Callback 1 */
}

/**
  * @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 */
  __disable_irq();
  while (1)
  {
  }
  /* 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,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

手动调整的代码

有几处的配置调整，需要手动进行：
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

例程下载

STM32 STM32CUBEIDE FreeRTOS操作教程（十三）：stask api 任务访问函数 例程

例程测试

例程测试效果如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

–End–


http://www.kler.cn/a/560941.html

相关文章：

  • 目标检测之FAST RCNN论文简读
  • AIGC技术助力空军招飞，近屿智能开启智能人才培育新征程
  • SSTI知识点汇总
  • docker离线安装记录
  • Vulnhun靶机-kioptix level 4-sql注入万能密码拿到权限ssh连接利用mysql-udf漏洞提权
  • 05C语言——数组
  • 95.【C语言】解析预处理(3)
  • 【安装及调试旧版Chrome + 多版本环境测试全攻略】
  • [特殊字符] Elasticsearch 双剑合璧：HTTP API 与 Java API 实战整合指南
  • 塔能科技构建智慧隧道生态系统——城市升级改造的协同创新典范
  • 【Java项目】基于Spring Boot的简历系统
  • 电脑没声音了怎么恢复正常？一键恢复电脑声音
  • 使 Windows 呈现 macOS 风格的多功能桌面美化软件
  • 连锁管理系统的五大核心设计及 PHP 源码分享
  • 【深度解析：基于 C 语言实现含 IP 城市地址因素的抖音式简化推荐算法】
  • 2.2 STM32F103C8T6最小系统板的四种有关固件的开发方式
  • 超导量子计算机的最新进展：走向实用化的量子革命
  • 官方文档学习TArray数组的运算符
  • GaussDB会话超时参数与最大连接数设置
  • 一文读懂Docker之Docker Swarm集群平台搭建