Stm32cubemx Learning (5) Input capture Experiment

Dossiers d'études personnels

Un.、Nouveaux travaux

2.、Sélectionnez le modèle de puce

Le tableau de développement que j'utilise est un atome de point positif STM32F103ZET6 Plaque centrale

Trois、Configurer l'horloge

Les plaques de développement sont soudées avec des vibrations cristallines externes,C'est pour ça que je RCC(Reset and Cock Control) Configuration sélectionnée Crystal/Ceramic Resonator（Quartz/Résonateur céramique）,Une fois la configuration terminée,À droite Pinout view La goupille correspondante sera marquée en vert.

Une fois la configuration de l'horloge externe à grande vitesse terminée ,Entrée Clock Configuration Options,Selon la situation réelle, Configurer l'horloge système pour 72 MHz,Les étapes de configuration sont les suivantes:,Enfin, appuyez sur Entrée, Le logiciel ajuste automatiquement les paramètres de division et d'octave .

Quatre、Configurer le mode de débogage

ST-Link C'est Serial Wire Mode de mise en service,Assurez - vous de régler！！！
Précédemment utilisé M0 La puce, Il n'y a aucun problème à ne pas configurer ce mode , Mais maintenant ce modèle ,Si vous ne configurez pas Serial Wire Mode, Une fois la procédure passée ST-Link Gravé sur puce, La puce ne peut plus être ST-Link Je l'ai identifié..（ Puis j'ai traversé STMISP Programme de gravure d'outils / La normale n'est revenue qu'après l'effacement ）

Cinq、Minuterie（Saisie des entrées）Configuration des paramètres

Je vais TIM2 L'accès à 1 Saisissez le canal d'essai comme entrée ,STM32CubeMX Configuration par défaut PA0 Capturé comme entrée IO Bouche（PA0 Avec cette fonction de multiplexage , Et pas besoin de remap ,Donc automatiquement PA0 Set to TIM_CH1 De GPIO）, Les paramètres du minuteur sont indiqués ci - dessous （ La configuration saisie peut être modifiée sans modification , Capture par défaut du bord ascendant ）：

Le facteur de division de fréquence est 72-1,Ça veut dire... 72 Division des fréquences（0Représentation 1 Division des fréquences,1 Représentation 2 Division des fréquences,Et ainsi de suite.）,TIM2 La fréquence de l'horloge est 72 MHz（Dans la figure ci - dessous,APB1 Timer clocks La fréquence de l'horloge est 72MHz,TIM2 Monté à APB1 Allez.）.Faites - le. 72 Après la séparation des fréquences, La fréquence devient 1MHz,C'est - à - dire compter par seconde 1000000 Une fois.Cycle défini à 1000-1（Il y a une réduction d'un,Je crois. Parce que le nombre minimum est 0）, Représente un cycle de synchronisation complet de 1000 Nombre de fois, Combinaison de la fréquence de comptage du minuteur , Le temps nécessaire pour qu'un minuteur déborde est 1ms.【 La fréquence détermine la période de capture de la capture d'entrée , Le timing est réglé à 1000 Juste pour faciliter le calcul】

La capture d'entrée nécessite l'ouverture du minuteur , Qu'il s'agisse d'un débordement de temps ou d'une capture d'entrée, il faut utiliser pour interrompre .

Six、Générer Keil Ingénierie

Paramètres IDE Et Catalogue et nom du projet ：

Stocker le Code de chaque périphérique dans un autre .c /.h Dans le document,Facile à gérer（ Sinon, tout sera mis dans main.c Moyenne）.

Voici la construction Keil À propos du projet TIM2（Saisie des entrées）Code initialisé：

/* TIM2 init function */
void MX_TIM2_Init(void)
{
    

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

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

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 72 - 1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 1000 - 1;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  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();
  }
  if (HAL_TIM_IC_Init(&htim2) != HAL_OK)
  {
    
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}

Sept、Où est écrit la fonction d'interruption

Lors de l'utilisation de la Bibliothèque standard , Nous écrivons le traitement d'interruption dans la fonction de traitement d'interruption la plus basse ,Par exemple: EXTI0_IRQHandler(),Mais... Hal La Bibliothèque a ajouté une fonction de rappel , Certaines des opérations nécessaires au rez - de - chaussée seront interrompues “Cacher” Debout.（ Si effacer l'interruption ）.

L'ordre d'appel interrompu est （Par EXTI0 Par exemple）：EXTI0_IRQHandler() —> HAL_GPIO_EXTI_IRQHandler() —> HAL_GPIO_EXTI_Callback().

TIM2 La fonction de service d'interruption pour est déjà stm32f1xx_it.c Définition moyenne（STM32CubeMX Généré automatiquement）

/** * @brief This function handles TIM2 global interrupt. */
void TIM2_IRQHandler(void)
{
    
  /* USER CODE BEGIN TIM2_IRQn 0 */

  /* USER CODE END TIM2_IRQn 0 */
  HAL_TIM_IRQHandler(&htim2);
  /* USER CODE BEGIN TIM2_IRQn 1 */

  /* USER CODE END TIM2_IRQn 1 */
}

HAL_TIM_IRQHandler() - Oui. HAL Interruption totale du minuteur de la Bibliothèque , Il y a beaucoup de code dedans ,Pas ici.,Il faut juste qu'on sache un peu——Quand TIM2 Débordement de la valeur de comptage ou autre événement （ Si la capture monte / Signal de bord de descente ）Heure, Le système exécute une série de fonctions de rappel d'interruption , Il s'agit notamment de Fonction de rappel de débordement de compte HAL_TIM_PeriodElapsedCallback() Et Saisissez la fonction de rappel de capture HAL_TIM_IC_CaptureCallback().

Huit、Exemple de test

Le port série a été utilisé dans l'expérience , Non mentionné dans la configuration ci - dessus , La configuration du port série peut être référencée à STM32CubeMx Apprendre（2）USART Expérience de port série

La partie centrale de mon code expérimental est la fonction de rappel d'interruption ：

//  Timer count overflow interruption Processing Callback Function 
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    
	if(IC_DONE_FLAG == 0)  //  Capture incomplète 
	{
    
		if(IC_START_FLAG == 1)  //  Un niveau élevé a été capturé 
		{
    
			IC_TIMES++;  //  Nombre de prises plus un 
		}
	}
}

//Timer input capture interruption Processing Callback Function
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)// Exécution lorsque l'interruption de capture se produit
{
    
	if(IC_DONE_FLAG == 0)  //  Capture incomplète 
	{
    
		if(IC_START_FLAG == 1)  // Il s'avère que c'est haut, Un bord de descente est maintenant capturé 
		{
    
			IC_VALUE = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);  //  Obtenir la valeur de capture 
			TIM_RESET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1);  //  Effacer d'abord les paramètres originaux 
			TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1,TIM_ICPOLARITY_RISING);//  Configuré pour capturer le bord ascendant 
			IC_START_FLAG = 0;  //  Réinitialisation du drapeau 
			IC_DONE_FLAG = 1;  // Terminer une capture de haut niveau
		}
		else  //  La capture n'a pas encore commencé , Première prise au bord ascendant 
		{
    
			IC_TIMES = 0;  //  Nombre de captures effacées 
			IC_VALUE = 0;  //  Valeur de capture zéro 
			IC_START_FLAG = 1;  //  Définir le drapeau qui capture le bord supérieur 
			TIM_RESET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1);  //  Effacer d'abord les paramètres originaux 
			TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1,TIM_ICPOLARITY_FALLING);//  Configuré pour la capture de bord de descente 
		}
		__HAL_TIM_SET_COUNTER(htim,0);  //  Réinitialisation du compteur de temps 
	}
}

Complet main.c

/* USER CODE BEGIN Header */
/** ****************************************************************************** * @file : main.c * @brief : Main program body ****************************************************************************** * @attention * * Copyright (c) 2022 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. * ****************************************************************************** */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
#include <stdio.h>

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

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

/* USER CODE BEGIN PV */


uint32_t IC_TIMES;  //  Nombre de captures ,Unité1ms
uint8_t IC_START_FLAG;  //  Drapeau de début de capture ,1： Haut niveau capturé ;0： Aucun niveau élevé n'a été capturé 
uint8_t IC_DONE_FLAG;  //  Capture du drapeau d'achèvement ,1： Une capture de haut niveau a été effectuée 
uint16_t IC_VALUE;  //  Saisissez la valeur de capture pour la capture 

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

/* USER CODE END 0 */

/** * @brief The application entry point. * @retval int */
int main(void)
{
    
  /* USER CODE BEGIN 1 */
	
	uint32_t time = 0;
  /* 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_TIM2_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1);  //OuvertTIM2Canal de capture pour1
  __HAL_TIM_ENABLE_IT(&htim2,TIM_IT_UPDATE);  //Activer les interruptions de mise à jour
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    
		HAL_Delay(10);
		
		if(IC_DONE_FLAG == 1)  //  Si une capture de haut niveau est terminée 
		{
    
			IC_DONE_FLAG = 0;  // La marque est effacée
			time = IC_TIMES * 1000;  //  Le temps d'impulsion est le nombre de captures  * 1000us
			time += IC_VALUE;  //  Plus le temps de capture （Moins de1msPartie de）
			printf("High level: %d us\n", time);
		}
		
    /* 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};

  /** 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.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 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();
  }
}

/* USER CODE BEGIN 4 */


//  Timer count overflow interruption Processing Callback Function 
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    
	if(IC_DONE_FLAG == 0)  //  Capture incomplète 
	{
    
		if(IC_START_FLAG == 1)  //  Un niveau élevé a été capturé 
		{
    
			IC_TIMES++;  //  Nombre de prises plus un 
		}
	}
}

//Timer input capture interruption Processing Callback Function
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)// Exécution lorsque l'interruption de capture se produit
{
    
	if(IC_DONE_FLAG == 0)  //  Capture incomplète 
	{
    
		if(IC_START_FLAG == 1)  // Il s'avère que c'est haut, Un bord de descente est maintenant capturé 
		{
    
			IC_VALUE = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);  //  Obtenir la valeur de capture 
			TIM_RESET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1);  //  Effacer d'abord les paramètres originaux 
			TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1,TIM_ICPOLARITY_RISING);//  Configuré pour capturer le bord ascendant 
			IC_START_FLAG = 0;  //  Réinitialisation du drapeau 
			IC_DONE_FLAG = 1;  // Terminer une capture de haut niveau
		}
		else  //  La capture n'a pas encore commencé , Première prise au bord ascendant 
		{
    
			IC_TIMES = 0;  //  Nombre de captures effacées 
			IC_VALUE = 0;  //  Valeur de capture zéro 
			IC_START_FLAG = 1;  //  Définir le drapeau qui capture le bord supérieur 
			TIM_RESET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1);  //  Effacer d'abord les paramètres originaux 
			TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_1,TIM_ICPOLARITY_FALLING);//  Configuré pour la capture de bord de descente 
		}
		__HAL_TIM_SET_COUNTER(htim,0);  //  Réinitialisation du compteur de temps 
	}
}
/* 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 */
  __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 */

Effets expérimentaux：

PA0 Correspond à un bouton sur mon tableau de développement , Quand je touche （Non pressé） Quand cette clé est pressée , Le port série imprime constamment des durées de haut niveau inutiles , La durée de ces impulsions indésirables est proche de , Tous. 10ms Gauche et droite, Description la durée du niveau de secousse de la clé est d'environ 10ms.

Quand vous appuyez longtemps sur la touche ,Encore une fois, Imprime l'heure à laquelle la clé est pressée , Comme les données des deux cercles rouges ci - dessous , La première haute durée est 4.35s, La deuxième haute durée est 1.59s.