- Version
- Télécharger 305
- Taille du fichier 0.19 KB
- Date de création 16 février 2022
- Télécharger
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 )
Tuto - Moteur pas a pas comment l'utiliser simplement |
.
.
Code Arduino |
Code principal :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 (); } |
.
Onglet de selection de la marche avant et arriere :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
// // 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//============================================== //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(); } } |
.
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 .