bonjour, j'ai récupérer ce code qui permet de faire fonctionner 1 moteur pap avec 2 poussoirs avant arrière testersur un nano avec un drivers ulm2003 .
question / est il possible sur un nano d'avoir 4 boutons (2 avants 2 arrières ) et 2
moteurs qui aurai des commandes séparer et même vitesse ?
j'ai chercher si il avait un code existant mais apparent non
si quelqu'un avais une solution
par avance merci
#include <Stepper.h>
const int stepsPerRevolution = 200;
const int senshoraire = 2; // le numéro de la broche du bouton senshoraire
const int sensantihoraire = 3; // le numéro de la broche du bouton sensantihoraire
// Initialise le moteur sur les broches 8 à 11
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
Bonjour,
Merci de lire les bonnes pratiques du forum francophone pour comprendre comment poster correctement votre code (tel quel, il ne sera que peu ou pas lu) entre les balises de code <CODE/> (utilisez le bouton en bas à droite pour éditer votre message)
De plus, votre message étant une question et non un projet fini, vous pouvez le déplacer dans la section International > Français en éditant le titre.
OK, et tu as compris ce que le code en question fait et comment il le fait? Parce que pour le coup, ce n'est pas très difficile de dupliquer les parties de code nécessaires à la gestion d'un moteur supplémentaire et des boutons associés.
oui j"ai compris le code en gros . je vais être franc avec toi . j'ai acheter une maison ou il y a tout a faire et cette commande me perpétrait d' économiser 1 nano sur le système vmc et j'ai pas trop le temp pour du code hélas surtout que pour certaint ce code 2 moteurs doit être un jeu d'enfant lol
ais par avance merci
senshoraire c'est le nom pour faire tourner le moteur 1 ou le moteur 2?
Il y a deux boutons différents -> il faut 2 noms différents et 2 instructions différentes dans le setup.
Par exemple senshoraire1 et senshoraire2. Pareil pour sensantihoraire
Pour faire tourner le deuxième moteur, il faut aussi dupliquer le code dans loop
#include <Stepper.h>
Stepper pap1(200, 8, 9, 10, 11);
const byte brochePap1CW = A1; // le numéro de la broche du bouton senshoraire
const byte brochePap1CCW = A2; // le numéro de la broche du bouton sensantihoraire
Stepper pap2(200, 4, 5, 6, 7);
const byte brochePap2CW = A3; // le numéro de la broche du bouton senshoraire
const byte brochePap2CCW = A4; // le numéro de la broche du bouton sensantihoraire
int vitesse;
void setup() {
pinMode(brochePap1CW, INPUT_PULLUP);
pinMode(brochePap1CCW, INPUT_PULLUP);
pinMode(brochePap2CW, INPUT_PULLUP);
pinMode(brochePap2CCW, INPUT_PULLUP);
vitesse = map( analogRead(A0), 0, 1023, 0, 200);
}
void loop() {
// on regarde la vitesse souhaitée
int nouvelleVitesse = map( analogRead(A0), 0, 1023, 0, 200);
// si la vitesse a changé, on la mémorise et l'applique
if (nouvelleVitesse != vitesse) {
vitesse = nouvelleVitesse;
pap1.setSpeed(vitesse);
pap2.setSpeed(vitesse);
}
// si on a une vitesse non nulle, on teste les boutons
if (vitesse > 1) {
// moteur 1
if (digitalRead(brochePap1CW) == LOW) pap1.step(1);
else if (digitalRead(brochePap1CCW) == LOW) pap1.step(-1);
// moteur 2
if (digitalRead(brochePap2CW) == LOW) pap2.step(1);
else if (digitalRead(brochePap2CCW) == LOW) pap2.step(-1);
}
}
à noter que régler la vitesse pour ne faire qu'un seul pas ne sert à rien - cf la doc technique.
déjà un gros merci a tous
J-M-L je viens de tester ton code , il répond a mes besoins
juste un petit truc a la mise sous tension du nano et du drivers les moteurs sont a l'état libre , après une première action sur l'un des boutons il reste en mode bloquer. est il possible de débloquer les bobines si aucune action bouton ?
( économisons l'energie )
vous pouvez le rajouter dans un else en prenant les bonnes broches pour pap1 et pap2.
Mais si vous coupez le jus, il n'y a plus de couple donc comme vous dites c'est "libre". S'il y a une force qui s'applique sur ce qui est connecté aux moteurs, ça va bouger. C'est pour cela que je l'avais viré.
Généralement on utilise un driver pour un moteur pas à pas et il y a une broche enable qui permet de détacher le moteur.
En fait le programme du post 10 fonctionne quasiment. Voici celui qui fonctionne chez moi (juste rajouté le ; manquant):
#include <Stepper.h>
const int stepsPerRevolution1 = 200;
const int stepsPerRevolution2 = 200;
// const int stepsPerRevolution3 = 200; // Inutile
// const int stepsPerRevolution4 = 200; // Inutile
const int senshoraire1 = A1; // le numéro de la broche du bouton senshoraire
const int sensantihoraire2 = A2; // le numéro de la broche du bouton sensantihoraire
const int senshoraire3 = A3; // le numéro de la broche du bouton senshoraire
const int sensantihoraire4 = A4; // le numéro de la broche du bouton sensantihoraire
/* Ce serait plus logique de mettre 1 pour le moteur 1 et 2 pour le moteur 2:
const int senshoraire1 = A1; // le numéro de la broche du bouton senshoraire
const int sensantihoraire1 = A2; // le numéro de la broche du bouton sensantihoraire
const int senshoraire2 = A3; // le numéro de la broche du bouton senshoraire
const int sensantihoraire2 = A4; // le numéro de la broche du bouton sensantihoraire
Et bien sûr changer aussi dans le setup et dans loop */
// Initialise le moteur 1 sur les broches 9 10 11 12
Stepper myStepper1(stepsPerRevolution1, 9, 10, 11, 12);
// Initialise le moteur 2 sur les broches 5 6 7 8 // **************** corrigé le moteur 1 en moteur 2!
Stepper myStepper2(stepsPerRevolution2, 5, 6, 7, 8);
int vitessemoteur;
void setup() {
pinMode(senshoraire1, INPUT_PULLUP);
pinMode(sensantihoraire2, INPUT_PULLUP);
pinMode(senshoraire3, INPUT_PULLUP);
pinMode(sensantihoraire4, INPUT_PULLUP); // Manquait un ; en fin
}
void loop() {
int sensorReading = analogRead(A0); // A0 entre potentiometre
int motorSpeed = map(sensorReading, 0, 1023, 0, 200);
if (digitalRead(senshoraire1) == LOW && motorSpeed > 1) {
myStepper1.setSpeed(motorSpeed);
myStepper1.step(1);
}
else if (digitalRead(sensantihoraire2) == LOW && motorSpeed > 1) {
myStepper1.setSpeed(motorSpeed);
myStepper1.step(-1);
}
else {
digitalWrite (9, LOW);
digitalWrite (10, LOW);
digitalWrite (11, LOW);
digitalWrite (12, LOW);
}
//-------- moteur 2
// {
//int sensorReading = analogRead(A0); // A0 entre potentiometre
//int motorSpeed = map(sensorReading, 0, 1023, 0, 200);
if (digitalRead(senshoraire3) == LOW && motorSpeed > 1) {
myStepper2.setSpeed(motorSpeed);
myStepper2.step(1);
}
else if (digitalRead(sensantihoraire4) == LOW && motorSpeed > 1) {
myStepper2.setSpeed(motorSpeed);
myStepper2.step(-1);
}
else {
digitalWrite (5, LOW);
digitalWrite (6, LOW);
digitalWrite (7, LOW);
digitalWrite (8, LOW);
}
}
Je vais vérifier cela, parce que le programme ci dessus fonctionne avec la vitesse qui varie en fonction de la tension sur A0
Je viens de regarder le code source de stepper. La variable qui m'intéresse est last_step_time. Elle est mise à zéro à l'initialisation, et est mise à jour par
// get the timeStamp of when you stepped:
this->last_step_time = now;
après chaque pas.
Avant de faire un pas, une attente est faite par:
void Stepper::step(int steps_to_move)
{
....
unsigned long now = micros();
// move only if the appropriate delay has passed:
if (now - this->last_step_time >= this->step_delay)
Ce qui me fait dire que la fonction step ne fera un pas que si le temps correspondant à la vitesse actuelle est passé. La variable last_step_time n'est pas réinitialisée et temps d'attente est avant le pas et pas après.
Je pense donc fortement que régler la vitesse du pas à pas est utile même si on ne fait qu'un seul pas. Ce qui correspond à ce que j'ai observé.
Je ne vois pas dans la doc technique que le contraire soit dit.
J’avais l’impression en lisant la doc que c’était si vous demandiez 100 (plus de deux) pas alors l’intervalle de temps entre les pas respectait la vitesse, et je me disais que si on ne demandait qu’un seul pas, il n’y avait plus d’intervalle et donc il faisait le pas à chaque demande, même si elles étaient rapprochées. Je n’avais pas regardé le code.
Donc effectivement s’ils vérifient si suffisamment de temps s’est écoulé ou attend pour respecter la vitesse même entre deux appels consécutifs à step() alors c’est utile.
// 2 moteurs pas à pas et 4 boutons. Pour chaque moteur on a un bouton pour
// le faire tourner dans un sens et un bouton pour le faire tourner dans
//l'autre. Les deux moteurs sont indépendants.
// Un potentiomètre règle la vitesse entre 0 et 200tr/mn
// Voir https://forum.arduino.cc/t/2-moteur-pas-a-pas-4-boutons/1384039
#include // V1.0.5 Voir http://arduino.dansetrad.fr/MTobjects
const uint8_t sensHoraireMoteur1 = A1; // Numéro de la broche du bouton senshoraire
const uint8_t sensAntihoraireMoteur1 = A2; // Numéro de la broche du bouton sensantihoraire
const uint8_t sensHoraireMoteur2 = A3; // Numéro de la broche du bouton senshoraire
const uint8_t sensAntihoraireMoteur2 = A4; // Numéro de la broche du bouton sensantihoraire
// *************************** Pour le premier moteur *************************************
MTstepStepper Moteur1(pin_Step 2, pin_Dir 5, pin_EN 8, accelerations_sur 0 pas_ou_micro_pas);
void rotationSensHoraireMoteur1(void)
{
Moteur1.setSpeed((analogRead(A0) / 5) RPM);
Moteur1.move(CONTINUE);
}
void rotationSensAntihoraireMoteur1(void)
{
Moteur1.setSpeed((analogRead(A0) / 5) RPM);
Moteur1.move(-CONTINUE);
}
void arretMoteur1(void)
{
Moteur1.stop();
}
MTbutton boutonSensHoraireMoteur1(sensHoraireMoteur1, rotationSensHoraireMoteur1, arretMoteur1);
MTbutton boutonSensAntihoraireMoteur1(sensAntihoraireMoteur1, rotationSensAntihoraireMoteur1, arretMoteur1);
// *************************** Pour le deuxième moteur ************************************
MTstepStepper Moteur2(pin_Step 3, pin_Dir 6, pin_EN 8, accelerations_sur 0 pas_ou_micro_pas);
void rotationSensHoraireMoteur2(void)
{
Moteur2.setSpeed((analogRead(A0) / 5) RPM);
Moteur2.move(CONTINUE);
}
void rotationSensAntihoraireMoteur2(void)
{
Moteur2.setSpeed((analogRead(A0) / 5) RPM);
Moteur2.move(-CONTINUE);
}
void arretMoteur2(void)
{
Moteur2.stop();
}
MTbutton boutonSensHoraireMoteur2(sensHoraireMoteur2, rotationSensHoraireMoteur2, arretMoteur2);
MTbutton boutonSensAntihoraireMoteur2(sensAntihoraireMoteur2, rotationSensAntihoraireMoteur2, arretMoteur2);
// Pour mettre autre chose?
void setup(){}
void loop(){}
merci olivier super je vais expliquer rapide a quoi cela va servir en gros > Moteur monter sur de vannes pvc de 100 pour aspirer ou évacuer l'air après si vous voulez je peux envoyer photo du module 1mx2m si je peu me permettre j'ai aussi d'autre idées. je ne sais pas faire mais cela pourra i
intéresser d'autre personnes . 1> un problème de boucle ecs 2> régulation temperature apre j'attende conseil pour la démarche a suivre . mais encore merci a ceux qui savent
Il n'y a pas à remercier, le programme du post 10 fonctionne parfaitement. C'est au contraire moi que me confond en remerciements pour me donner un exemple concret pour illustrer ma bibliothèque. Et comme ce topic est cité dans mes pages, il est de bon ton que je le signale.
en bas à droite pour éditer votre message)