Je dispose d'une carte Arduino UNO et je voudrais y relier 2 moteurs PaP et 2 potentiomètres.
J'arrive sans problème à faire fonctionner 1 moteur et varier sa vitesse à l'aide de mon potentiomètre.
Mon problème est si je câble 2 moteurs Pap et deux potentiomètres et que j'imbrique le code pour ces deux moteurs, ça ne fonctionne pas...
Voici un aperçu de mon code pour 1 moteur...
Texte préformaté// Rotation moteur et Vitesse par Potentiometre OK 30/09/2022
// Rotation moteur et Vitesse par Potentiometre OK 30/09/2022
int tempo=1;
int tourne=0;
int vitesse=1;
#define dirPin 6
#define stepPin 3
#define stepsPerRevolution 200
void setup() {
// Declare pins en sorties:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Changement de direction:
digitalWrite(dirPin, LOW);
vitesse = analogRead(A0); // On lit la valeur du potentiomètre
tempo = map(vitesse, 0, 1023, 850, 1500); // On convertit la valeur du potentiomètre en vitesse
//Mouvement du moteur:
for (int i = 0; i < stepsPerRevolution; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(tempo);
digitalWrite(stepPin, LOW);
delayMicroseconds(tempo);
}
}
Voici mon code imbriqué, mais il ne fonctionne pas!`
int tempo=1;
int tourne=0;
int vitesse=1;
int tempo1=1;
int tourne1=0;
int vitesse1=1;
#define dirPin 6
#define stepPin 3
#define dirPin 13
#define stepPin 12
#define stepsPerRevolution 200
void setup() {
// Declare pins en sorties
pinMode(stepPin 3, OUTPUT);
pinMode(dirPin 6, OUTPUT);
pinMode(stepPin 12, OUTPUT);
pinMode(dirPin 13, OUTPUT);
}
void loop() {
// selection du sens de rotation:
digitalWrite(dirPin,6, LOW);
vitesse = analogRead(A0); // On lit la valeur du potentiomètre
tempo = map(vitesse, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
// Spin the stepper motor 1 revolution :
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin3, HIGH);
delayMicroseconds(tempo);
digitalWrite(stepPin3, LOW);
delayMicroseconds(tempo);
digitalWrite(dirPin,13, LOW);
vitesse = analogRead(A1); // On lit la valeur du potentiomètre
tempo = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
for (int i = 0; i < stepsPerRevolution; i++) {
digitalWrite(stepPin12, HIGH);
delayMicroseconds(tempo1);
digitalWrite(stepPin12, LOW);
delayMicroseconds(tempo1);
}
Ton code n'est pas vraiment imbriqué, mais séquentiel, tu essaye de faire tourner moteur 1, puis moteur 2.
Tu ne calcule pas tempo1, qui vaut toujours 1, tu n'utilise pas la valeur renvoyé par analogRead(A1)
Si tu corrige tes mauvais copier/coller que ce passe t-il?
Tu as fait un copier/coller te ton code pour le premier moteur, mais tu n'as pas tout changé.
digitalWrite(dirPin,13, LOW);
vitesse = analogRead(A1); // On lit la valeur du potentiomètre
tempo = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
Hors tu voulais plutôt ça
digitalWrite(dirPin,13, LOW);
vitesse1 = analogRead(A1); // On lit la valeur du potentiomètre
tempo1 = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
Oui j'ai fait des changements car ça ne compilait pas et je me suis un peu égaré... De toute façon, même lorsque j'arrive à compiler (après de nombreux tests) ça ne fonctionne pas au mieux, mes deux moteurs tournent mais le potentiomètre agit sur les deux en même temps. Il me faut une commande de vitesse séparée.
tu as fais les changements que je t'ai indiqué et tes deux moteurs tournent à la même vitesse, l'un après l'autre?
Peux tu donner ton dernier code testé et dire exactement le comportement?
Hélas, malgré ces changements, le code génère des erreurs et ne compile pas. Avec toutes les modifs que j'ai fais, j'ai mélangé le code qui tournait sans prendre en compte la vitesse des moteurs séparément.
Voici mon dernier code. Moteur 1 sur Y et moteur 2 sur X (sur mon shield CNC).
Le code compile, mais aucun moteur ne tourne...
int tempo=1;
int tourne=0;
int vitesse=1;
int tempo1=1;
int tourne1=0;
int vitesse1=1;
#define dirPin 6
#define stepPin 3
#define dirPin 13
#define stepPin 12
#define stepsPerRevolution 200
void setup() {
// Declare pins en sorties
pinMode (stepPin , OUTPUT);
pinMode(dirPin , OUTPUT);
pinMode (A0, INPUT);
pinMode (A1, INPUT);
}
void loop() {
// selection du sens de rotation:
// digitalWrite dirPin , LOW;
vitesse = analogRead(A0); // On lit la valeur du potentiomètre
tempo = map(vitesse, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
// digitalWrite dirPin , LOW;
vitesse = analogRead(A1); // On lit la valeur du potentiomètre
tempo1 = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
// Moteur 1 :
for (int i = 0; i < stepsPerRevolution; i++)
// These four lines result in 1 step:
digitalWrite (stepPin, HIGH);
delayMicroseconds(tempo);
digitalWrite (stepPin, LOW);
delayMicroseconds(tempo);
//Moteur 2
for (int i = 0; i < stepsPerRevolution; i++)
digitalWrite (stepPin, HIGH);
delayMicroseconds(tempo1);
digitalWrite (stepPin, LOW);
delayMicroseconds(tempo1);
}
Pourquoi ne pas utiliser une bibliothèque comme AccelStepper, elle s'occuperai de générer les signaux et tu pourras, ainsi, imbriquer tes 2 moteurs plus aisément.
Quel type de moteur as-tu et quel driver?
Des détails sur AccelStepper, ici.
Voici mon dernier code qui compile et qui actionne bien les deux moteurs. Par contre, seul le potentiomètre relié sir A0 permet de varier la vitesse, mais des deux moteurs simultanément
int tempo=1;
int tourne=0;
int vitesse=1;
int tempo1=1;
int tourne1=0;
int vitesse1=1;
const int dirPiny=6;
const int stepPiny=3;
const int dirPinx=5;
const int stepPinx=2;
#define stepsPerRevolution 200
void setup() {
// Declare pins en sorties
pinMode (stepPinx, OUTPUT);
pinMode(dirPinx, OUTPUT);
pinMode (stepPiny, OUTPUT);
pinMode(dirPiny, OUTPUT);
pinMode (A0, INPUT);
pinMode (A1, INPUT);
}
void loop() {
// selection du sens de rotation:
digitalWrite (dirPinx , LOW);
vitesse = analogRead(A0); // On lit la valeur du potentiomètre
tempo = map(vitesse, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
digitalWrite (dirPiny , HIGH);
vitesse = analogRead(A1); // On lit la valeur du potentiomètre
tempo1 = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
// Moteur 1 :
for (int i = 0; i < stepsPerRevolution; i++)
// These four lines result in 1 step:
digitalWrite (stepPiny, HIGH);
delayMicroseconds(tempo);
digitalWrite (stepPiny, LOW);
delayMicroseconds(tempo);
//Moteur 2
for (int i = 0; i < stepsPerRevolution; i++)
digitalWrite (stepPinx, HIGH);
delayMicroseconds(tempo1);
digitalWrite (stepPinx, LOW);
delayMicroseconds(tempo1);
}
Je ne saisi pas ce qui bloque...
Je vais me pencher vers cette librairie AccelStepper, mais étant vraiment novice, j'aurai aimé trouver un exemple applicable.
Je pense que utiliser une librairie tel que AccelStepper sera une bonne idée.
mais il faut d'abords respecter les bases.
tempo1 est à priori basé sur vitesse1, mais tu ne récupère pas la position de ton potentiomètre dans vitesse1, mais vitesse.
Cela fait plusieurs fois que je te l'indique.
Essaye de faire attention à ce que tu veux faire et ce que tu fais dans ton code.
Puis essaye de comprendre ce que fait chacune de tes instructions.
Après tes erreurs n'explique pas pourquoi ça ne marche pas comme tu veux, mais là le code ne correspond déjà pas à ce que tu veux faire
Même en utilisant une librairie qui ferra correctement le "multitâche", si tu ne maitrise pas plus ce que tu fais, cela sera de toute façon compliqué.
Bon, avec ce code et en tenant compte des conseils et corrections mentionnées ci-dessus, mes deux moteurs tournent mais les deux potentiomètres agissent simultanément sur les deux moteurs! Bref, c'est pas encre ça...
int tempo=1;
int tourne=0;
int vitesse=1;
int tempo1=1;
int tourne1=0;
int vitesse1=1;
const int dirPiny=6;
const int stepPiny=3;
const int dirPinx=5;
const int stepPinx=2;
#define stepsPerRevolution 200
void setup() {
// Declare pins en sorties
pinMode (stepPinx, OUTPUT);
pinMode(dirPinx, OUTPUT);
pinMode (stepPiny, OUTPUT);
pinMode(dirPiny, OUTPUT);
pinMode (A0, INPUT);
pinMode (A1, INPUT);
}
void loop() {
// selection du sens de rotation:
digitalWrite (dirPinx , LOW);
vitesse = analogRead(A0); // On lit la valeur du potentiomètre
tempo = map(vitesse, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
digitalWrite (dirPiny , HIGH);
vitesse1e = analogRead(A1); // On lit la valeur du potentiomètre
tempo1 = map(vitesse1, 0, 1023, 500, 1500); // On convertit la valeur du potentiomètre en vitesse
// Moteur 1 :
for (int i = 0; i < stepsPerRevolution; i++)
// These four lines result in 1 step:
digitalWrite (stepPiny, HIGH);
delayMicroseconds(tempo);
digitalWrite (stepPiny, LOW);
delayMicroseconds(tempo);
//Moteur 2
for (int i = 0; i < stepsPerRevolution; i++)
digitalWrite (stepPinx, HIGH);
delayMicroseconds(tempo1);
digitalWrite (stepPinx, LOW);
delayMicroseconds(tempo1);
}
Oui, ton intension est fort louable, mais tu débutes "fort", faire tourner 2 moteurs pas à pas (MPAP), en même temps et à des vitesses différentes. Tu ne pourrais qu'être déçu du résultat.
Contentes toi, pour débuter, de ne faire tourner, à une vitesse variable, qu'un MPAP. Ensuite, avec une bibliothèque, fais le avec 2 MPAP.
Les moteurs sont des Nema 17 et les drivers sont des DRV8825. Le tout sur un UNO et Shield CNC.
Oui, je sais je ne démarre pas par du plus simple (Je m'en rend compte à mes dépends).
Mais en fait c'est une application pratique qui exige ce fonctionnement. C'est un système expérimental sans prétention dont mon fils à besoin pour une application pratique. Je suis retraité et ça m'occupe entre autres choses et j'aime ça.
, donne ton code et les erreurs de compilation que cela te donne
