利用CubeMX初始化TIM与串口并测试FreeRTOS的中断管理函数

测试

创建两个任务start_task()与interrupt_task(), 这两个任务的功能如下：

start_task()：创建另一个任务

interrupt_task()：中断测试任务，任务中会调用FreeRTOS的关中断函数portDISABLE_INTERRUPTS()来将中断关闭一段时间

CubeMX的配置

首先是FreeRTOS的配置

箭头处是FreeRTOS所能控制的最大和最低的优先级，高于或者低于这两个优先级的中断无法被FreeRTOS的中断控制函数控制

创建好两个任务

这样一来FreeRTOS基本配置完成

STM32外设的配置

这里先确定好几个LED用作测设

时钟源的配置

这一要把Debug的模式改一下否则程序只能下载一次，然后我这里的时钟源选择是TIM1

初始化TIM2和TIM3，二者我都是初始化为1ms产生一次中断计数，时钟源都要选择为内部时钟源，记得要开启自动重装载，向上计数

这里要把TIM2和TIM3的中断都使能

在这里我把中断优先级分组设成了第四组。为了要测试FreeRTOS的中断控制函数，我就把TIM2的抢占优先级设置成了2，为了不影响串口的收发我把它的抢占优先级设置为了3。

需要注意的是，在FreeRTOS所控制的优先级之外的中断中是不可以使用FreeRTOS内置的API函数的，就算是带有IRQ后缀的函数也不可以，所以这里可以把是否使用FreeRTOS函数的选项给取消了

串口模式选择收发，并且使能它的中断

这里就是时钟树的配置，输入频率要和自己单片机实际使用的晶振一样，然后后面的HCLK频率配置只需要写好系统会自动配置

这里注意下函数是否为静态的，然后就可以生成代码了

代码

定时中断

/* 中断回调函数 1s 一次中断 输出测试语句 并且LED闪烁 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */
    static int time2,time3 = 0;

  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */
    if(htim == (&htim2))
    {
        time2++;
        if(time2 == 1000)
        {
            time2 = 0;
            printf("TIM2_OK\r\n");
            HAL_GPIO_TogglePin(LED_B_GPIO_Port,LED_B_Pin);
        }
    }
    if(htim == (&htim3))
    {
        time3++;
        if(time3 == 1000)
        {
            time3 = 0;
            printf("TIM3_OK\r\n");
            HAL_GPIO_TogglePin(LED_R_GPIO_Port,LED_R_Pin);
        }
    }    
  /* USER CODE END Callback 1 */
}

延迟函数

这里用的是正点原子的延迟函数,记录一下方便以后移植使用

#include "delay.h"
#include "cmsis_os.h"

static u32 fac_us=0;
static u16 fac_ms=0;

extern void xPortSysTickHandler(void);

/* 参数为倍频后的HCLK 我这里是100MHz */
void delay_init(u8 SYSCLK)
{
    u32 reload;
      HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);//SysTick频率为HCLK
    fac_us=SYSCLK;                            //不论是否使用OS,fac_us都需要使用
    reload=SYSCLK;                            //每秒钟的计数次数 单位为K       
    reload*=1000000/configTICK_RATE_HZ;        //根据configTICK_RATE_HZ设定溢出时间
                                            //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右    
    fac_ms=1000/configTICK_RATE_HZ;            //代表OS可以延时的最少单位        
      SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    SysTick->LOAD=reload;                     //每1/configTICK_RATE_HZ断一次    
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //开启SYSTICK
}

void delay_us(u32 nus)
{        
    u32 ticks;
    u32 told,tnow,tcnt=0;
    u32 reload=SysTick->LOAD;                //LOAD的值             
    ticks=nus*fac_us;                         //需要的节拍数 
    told=SysTick->VAL;                        //刚进入时的计数器值
    while(1)
    {
        tnow=SysTick->VAL;    
        if(tnow!=told)
        {        
            if(tnow<told)tcnt+=told-tnow;    //这里注意一下SYSTICK是一个递减的计数器就可以了.
            else tcnt+=reload-tnow+told;        
            told=tnow;
            if(tcnt>=ticks)break;            //时间超过/等于要延迟的时间,则退出.
        &#125;  
    &#125;                                        
&#125;

void delay_ms(u32 nms)
&#123;    
    if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    &#123;        
        if(nms>=fac_ms)                        //延时的时间大于OS的最少时间周期 
        &#123; 
               vTaskDelay(nms/fac_ms);             //FreeRTOS延时
        &#125;
        nms%=fac_ms;                        //OS已经无法提供这么小的延时了,采用普通方式延时    
    &#125;
    delay_us((u32)(nms*1000));                //普通方式延时
&#125;

/* 不会引起任务调度的延迟函数 */
void delay_xms(u32 nms)
&#123;
    u32 i;
    for(i=0;i<nms;i++) delay_us(1000);
&#125;

串口收发函数

在usart.c文件中添加，这样就可以使用printf()函数了

int fputc(int ch, FILE *f)
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
  return ch;
}

int fgetc(FILE *f)
{
  uint8_t ch = 0;
  HAL_UART_Receive(&huart1, &ch, 1, 0xffff);
  return ch;
}

注意在main.h文件中

#include <stdio.h>
#include <string.h>    

在main.c文件中定义两个数组

/* 定义两个数组 */
u8 aRxBuffer[RXBUFFERSIZE];            //HAL库使用的串口接收缓冲
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if(huart->Instance==USART1)//如果是串口1
    {
        HAL_UART_Transmit(&huart1,aRxBuffer,1,100);    // 接收到数据马上使用串口1发送出去
        HAL_UART_Receive_IT(&huart1,aRxBuffer,1);        // 重新使能串口1接收中断
    }
}

最后使能这几个用到的中断

HAL_TIM_Base_Start_IT(&htim2);
HAL_TIM_Base_Start_IT(&htim3);
HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);

任务函数

void StartDefaultTask(void const * argument)
{
  /* USER CODE BEGIN StartDefaultTask */

    taskENTER_CRITICAL();/* 进入临界区 */

  /* definition and creation of interrupt_task */
  osThreadDef(interrupt_task, Start_interrupt_task, osPriorityNormal, 0, 128);
  interrupt_taskHandle = osThreadCreate(osThread(interrupt_task), NULL);

    vTaskDelete(Start_TaskHandle); /* 删除开始任务 */ 

    taskEXIT_CRITICAL();/* 退出临界区 */

  /* USER CODE END StartDefaultTask */
}

void Start_interrupt_task(void const * argument)
{
  /* USER CODE BEGIN Start_interrupt_task */
    static u32 num = 0;
    while(1)
    {
        num++;
        if(num == 5)
        {
            num =0;
            printf("中断关闭.......\r\n");
            portDISABLE_INTERRUPTS();
            delay_xms(5000);
            printf("打开中断.......\r\n");
            portENABLE_INTERRUPTS();
        }
        HAL_GPIO_TogglePin(LED_G_GPIO_Port,LED_G_Pin);
        vTaskDelay(1000);
    }

  /* USER CODE END Start_interrupt_task */
}

几个需要注意的

1. CubeMX生成的代码最好不要乱修改，用户自己的代码最好写在CubeMX规定的代码区域
2. 某些需要在多个文件中用到的变量或者数组，可以在main.c文件中定义，然后在main.h文件中extern
3. 中断处理函数集中在stm32f4xx_it.c这个文件中，中断处理函数一般集中在main.c文件下，这样方便管理