Moteur pas à pas de contrôle STM32 : entraînement de moteur pas à pas en boucle fermée basé sur l'interruption de minuterie de la bibliothèque HAL + contrôle précis du nombre d'impulsions

Enterprise 2023-08-26 03:25:41 views: null

Moteur pas à pas de contrôle STM32 : entraînement de moteur pas à pas en boucle fermée basé sur l'interruption de minuterie de la bibliothèque HAL + contrôle précis du nombre d'impulsions

1. Pilote en boucle fermée de moteur pas à pas

Le pilote en boucle fermée du moteur pas à pas utilisé dans cet article est le pilote en boucle fermée du moteur pas à pas Emm42_V4.0. Le pilote en boucle fermée dispose de son propre algorithme de contrôle vectoriel en boucle fermée FOC, qui peut réaliser un contrôle en trois boucles du couple, de la vitesse et de la position.
Comme le montre la figure ci-dessous, les A+, A-, B+ et B- du pilote de moteur en boucle fermée à 42 étapes sont connectés au moteur pas à pas, et le moteur pas à pas est entraîné et contrôlé via l'activation, l'impulsion et bornes de direction à droite.

Deux, configuration CubeMx

La configuration de l'horloge est requise en premier.

1、Configuration de l'horloge

insérer la description de l'image ici
Avant de configurer l'horloge, vous devez d'abord ouvrir le RCC dans Brochage et configuration, sélectionner Résonateur cristal/céramique pour ouvrir l'oscillateur à cristal externe.
Définissez ensuite les paramètres en fonction de la fréquence de l'oscillateur à cristal externe de votre microcontrôleur, comme indiqué dans la figure ci-dessous.
insérer la description de l'image ici

2. Configuration de la minuterie du terminal d'impulsion

Revenez à nouveau à Brochage et configuration, sélectionnez la minuterie de votre choix dans Minuteries, ici je choisis la minuterie 2, puis j'allume l'horloge interne (Source de l'horloge : Horloge interne).
Configurez la fonction du canal comme sortie PWM (génération PWM). Ici, j'ai utilisé 4 moteurs pas à pas, donc 4 canaux ont été sélectionnés. (La vidéo suivante montre uniquement un moteur pas à pas, et il en va de même pour les autres moteurs pas à pas. Le câblage et le programme supplémentaire seront corrects.)
Ensuite, ouvrez les paramètres NVIC pour activer l'interruption de la minuterie. Comme indiqué ci-dessous.
insérer la description de l'image ici
Ensuite, réglez la fréquence de la minuterie en fonction de l'horloge que vous avez définie à l'étape précédente et de la fréquence que votre lecteur peut transporter.
Par exemple, la fréquence d'impulsion maximale du pilote que j'utilise est de 120 KHZ et la vitesse maximale est de plus de 2 200 tours, c'est-à-dire que si je veux atteindre la vitesse la plus élevée, je peux configurer un moteur pas à pas avec un angle de pas de 1,8° pour être 16 subdivisions, soit (360 ÷ 1,8) × 16 = 3200 impulsions pour un tour ( le nombre d'impulsions de commande sera mentionné ci-dessous), puis utiliser 120K ÷ 3200 = 37,5 tours/s, soit 2250 tours par minute. Comme le montre la figure ci-dessous, mon tim2 appartient à APB1 et le réglage de l'horloge est de 84 MHz.
insérer la description de l'image ici
Le microcontrôleur que j'utilise est le STM32F407, donc le bus APB1 correspond ici aux timers généraux tim2 ~ 5, aux timers de base tim6, tim7 et aux timers généraux tim12 ~ 14. Le bus APB2 correspond aux temporisateurs avancés tim1, tim8 et aux temporisateurs à usage général tim9 ~ 11.
Faites donc attention à ne pas utiliser à mauvais escient la fréquence d'horloge du temporisateur APB1 comme fréquence d'horloge APB2 .
Par conséquent, en prenant ma configuration comme exemple, utilisez 84M ÷ 120K = 700, puis utilisez ces 700 pour allouer le coefficient de pré-échelle et la période de comptage, comme indiqué dans la figure ci-dessous. Ici, pour faciliter le réglage ultérieur du cycle de service PWM, la période de comptage est fixée à 100, puis le PSC est à 7.
Formule : fréquence de sortie PWM = fréquence d'horloge de la minuterie ÷ ((psc+1) × (arr + 1)).
insérer la description de l'image ici

Utilisez un oscilloscope pour vérifier s'il y a un problème avec la fréquence et la forme d'onde. Le programme utilisé ici sera décrit en détail ci-dessous, avec un rapport cyclique de 50 % et une fréquence de 120 KHZ.
insérer la description de l'image ici

3. Activer et configurer la configuration des broches du terminal

Comme le montre la figure ci-dessous, cliquez avec le bouton gauche sur la broche que vous souhaitez utiliser pour la configurer comme sortie, ce qui est très simple. Ici, j'utilise PC0-4 comme terminal d'activation et PG0-4 comme terminal de direction. Vous pouvez choisir les broches qui n'occuperont pas les fonctions dont vous avez besoin comme de simples broches de sortie de niveau haut et bas en fonction de vos besoins.
insérer la description de l'image ici
Entrez ensuite dans le gestionnaire de projet pour configurer le nom du projet et l'environnement de compilation, générer les fichiers .c, .h, etc., et tout ira bien.

Trois, programme de moteur pas à pas de contrôle d'interruption de minuterie STM32F407

Mettez d'abord le schéma de configuration des broches, le programme semble un peu plus clair.

0. Schéma de configuration des broches

La configuration des broches est indiquée ci-dessous.
insérer la description de l'image ici

1. La fonction de la bibliothèque HAL utilisée

La fonction de ces deux fonctions sera expliquée ci-dessous.

HAL_TIM_PWM_Stop(&htimx,TIM_CHANNEL_x);
HAL_TIM_PWM_Start(&htimx,TIM_CHANNEL_x);

2. Configuration d'initialisation de la minuterie de déclenchement d'impulsion

Dans le projet généré par CubeMx, il vous suffit de trouver le programme d'initialisation en fonction du timer précédemment défini, puis d'ajouter le programme suivant à la fin du programme, mais vous devez configurer les paramètres en fonction du timer et du canal que vous configurez . S'il est réglé sur la minuterie 2, appuyez simplement sur Ctrl F pour rechercher MX_TIM2_Init.

// 添加程序
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);

La fonction HAL_TIM_PWM_Start est une fonction pour démarrer la sortie PWM, qui correspond aux 4 canaux du timer 2 comme indiqué ci-dessus. Ce qui suit est la fonction d'initialisation modifiée initiale que j'ai générée sur la base de la bibliothèque HAL. Le sConfigOC est proposé pour faciliter l'écriture de la fonction de réglage PWM ci-dessous. Les deux étapes sont nécessaires.

/* ============================== 步进电机脉冲触发定时器初始化 ============================== */

TIM_HandleTypeDef htim2;
TIM_OC_InitTypeDef Motor_PWM_sConfigOC = {
    
    0};

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

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

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 7-1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 100-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_PWM_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();
  }
  Motor_PWM_sConfigOC.OCMode = TIM_OCMODE_PWM1;
  Motor_PWM_sConfigOC.Pulse = 0;
  Motor_PWM_sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  Motor_PWM_sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    
    
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    
    
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    
    
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  {
    
    
    Error_Handler();
  }

  HAL_TIM_MspPostInit(&htim2);
	
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);

}

3. Réglage des impulsions du moteur pas à pas

Comme indiqué ci-dessous, prenez le moteur pas à pas 1 comme exemple, arrêtez d'abord la sortie PWM du canal 1 de la minuterie 2, puis définissez le cycle de service, configurez le canal et rallumez le PWM. HAL_TIM_PWM_Stop est une fonction pour arrêter la sortie PWM du timer x canal x.

void Motor1_pwm_Set(int motor1_n)
{
    
    
   HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
   Motor_PWM_sConfigOC.Pulse = motor1_n;
   HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_1);
   HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
}

4. Activer, désactiver et changer la direction du moteur pas à pas

Comme indiqué ci-dessous, configurez les niveaux haut et bas.

void Motor1_enable(void)			// 电机1使能
{
    
    
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
}
void Motor1_disable(void)			// 电机1失能
{
    
    
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
}
void Motor1_course(char course_mod)			// 电机1改变方向
{
    
    
	if(course_mod == 1){
    
    HAL_GPIO_WritePin(GPIOG, GPIO_PIN_0, GPIO_PIN_SET);}		// 正转
	else if(course_mod == 0){
    
    HAL_GPIO_WritePin(GPIOG, GPIO_PIN_0, GPIO_PIN_RESET);}			// 反转
}

5. Le moteur pas à pas tourne vers l'avant programme main.c

Démarrez le moteur pas à pas 1, réglez le cycle de service à 50 % et tournez vers l'avant.

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();
  /* USER CODE BEGIN 2 */
	Motor_PWM_MX_TIM2_Init();
	Motor_PWM_MX_TIM2_Init();	// 定时器初始化

	Motor1_pwm_Set(50);		// 设置占空比为50%(50/100)
	Motor1_course(1);		// 正转
	Motor1_enable();		// 使能
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */
}

6. Démonstration d'effet vidéo

commande de moteur pas à pas

4. Le moteur pas à pas en boucle fermée contrôle avec précision le nombre d'impulsions

1. La fonction de la bibliothèque HAL utilisée

De même, les fonctions de ces trois fonctions seront expliquées ci-dessous.

HAL_TIM_PWM_Start_IT(&htimx, TIM_CHANNEL_x);
HAL_TIM_PWM_Stop_IT(&htimx, TIM_CHANNEL_x);
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim);

2. Changer la fréquence d'impulsion du moteur pas à pas

Tout d'abord, définissez le nombre de pas de subdivision du moteur pas à pas sur 16, comme indiqué dans la figure ci-dessous, un moteur pas à pas avec un angle de pas de 1,8° est utilisé ici. Avec cette configuration de paramètres, 16 impulsions sont envoyées pour tourner de 1,8°, donc les impulsions nécessaires pour effectuer un tour sont (360° ÷ 1,8°) × 16 = 3 200 impulsions.
insérer la description de l'image ici
Sur la base du pilote de moteur pas à pas ci-dessus, je souhaite modifier la vitesse à environ 5 tours/s, nous devrions donc modifier la fréquence d'impulsion à 120 KHZ. En utilisant les 3 200 impulsions par tour mentionnées ci-dessus, 16 000 impulsions sont nécessaires pour 5 tours, changez donc 120 KHZ en 16 KHZ. Calculez ensuite à nouveau le PSC, qui est (84M ÷ 16K) ÷ 100 = 52,5.
Modifiez le PSC dans l'initialisation de la minuterie de déclenchement d'impulsion du moteur pas à pas ci-dessus Motor_PWM_MX_TIM2_Init à 53 :

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 53-1;

Dans le même temps, la fonction HAL_TIM_PWM_Start() précédente doit être supprimée, c'est-à-dire que le programme suivant doit être supprimé :

  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);

3. Modifier le programme de réglage des impulsions du moteur pas à pas

Comme nous n'utilisons plus HAL_TIM_PWM_Start et HAL_TIM_PWM_Stop, ces deux fonctions doivent également être supprimées lors du changement de programme. Prenons l'exemple du moteur pas à pas 1, passez au programme suivant :

void Motor1_pwm_Set(int motor1_n)
{
    
    
   Motor_PWM_sConfigOC.Pulse = motor1_n;
   HAL_TIM_PWM_ConfigChannel(&htim2, &Motor_PWM_sConfigOC, TIM_CHANNEL_1);
}

Bien sûr, il convient de noter que la fonction que nous avons définie maintenant n'a pas de programme pour arrêter PWM, nous devons donc nous rappeler d'appeler HAL_TIM_PWM_Stop_IT pour désactiver la sortie de la minuterie PWM avant de modifier le PWM .

4. Fonction de rappel d'interruption de la minuterie PWM

Avant d'utiliser l'interruption du timer, n'oubliez pas de redéfinir la fonction de rappel du timer dans votre programme.
Ajoutez éventuellement le programme suivant à votre stm32f4xx_it.c :

/* USER CODE BEGIN 1 */
int PWM_num = 0;	// 脉冲数
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
    
    
	if(htim->Instance == htim2.Instance)	// 确认是否为步进电机脉冲中断的回调
	{
    
    
		PWM_num ++;
		if(PWM_num >= 3200)		// 第3200次（一圈）
		{
    
    
			PWM_num = 0;
			HAL_TIM_PWM_Stop_IT(&htim2, TIM_CHANNEL_1);		// 停止输出PWM
			//HAL_GPIO_TogglePin(GPIOF, GPIO_PIN_10);		// 翻转led灯电平 
		}
	}
}
/* USER CODE END 1 */

Dans le programme ci-dessus, vous pouvez voir que PWM_num s'accumule, et il sera accumulé une fois à chaque fois que la fonction de rappel est appelée. Nous appellerons la fonction HAL_TIM_PWM_Start_IT une fois dans la fonction principale. Vous pouvez le deviner en devinant. Le but de ceci La fonction est de permettre à la minuterie de produire du PWM. Et la fonction de rappel est appelée à chaque fois qu'une impulsion est envoyée .
Comme le montre la figure ci-dessous, la bibliothèque de fonctions HAL pointée par la flèche a été écrite pour nous et elle appellera notre fonction de rappel d'interruption mentionnée ci-dessus.
insérer la description de l'image ici

5. Le moteur pas à pas tourne d'un cercle vers l'avant et le programme main.c en boucle fermée

Voici le programme de fonction principal :

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();
  /* USER CODE BEGIN 2 */
	Motor_PWM_MX_TIM2_Init();
	
	Motor1_pwm_Set(50);
	HAL_TIM_PWM_Start_IT(&htim2, TIM_CHANNEL_1);
	Motor1_course(1);
	Motor1_enable();

  /* USER CODE END 2 */

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

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

6. Démonstration d'effet vidéo

Moteur pas à pas en boucle fermée - contrôle précis du nombre d'impulsions

5. Lien du programme

Le programme a été empaqueté et téléchargé sur les ressources de csdn.
CSDN: bibliothèque HAL STM32F407 programme de moteur pas à pas de contrôle d'interruption de minuterie
CSDN: bibliothèque HAL STM32F407 contrôle d'interruption de minuterie moteur pas à pas en boucle fermée le numéro d'impulsion de contrôle précis
peut également être téléchargé via le lien suivant:

Programme de moteur pas à pas de contrôle d'interruption de minuterie STM32F407 :
lien : https://pan.baidu.com/s/1svRzVW_7elkHg7wwQ4AN5A
code d'extraction : hpzq
STM32F407 contrôle d'interruption de minuterie numéro d'impulsion de contrôle de précision du moteur pas à pas en boucle fermée :
lien : https://pan .baidu .com/s/1QIyusKAbusqyMl_VTkjKxg
Code d'extraction : 4rml

Je suis étudiant et j'étudie actuellement. Cet article peut être considéré comme mes notes d'étude. Veuillez me corriger si je me trompe.

Je suppose que tu aimes

Origine blog.csdn.net/xztli/article/details/127179256
conseillé
Classement
du quotidien
Plus
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)
2024-07-12(0)
2024-07-11(0)
2024-07-10(0)
2024-07-09(0)
2024-07-08(0)

Code World

© 2018 codetd.com