Faire tourner moteur pas a pas tres lentement

Bonjour
je suis constructeur pour des scénographie , c est la première fois que j utilise des moteur pas a pas voici mon probléme.
Je travail avec un Nema 34 série TS 1 axe 12,0Nm et un driver CL86T
Pour une scénographie de théatre je dois faire tourné des chassis de 3M50 sur 1 M trés lentement 45 degré en 1h

je voulais savoir si quelque un avait une idée de comment coder tout ça? si possible sans des accoups
je pensais mettre un delais dune minute ou plus entre chaque pas....vous pensez que ca fonctionne?
merci d avance

site : https://www.omc-stepperonline.com/fr/nema-34-moteur-pas-a-pas

Un moteur pas à pas Nema 34 est un moteur pas à pas avec une plaque frontale de 3,4 x 3,4 pouces (86 x 86 mm).

Nema c'est une norme dimensionnelle,c'est la dimension de la semelle de fixation.
Cela ne dit pas la puissance du moteur ni quel est l'angle par pas : 1,8° ou 0,9 ° ou x° ?
Il faut la référence exacte du moteur.

Avec ta proposition de pas entier, le moteur tournera par à-coups.

Pour un mouvement plus fluide
Il y a la solution des micropas.
Il y a aussi la solution d'un engrenage réducteur mécanique.

ou les deux ensemble.

Cela dépend de tes contraintes.

comme ce kit ?

45° c'est 1/8ème de tour. Si vous avez 1000 pas par tour ça veut dire faire 125 pas en une heure ou si vous pouvez faire 4 micro-pas par pas, faire 600 micros-pas par heure, soit un micro-pas toutes les 6 secondes

si votre code ne fait rien d'autre, effectivement un délai peut faire l'affaire

void loop() {
  faireMicroPas();
  delay(6000);
}

mais il ne s'arrête pas à 45° et continuera...

merci pour vos réponses , c est bien le Kit pas à pas en boucle fermée Nema 34 série TS 1 axe 12,0Nm(1699,34oz.in)... je vais essayer d' acheter un réducteur mécanique pour voir ce que ça donne...et travailler sur le delay..

par contre si je mets un délay je ne pourrais pas décider d' arrêter le moteur a 45°?.... Vous pensez qu' il y a des solutions en termes de programmation?

Bonjour scarface2012

Oui, utiliser les millis(), voire l'exemple Blink Without Delay
En effet, pendant un delay(), l'Arduino ne fais plus rien qu'attendre :woozy_face:

A+
Cordialement
jpbvbricole

Bien sûr - vous comptez les pas et quand vous arrivez à 45° (600 micro-pas) vous ne donnez plus d’ordre.

Une approche avec Millis() et une petite machine à etat est bien sûr est « plus propre » en terme de structure du code mais s’il n’y a pas d’autre besoin…

Bonjour scarface2012
Une autre solution, avec la bibliothèque Accelstepper et un setMaxSpeed() à 0.166, une impulsion toutes les 6 secondes.

Cordialement
jpbbricole

Merci pour toute ces infos.... Je suis en train d avancé sur la production mais je me rend compte que j aimerais bien êtres fortement aidé sur toute la programmation.
En effet j arrive a programmé basiquement en arduino, et je me rend compte que pour un résultat satisfaisant il me faudrait un programmateur. je voulais savoir si quelque un pouvait m aider a coder ? et a valider le schéma de câblage
Je vous explique le projet global et vous me dite si quelque un est intéressé pour m aider.

je vais installer 8 moteurs pas a pas

les 8 moteurs seront commander par une carte arduino et devrons donc tournée de 45 degré et s arrêter en 60minutes.
Toute les alimentation et drivers seront déportées à 4 mètres des moteurs pour le bruit. en piéce jointe un plan de la scéno avec chassis ouverte et fermé.
je voudrais donc avoir des détails sur la cablage est il possible de linker les 8 steppers driver?
et d envoyé seulement au premier driver les impulsions?
merci pour votre réponse


Bonjour scarface2012

Les 8 moteurs feront toujours le même mouvement ou c'est 8 moteurs indépendants ?
Comment se déclenchera le mouvement.

Cordialement
jpbbricole

les 8 moteurs ferons toujours le même mouvement en même temps et le déclenchement sera fait par un régisseur en début de spectacle sur un ordi ou bouton poussoir.....
merci

Bonjour scarface2012

Je n'ai pas d'expérience de moteurs pas à pas en boucle fermée, mais peut on imaginer qu'ils fonctionnent tous "comme uin seul homme" et que l'on mette les 8 commandes (DIR, STEP et ENABLE) tous en parallèle?

Quelle serait la liaison entre l'ordi du régisseur et l'Arduino, fil?
Quelle est la distance entre l'Arduino et le régisseur?

A+
Cordialement
jpbbricole

Bonjour jpbbricole
Je compte connecter l ordi a la carte Arduino avec un câble USB et un booster USB de 10M . Je pense que la carte Arduino sera sur scène et l ordinateurs en régie. Je vais essayer de codé ça se soir . Il y a des code existant que je peux copier coller facilement ?

Bonjour scarface2012

Je peux te faire ça, avec un bouton pour démarrer depuis l'Arduino et la possibilité de démarrer depuis le câble USB et ce, pour demain.
Au départ, ce sera pour un moteur.

A+
Bonne soirée.
jpbbricole

Ouha trop bien ! Tu peux m envoyer ton mail perso ?

Ce n'est pas nécessaire, je fais ça pour le plaisir et de façon totalement désintéressée.

Mon seul but est de te faire plaisir et que tu devienne, comme moi, un mordu d'Arduino :wink:

A+
Bonne soirée.
jpbbricole

oki grand merci , les moteurs pas a pas et arduino m ouvrent des possibilités de dingue en matière de construction scénographie....ça parait sans limite;;;;
encore merci bonne soirée

Bonjour scarface2012

Voilà un « premier jet » du programme, il nécessite 2 bibliothèques :
Pour les moteurs pas à pas (MPAP), AccelStepper et, pour le bouton poussoir, JC_Button.

Pour le câblage du bouton (BP), il est d’un côté au GND de l’Arduino et de l’autre à la pin const int bpPpin = 3;

Pour le câblage du driver du MPAP :

const int mpapSignDirPin = 5; // Pin du signal DIR
const int mpapSignStepPin = 6; // Pin du signal STEP
const int mpapSignEnaPin = 7; // Pin du signal ENABLE

Il est possible qu’il faille inverser DIR, STEP ou ENABLE, ça se fait ici :

// DIR STEP ENABLE
mpap.setPinsInverted(false, false, true); // Inversion des signaux

Un true à ENABLE signifie que ce signal est actif à LOW.

Les paramètres de fonctionnement sont :

const long mpapStepsMicroNombre = 500; // Nombre de pas en 1/8
float mpapStepsTempo = 6.0; // Un pas toutes les x.x secondes

Le déplacement est de 500 micro-pas avec un pas toutes les 6 secondes, tu peux jouer avec ces valeurs.

Les rôles du bouton ;
Première pression, démarrage, pression suivante, en pause, pression suivante, redémarrage ……
Longue pression (2 secondes)= RAZ du système.

Commande depuis le PC via l’USB, à 115200, commandes terminées par LF (\n) ou LF et CR (\n\r):
START Démarrage du déplacement.
PAUSE Mise en pause du déplacement
CONT Redémarrage suite à pause.
RAZ RAZ du système.

Il y a des informations quant au fonctionnement du système, dans le moniteur (115200), en fonctionnement, les pas restants sont affichés toutes les secondes (displayTempo = 1000;).

Nombre des pas :	500
Tempo des pas :		0.17 sec.
Etat change : Arret
Etat change : Marche
Pas restants: 499
Pas restants: 499
Pas restants: 499
Pas restants: 498
Etat change : Pause
Etat change : Marche
Pas restants: 497
Pas restants: 497
Pas restants: 497
Etat change : Pause
Etat change : Marche
Pas restants: 496
Pas restants: 496
Etat change : Pause
Etat change : Arret

Le programme :

/*
    Name:       AF_scarface2012_PasApasTresLentement.ino
    Created:	20.07.2024
    Author:     jpbbricole
				https://forum.arduino.cc/t/faire-tourner-moteur-pas-a-pas-tres-lentement/1283008/16
	20.07.2024	Première version #17
*/
#include <AccelStepper.h>     // https://www.pjrc.com/teensy/td_libs_AccelStepper.html
#include <JC_Button.h>     // https://github.com/JChristensen/JC_Button  Gestion du bouton poussoir

//------------------------------------- Moteur pas à pas (mpap)
const int mpapSignDirPin = 5;     // Pin du signal DIR
const int mpapSignStepPin = 6;     // Pin du signal STEP
const int mpapSignEnaPin = 7;     // Pin du signal ENABLE

AccelStepper mpap(AccelStepper::DRIVER, mpapSignStepPin, mpapSignDirPin);     // Driver, STEP, DIR

const unsigned long displayTempo = 1000;     // Afficher toutes les secondes
unsigned long displayMillis = millis();     // Afficher toutes les secondes, chrono

const long mpapStepsMicroNombre = 500;     // Nombre de pas en 1/8
float mpapStepsTempo = 6.0;     // Un pas toutes les x.x secondes

//------------------------------------- Bouton poussoir (bp)
const int bpPpin = 3;     // Pin du bouton poussoir, un côté à GND
const boolean buttPullup = true;     // PULLUP internes
const boolean buttInvert = true;     // Actif à LOW
const int buttDebounce = 20;     // Temps anti rebonds

//------------------------------------- Etats du programme
const String prgEtatLabel[] = {"Marche", "Pause", "Arret"};
enum {prgEtatEnMarche, prgEtatEnPause, prgEtatEnArret};
int prgEtat;     // Etat du programme

//                PULLUP Inverted   Anti-rebonds
Button bp(bpPpin, true,    true,        20);     // Création du bouton

void setup()
{
	Serial.begin(115200);
	delay(500);

	bp.begin();

	//--------------------------------- Moteur pas à pas (mpap)
	//                    DIR    STEP   ENA
	mpap.setPinsInverted(false, false, true);     // Inversion des signaux
	mpap.setEnablePin(mpapSignEnaPin);     /// Pin d'activation
	mpap.setMaxSpeed(1.0 / mpapStepsTempo);     // Toutes les x secondes
	mpap.enableOutputs();     // Activer le driver

	Serial.println("Nombre des pas :\t" + String(mpapStepsMicroNombre));
	Serial.println("Tempo des pas :\t\t" + String(mpap.maxSpeed()) + " sec.");

	prgEtatChange(prgEtatEnArret);

	mpap.moveTo(500);     // Aler à 500 pas
}

void loop()
{
	//--------------------------------- Bouton poussoir
	bp.read();     // Lecture du bouton poussoir
	if (bp.pressedFor(2000))     // Si BP presse 1 seconde
	{
		if (prgEtat != prgEtatEnArret)
		{
			mpapReset();
		}
	}
	else if (bp.wasPressed())     // Si BP a été pressé
	{
		if (prgEtat == prgEtatEnArret)
		{
			mpapStart();
		}
		else if (prgEtat == prgEtatEnMarche)
		{
			mpapPause();
		}
		else if (prgEtat == prgEtatEnPause)
		{
			prgEtatChange(prgEtatEnMarche);
		}
	}

	//--------------------------------- Commandes PC
	if (Serial.available())
	{
		//String cmdRx = Serial.readStringUntil('\n');
		
		cmdExecute(Serial.readStringUntil('\n'));     // Réception de la commande terminée par Nouvelle ligne
	}

	//--------------------------------- Affichage
	if (millis() - displayMillis >= displayTempo)
	{
		if (prgEtat == prgEtatEnMarche)
		{
			Serial.println("Pas restants: " + String(mpap.distanceToGo()));
		}

		displayMillis = millis();
	}

	if (prgEtat == prgEtatEnMarche)
	{
		mpap.run();     // Tant qu'il y a des pas à faire (mpap.distanceToGo() != 0)
	}
}

void prgEtatChange(int newEtat)     // Changement d'état du programme
{
	prgEtat = newEtat;

	Serial.println("Etat change : " + prgEtatLabel[prgEtat]);
}

//--------------------------------- Moteur pas à pas
void mpapStart()
{
	mpap.moveTo(mpapStepsMicroNombre);     // Aller à
	prgEtatChange(prgEtatEnMarche);
}

void mpapPause()
{
	prgEtatChange(prgEtatEnPause);
}

void mpapReset()
{
	mpap.stop();
	mpap.setCurrentPosition(0);
	prgEtatChange(prgEtatEnArret);
}


void cmdExecute(String cmdRx)
{
	cmdRx.trim();     // Pour nettoyer la chaîne reçue
	cmdRx.toUpperCase();     // Tout en majuscule
	cmdRx.replace(" ", "");     // Supprimer les espaces

	Serial.println("Comande recue : " + cmdRx);

	if (cmdRx == F("START"))
	{
		mpapStart();
	}
	else if (cmdRx == F("PAUSE"))
	{
		mpapPause();
	}
	else if (cmdRx == F("CONT"))
	{
		prgEtatChange(prgEtatEnMarche);
	}
	else if (cmdRx == F("RAZ"))
	{
		mpapReset();
	}
	else
	{
		Serial.println("Commande inconnue : " + cmdRx);
	}
}

A ta disposition pour toutes questions et évolutions de ce programme.

PS: Règles tes switches sur 1600 (1/8 de pas)
image

Cordialement
jpbbricole

Bonjour,
Ce que l’on oublie de te signaler c’est que si tu utilises des micro-pas (8) il ne va te rester que 19,51% du couple de ton moteur. Ouch !

Pas à tous les pas...Ouf!

Je ne suis pas tout à fait d'accord.

Ce que tu dis est vrai dans le principe.
Mais il ne faut pas oublier que dans les drivers dans les circuits intégrés pilotes matériels actuels il y a de l'intelligence et ce fait est pris en charge et compensé.

La conséquence est que le réglage du courant n'est pas trivial.
La variation du courant dans les deux bobinages est sinusoïdale par construction dans le circuit intégré.

Ma compréhension du réglage du courant :
Il faut considérer le courant comme une valeur efficace.
Si, en pas entier la datasheet du moteur dit 1A par bobinage il faut régler le courant à 1*racine(2) = 1,41 A.

1 Like