pilotage d'un Stepper par L298N

Salut à tous !
je suis confronté à un problème pour le pilotage de mon moteur pas à pas linéaire bipolaire (une vis avance et recule) (12V, 0.4A), modèle 39BYGL215A
j’utilise un controleur L298N que j’ai branché de la facon ci dessous à mon moteur
mes diode sont des BYV27 100 Ultra fast,
j’utilise ce code la, juste pour tester le controle de mon moteur et lui faire faire un aller retour
le probleme est que lorsque je pose mon moteur a plat (vis horizontale) mon moteur vibre et la vis tourne de facon irrégulière, (on dirait qu’il subit des frottements) et ne respecte pas du tout le code
lorsque je prend mon moteur dans les mains et que je met la vis à la verticale, elle descend… je le retourne, elle change de sens et descend dans l’autre sens toujours sans respecter le code, mais cette fois ci tourne de facon régulière (comme si il n’y avait plus de frottements)
dans le datasheet de mon moteur il est dit "rate voltage : 12V et en sortie de chaque phase j’ai mesuré 2.3V et 0.4A
est ce que mon moteur a besoin d’une alimentation exterieure pour amplifier le voltage des phase ?
je ne sais pas quoi faire, si quelqu’un peut me filer un coup de main ce serait vraiment cool

// — Déclaration des constantes —
const int NombrePas=200; // Nombre de pas du servomoteur

// — constantes des broches —

const int Pas_1=2; //declaration constante de broche
const int Pas_2=3; //declaration constante de broche
const int Pas_3=4; //declaration constante de broche
const int Pas_4=5; //declaration constante de broche

// — Déclaration des variables globales —

// — Déclaration des objets utiles pour les fonctionnalités utilisées —
Stepper stepper(NombrePas, Pas_1, Pas_3, Pas_2, Pas_4); // crée un objet Stepper pour contrôler le moteur pas à pas
// Pas_1 et Pas_3 commandent la 1ère phase, Pas_2 et Pas_4 la 2ème phase

//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup() { // debut de la fonction setup()

// — ici instructions à exécuter au démarrage —

// initialise la vitesse de rotation du moteur pas à pas en tour par minute
stepper.setSpeed(200);

// ------- Broches en sortie -------

pinMode(Pas_1, OUTPUT); //met la broche en sortie
pinMode(Pas_2, OUTPUT); //met la broche en sortie
pinMode(Pas_3, OUTPUT); //met la broche en sortie
pinMode(Pas_4, OUTPUT); //met la broche en sortie

// ------- Broches en entrée -------

// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------

} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

// — ici instructions à exécuter par le programme principal —

for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(100); // 100 pas en sens positif
}

delay (1000);

for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(-100); // 100 pas en sens négatif
}

delay (1000);

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

Pour commencer : réclamer une réponse au bout de 2 h est le meilleur moyen pour ne pas en avoir.

Pour poursuivre un peu de bon sens et de logique seraient les bienvenus.

  • si le moteur est spécifié pour 12 V pourquoi s'entêter à vouloir le faire fonctionner sous 5V ? La démarche logique pour faire des tests est de se mettre dans les conditions normales de la spec et quand cela fonctionne correctement on peut envisager de tester sous d'autres conditions.

-Question puissance d'alim il faut : a) avoir les pieds sur terre pour évaluer les puissances mises en jeu. b) se documenter, ne serait-ce que sur ce forum avec le moteur de recherche. Si tu avais fais cela tu aurais vu que le sujet a été abordé des dizaines de fois.

Edit : regardes les questions de couple (torque en anglais) en fonction de la tension d'alimentation et de frottement et tu auras un début d'explication

Salut !
Désolé d’avoir pu parraitre si préssé, je viens de recevoir les pièces aujourd’hui et j’étais un peu deçu que ça ne marche pas
Bref, J’ai déjà fait mes recherches avant d’aller sur le Forum Arduino
Le problème est que grâce à la fonction “Stepper” le microcontroleur ATMEGA328 me fournit un signal en quadrature de phase (les bobines sont alimentés successivement de manière bien précise pour faire fonctionner le système pas à pas. Le signal est décalés dans chaque phase)
Je ne sais pas comment faire pour alimenter mon moteur en quadrature de phase autrement que par cette fonction Stepper,il y a t’il un moyen de controler ce torque pour augmenter l’alimentation de chaque phase tout en gardant cette quadrature de phase.

Le torque couple est fonction de la tension d'alimentation, il n'est garanti que pour la tension nominale un point c'est tout.

  • Il faut une alim 12 V de tension, capable de fournir autant de fois 0,4A qu'il y aura de bobinages actionnés simultanément (prévoir large).
  • Il faut une alim 5V pour la carte arduino. Ne pas oublier de relier ensemble les masses des deux alims.
  • Et entre la carte et le moteur il faut une interface : le circuit intégré L298.

En entrée le L298 reçoit les signaux "qui vont bien" que la librairie "Stepper" lui aura confectionné. En sortie il se comporte comme un pont en "H" qui alimente les bobinages du moteur. Je suppose que le L298 n'est pas nu mais déjà monté sur une carte avec des connecteurs : voir la notice de la carte pour le câblage.

Ok !
mon L298 est nu, jai rajouté les diode avec le datasheet
je n’ai pas mis ajouté d’alimentation exterieure j’ai juste mis l’alimentation du moteur au +5V d’arduino et j’ai abaissé la vitesse de rotation à 60tr/min et ça marche bien
par contre, je n’arrive pas à commander mon moteur avec un bouton poussoir, j’aimerais obtenir un déplacement micrométrique et donc un seul et unique pas quand je le souhaite !
Seulement la fonction loop ne s’arrete jamais, j’ai essayé ça comme code, (avec une LED pour vérifier ma commande) mais ça ne marche pas des masses, mon moteur tourne continuellement,

#include <Stepper.h> // librairie pour moteurs pas à pas

// — Déclaration des constantes —
const int NombrePas=200; // Nombre de pas du servomoteur

// — constantes des broches —

const int Pas_1=2; //declaration constante de broche
const int Pas_2=3; //declaration constante de broche
const int Pas_3=4; //declaration constante de broche
const int Pas_4=5; //declaration constante de broche
const int BP=8; // Constante pour la broche 2
const int LED=9; // Constante pour la broche 3

// — Déclaration des variables globales —
int etatLED=0; // variable d’état de la LED
int etatPas_1=0;
int etatPas_2=0;
int etatPas_3=0;
int etatPas_4=0;

// — Déclaration des objets utiles pour les fonctionnalités utilisées —
Stepper stepper(NombrePas, Pas_1, Pas_3, Pas_2, Pas_4); // crée un objet Stepper pour contrôler le moteur pas à pas
// Pas_1 et Pas_3 commandent la 1ère phase, Pas_2 et Pas_4 la 2ème phase

//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup() { // debut de la fonction setup()

// — ici instructions à exécuter au démarrage —

// initialise la vitesse de rotation du moteur pas à pas en tour par minute
stepper.setSpeed(60);

// ------- Broches en sortie -------

pinMode(Pas_1, OUTPUT); //met la broche en sortie
pinMode(Pas_2, OUTPUT); //met la broche en sortie
pinMode(Pas_3, OUTPUT); //met la broche en sortie
pinMode(Pas_4, OUTPUT); //met la broche en sortie
pinMode (LED,OUTPUT); // Broche LED configurée en sortie

// ------- Broches en entrée -------

pinMode (BP,INPUT); // Broche BP configurée en entrée

// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------

} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

// — ici instructions à exécuter par le programme principal —

if (digitalRead(BP)==LOW) { // si appui sur le BP

digitalWrite(LED,1);
for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(1); // un pas en sens négatif

}

if (digitalRead(BP)==HIGH) { // si appui sur le BP

digitalWrite(LED,0);
for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(0); // zéro pas

}

}
}
}
// fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin

Il y a tellement de raisons pour les quelles ça ne peut pas marcher que cela ne donne pas envie de répondre saf à se moquer .

1) l'alimentation de l'arduino est prévue pour l'arduino et éventuellement un peu de logique supplémentaire. Connecter un moteur sur l'alimentation de la logique peut conduire au paradis des microcontrôleurs. 2) ton choix de moteur est loin de l'optimum : résistance et inductance des bobinages élevées donc temps de montée (et de descente) assez long. Si on ne va pas trop vite ça reste gérable. 3) si il est écrit 12volt, ça marchera beaucoup moins bien avec 5v surtout si l'alimentation 5v s'écroule . 4) tu dis que ton L298 est nu. Comment sont raccordés les moteurs, les alimentations et les entrées logiques ? Avec des fils volants et des pinces croco ? Soudés et comment ? A t-il survécu à tes différentes tentatives ?

Il n'y a pas de miracles ! - séparer les alimentations - contrôler et fiabiliser le cablage - essayer de tourner en mode pas à pas ou presque - vérifier que les branchements des enroulements sont corrects : le L298 est protégé contre les les branchements léthaux mais rien n'interdit de penser que les pins 1234 ne sont pas raccordés dans le bon ordre. - etc ...

Une photo ?

Je suis novice ! je le reconnais,je suis sur Arduino depuis 1 semaine, j'essaie de comprendre la logique de programmation pour arriver à mon but. Je suis venu sur le forum pour avoir de l'aide de personnes plus expérimentés que moi, je trouve ça un peu léger de se moquer :astonished: ! Sinon ! j'ai acheté ce moteur pas à pas bipolaire (12V/0.4A) dans l'objectif d'avoir un déplacement [u]linéaire/u d'une dizaine de microns par pas j'ai couplé ce moteur à un contrôleur L298 pour pouvoir le contrôler via Arduino (je met le schéma de câblage avec) je l'ai fait sur une plaque électronique, j'ai vérifié plusieurs fois les branchements mon moteur bipolaire est alimenté par Arduino, (je me suis dit que pour une utilisation à une vitesse très lente ça suffirait), il marche très bien à basse vitesse le problème est que je n'arrive pas à stopper le fonction loop() dans le programme, c'est pour ça que j'ai tenté de mettre un interrupteur :sweat_smile:

Il n'est pas question de se moquer mais il faut admettre que tu n'as pas mis toutes les chances de ton coté en démarrant directement avec un moteur 12V alimenté sous 5V et en mélangeant les alims.

Il est un principe de base : que ce soit pour des relais ou des moteurs on ne mélange pas les alimentations. Ces composants quand ils se mettent en route provoquent des appels de courant qui peuvent faire écrouler la tension de sortie de l'alim. Par effet de cascade la baisse de la tension d'alim, même très courte, peut provoquer des erreurs dans le micro-controleur.

J'ai compris que tu n'as pas d'alim 12V sous la main mais il t'en faudra une un jour ou l'autre.

Quant à débuter autant mettre toutes les chances de son coté : sur Ebay on trouve des kits moteur pas à pas 5 Volts + carte toute montée avec un L298 pour un prix avoisinant les 5€. Pourquoi ne pas se faire la main avec ? On dispose tous au fond de nos tiroirs de chargeur 5Volts 500mA ou 1A qui nous restent d'appareils tombés en panne. Bien sur ce sont des moteurs unipolaires mais c'est la même librairie qui gère les deux types de moteur.

Tu compte faire des déplacements de quelques dizaines de microns par pas, a priori je n'ai pas de remarques mais on entre dans de la mécanique de précision avec une bonne gestion des frottements et du jeu fonctionnel.

PS : édite le message où tu as placé ton code et place le code entre les balises # (voir vers la fin de la 2eme ligne d'icones)

Oui, j’ai tenté le coup en branchant mon moteur à l’alim d’Arduino, ça à marché j’ai laissé comme ça, mais c’est bon maintenant j’ai pris une alimentation exterieure pour ne pas avoir de soucis
Par contre mon code n’est vraiment pas au point ! je voudrais en actionnant un bouton poussoir le faire avancer juste d’un seul et unique pas mais la fonction loop() se continue indéfiniement et je ne sais pas vraiment comment y remerdier
j’ai tenté de faire ça…

#include <Stepper.h> // librairie pour moteurs pas à pas

// — Déclaration des constantes —
const int NombrePas=200; // Nombre de pas du servomoteur
const int APPUI=LOW; // constante pour tester état BP
const int PAS_APPUI=HIGH;
// — constantes des broches —

const int Pas_1=2; //declaration constante de broche
const int Pas_2=3; //declaration constante de broche
const int Pas_3=4; //declaration constante de broche
const int Pas_4=5; //declaration constante de broche
const int BP=8; // Constante pour la broche 2
const int LED=9; // Constante pour la broche 3

// — Déclaration des variables globales —
int etatLED=0; // variable d’état de la LED

// — Déclaration des objets utiles pour les fonctionnalités utilisées —
Stepper stepper(NombrePas, Pas_1, Pas_3, Pas_2, Pas_4); // crée un objet Stepper pour contrôler le moteur pas à pas
// Pas_1 et Pas_3 commandent la 1ère phase, Pas_2 et Pas_4 la 2ème phase

//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup() { // debut de la fonction setup()

// — ici instructions à exécuter au démarrage —

// initialise la vitesse de rotation du moteur pas à pas en tour par minute
stepper.setSpeed(1);

// ------- Broches en sortie -------

pinMode(Pas_1, OUTPUT); //met la broche en sortie
pinMode(Pas_2, OUTPUT); //met la broche en sortie
pinMode(Pas_3, OUTPUT); //met la broche en sortie
pinMode(Pas_4, OUTPUT); //met la broche en sortie
pinMode (LED,OUTPUT); // Broche LED configurée en sortie

// ------- Broches en entrée -------

// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------

} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

// — ici instructions à exécuter par le programme principal —

if (digitalRead(BP)==APPUI) { // si appui sur le BP la LED s’allume et le moteur effectue 1 pas

digitalWrite(LED,HIGH); // la LED est allumée
for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(1); // un pas en sens positif
}
}
if (digitalRead(BP)==PAS_APPUI) { // la LED et le moteur ne sont pas actionné

digitalWrite(LED,LOW); // la LED est éteinte
for (int i=1; i<=NombrePas; i++){ // boucle de défilement du nombre de pas
stepper.step(0); // aucun pas
}
}

delay (1000);

}// fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin

Bien pour l'alim, j'espère qu'elle est 12V. :grin:

Pour le code perso je dis joker, je suis un électronicien et j'ai déjà du mal à relire mon code alors celui des autres....

Je ferais quand même une remarque : tu n'as mis aucun Serial.Print('Message xyz") de débogage. Quand on n'est pas assuré du fonctionnement, c'est à dire qu'on passe bien dans les boucles qui vont bien, on place des messages pour suivre le déroulement du programme. Rien qu'en faisant ainsi on détecte bien des erreurs.

Pour la présentation du code je note l'effort mais ce n'est pas la bonne icône, tu as pris celle pour les citation il faut prendre celle avec un dieze #. Ah y sont ch***t sur ce forum ! Mais tu verra qu'en faisant ainsi le code est plus facile à lire.

Bon déjà, réassigner les HIGH et LOW en APPUI et PAS_APPUI c'est un peu inutile ... Mais bon chacun fait ce qu'il veut xD

Sinon je comprends pas : quand il y a un appui sur le bouton tu lances une boucle de 200 itérations de 1 pas donc forcement il fait un tour ...

J'insiste lourdement : avec un Serial.Print à l'entrée dans une itération tu aurais eu 200 fois le même message ce qui t'aurais mis la puce à l'oreille. C'est un principe général quand on fait de la mise au point et quelque soit le domaine : - Placer le maximum de signes pouvant attirer l'attention - Décomposer les tâches complexes en sous tâches les plus élémentaires possible. Quand cela fonctionne on peut regrouper les sous tâches et supprimer les messages devenus inutiles.

Bonjour Si on veut ne faire qu'une seule fois une ou une série d'instructions suite à une condition [if(...){], on utilise un drapeau (flag). soit le flag F [boolean F = true;] dans la boucle void(){ on a la condition A: [if(A... ){] si celle-ci est remplie on regarde le flag F si il est true, on fait les instructions à ne faire qu'une fois dont la dernière est [F = false;]. tant que la condition A est remplie on passera au dessus de ces instructions à chaque boucle. Une fois que la condition A n'est plus remplie on met le flag F à true [F = true;] dans un else { PS: définir les variables suivant leur utilisation par ex. si une variable ne peut évoluer entre 0 et 200 utiliser byte, si c'est un drapeau, utiliser boolean ou byte, etc. Bien sûr nos programmes sont en général petits et la mémoire ram est suffisante, mais c'est une habitude à prendre. A+

c'est bon tout fonctionne ! J'ai finalement installé un bouton poussoir qui a chaque impulsion fait avancer la vis du moteur de 10 um j'aimerais pouvoir communiqué avec l'ordi depuis une interface qui puisse me dire combien de fois j'ai appuyé sur le bouton poussoir, et donc de quelle distance ma vis a avancer je ne sais pas si c'est possible, j'ai vu qu'il y avait des interfaces processing mais je ne sais pas vraiment comment ça fonctionne merci ;)

J'ai finalement installé un bouton poussoir qui a chaque impulsion fait avancer la vis du moteur de 10 um

Belle réussite, je suis curieux de voir la mécanique. Serait-il possible de voir des photos ?

Les pas de 10µm c'est du mesuré (avec palmer ou autre contrôleur de précision) ou du théorique ?

J'ai juste mis un bouton poussoir avec un delay de 200ms pour avoir une unique impulsion Voici une photo cest un peu le bazarre dans mes fils J'utilise une caméra micrométrique pour les mesure mais j'aimerais mettre en place un systeme plus précis, !

Ok, merci. Pour le moment la vis sans fin n'est pas chargée. Les essais en charge sont-il déjà programmés?

mathieu-qc: J'ai juste mis un bouton poussoir avec un delay de 200ms pour avoir une unique impulsion Voici une photo cest un peu le bazarre dans mes fils J'utilise une caméra micrométrique pour les mesure mais j'aimerais mettre en place un systeme plus précis, !

Bonsoir comme evoqué par Alienboats et 68tjs Là sans jeu de mots , c'est la mecanique qui dirige tu veux faire une table de déplacement micrometrique ? Quel amplitude de déplacement absolu ? sur combien d'axes ? tes 10µ ou 1/100mm c'est quoi exactement ? un valeur de positionnement reproductible ( partir et revenir sur "cible" à 10µ pres) ou une "simple"resolution de deplacement ?

Comment ça c'est la mécanique qui dirige ? et je vais me mettre au montage mécanique d'ici peu, je ferais les test avec j'ai besoin de faire varier ma vis sans fin sur un total de 3mm avec une précision de 10 ?m. J'ai testé rapidement le mécanisme avec une caméra micrométrique, ça fonctionne correctement. Mais j'aimerais testé le mécanisme avec une mesure précise,

mathieu-qc: Comment ça c'est la mécanique qui dirige ? j'ai besoin de faire varier ma vis sans fin sur un total de 3mm avec une précision de 10 ?m. J'ai testé rapidement le mécanisme avec une caméra micrométrique, ça fonctionne correctement. Mais j'aimerais testé le mécanisme avec une mesure précise,

c'est quoi les specifs reelles de précision de ta "camera micrométrique" ? :grin: tu veux de la précision ou de la résolution ?