QXZ_QXZL/low3/applications/timer/timer.c

#include "timer.h"
#include "stm32_hal_legacy.h"

TIM_HandleTypeDef htim14;
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim7;

static void (*s_TIM_CallBack)(void);
static uint32_t g_iRunTime = 0;

void MODBUS_Tim14_Init(void)
{
    uint32_t usPeriod;
    uint16_t usPrescaler;
    uint32_t uiTIMxCLK;

    uiTIMxCLK = SystemCoreClock / 2;
    usPrescaler = uiTIMxCLK / 1000000 ; /* 分频到周期 1us */
    usPeriod = 0xFFFF;  /* 103支持16位 */

    /* Time base configuration */
    TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    TIM_MasterConfigTypeDef sMasterConfig = {0};

    htim14.Instance = TIM14;
    htim14.Init.Prescaler = usPrescaler;
    htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim14.Init.Period = usPeriod;
    htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    HAL_TIM_Base_Init(&htim14);

    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    HAL_TIM_ConfigClockSource(&htim14, &sClockSourceConfig);

    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    HAL_TIMEx_MasterConfigSynchronization(&htim14, &sMasterConfig);

    __HAL_TIM_CLEAR_FLAG(&htim14,TIM_FLAG_UPDATE);//定时器中断关闭
    __HAL_TIM_ENABLE_IT(&htim14,TIM_IT_UPDATE);   //使能更新中断一定要使能
    /* TIMx enable counter */
    HAL_TIM_Base_Stop_IT(&htim14);

    HAL_NVIC_SetPriority(TIM14_IRQn, 4, 0);
    HAL_NVIC_EnableIRQ(TIM14_IRQn);
}

//以下用来判断是否经过3.5个字节的时间
//在串口接受中断函数中被调用，每接受一个调用一次，重新开始计时
void bsp_StartHardTimer(uint32_t _uiTimeOut, void * _pCallBack)
{
    uint32_t cnt_now;
    uint32_t cnt_tar;
    if (_uiTimeOut < 5)
    {
        ;
    }
    else
    {
        _uiTimeOut -= 5;
    }

    __HAL_TIM_SetCounter(&htim14,0);
    HAL_TIM_Base_Start_IT(&htim14);

    cnt_now = __HAL_TIM_GetCounter(&htim14);     /* 读取当前的计数器值 */

    cnt_tar = cnt_now + _uiTimeOut;         /* 计算捕获的计数器值 */
    //rt_kprintf("cnt_tar is %d  \n",cnt_tar);
    s_TIM_CallBack = (void (*)(void))_pCallBack;
    __HAL_TIM_SetCompare(&htim14, TIM_CHANNEL_1,cnt_tar);       /* 设置捕获比较计数器CC3 */
    __HAL_TIM_CLEAR_IT(&htim14, TIM_IT_CC1);
    __HAL_TIM_ENABLE_IT(&htim14, TIM_IT_CC1);
}

//如果没有新数据接受，超时进入中断函数，将标志位置1
//time14回调函数
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == htim14.Instance)
    {
        //rt_kprintf("HAL_TIM_OC_DelayElapsedCallback\n");
        if(__HAL_TIM_GET_IT_SOURCE(&htim14,TIM_IT_CC1)!=RESET)
        {
            __HAL_TIM_CLEAR_IT(&htim14, TIM_IT_CC1);
            __HAL_TIM_DISABLE_IT(&htim14, TIM_IT_CC1);
            s_TIM_CallBack();   //将标志位置1
        }
    }
}

extern uint32_t Config_at_Cnt;        //配置函数延时变量,定时器内部累加
extern uint16_t Config_lora_at_Cnt;

uint8_t  GPS_Startflag = 0;//4G模块上电标准位  1：上电
uint32_t GPS_Start_Cnt = 0;//4G GPS功能打开标志
//tim3和tim7 回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    //rt_kprintf("HAL_TIM_PeriodElapsedCallback\n");
    if(htim->Instance == htim3.Instance)
    {
        g_iRunTime++;
        if(g_iRunTime > 0x7FFFFFFF) g_iRunTime = 0;
        //rt_kprintf("HAL_TIM_PeriodElapsedCallback  for  tim3\n");
    }
    else if(htim->Instance == htim7.Instance)
    {
           Config_at_Cnt ++;
            if(GPS_Startflag)
            {
                GPS_Start_Cnt++;
            }
           Config_lora_at_Cnt++;
            //rt_kprintf("HAL_TIM_PeriodElapsedCallback for  tim7\n");
    }
}



//定时器3用于计数,1ms进入中断
void MODBUS_Tim3_Init(void)
{

    TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    TIM_MasterConfigTypeDef sMasterConfig = {0};

    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 63;//35; //改  71
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = 999;
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
//  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    HAL_TIM_Base_Init(&htim3);
    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);

    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);

    /* 配置TIM定时中断 (Update) */
    HAL_NVIC_SetPriority(TIM3_IRQn, 4, 2);
    HAL_NVIC_EnableIRQ(TIM3_IRQn);

     __HAL_TIM_ENABLE_IT(&htim3,TIM_IT_UPDATE);   //使能更新中断一定要使能
    HAL_TIM_Base_Start_IT(&htim3);
}

//以下用来判断是否超时
//获取当前计数器计数值
uint32_t bsp_GetRunTime(void)
{
    int32_t runtime;

    __set_PRIMASK(1);       /* 关中断 */

    runtime = g_iRunTime;   /* 这个变量在Systick中断中被改写，因此需要关中断进行保护 */

    __set_PRIMASK(0);       /* 开中断 */

    return runtime;
}

//获取间隔时间
//如果现在时间比形参大  返回现在时间 - 形参
//如果现在时间比形参小  返回最大计算 - 现在时间与形参差值
uint32_t bsp_CheckRunTime(int32_t _LastTime)
{
    int32_t now_time;
    int32_t time_diff;

    __set_PRIMASK(1);       /* 关中断 */

    now_time = g_iRunTime;  /* 这个变量在Systick中断中被改写，因此需要关中断进行保护 */

    __set_PRIMASK(0);           /* 开中断 */
    //rt_kprintf("now_time is %d ",now_time);
    if (now_time >= _LastTime)//如果现在时间比形参大
    {
        time_diff = now_time - _LastTime; //返回现在时间-形参

    }
    else
    {
        time_diff = 0x7FFFFFFF - _LastTime + now_time;

    }
    return time_diff;
}



/* 扩展变量 ------------------------------------------------------------------*/
/* 私有函数原形 --------------------------------------------------------------*/
/* 函数体 --------------------------------------------------------------------*/
extern void Error_Handler(void);
/**
  * 函数功能: 基本定时器7初始化
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明: 无
  */
void GENERAL_TIM7_Init(void)
{
    TIM_MasterConfigTypeDef sMasterConfig = {0};

      /* USER CODE BEGIN TIM7_Init 1 */

      /* USER CODE END TIM7_Init 1 */
      htim7.Instance = TIM7;
      htim7.Init.Prescaler = 63;
      htim7.Init.CounterMode = TIM_COUNTERMODE_UP;
      htim7.Init.Period = 1000-1;//改  1000 -> 1000-1
      htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
      if (HAL_TIM_Base_Init(&htim7) != HAL_OK)
      {
        Error_Handler();
      }
      sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
      sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
      if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig) != HAL_OK)
      {
        Error_Handler();
      }
      /* USER CODE BEGIN TIM7_Init 2 */


        __HAL_TIM_ENABLE_IT(&htim7,TIM_IT_UPDATE);   //使能更新中断一定要使能这一句话困扰了我两天
        HAL_TIM_Base_Start_IT(&htim7);


      /* USER CODE END TIM7_Init 2 */
}







void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM7)
  {
  /* USER CODE BEGIN TIM7_MspInit 0 */

     //rt_kprintf("Instance==TIM7 \n");


  /* USER CODE END TIM7_MspInit 0 */
    /* TIM7 clock enable */
    __HAL_RCC_TIM7_CLK_ENABLE();

    /* TIM7 interrupt Init */
    HAL_NVIC_SetPriority(TIM7_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM7_IRQn);
  /* USER CODE BEGIN TIM7_MspInit 1 */

  /* USER CODE END TIM7_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM14)
  {
  /* USER CODE BEGIN TIM14_MspInit 0 */

  /* USER CODE END TIM14_MspInit 0 */
    /* TIM14 clock enable */
    __HAL_RCC_TIM14_CLK_ENABLE();

    /* TIM14 interrupt Init */
    HAL_NVIC_SetPriority(TIM14_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM14_IRQn);
  /* USER CODE BEGIN TIM14_MspInit 1 */

  /* USER CODE END TIM14_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM17)
  {
  /* USER CODE BEGIN TIM17_MspInit 0 */

  /* USER CODE END TIM17_MspInit 0 */
    /* TIM17 clock enable */
    __HAL_RCC_TIM17_CLK_ENABLE();
  /* USER CODE BEGIN TIM17_MspInit 1 */

  /* USER CODE END TIM17_MspInit 1 */
  }
}
void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
{

  //GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(timHandle->Instance==TIM14)
  {
  /* USER CODE BEGIN TIM14_MspPostInit 0 */

  /* USER CODE END TIM14_MspPostInit 0 */
#if 0
    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM14 GPIO Configuration
    PA4     ------> TIM14_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_4;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF4_TIM14;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM14_MspPostInit 1 */

  /* USER CODE END TIM14_MspPostInit 1 */
#endif
  }

}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM7)
  {
  /* USER CODE BEGIN TIM7_MspDeInit 0 */

  /* USER CODE END TIM7_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM7_CLK_DISABLE();

    /* TIM7 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM7_IRQn);
  /* USER CODE BEGIN TIM7_MspDeInit 1 */

  /* USER CODE END TIM7_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM14)
  {
  /* USER CODE BEGIN TIM14_MspDeInit 0 */

  /* USER CODE END TIM14_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM14_CLK_DISABLE();

    /* TIM14 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM14_IRQn);
  /* USER CODE BEGIN TIM14_MspDeInit 1 */

  /* USER CODE END TIM14_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM17)
  {
  /* USER CODE BEGIN TIM17_MspDeInit 0 */

  /* USER CODE END TIM17_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM17_CLK_DISABLE();
  /* USER CODE BEGIN TIM17_MspDeInit 1 */

  /* USER CODE END TIM17_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */







int timer_init(void)
{

    MODBUS_Tim14_Init();
    MODBUS_Tim3_Init();
    GENERAL_TIM7_Init();
   // rt_kprintf("                           timer_init\n");
    return 0;
}





INIT_APP_EXPORT(timer_init);

//MSH_CMD_EXPORT(show_timer_count, show_timer_count);