Bonjour,
J'ai actuellement un programme permettant de faire tourner un moteur dans les 2 sens. Je dois capter la vitesse d'un vélo pour que mon moteur fonctionne. Mon moteur doit tourner dans un sens quand la vitesse dépasse 10km/h.
J'ai un compteur de vitesse avec un aimant et je me demandais si je pouvais capter le signal du compteur et l'utiliser pour dire quand mon moteur doit tourner.
Si tu arrives à compter le nombre de tour de roue à la seconde ou minute c'est facile de connaitre la vitesse (théorique) en multipliant par le périmètre de la roue enfin je vais pas t'apprendre la regle de 3.
Si je calcule le nombre de changement d'état (état bas = aimant capté, état haut = aimant non capté) sur 15 secondes, logiquement il y a un état bas par tour quand l'aimant passe devant le capteur donc cela me donne le nombre de tours en 15 secondes. Je peux ensuite multiplier ce nombre par quatre pour l'avoir en tour/min non ?
Oui, si tu connais le nombre de tour en 15 secondes, tu multiplies par 4 pour connaître en 1 minute, ensuite multiplies par (Pi D) pour ta roue et tu connais ta vitesse en minute X 60 pour avoir en heure le tout mis en Km et tu connais ta vitesse en KM/H
Voici le code que j'ai fais, je voudrais savoir si c'est cohérent. Je n'ai pas encore pu le tester car je n'ai pas encore le capteur.
J'utilise un motor shield aussi.
int DIR_A = 12;
int PWM_A = 3;
int BRAKE_A = 9;
int sensorPin= 1; // Pin reliée au capteur magnétique
int etat = 0; // etat Pin
int ancien_etat = 0; // ancien etat Pin
long chrono = 0; // valeur courante du chrono
long chrono_depart = 0; // valeur de départ du chrono
long duree_test = 5000; // test sur 5 secondes
int nb_chgt = 0; // nombre de changement d'état, 1 par tour
void setup () {
pinMode (DIR_A, OUTPUT);
pinMode(BRAKE_A, OUTPUT);
pinMode(sensorPin,INPUT);
chrono_depart = millis();
}
void loop () {
etat=digitalRead(sensorPin);
if (millis()- chrono_depart < duree_test) {
if (etat != ancien_etat) {
nb_chgt = nb_chgt + 1 ;
ancien_etat = etat; }
} else {
if(nb_chgt*12 > 80) // *12 pour avoir des tours/min
digitalWrite(BRAKE_A, LOW);
digitalWrite(DIR_A, HIGH);
analogWrite(PWM_A, 255);
delay( 420 );
digitalWrite(BRAKE_A, HIGH);
}
chrono_depart=millis();
nb_chgt = 0;
etat=digitalRead(sensorPin);
if (millis()- chrono_depart < duree_test) {
if (etat != ancien_etat) {
nb_chgt = nb_chgt + 1 ;
ancien_etat = etat; }
} else {
if(nb_chgt*12 < 80)
digitalWrite(BRAKE_A, LOW);
digitalWrite(DIR_A, LOW);
analogWrite(PWM_A, 255);
delay( 420 );
digitalWrite(BRAKE_A, HIGH);}
}
Attendre 15 secondes pour effectuer une mesure me semble bien long, avec des délais de réaction « poussifs ».
Pourquoi ne pas mesurer la durée pour un tour, en déduire la vitesse linéaire à partir du périmètre de la roue n’est pas très compliqué ?
V = L / T donc V = P / T.
La vitesse est alors en mètres par seconde, convertir en km/heure n’est pas sorcier.
Seule subtilité dans le programme : Mesurer avec une bonne précision la période T pour un tour.
Sans me prendre la tête, j’attends que l’aimant est passé, j’ouvre une boucle avec un compteur qui incrémente toutes les 1mS par exemple et j’arrête le comptage au retour de l’aimant. Nous avons alors la période en mS ce qui est certainement exagérément précis.
Bonjour,
J'ai actuellement un problème avec mon programme il ne fonctionne pas correctement.
J'ai donc fais deux programmes séparant les deux fonctions et ils fonctionnent parfaitement tout seul.
Celui-ci vérifie si la vitesse est supérieur à 10km/h et fait tourner le moteur dans un sens.
code 1 :
int DIR_A = 12;
int PWM_A = 3;
int BRAKE_A = 9;
int sensorPin= 2; // Pin reliée au capateur magnétique
int etat = 0; // etat Pin
int ancien_etat = 0; // ancien etat Pin
long chrono = 0; // valeur courante du chrono
long chrono_depart = 0; // valeur de départ du chrono
long duree_test = 5000; // test sur 5 secondes
int nb_chgt = 0; // nb de changement etat Pin
void setup () {
Serial.begin (19200);
pinMode(sensorPin,INPUT);
Serial.println ("En cours de mesure ...");
chrono_depart = millis();
pinMode (DIR_A, OUTPUT);
pinMode(BRAKE_A, OUTPUT);
}
void loop() {
etat = digitalRead(sensorPin);
if (millis()- chrono_depart < duree_test) {
if (etat != ancien_etat) {
nb_chgt = nb_chgt + 1 ;
ancien_etat = etat;
}
} else {
Serial.print ("nombre de changement d'état : ");
Serial.print (nb_chgt);
Serial.println (" changements");
delay(5000);
if( nb_chgt*12>80){
digitalWrite(BRAKE_A, LOW);
digitalWrite(DIR_A, HIGH);
analogWrite(PWM_A, 255);
delay( 300 );
digitalWrite(BRAKE_A, HIGH);}
delay(10000);
Serial.println ("En cours de mesure ...");
chrono_depart=millis();
nb_chgt = 0;
}
}
Celui-ci vérifie si la vitesse est inférieur à 10km/h et fait tourner le moteur dans l'autre sens. Mais je veux que cette partie du code ne s'effectue qu'une fois que le moteur à tourné dans un sens car la vitesse était supérieur à 10km/h. Et mon moteur ne doit pas se remettre en route si la vitesse est encore supérieur à 10km/h au prochain test.
En gros quand le moteur a tourné dans un sens, après mon code ne doit que vérifier si la vitesse est inférieur à 10km/h. Une fois que la vitesse est inférieur à 10km/h il doit de nouveau verifier si la vitesse est supérieur à 10km/h.
Mais je n'y arrive pas donc je vous demande votre aide. Si mes explications ne sont pas claires ou s'il manque des infos dites le moi.
code 2 :
int DIR_A = 12;
int PWM_A = 3;
int BRAKE_A = 9;
int sensorPin= 2; // Pin reliée au capateur magnétique
int etat = 0; // etat Pin
int ancien_etat = 0; // ancien etat Pin
long chrono = 0; // valeur courante du chrono
long chrono_depart = 0; // valeur de départ du chrono
long duree_test = 5000; // test sur 5 secondes
int nb_chgt = 0; // nb de changement etat Pin
void setup () {
Serial.begin (19200);
pinMode(sensorPin,INPUT);
Serial.println ("En cours de mesure ...");
chrono_depart = millis();
pinMode (DIR_A, OUTPUT);
pinMode(BRAKE_A, OUTPUT);
}
void loop() {
etat = digitalRead(sensorPin);
if (millis()- chrono_depart < duree_test) {
if (etat != ancien_etat) {
nb_chgt = nb_chgt + 1 ;
ancien_etat = etat;
}
} else {
Serial.print ("nombre de changement d'état : ");
Serial.print (nb_chgt);
Serial.println (" changements");
delay(5000);
if( nb_chgt*12<80){
digitalWrite(BRAKE_A, LOW);
digitalWrite(DIR_A, LOW);
analogWrite(PWM_A, 255);
delay( 300 );
digitalWrite(BRAKE_A, HIGH);}
delay(10000);
Serial.println ("En cours de mesure ...");
chrono_depart=millis();
nb_chgt = 0;
}
}
hadopix:
En gros quand le moteur a tourné dans un sens, après mon code ne doit que vérifier si la vitesse est inférieur à 10km/h. Une fois que la vitesse est inférieur à 10km/h il doit de nouveau verifier si la vitesse est supérieur à 10km/h.
Et avec des if(...) Else(...) et des "OU" (||) et des "AND" (&&) tu t'en sors pas?
Où est-ce que je pourrais rajouter des "OU" ou des "ET" ? Je n'en ai jamais utilité étant que je suis débutant ^^
Est ce que sa pourrait marcher avec une boucle "tant que" ? tant que la vitesse > 80 , alors faire le code 2 ? et faire la même chose avec tant vitesse < 80, alors faire le code 1 ?
bonjour,
des choses comme ca, c'est source d'erreur
if( nb_chgt*12<80){
ca serait mieux
if( (nb_chgt*12) < 80){
idem pour
if (millis()- chrono_depart < duree_test) {
En gros quand le moteur a tourné dans un sens, après mon code ne doit que vérifier si la vitesse est inférieur à 10km/h. Une fois que la vitesse est inférieur à 10km/h il doit de nouveau verifier si la vitesse est supérieur à 10km/h.
Mais je n'y arrive pas donc je vous demande votre aide. Si mes explications ne sont pas claires ou s'il manque des infos dites le moi.
vu que la vitesse est < à 10km/h pour vérifier si elle est > 10k/h
c'est un non sens, non?
ou alors pas clair
En fait, mon moteur sert à remonter et à descendre un système de roulette sur un vélo couché. Elles ne servent que pour le démarrage et quand on ralentit car c'est pour stabiliser un vélo couché au départ et à l'arrivée ou quand on freine.
Quand mon vélo démarre, les roulettes sont au sol, mon programme doit alors vérifier quand est ce que la vitesse est supérieur à 10km/h. Si la vitesse > 10km/h, le moteur tourne et la roulette se lève.
Ensuite il doit vérifier si la vitesse repasse sous 10km/h et si c'est le cas.
Si la vitesse < 10km/h, le moteur tourne dans l'autre sens et les roulettes redescendent.
Peut-être que c'est plus clair comme ça.
Mais quand j'ai testé le premier programme que j'avais fait, il tournais après chaque test dans un sens ou l'autre selon la vitesse ou alors il ne faisait rien.
C'est juste que si mon moteur tourne deux fois de suite dans le même sens et ben le système appréciera pas ^^ et vélo ou vélo couché ou autre peut importe ^^
