Controle d’un moteur pas a pas comme un moteur asynchrone

Version
Télécharger 368
Taille du fichier 0.19 KB
Date de création 16 février 2022
Télécharger

Bonjour,
Cette page va bientôt être supprimée et remplacée par une nouvelle référence dédiée aux moteurs pas à pas. Vous trouverez désormais l’intégralité de la documentation technique (codes, schémas et tutoriels) à cette adresse :

[Lien]. https://www.redohm.fr/download/le-hub-ultime-des-tutos-sur-les-moteurs-pas-a-pas/

N’hésitez pas à consulter cette nouvelle page, qui s’inscrit dans un ensemble plus complet de ressources sur les moteurs pas à pas

Mise à jour le 18/02/2022 : Cet article a pour but de vous expliquer le fonctionnement d'un moteur pas-à-pas le plus simplement possible ,c'est à dire en utilisant un bouton qui va nous permettre de sélectionner la marche avant ou la marche arrière avec un potentiomètre nous permettant de définir la vitesse que l'on souhaite obtenir.

Sommaire :

Important pour le réglage du courant sur les drivers
Tuto - Moteur pas a pas comment l'utiliser simplement
Programme en 3 onglets
- Onglet principal ( configuration des entrees sorties etc.. )
- Onglet 01_marche_av_ar selection de la direction
- Onglet deplacement_moteur traitant de la vitesse du moteur
Pour tout probléme.
Retour au menu des moteurs pas à pas.

Le réglage du courant sur les drivers

Information importante pour le réglage du courant : Pour un moteur donné, plus le courant du driver est élevé, plus le couple est élevé, mais cela entraîne plus d’échauffement dans le moteur et le driver. Par conséquent, le courant de sortie est en général ajusté de façon à éviter une surchauffe du moteur lors d’une utilisation prolongée. Le raccordement en série ou en parallèle des bobinages modifie de manière significative les inductance et résistance résultantes d’où l’importance d’en tenir compte lors du choix du courant de sortie. L’intensité communiquée par le fabricant du moteur est importante pour sélectionner le courant, mais il faut également tenir compte du mode de raccordement.

En règle générale pour optimiser les performances du moteur il suffit d’utiliser une tension aussi élevée que possible (attention de ne pas dépasser la tension max du driver par sécurité choisissez toujours une tension max -10%) ce qui permet d’avoir un couple plus élevé. Mais il faut impérativement limiter le courant nominale du driver à celui du moteur.

À savoir: certains drivers nous donnent la possibilité d’avoir un système d’auto-configuration , ce qui permet d’obtenir des performances optimum ( sur le DM860 par exemple )

Retour au sommaire

Tuto - Moteur pas a pas comment l'utiliser simplement

Retour au sommaire

Code Arduino

Code principal :

//***********************************************************
// RedOhm
// le 20/01/2022
//
// Pilotage d'un moteur pas a pas comme un moteur asynchrone
//
// but :
// 1 - creation d'un generateur d'impulsion pour la vitesse du moteur
// ( avec la fonction micros() )
// 2 - Creation de la fonction debrayage du moteur
// 3 - Pilotage marche avant et marche arriere a l'aide d'un bouton inverseur
// 4 - Possibilite de modifier la vitesse par le biai d'un potentiometre
//
//
// Ce programme est un logiciel libre: vous pouvez le redistribuer
// et / ou le modifier
// Ce programme est distribué dans l'espoir qu'il vous sera utile,
//
// Par: Mazelin Herve
// IDE Arduino 1.8.13
//**********************************************************


//**********************************************************
//    base de temps pour le train impulsion du driver
//
//**********************************************************

// Declaration des variables demarrage
// unsigned long-> déclare une variable de type long non signé
// pour la base de temps il y a 1 000 microsecondes dans une milliseconde
//                     et
// 1 000 000 microsecondes dans une seconde.
unsigned long demarrage = micros();

// Declaration des variables
// int -> declare une variable du type int (pour integer, entier en anglais)
// elles peuvent stocker des valeurs de - 32 768 à 32 767
int base_de_temps1 = 1 ;



// Definit le sens de rotation en fonction de l'etat bas ou haut
int DIR = 12;
// ce signal est utilisé pour permettre ou interdire l’utilisation du
// driver. Le moteur est hors tension
// une impulsion montante ou descendante sur cette entrée fait
// avancer le moteur d’un pas. La tension de l’impulsion doit
// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.
// La largeur d’impulsion doit être de minimum 2,5 μs pour un
// fonctionnement correct.
int PUL = 11;
// ce signal est utilisé pour permettre ou interdire l’utilisation du
// driver. Le moteur est hors tension
int ENA = 13;

// declaration de variable x
int x ;
// creation de la variable de base de temps pour le train d'impulsion
// pour le driver
int vitesse ;

// declaration de l'inter 3 positions
int marche_avant = 3;// declaration de la pin 3 pour la marche avant
int marche_avant_variable ;// declaration de la variable de transfert
int marche_arriere = 4;// declaration de la pin 4 pour la marche arriere
int marche_arriere_variable ;// declaration de la variable de transfert

int passage_avant = 0 ;
int passage_arriere = 0 ;

// declaration de l'entree analogique 1 pour la consigne vitesse
// par le potentiometre
int consigne = A1 ;


//  Un programme Arduino doit impérativement contenir cette fonction
//  Elle ne sera exécutee une seule fois au démarrage du microcontroleur
//  Elle sert à configurer globalement les entrées sorties
void setup() {

  // initialisation de la connexion série
  // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
  Serial.begin(115200);
  // on attent que le port de communication soit pret
  while (!Serial) {
    ;
  }

  // Configure la broche spécifiée pour qu'elle se comporte soit en entrée,
  // soit en sortie.
  // Configuration des broches pour le driver
  pinMode (PUL, OUTPUT);
  pinMode (DIR, OUTPUT);
  pinMode (ENA, OUTPUT);
  // Configuration des broches pour les boutons
  pinMode (marche_avant, INPUT_PULLUP); //Bouton marche avant
  pinMode (marche_arriere, INPUT_PULLUP); //Bouton marche arriere
}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()
void loop() {

  // lecture de l'entree numerique qui me determine la direction
  marche_avant_variable = digitalRead(marche_avant);
  marche_arriere_variable = digitalRead(marche_arriere);

  // lecture de l'entree analogique qui me determine la valeur
  // de la vitesse
  x = analogRead(consigne);
  // la base de temps et defini en fonction du nombre de point
  // par tours sur votre driver
  vitesse = map ( x, 1023, 0, 3500, 0);

  selection_av_ar ();

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

//***********************************************************

// RedOhm

// le 20/01/2022

// Pilotage d'un moteur pas a pas comme un moteur asynchrone

// but :

// 1 - creation d'un generateur d'impulsion pour la vitesse du moteur

// ( avec la fonction micros() )

// 2 - Creation de la fonction debrayage du moteur

// 3 - Pilotage marche avant et marche arriere a l'aide d'un bouton inverseur

// 4 - Possibilite de modifier la vitesse par le biai d'un potentiometre

// Ce programme est un logiciel libre: vous pouvez le redistribuer

// et / ou le modifier

// Ce programme est distribué dans l'espoir qu'il vous sera utile,

// Par: Mazelin Herve

// IDE Arduino 1.8.13

//**********************************************************

// base de temps pour le train impulsion du driver

//**********************************************************

// Declaration des variables demarrage

// unsigned long-> déclare une variable de type long non signé

// pour la base de temps il y a 1 000 microsecondes dans une milliseconde

// et

// 1 000 000 microsecondes dans une seconde.

unsigned long demarrage = micros();

// Declaration des variables

// int -> declare une variable du type int (pour integer, entier en anglais)

// elles peuvent stocker des valeurs de - 32 768 à 32 767

int base_de_temps1 = 1 ;

// Definit le sens de rotation en fonction de l'etat bas ou haut

int DIR = 12;

// ce signal est utilisé pour permettre ou interdire l’utilisation du

// driver. Le moteur est hors tension

// une impulsion montante ou descendante sur cette entrée fait

// avancer le moteur d’un pas. La tension de l’impulsion doit

// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.

// La largeur d’impulsion doit être de minimum 2,5 μs pour un

// fonctionnement correct.

int PUL = 11;

// ce signal est utilisé pour permettre ou interdire l’utilisation du

// driver. Le moteur est hors tension

int ENA = 13;

// declaration de variable x

int x ;

// creation de la variable de base de temps pour le train d'impulsion

// pour le driver

int vitesse ;

// declaration de l'inter 3 positions

int marche_avant = 3;// declaration de la pin 3 pour la marche avant

int marche_avant_variable ;// declaration de la variable de transfert

int marche_arriere = 4;// declaration de la pin 4 pour la marche arriere

int marche_arriere_variable ;// declaration de la variable de transfert

int passage_avant = 0 ;

int passage_arriere = 0 ;

// declaration de l'entree analogique 1 pour la consigne vitesse

// par le potentiometre

int consigne = A1 ;

// Un programme Arduino doit impérativement contenir cette fonction

// Elle ne sera exécutee une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(115200);

// on attent que le port de communication soit pret

while (!Serial) {

;

}

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée,

// soit en sortie.

// Configuration des broches pour le driver

pinMode (PUL, OUTPUT);

pinMode (DIR, OUTPUT);

pinMode (ENA, OUTPUT);

// Configuration des broches pour les boutons

pinMode (marche_avant, INPUT_PULLUP); //Bouton marche avant

pinMode (marche_arriere, INPUT_PULLUP); //Bouton marche arriere

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

// lecture de l'entree numerique qui me determine la direction

marche_avant_variable = digitalRead(marche_avant);

marche_arriere_variable = digitalRead(marche_arriere);

// lecture de l'entree analogique qui me determine la valeur

// de la vitesse

x = analogRead(consigne);

// la base de temps et defini en fonction du nombre de point

// par tours sur votre driver

vitesse = map ( x, 1023, 0, 3500, 0);

selection_av_ar ();

}

Retour au sommaire

Onglet de selection de la marche avant et arriere :

//
//  selection marche avant marche arriere
//

void selection_av_ar ()

{
 
  // marche avant moteur = 0 ou Low logique inversée
  // verification si l'interrupteur est bien sur la position 
  // marche avant
  if (marche_avant_variable == 0 )
  {
    //validation de la marche avant sur le driver 
    digitalWrite(DIR, LOW);
    //activation du driver  
    digitalWrite(ENA, HIGH);
    // aller au sous programme deplacement 
    deplacement ();
    // envoie du message à l'operateur
    if (passage_avant == 0 )
    {
      Serial.println("Marche avant");
      passage_avant = 1;
    }
  }

  // marche arriere moteur = 0 ou Low logique inversée 
  // verification si l'interrupteur est bien sur la position 
  // marche arriere  
  else if (marche_arriere_variable == 0 )
  {
    //validation de la marche arriere sur le driver 
    digitalWrite(DIR, HIGH);
    //activation du driver  
    digitalWrite(ENA, HIGH);
    // aller au sous programme deplacement 
    deplacement ();

    // controle d'affichage 
    if (passage_arriere == 0 )
    {
      Serial.println("Marche arriere");
      passage_arriere = 1;
    }
  }
  

  // verification si l'interrupteur est bien au centre 
  else if ((marche_avant_variable == 1 )&&(marche_arriere_variable == 1))
  {
    
    digitalWrite(ENA, LOW);// blocage du driver 
    // envoie du message à l'operateur
    // 1 seul fois afin de ne pas occuper le bus serie 
    if ((passage_avant == 1 )||(passage_arriere== 1))
    {
      Serial.println("Arret ");
      passage_avant = 0;
      passage_arriere = 0 ;
    }

  }
  
}

// selection marche avant marche arriere

void selection_av_ar ()

{

// marche avant moteur = 0 ou Low logique inversée

// verification si l'interrupteur est bien sur la position

// marche avant

if (marche_avant_variable == 0 )

{

//validation de la marche avant sur le driver

digitalWrite(DIR, LOW);

//activation du driver

digitalWrite(ENA, HIGH);

// aller au sous programme deplacement

deplacement ();

// envoie du message à l'operateur

if (passage_avant == 0 )

{

Serial.println("Marche avant");

passage_avant = 1;

}

// marche arriere moteur = 0 ou Low logique inversée

// verification si l'interrupteur est bien sur la position

// marche arriere

else if (marche_arriere_variable == 0 )

{

//validation de la marche arriere sur le driver

digitalWrite(DIR, HIGH);

//activation du driver

digitalWrite(ENA, HIGH);

// aller au sous programme deplacement

deplacement ();

// controle d'affichage

if (passage_arriere == 0 )

{

Serial.println("Marche arriere");

passage_arriere = 1;

}

// verification si l'interrupteur est bien au centre

else if ((marche_avant_variable == 1 )&&(marche_arriere_variable == 1))

{

digitalWrite(ENA, LOW);// blocage du driver

// envoie du message à l'operateur

// 1 seul fois afin de ne pas occuper le bus serie

if ((passage_avant == 1 )||(passage_arriere== 1))

{

Serial.println("Arret ");

passage_avant = 0;

passage_arriere = 0 ;

}

Onglet de selection pour la vitesse :

//==============================================
//Fonction de deplacement du moteur
//  creation du train d'impulsion 
//==============================================

void deplacement()
{
  
  // la ligne if  effectue la difference entre le temps actuel et le
  // temps de debut de boucle .
  if (micros() - demarrage > vitesse)
  {
    //Inversion de la valeur de la variable memoire et envoie l'information
    //à la broche
    digitalWrite(PUL, base_de_temps1 = !base_de_temps1);
    // on reinitialise la variable demarrage avec le contenu de micros()
    demarrage = micros();

  }
}

//==============================================

//Fonction de deplacement du moteur

// creation du train d'impulsion

//==============================================

void deplacement()

{

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .

if (micros() - demarrage > vitesse)

{

//Inversion de la valeur de la variable memoire et envoie l'information

//à la broche

digitalWrite(PUL, base_de_temps1 = !base_de_temps1);

// on reinitialise la variable demarrage avec le contenu de micros()

demarrage = micros();

}

Retour au sommaire

Pour tout probléme

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour au sommaire