DFR : Shield 2 moteurs pas-à-pas DRI0023

–

Mise à jour le 30/01/2020 : Shield moteur basé sur le driver A4988 permettant de contrôler 2 moteurs pas-à-pas à partir de 4 sorties digitales jusqu’à 2 A par phase.

Sommaire :

Description du Shield 2 moteurs pas-à-pas DRI0023
Application et mise en oeuvre du pilote moteur DRV8825
Régulation du courant dans les moteurs pas à pas
Explication pour la connexion d’un moteur pas à pas bipolaire
Schéma de câblage et repérage .
Programme permettant de comprendre le principe de fonctionnement
Source d’information
Quelques applications de cette carte
- Prise de mesure avec le laser lidar Lite V3
Pour tout problème
Retour au menu principal de DFRobot
Retour au menu Laser Lidar création d’une tourelle

A suivre cet article est mis à jour régulièrement

Description du Shield 2 moteurs pas-à-pas DRI0023

Shield moteur basé sur deux drivers DRV8825 permettant de contrôler 2 moteurs pas-à-pas à partir de 4 sorties digitales jusqu’à 2 A par phase.

Chaque moteur peut fonctionner en pas complet, demi pas, 1/4 de pas, 1/16 de pas et 1/32 de pas (réglage par dip switch). Ce module est également équipé d’un support pour module Xbee ou compatible.

Les entrées/sorties non utilisées sont disponibles sur un connecteur 3 broches pour le raccordement de capteurs.

Caractéristiques et spécificités.

Information sur le driver :
- Alimentation à prévoir : 8,2 à 45 Vcc (pour les moteurs)
- Sortie : 2 A par phase
- Compatibilité : avec les microcontrôleurs 3,3 V et 5 V
- Réglage du courant : par potentiomètre
- Pilote de moteur : DRV8825 pas à pas bipolaire Microstepping
- Résolution : Six résolutions de micropas différentes (pas complet, 1/2 étape, 1/4 étape, 1/8-étape, 1/16-étape, 1/32-étape)
- Compatibilité ; Convient aux moteurs pas à pas biphasés et à quatre fils.
Information sur la carte en particulier DRI0023 :
- Sorties utilisées : D4, D5, D6 et D7
- Raccordement : borniers à ressorts
- Dimensions : 85 x 55 x 29 mm
- Compatible avec les contrôleurs : Arduino UNO R3 , Leonardo , Mega
- Prends en charge les modules suivants : modules XBee, XBee Wi-Fi, Bluetooth et RF
Référence fabricant : DRI0023

Retour au sommaire

Application et mise en oeuvre du pilote moteur DRV8825

Le DRV8825 fournit une solution de pilote de moteur intégrée pour les imprimantes, scanners et autres applications d’équipement automatisé. L’appareil dispose de deux pilotes de pont en H et d’un indexeur à micropas, et est destiné à entraîner un moteur pas à pas bipolaire. Le bloc de commande de sortie se compose de MOSFET de puissance à canal N configuré comme des ponts en H complets pour entraîner les enroulements du moteur. Le DRV8825 est capable de piloter jusqu’à 2,5 A de courant à partir de chaque sortie (avec dissipation thermique appropriée, à 24 V et 25 ° C).

Une interface STEP / DIR simple permet une interface facile avec les circuits du contrôleur. Les broches de mode permettent de configurer le moteur en mode pas à pas jusqu’à 1/32. Un mode veille de faible puissance est fourni, ce qui coupe les circuits internes pour obtenir une consommation de courant de repos très faible. Ce mode veille peut être défini à l’aide d’une broche nSLEEP dédiée.

Des fonctions d’arrêt internes sont prévues pour les surintensités, les courts-circuits, les verrouillages sous tension et les surchauffes. Les conditions de défaut sont indiquées via la broche nFAULT.

Fonction sur le pilote DRV8825

Retour au sommaire

Régulation du courant dans les moteurs pas à pas

Le courant à travers les enroulements du moteur est régulé par une régulation de courant PWM à fréquence fixe, ou courant haché. Lorsqu’un pont en H est activé, le courant monte à travers l’enroulement à un taux dépendant de la tension continue et l’inductance de l’enroulement. Une fois que le courant atteint le seuil de découpage actuel, le pont se désactive jusqu’au début du prochain cycle PWM.

Dans les moteurs pas à pas, la régulation de courant est utilisée pour faire varier le courant dans les deux enroulements de manière semi-sinusoïdale pour fournir un mouvement fluide.

Le courant de découpage PWM est réglé par un comparateur qui compare la tension aux bornes d’une résistance de détection de courant connecté aux broches xISEN, multiplié par un facteur 5, avec une tension de référence. La tension de référence est entrée sur la broche xVREF.

Le courant de hachage pleine échelle (100%) est calculé dans l’équation suivante .

Exemple:
Si une résistance de détection de 0,25 Ω est utilisée et que la broche VREFx est de 2,5 V, le courant de découpage pleine échelle (100%) sera

2,5 V / (5 x 0,25 Ω) = 2 A.

La tension de référence est mise à l’échelle par un DAC interne qui permet un pas fractionnaire d’un moteur pas à pas bipolaire.

Retour au sommaire

Explication pour la connexion d’un moteur pas à pas bipolaire

Les moteurs pas à pas bipolaires ont généralement quatre ou six conducteurs. Ces moteurs pas à pas à deux phases ont une bobine par phase, avec un fil connecté à chaque extrémité de chaque bobine. Les versions à six conducteurs permettent également d’accéder aux centres des deux bobines, de sorte que le moteur peut éventuellement être commandé par un pilote unipolaire. Lors du contrôle d’un moteur pas à pas à six dérivations avec un pilote bipolaire , seules les extrémités des bobines sont utilisées et les deux dérivations de prise centrales doivent être laissées déconnectées.

Retour au sommaire

Schéma de câblage et repérage du driver

DRI0023 – Documentation de la carte avec le schéma de câblage

DRI0023 – Schéma de câblage côté moteur pas à pas

Retour au sommaire

Programme permettant de comprendre le principe de fonctionnement

//
//
//*********************************************************************
//*                                                                   *
//* Programme permettant de piloter les 2 moteurs pas à pas           *
//* afin de tester le principe de fonctionnement de la carte          *
//*                                                                   * 
//*                                                                   *
//* RedOhm                                                            *
//* Programme : H-Mazelin                                             *
//* Le 17-11-2019                                                     *
//*                                                                   *
//* Version de IDE Arduino 1.8.8                                      *
//* Nom du programme :                                                * 
//* Principe de fonctionnement                                        *
//* Notre site : https://www.redohm.fr                                *
//*                                                                   *
//*********************************************************************
 



// on declare la broche pour donner le sens de la direction au moteur 1
int M1dirpin = 4;
// declaration de la broche pour la vitesse et le nombre de pas moteur 1
int M1steppin = 5;
// on declare la broche pour donner le sens de la direction au moteur 2
int M2dirpin = 7;
// declaration de la broche pour la vitesse et le nombre de pas moteur 2
int M2steppin = 6;

// La fonction setup () est exécutée une fois lorsque le programme démarre. 
// Il sert à définir les propriétés d'environnement initiales 
// au démarrage du programme.
void setup()
{

  // Affectation des broches en sorties 
  pinMode(M1dirpin,OUTPUT);
  pinMode(M1steppin,OUTPUT);
  pinMode(M2dirpin,OUTPUT);
  pinMode(M2steppin,OUTPUT);


  //Declaration de variable j en entier  
  int j;
  // Met le programme en pause pendant la durée (en microsecondes)
  // spécifiée par le paramètre. Il y a mille microsecondes en une 
  // milliseconde et un million de microsecondes en une seconde.
  delayMicroseconds(2);
  // Met un niveau logique LOW sur la broche numérique pour valider la 
  // direction du moteur 1 et 2 pour faire tourner le moteur en sens inverse
  // il faudra appliquer la valeur HIGH 
  digitalWrite(M1dirpin,LOW);
  digitalWrite(M2dirpin,LOW);
  // Demarrage d'une boucle de 15000 afin de generer le nombre de pas 
  // à parcourir 
  for(j=0;j<=15000;j++  )
    {
    // le passage de l'etat haut à l'etat bas genere un train d'impulsion 
    // les temporisations definissent la vitesse de la rotation des moteurs   
    digitalWrite(M1steppin,LOW);
    digitalWrite(M2steppin,LOW);
    delayMicroseconds(2);
    digitalWrite(M1steppin,HIGH);
    digitalWrite(M2steppin,HIGH);
    delay(1);
  }

  
}


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

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

//* *

//* Programme permettant de piloter les 2 moteurs pas à pas *

//* afin de tester le principe de fonctionnement de la carte *

//* *

//* RedOhm *

//* Programme : H-Mazelin *

//* Le 17-11-2019 *

//* *

//* Version de IDE Arduino 1.8.8 *

//* Nom du programme : *

//* Principe de fonctionnement *

//* Notre site : https://www.redohm.fr *

//* *

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

// on declare la broche pour donner le sens de la direction au moteur 1

int M1dirpin = 4;

// declaration de la broche pour la vitesse et le nombre de pas moteur 1

int M1steppin = 5;

// on declare la broche pour donner le sens de la direction au moteur 2

int M2dirpin = 7;

// declaration de la broche pour la vitesse et le nombre de pas moteur 2

int M2steppin = 6;

// La fonction setup () est exécutée une fois lorsque le programme démarre.

// Il sert à définir les propriétés d'environnement initiales

// au démarrage du programme.

void setup()

{

// Affectation des broches en sorties

pinMode(M1dirpin,OUTPUT);

pinMode(M1steppin,OUTPUT);

pinMode(M2dirpin,OUTPUT);

pinMode(M2steppin,OUTPUT);

//Declaration de variable j en entier

int j;

// Met le programme en pause pendant la durée (en microsecondes)

// spécifiée par le paramètre. Il y a mille microsecondes en une

// milliseconde et un million de microsecondes en une seconde.

delayMicroseconds(2);

// Met un niveau logique LOW sur la broche numérique pour valider la

// direction du moteur 1 et 2 pour faire tourner le moteur en sens inverse

// il faudra appliquer la valeur HIGH

digitalWrite(M1dirpin,LOW);

digitalWrite(M2dirpin,LOW);

// Demarrage d'une boucle de 15000 afin de generer le nombre de pas

// à parcourir

for(j=0;j<=15000;j++ )

{

// le passage de l'etat haut à l'etat bas genere un train d'impulsion

// les temporisations definissent la vitesse de la rotation des moteurs

digitalWrite(M1steppin,LOW);

digitalWrite(M2steppin,LOW);

delayMicroseconds(2);

digitalWrite(M1steppin,HIGH);

digitalWrite(M2steppin,HIGH);

delay(1);

}

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

void loop()

{

}

Retour au sommaire

Source d’information

Source d’information ;

Wiki.dfrobot.com . Pour toute la partie technique de la carte
Texas instruments . Pour le circuit DRV8825

Documentation technique :

Schéma électronique de la carte DRI 0023 ( pdf )
Fiche technique du pilote DRV8825 de chez Texas Instrument

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 celles qui vous intéressent .

Facebook Twitter Youtube

Retour au sommaire