Bonjour,
je suis en classe de Terminal STI2D et dans le cadre de mon projet de fin d'année je dois coder deux moteur avec deux potentiomètre.
j'ai réussi mais la vitesse n'est pas progressive elle passe de -140 a 140.
j'ai donc besoin d'aide pour que la vitesse soit progressive.
#include "CytronMotorDriver.h"
#include "pins_arduino.h"
// Configure the motor drivers.
CytronMD motor1(PWM_DIR, 3, 4); // PWM 1 = Pin 3, DIR 1 = Pin 4.
CytronMD motor2(PWM_DIR, 9, 10); // PWM 2 = Pin 9, DIR 2 = Pin 10.
const int potPin1 = A0; // Potentiometer 1 connected to analog pin A0
const int potPin2 = A1; // Potentiometer 2 connected to analog pin A1
void setup() {
pinMode(potPin1, INPUT); // Set potentiometer 1 pin as input
pinMode(potPin2, INPUT); // Set potentiometer 2 pin as input
Serial.begin(9600);
}
void loop() {
// Read potentiometer values
int potValue1 = analogRead(potPin1);
int potValue2 = analogRead(potPin2);
Serial.print("Valeur du potentiomètre 1 : ");
Serial.print(potValue1);
Serial.print(" | Valeur du potentiomètre 2 : ");
Serial.println(potValue2);
// Map potentiometer values to motor speeds
int pwmValue1 = map(potValue1, 0, 1023, -255, 255);
int pwmValue2 = map(potValue2, 0, 1023, -255, 255);
if ( (pwmValue1>-20) && (pwmValue1<20) ){
motor1.setSpeed(abs(pwmValue1));
motor1.setSpeed(0);
motor2.setSpeed(abs(pwmValue2));
motor2.setSpeed(0);
} else if (pwmValue1 > 0) {
motor1.setSpeed(abs(pwmValue1));
motor1.setSpeed(140);
} else if (pwmValue1 < 0) {
motor1.setSpeed(abs(pwmValue1));
motor1.setSpeed(-140);
} else if (pwmValue2 > 0) {
motor2.setSpeed(abs(pwmValue2));
motor2.setSpeed(140);
} else if (pwmValue2 < 0){
motor2.setSpeed(abs(pwmValue2));
motor2.setSpeed(-140);
}
delay(100);
}
}
Demandes tu une progressivité ?
As tu une connaissance au moins basique du langage c++, notamment l'utilisation des variables dans une boucle ou dans la fonction loop appelée en boucle?
Je ne suis pas familier de cette librairie mais le code suivant me parait suspect.
A priori tu demande que la librairie fasse tourner ton moteur 1 a la valeur absolue de pwmValue1 et immédiatement à près ramener la vitesse à 0.
Ton code ressemble un peu à l'exemple de base de la librairie, mais que tu aurais modifier en oubliant d'appliquer chaque valeur de vitesse au deux moteurs, plutôt qu'au même.
Je suis débutant dans le c++, je n'y connais pas grand chose j'ai encore beaucoup à apprendre.
La vitesse n'est pas progressive elle passe de 140 a -140 d'un coup sec
A vrai dire je voulais des conseils sur comment faire pour que la vitesse soit progressive avec le potentiomètre.
Ce n'est pas un soucis, on est tous passé par là
Par contre, il faut rester logique, si tu demande des choses contradictoire, il y a peu de chance que ton programme se comporte correctement.
A tu compris ce qui ne va pas dans le code que je t'ai montré?
Cela n'a pas de sens de demandé en même temps ou presque à ton moteur 1 de tourner à deux vitesses différentes.
dans l'exemple, il faisait tourner le moteur 1 à une vitesse et le moteur 2 à une autre.
Concernant ta demande de vitesse progressive.
Tu peux le faire dans un premier temps dans une boucle(for par exemple) en ajoutant un incrément à chaque itération pour aller de la vitesse actuel à celle demandé.
Je ne sais pas si ca te parle ?
L'idéal serait à terme, de ne pas faire une boucle, mais d'utilisé le fait que la fonction loop est appeler indéfiniment. Pour ne pas bloquer l'utilisation du potentiomètre, pendant l'accélération ou la décélération.
j'ai changé les valeur mais ça ne marche pas et je ne comprend pas le message d'erreur. Need help
Pour ceux qui ne comprennent pas mon but est de contrôler les deux moteurs avec deux potentiomètres (1 potentiomètre par moteur). la vitesse doit être progressive, pour l'instant la vitesse passe instantanément de -140 a 140 avec une plage de donnée pour que les moteur s'arrête.
#include "CytronMotorDriver.h"
#include "pins_arduino.h"
// Configure the motor drivers.
CytronMD motor1(PWM_DIR, 3, 4); // PWM 1 = Pin 3, DIR 1 = Pin 4.
CytronMD motor2(PWM_DIR, 9, 10); // PWM 2 = Pin 9, DIR 2 = Pin 10.
const int potPin1 = A0; // Potentiometer 1 connected to analog pin A0
const int potPin2 = A1; // Potentiometer 2 connected to analog pin A1
void setup() {
pinMode(potPin1, INPUT); // Set potentiometer 1 pin as input
pinMode(potPin2, INPUT); // Set potentiometer 2 pin as input
Serial.begin(9600);
}
void loop() {
// Read potentiometer values
int potValue1 = analogRead(potPin1);
int potValue2 = analogRead(potPin2);
Serial.print("Valeur du potentiomètre 1 : ");
Serial.print(potValue1);
Serial.print(" | Valeur du potentiomètre 2 : ");
Serial.println(potValue2);
// Map potentiometer values to motor speeds
int pwmValue1 = map(potValue1, 0, 1023, -255, 255);
int pwmValue2 = map(potValue2, 0, 1023, -255, 255);
if ( (pwmValue1>-20) && (pwmValue1<20) ){
motor1.setSpeed(abs(pwmValue1));
motor1.setSpeed(0);
motor2.setSpeed(abs(pwmValue2));
motor2.setSpeed(0);
} else if (pwmValue1 > 0) {
motor1.setSpeed(abs(pwmValue1));
pwmValue1.setSpeed(140);
} else if (pwmValue1 < 0) {
motor1.setSpeed(abs(pwmValue1));
pwmValue1.setSpeed(-140);
} else if (pwmValue2 > 0) {
motor2.setSpeed(abs(pwmValue2));
pwmValue2.setSpeed(140);
} else if (pwmValue2 < 0){
motor2.setSpeed(abs(pwmValue2));
pwmValue2.setSpeed(-140);
}
delay(100);
}
le faite de changer les valeurs ne va pas rendre la demande progressive!
Comme je te l'ai indiqué dans mon précédent message c'est à toi de le faire et je t'ai donné une façon de le faire.
As tu essayé de le mettre en œuvre ?
@fdufnews t'a aussi donné une façon de le faire, as tu aussi essayer de le mettre en oeuvre?
Ce code compile ?
la variable pwmValue1 étant du type de base pour définir un entier, ce n'est pas un objet qui possède des fonctions que l'on peut appeler.
Que voulais tu faire en écrivant cette partie ?
Si tu ne comprends pas une question, ne l'évite pas, indique simplement, que tu ne comprends pas ce que l'on veut t'indiquer.
merci de répondre aussi rapidement.
Je n'ai pas essayé votre technique ou celle de @fdufnews car je ne les comprenais pas.
je ne sais pas pourquoi cela ne marche pas
voici le message d'erreur.
merci d'avance de ta réponse.
error: request for member 'setSpeed' in 'pwmValue2', which is of non-class type 'int'
Comme je te l'ai indiqué la fonction setSpeed appartient à la classe CytronMD
Ta variable pwmValue2 n'est pas du type CytronMD?
comme la variable pwmValue2 représente la position te ton potentiomètre et que les valeurs que tu as définis et entre -255 et 255, si ton potentiomètre est en pile position médiane, alors pwmValue2 vaudrait 0.
avec l'instruction "pwmValue1.setSpeed(140);" tu demandes à ton programme de faire 0.setSpeed(140), ce qui n'a pas de sens
Je ne sais pas à qui tu t'adresse, je ne t'ai pas conseillé de librairie
Comprends tu la notion de variable ?
As tu compris l'utilité/fonctionnalité de la fonction "loop"?
quand je n'utilise pas pwmValue le moteur ne veut pas tourner (il ne fonctionne pas).
dans les premiers message vous me proposé une librairie.
je comprend la notion de variable et la fonctionnalité de la fonction loop (dois je enlever la fonction loop selon toi ?).
A noter quand même que depuis maintenant 1 semaine tu dis ne pas arriver a obtenir une vitesse progressive, tu fais des modifications de code au hasard mais en même temps tu n'expliques pas comment ton système devrait se comporter.
Quand on a un problème on le pose clairement en fournissant les informations nécessaires.
les données d'entrée,
les données de sorite
le comportement attendu,
le comportement obtenu
Si on analyse un peu ton code et le sens de tes questions, on en déduit que tu as le matériel suivant:
il y a 2 moteurs, 2 potentiomètres. Chaque potentiomètre est associé à un moteur.
il y a une plage de débattement du potentiomètre morte pour laquelle on arrête le moteur.
Il y a une plage de débattement du potentiomètre qui fait tourner le moteur dans un sens.
Il y a une plage de débattement du potentiomètre qui fait tourner le moteur dans l'autre sens.
On va dire par convention que:
la zone morte se trouve au milieu de la plage de débattement du potentiomètre.
si on tourne le potentiomètre vers la gauche, au-delà de la zone morte, le moteur doit tourner dans le sens antihoraire.
si on tourne le potentiomètre vers la droite, au-delà de la zone morte, le moteur doit tourner dans le sens horaire.
lorsque la position du potentiomètre est hors de la zone morte, la vitesse des moteurs doit être proportionnelle à la position. La vitesse la plus lente lorsque le potentiomètre est proche de la zone morte, la plus rapide lorsque le potentiomètre est dans l'une des deux butées.
Les lignes:
pwmValue1.setSpeed(140);
pwmValue1.setSpeed(-140);
pwmValue2.setSpeed(140);
pwmValue2.setSpeed(-140);
Ne servent à rien, elle faussent la lecture des potentiomètres:
// Map potentiometer values to motor speed|
int pwmValue1 = map(potValue1, 0, 1023, -255, 255);
int pwmValue2 = map(potValue2, 0, 1023, -255, 255);
, d'autant plus que tu ne peut pas mettre une valeur ainsi dans la variable pwmValue1 ou pwmValue2 ainsi. Tu peux faire pwmValue1 = 140, par exemple.
Non ce n'est pas ce que je veux faire, pour l'instant les moteurs avance recule et ce stop brusquement. Mon but est de faire varier la vitesse progressivement (en fonction de l'inclinaisons du potentiomètre vers l'avant de 30° et vers l'arrière de 30°).
Faut il que je te donne plus d'infos comme le matériel utilisé ou bien autre chose ?
