Mise à jour le 13/02/2022 .
Sommaire :
- Câblage et principe de fonctionnement d’un moteur pas a pas avec frein électromagnétique.
- Masse commune.
- Alimentation 5Vdc circuit microcontrôleur.
- Alimentation 24Vdc driver moteur pas a pas.
- Connexions du driver en collecteur ouvert (anode commune)
- Cablage du signal de direction
- Cablage du signal de vitesse de rotation
- Principe de fonctionnement pour la partie débrayage
- Programme pour le pilotage du moteur pas à pas avec frein
- Tutoriel
- A savoir sur l’utilisation des informations de cet article .
- Retour au menu les moteurs pas à pas
.
|
.
Câblage et principe de fonctionnement d’un moteur pas a pas avec frein électromagnétique.
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 )
Création de la masse commune
Alimentation 5Vdc circuit microcontrôleur
Alimentation 24Vdc du driver
Connexions du driver en collecteur ouvert (anode commune)
Cablage du signal pour le choix de la direction
- Validation de DIR (fil violet) ce signal doit être appliqué minimum 5 μs avant le signal PUL. La tension du signal DIR doit être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS,et activation du frein electromagnetique
Retour au sommaire
Câblage de l’information vitesse.
Validation de PUL(fil vert). Défini la vitesse de rotation et le nombre de pas (distance ) La largeur d’impulsion doit être de minimum 2,5 μs pour un fonctionnement correct.
.
|
.
//
//
// *********************************************************
//
// Pilotage d'un moteur pas a pas avec frein de maintien
//
// mise en position d'initialisation en phase de demarrage
// deplacement des axes en manuel
// rotation en automatique
//
// Le 29/06/2021
// H.Mazelin pour RedOhm
//
// *********************************************************
//
// Active la broche 11 sur Arduino pour piloter la broche PULSE
// Pulse signal : en mode impulsion simple (pulse/direction),
// une impulsion montante sur cette entrée fait avancer le moteur
// d’un pas.La tension de l’impulsion doit etre de 4,5 a 5 V
// pour un état HAUT et 0 a 0,5 V pour un état BAS. La largeur
// d’impulsion doit être au minimum a 2,5 μs pour un fonctionnement
// correct.
int PUL=11;
// Active la broche 12 sur Arduino pour piloter la broche DIR
// DIR signal : en mode impulsion simple, ce signal a des niveaux de tension
// haut et bas qui représentent les deux directions de rotation du moteur.
int DIR=12;
// Active la broche 13 sur Arduino pour piloter la broche ENA
// Enable signal : ce signal est utilise pour permettre ou d'interdire
// l’utilisation du driver. Un signal haut permet d’utiliser
// le driver tandis qu’un signal bas le bloque.
int ENA=13;
// Rappel sur les variables
// Les variables déclarées en tête de programme sont des
// variables globales et peuvent être utilisées partout
// dans le programme.
int basse_de_temps ;
// *********************************************************
// Declaration des axes
// *********************************************************
// le potentiomètre, branché sur la broche analogique 1
int potar_rotation = 1;
// creation de la variable rotation
int valeur_rotation ;
// --------------- demande de rotation ----------------------
// déclaration de l'entrée du bouton branché sur la broche 6
// de votre carte Arduino
int bouton6 = 6;
// variable du type int pour stocker les valeurs de passage du bouton6
int bouton6v;
// --------------- mise en place manuel ---------------------
// déclaration de l'entrée du bouton branché sur la broche 7
// de votre carte Arduino
int bouton7 = 7;
// variable du type int pour stocker les valeurs de passage du bouton6
int bouton7v;
int sortie_frein = 8;
// -------- Variable annexe --------------------------------
//variable pour la mise en position manuelle
int menu7 ;
//Variable pour le menu
int cobot_attend = 1 ;
// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// ---------------------------------------------------------------------------
void setup() {
//ouvre le port série et fixe le debit de communication à 9600 bauds
Serial.begin(9600);
// on attent que le port de communication soit pret
while (!Serial) {
;
}
// *********************************************************
// Configuration des entrees pour les boutons de selection
// *********************************************************
// pinMode :Configure la broche spécifiée pour qu'elle se comporte soit
// en entrée, soit en sortie
// bouton de rotation
pinMode (bouton6,INPUT );
// bouton de deverouillage tourelle
pinMode (bouton7,INPUT );
// sortie pilotage frein
pinMode (sortie_frein,OUTPUT );
// *********************************************************
// Configuration des sorties pour le pilotage du driver
// *********************************************************
// vitesse et deplacement pour le driver
pinMode (PUL, OUTPUT);
// sens de rotation pour le driver
pinMode (DIR, OUTPUT);
// activation ou non du driver
pinMode (ENA, OUTPUT);
// base de temps par defaut
basse_de_temps = 1300;
// affichage a l'ecran de la presentation
Serial.println(" - Cobot Oryon - ");
Serial.println(" Construction RedOhm" );
Serial.println ("");
// Temporisation pour les circuits electriques
for (int delai = 0; delai<5;delai++)
{
Serial.print(".");delay(300);
}
Serial.println("Pret ");
// Position actuel
Serial.println("");
Serial.print("Position de la tourelle => ");
Serial.println(valeur_rotation = analogRead (potar_rotation));
// *******************************************************
// Mise en position du cobot en position central
// controle si on se trouve a droit
// *******************************************************
if ( valeur_rotation<527 )
{
digitalWrite(ENA,HIGH);//Verouillage du driver
digitalWrite(DIR,LOW);//choix de la direction
digitalWrite(sortie_frein, LOW);//deblocage frein
delay(100);// temps de securite entre le frein et le deverouillage
// La boucle while est une boucle sans fin, jusqu'à ce que la
// condition ou l'expression entre les parenthèses deviennent fausses
while ( valeur_rotation<528 )
{
digitalWrite(PUL,HIGH);// etat haut de la sortie
delayMicroseconds(500);
digitalWrite(PUL,LOW); // mise a l'etat bas de la sortie
delayMicroseconds(500);
//lecture de la position actuelle
valeur_rotation = analogRead (potar_rotation);
// affichage de la position actuel
Serial.println(valeur_rotation );
}
}
// *******************************************************
// Mise en position du cobot en position central
// controle si on se trouve a gauche
// *******************************************************
else if ( valeur_rotation>526 )
{
digitalWrite(ENA,HIGH);//Verouillage du driver
digitalWrite(DIR,HIGH);//choix de la direction
digitalWrite(sortie_frein, LOW);//deblocage frein
delay(100);// temps de securite entre le frein et le deverouillage
// La boucle while est une boucle sans fin, jusqu'à ce que la
// condition ou l'expression entre les parenthèses deviennent fausses
while ( valeur_rotation>526 )
{
digitalWrite(PUL,HIGH);
delayMicroseconds(500);
digitalWrite(PUL,LOW);
delayMicroseconds(500);
//lecture de la position actuelle
valeur_rotation = analogRead (potar_rotation);
// affichage de la position actuelle
Serial.println(valeur_rotation );
}
}
}
// ---------------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop ()
// ---------------------------------------------------------------------------
void loop() {
// *********************************************************
// creation du menu du cobot
// *********************************************************
if (cobot_attend == 1)
{
// appel de la fonction -> cobot_en_attente
cobot_en_attente();
}
else if (cobot_attend == 0)
{
// libre de code
}
// teste du bouton de demarrage cycle
bouton6v = digitalRead(bouton6);
if (bouton6v == 1)
{
Serial.println(" Demarrage cycle ");
//Lancement du sous programme de rotation
rotation();
delay(100);
// appel de la fonction -> cobot_en_attente
cobot_en_attente ();
}
else if (bouton6v == 0)
{
}
// teste du bouton fonctionnement en mode apprentissage
bouton7v = digitalRead(bouton7);
if (bouton7v == 1)
{
if (menu7 == 0)
{
Serial.println(" Mise en position en manuel ");
Serial.println(" Deblocage frein ");
}
//deblocage frein
digitalWrite(sortie_frein, LOW);
// temps de securite entre le frein et le deverouillage
delay(100);
//deverouillage driver
digitalWrite(ENA,LOW);
// Lecture de l'entree analogique et transfert dans la
// variable valeur_rotation
valeur_rotation = analogRead (potar_rotation);
// Affichage de la valeur de la position de la rotation
valeur_rotation = analogRead (potar_rotation);
Serial.print("Valeur de la rotation =>");
Serial.println(valeur_rotation);
menu7 = 1;
}
else if (bouton7v == 0)
{
digitalWrite(sortie_frein, HIGH);//blocage frein
digitalWrite(ENA,HIGH);//verouillage driver
menu7=0;
}
}
//*************************************************
// cobot en rotation
//*************************************************
void rotation()
{
Serial.println("ok" );
digitalWrite(sortie_frein, LOW);//deblocage frein
// temps de securite entre le frein et le deverouillage du driver
delay(100);
// boucle de repetition de cycle
for (int repete=0; repete<1; repete++)
{
basse_de_temps = random ( 300,850);
Serial.print(" Base de temps vitesse avant => " );
Serial.println( basse_de_temps );
digitalWrite(DIR,LOW);
digitalWrite(ENA,HIGH);
for (int i=0; i<5200; i++)
{
digitalWrite(PUL,HIGH);
delayMicroseconds(basse_de_temps);
digitalWrite(PUL,LOW);
delayMicroseconds(basse_de_temps);
}
delay (1000);
basse_de_temps = random ( 500,2500);
Serial.print(" Base de temps vitesse arriere => " );
Serial.println( basse_de_temps );
digitalWrite(DIR,HIGH);
digitalWrite(ENA,HIGH);
for (int i=0; i<5200; i++)
{
digitalWrite(PUL,HIGH);
delayMicroseconds(basse_de_temps);
digitalWrite(PUL,LOW);
delayMicroseconds(basse_de_temps);
}
delay (1000);
}
// blocage frein
digitalWrite(sortie_frein, HIGH);
// temps de securite entre le frein et le deverouillage du driver
delay(100);
}
//*************************************************
// cobot en attente
//*************************************************
void cobot_en_attente ()
{
cobot_attend = 0;
Serial.println("");
Serial.println("");
Serial.println("=================================================");
Serial.println(" Cobot Oryon en attente ");
Serial.println("=================================================");
Serial.println("");
Serial.println("bouton rouge -> Deverouillage frein");
Serial.println("bouton vert -> Lancement programme ");
Serial.println("");
}
.
Retour au sommaire
|
.
.
Retour au sommaire
A savoir sur l’utilisation des informations |
.
Les informations sur les caractéristiques et spécificités des moteurs pas à pas et des materiels qui sont fournis sur cette page correspondent aux informations des fiches techniques du constructeur si malgré le soin apporté à la réalisation de cet article une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable.
Les programmes , schémas et autres que ceux donnés par le constructeur font parti des montages utiles à nos applications si malgré le soin apporté à nos montages une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable .
L’ensemble des informations techniques de cet article a été utilisé pour nos applications, elles vous sont fournies comme un exemple de document de travail. Mais nous ne pourrions être tenu responsables d’une mauvaise utilisation de celle-ci.
.
Retour au sommaire