Salut je suis élève en classe de terminal de STI2D et j'aimerai solliciter votre pour mon projet de SIN. Mon projet porte sur le vélo à assistance électrique et mon travail à moi c'est l'acquisition la vitesse en km/h du cycle. Et pour avoir la vitesse du vélo parcourir j'ai opter comme solution le capteur ILS sur fourche et un aimant sur rayon. En effet lors du pédalage le capteur détectera la présence de pédalage grâce au passage de l'aimant devant le capteur. Ce compteur de tour me permettra à travers un programme Arduino de recevoir le nombre de tour effectué et de calculer la vitesse. Mais vu que je n'es pas de capteur à ma disposition je fais une simulation avec le capteur de l’anémomètre.

J'ai crée un programme mais il ne marche pas comme je voulais:

int anemo = 3;

int nbrcompt = 0;

long vitesse = 0;

long chrono = 0 ;

long chronodepart =0 ;

long duree = 0 ;

void nbrcomptage()

{

nbrcompt++;

}

serial.begin(9600);

pinMode(anemo,INPUT);

chronodepart = millis();

}

void loop()

{

delay(500);

chrono = millis();

vitesse = nbrcompt/chrono*60;

if (chrono - chronodepart > dureetest) {

  serial.print ("nbrcompt");

  serial.print ("chrono");

  serial.print ("vitesse");

}

}

Merci d'avance pour ce qui voudrons bien m'aider .

-
Edité par LauraineDigbeuti 17 avril 2017 à 23:06:57

Sans les balises code, c'est illisible...

Il te faut poster ton code en utilisant le bouton </>.

Une petite explication de ce qui ne marche pas serait aussi bienvenu.

Est-ce que le programme ne marche pas du tout et affiche toujours 0 ?

Est-ce que le programme affiche un nombre incorrect ?

Autre ?

En regardant rapidement ton programme, tu as probablement un problème ici : nbrcompt/chrono*60

Tes variables son de type int ou long donc la division sera une dision entière qui donnera un nombre entier (1, 2, 3, 4...)

Puis quand tu vas faire la multiplication, tu vas forcément obtenir des nombres multiple de 60 : 60, 120, 180, 240...

Le plus simple serait de faire le calcul sur des flotant : ((float)nbrcompt)/((float)chrono)*((float)60)

Ensuite, pour l'affichage, ce serait bien d'afficher les variables en plus du texte.

serial.print("nbrcompt=");
serial.print(nbrcompt);
serial.println();
serial.print("chrono=");
serial.print(chrono);
serial.println();
serial.print("vitesse=");
serial.print(vitesse);
serial.println();

Merci de m'avoir répondu .

D'abord,  j'aimerai savoir à quoi sert la fonction millis (); Ensuite dans mon programme j'aimerai avoir la vitesse en tr/mn puis en km/h mais je ne sais comment faire.

Au début de mon programme j'avais crée une variable long dureetest = 60000; //  Pour tester le nombre de tour sur une minute

Mais lorsque je fais la simulation le terminal série m'affiche que le chrono des valeurs en mille ... et pour la vitesse, le comptage de tour il m'affiche 0.

Pour la formule de calcul de vitesse (vitesse = nbrcompt/chrono*60 ) je ne suis pas sur .

La fonction millis renvoie le nombre de millis seconde écoulé depuis le début du programme arduino.

C'est pratique pour déclencher une action après un certain temps sans avoir à bloquer le programme avec la fonction delais.

----------

Passer de tr/min en km/h nécessite de connaitre le rayon de la roue.

En effet, une roue énorme parcourt plus de distance (et donc avance plus vite) qu'une roue toute petite tournant à la même vitesse de rotation en tr/min.

En un tour, la distance parcourut correspond au périmètre de la roue soit 2*pi*rayon

Avec un rayon en cm et une vitesse de rotation en tr/min, on a la vitesse en km/h qui vaut : nbTrMin*60*2*pi*rayon/100000

-
Edité par lorrio 18 avril 2017 à 23:23:07

Merci pour votre réponse sur la fonction millis .

Le rayon de ma roue faire 26 pouces = 0.6604 m ,ensuite pouvez vous m'expliquer pourquoi vous faites nbTrMin*60*2*pi*rayon/100000 ? D’où vient les 100000 que vous divisez?

J'ai réfléchi à un nouveau programme qui pourrait me donner le nombre de comptage, la vitesse en tr/min et la vitesse en km/h mais il ne m'affiche toujours des 0

float rayon=0.6604;
float rpm=0;
float vitesse=0;
long temps = 0;
long tempsecoule = 0;
long dureetest = 0;
volatile int comptageImpulsion = 0;

void setup(){

Serial.begin(11520);
tempecoule = millis();
attachInterrupt(1,compteurImp,RISSING);

}

void loop(){

temp = millis();
if(temps - tempsecoule >= dureetest){
rpm = comptageImpulsion/dureetest ;
vitesse =(rpm*2*3.14*rayon/60);
Serial.print("comptageImpulsion=");
Serial.print(comptageImpulsion);
Serial.println();
Serial.print("temps=");
Serial.print(temps);
Serial.println();
Serial.print("rpm=");
Serial.print(rpm);
Serial.println();
Serial.print("vitesse=");
Serial.print(vitesse);
Serial.println();
 
comptageImpulsion = 0;

while(1){}
}
}

void compteurImpu(){
comptageImpulsion = comptageImpulsion+1;
}

. 

lorrio a écrit:

Avec un rayon en cm et une vitesse de rotation en tr/min, on a la vitesse en km/h qui vaut : nbTrMin*60*2*pi*rayon/100000

On va un résultat de sortie en km par heure alors qu'on a une entrée en tours par minutes.

Il y a 60 minutes dans une heure dans on multiplie par 60.

En un tours, la distance parcourut correspond au périmètre de la roue, donc on multiplie le nombre de tours par 2*pi*rayon pour avoir la distance.

J'ai aussi précisé que le rayon était en cm donc pour avoir une distance en km, il faut diviser par 100000.

----------

Tu as un problème dans tes formules :

long dureetest = 0;

rpm = comptageImpulsion/dureetest ;

En math, une division par 0 est strictement interdite.

Sur arduino, je ne sais pas comment ça se passe... peut-être que le résultat fait 0.

----------

Tu as aussi un problème sur l'architecture car tu fais ton affichage dans setup au lieux de le faire dans loop.

OK merci pour ta réponse mais je ne crois pas nécessaire de diviser par 100000 pour avoir avoir la vitesse en km/h car j'ai déjà converti le rayon en mètre.

Je ne vois pas le problème sur l'architecture de mon programme.

J'ai corrigé mon programme en écrivant long dureetest = 60000;

-
Edité par LauraineDigbeuti 21 avril 2017 à 18:15:51

Faire un affichage toutes les minutes, c'est pas super pour l'utilisateur...

Il serait plus judicieux de faire un affichage toutes les 5 secondes.

Quand à ne pas diviser par 100000, c'est valable si ton rayon est en km (si tu laisses ton rayon en mètre, alors tu auras une vitesse en m/h)

Mais avant de partir dans ces calculs compliqué, tu ferais mieux de vérifier que ton capteur marche en affichant le nombre d'impulsions détecté.

Exemple:

long temps = 0;
long tempsecoule = 0;
long dureetest = 3000;

volatile int comptageImpulsion = 0;
 
void setup(){
	Serial.begin(115200);
	temps = millis();
	attachInterrupt(1,compteurImp,RISSING);
}
 
void loop(){

	tempsecoule = ( millis() - temps );

	if ( tempsecoule >= dureetest ) {

		Serial.print("comptageImpulsion=");
		Serial.print(comptageImpulsion);

		comptageImpulsion = 0;
		temps = millis();

	}

}

void compteurImpu(){
	comptageImpulsion = comptageImpulsion+1;
}

Une fois que tu es certain que ton capteur marche, alors tu pourras convertir ta vitesse.

Exemple :

long temps = 0;
long tempsecoule = 0;
long dureetest = 3000;
double vitesse = 0.0;

volatile int comptageImpulsion = 0;
 
void setup(){
	Serial.begin(115200);
	temps = millis();
	attachInterrupt(1,compteurImp,RISSING);
}
 
void loop(){

	tempsecoule = ( millis() - temps );

	if ( tempsecoule >= dureetest ) {

		Serial.print("comptageImpulsion=");
		Serial.print(comptageImpulsion);

		// Pour le moment, notre vitesse est en nombre d'impulsion par tempsecoule 
		vitesse = comptageImpulsion;

		// On converti la vitesse en nombre d'impulsion par heures
		vitesse = ( vitesse * ( 1000.0 * 60.0 * 60.0 ) / tempsecoule );
		
		// On converti la vitesse en km par heures
		vitesse = ( vitesse * ( 2.0 * 3.14 * 0.6604 / 1000.0 ) );
		
		Serial.print("vitesse=");
		Serial.print(vitesse);
		
		comptageImpulsion = 0;
		temps = millis();

	}

}

void compteurImpu(){
	comptageImpulsion = comptageImpulsion+1;
}

-
Edité par lorrio 25 avril 2017 à 19:24:57

salut merci pour les programmes j'ai faire des tests avec les deux programmes et sa m'affiche des valeurs cohérents. 

Par contre je ne comprends pas le calcul de vitesse et aussi la ligne temps = (millis() - temps);

vitesse = ( vitesse * ( 1000.0 * 60.0 * 60.0 )/dureetest );
         
        // On converti la vitesse en km par heures
vitesse = ( vitesse * ( 2.0 * 3.14 * 0.6604 / 1000.0 ) );
         

Ah tient, petite erreur, il serait plus logique d'avoir vitesse = ( vitesse * ( 1000.0 * 60.0 * 60.0 ) / tempsecoule ); plutôt que vitesse = ( vitesse * ( 1000.0 * 60.0 * 60.0 ) / dureetest );

Mais bon, cela ne change pas grand chose.

----------

Pour en revenir à ta question, le programme provoque un affichage toutes 3 secondes environ grâce à cette architecture :

void loop() {

	tempsecoule = ( millis() - temps );

	if ( tempsecoule >= dureetest ) {

		[...]
	
		temps = millis();

	}
	
}

Au départ, millis() vaut 0 et temps vaut 0.

De ce fait, tempsecoule = ( millis() - temps ); vaudra aussi 0.

Du coup, le programme ne rentre pas dans le if car 0 n'est pas supérieur ou égal à 3000.

Petit à petit, le temps s'écoule donc la valeur de millis() augmente : 1, 2, 3, ... jusqu'à atteindre 3000.

A ce moment là, tempsecoule = ( millis() - temps ); vaudra 3000 donc le programme rentre dans le if.

En rentrant dans le if, il provoque un affichage puis exécute temps = millis(); donc temps vaudra 3000 à partir de maintenant.

Puis loop recommence avec tempsecoule = ( millis() - temps ); qui cette fois ci vaut 0 car 3000 - 3000 = 0.

Et encore petit à petit, le temps s'écoute donc la valeur de millis() augmente encore : 3001, 3002, 3003... jusqu'à atteindre 6000.

A ce moment là tempsecoule = ( millis() - temps ); vaudra 3000 (car 6000-3000=3000) donc le programme rentre dans le if.

En rentrant dans le if, il provoque un affichage.

Et ainsi de suite, on a un affichage toutes les 3 secondes quand millis = 3000, 6000, 9000...

Si tu changes la valeur de dureetest pour mettre 2000, tu auras un affichage toutes les 2 secondes.

----------

Quand à l'affichage de la vitesse en km/h, on sait que comptageImpulsion impulsion contient le nombre d'impulsion qu'il y a eu sur ces 3 secondes.

Vu qu'on veut une vitesse en km/h, il faudrait que l'on connaisse le nombre d'impulsions qu'il y a eu une heure.

Donc il faudrait multiplier comptageImpulsion par 1200 étant donné qu'il y a 1200 fois 3 secondes en une heure.

Et ça, c'est justement l'objectif de la ligne vitesse = ( vitesse * ( 1000.0 * 60.0 * 60.0 ) / dureetest );

En effet, je te laisse faire le calcul et tu verras que ( 1000.0 * 60.0 * 60.0 ) / dureetest = ( 1000.0 * 60.0 * 60.0 ) / 3000 = 1200.

Si tu veux savoir d'où viennent ces chiffres, c'est facile :

- il y a 1000ms en une seconde, d'où le 1000.

- il y a 60 secondes en une minute, d'où le premier 60

- il y a 60 minutes en une heure, d'où le seconde 60

- puis la division par dureetest qui est en ms

On sait que la roue fait un tour par impulsion donc une fois qu'on connait le nombre d'impulsions par heure, il n'y a plus qu'à multiplier ce nombre par la distance parcourue en un tour pour avoir la vitesse en km/h.

C'est justement l'objectif de la ligne vitesse = ( vitesse * ( 2.0 * 3.14 * 0.6604 / 1000.0 ) ); sachant que

- la multiplication par 2.0 * 3.14 * 0.6604 correspond à la formule du périmètre (2*pi*rayon)

- la division par 1000 permet de passer en km sachant que le rayon est en mètre.

-
Edité par lorrio 25 avril 2017 à 19:43:34

Salut merci pour votre explication je comprends mieux le calcul et encore merci pour votre aide sa m'a été d'une grande aide

Salut lorrio je rencontre un problème au niveau du programme. j'ai fait le test avec le capteur de vitesse et un aimant et le programme m'affiche des vitesses à l'infini qui sont 10 fois plus grand que ce dont je devais avoir. Mon souci est que ma vitesse afficher sur le terminal série n'est pas constant ni cohérent exemple au lieu 12 km/h il m'affiche 43km/h, 58, 79 ...

Ce serait bien que tu nous donnes le code que tu as ainsi qu'un copié/collé exact de ce qu'il s'affiche dans la console.

unsigned long dureetest = 2000;
float vitesse = 0.0;
float rph = 0.0;
float distance = 0;
volatile int comptageImpulsion = 0;

void setup(){

serial.begin(115200);
temps = millis();
attachInterrupt(1,compteurImp,RISING);

}

void loop(){

tempsecoule = millis()-temps;
distance = 100 * vitesse * (tempsecoule/(3600.0*1000.0));

if (tempsecoule >= dureetest){

 serial.print("comptageImpulsion=");
 serial.print(comptageImpulsion);
 serial.println();

 serial.print("distance=");
 serial.print(distance);
 serial.println();

rph = comptageImpulsion;

rph =(rph*(1000.0*3600.0)/tempsecoule);

vitesse = (rph*(2.0*3.14*0.3048/1000.0));

 serial.print("vitesse=");
 serial.print(vitesse);
 serial.println();

comptageImpulsion = 0;
temps = millis();
}
}

void compteurImp(){
comptageImpulsion = comptageImpulsion + 1;

}

je reçois sur le terminale :

comptageImpulsion = 0

distance = 0.00

vitesse = 0.00

comptageImpulsion = 52

distance = 0.00

vitesse = 179.16

comptageImpulsion = 86

distance = 9.95

vitesse = 296.31

comptageImpulsion = 78

distance = 16.46

vitesse = 268.75

Excusez moi d'avoir écrire car je n'arrivais pas à faire un copie coller, voila ce que m'affiche mon programme au lieu d'une vitesse de 22 km/h que me mesure un autre capteur de vitesse .

-
Edité par LauraineDigbeuti 15 mai 2017 à 18:23:08

52 impulsions (voir même parfois plus) en 2 secondes, ça me parait beaucoup.

Cela voudrait dire que ta roue fait plus de 25 tours par secondes, je n'y crois pas trop.

Ce n'est donc pas étonnant que tu trouves des vitesses de l'ordre de 200 km/h.

C'est quoi comme capteur que tu utilises ???

As tu vérifié qu'il n'y a pas une phénomène de rebond sur ton capteur ?

Parce que si il y a des rebonds sur ta capteur, ton arduino va détecter plusieurs impulsions au lieux d'une seule, ce qui explique les valeurs aberrante.

----------

Je profite aussi de ce message pour faire une petite parenthèse sur ton calcul de la distance qui est complètement faux.

Pour t'en rendre compte, imaginons que tu pédales à 20km/h pendant deux heures puis que tu t'arrêtes.

Étant à l'arrêt, ta vitesse est de 0 donc ton, calcul 100 * vitesse * (tempsecoule/(3600.0*1000.0)) va donner le résultat 0 alors que tu auras parcourut 40km.

J'ai comme capteur un capteur ILS . Ce qui me dérange c'est le nombre d'impulsion que m'affiche le terminal et à chaque fois j'ai des impulsions en plus alors je me demande si le problème vient du capteur où de mon programme ???

Pour ce qui est de la formule de distance on sait que vitesse = distance/temps équivaut à distance =vitesse * temps . Et comme ma vitesse est en km/h et le tempsecoule en millisecondes alors je le convertir en heure d'où tempsecoule/(3600*1000) .

Enfin je multiplie par 100 pour avoir un nombre de deux chiffres après la virgule sinon je reçois un nombre de 0,... c'est fait exprès.

vitesse = distance / temps, c'est valable UNIQUEMENT pour une vitesse constante.

Si ta vitesse n'est pas constante, il faut faire une intégration.

je ne vois pas de quoi tu veux parler

Je veux te dire que ta formule est fausse.

Prenons un autre exemple pour te le prouver :

Imaginons que tu fasses un trajets de 4 heures avec :

- les 2 premières heures sur une nationale à 100km/h

- les 2 heures suivantes sur une petite route sinueuse à 30km/h

Maintenant, intéressons nous à la distance au 3/4 du  temps de parcourt, soit après 3 heures de voyage.

On bout de ces 3 heures, on aura fait 2h à 100km/h et 1h à 30km/h soit une distance de 230km.

Mais si l'on prend ta formule, on a : temps = 3h, vitesse = 30km/h, donc distance = 3 * 30 = 90km.

Donc la formule est fausse.

OK alors pourrais tu stp me donner la formule de la distance à utiliser car moi je ne vois comme formule de distance: distance = vitesse * temps de plus ma distance s'affiche que lorsque je mets float sinon j'ai comme affichage 0 km.

Ta variable temps écoulé est un entier donc quand tu divises par 3600000, c'est une division entière qui donnera donc forcément un nombre entier.

Au final, temps que le temps écoulé est inférieur à 1h, la division entière donne 0 donc ta distance est à 0.

Voila pourquoi il te faut passer par des float.

Sinon, pour ce qui est de la distance total, il te faut incrémenter une variable à chaque itération de ton code.

Ce qui donne le code suivant :

float distance = 0;
 
void loop() {
 
	[...]
	 
	if ( tempsecoule >= dureetest ){

		[...]
		
		distance = ( distance + ( ( vitesse * tempsecoule ) / 3600000.0 ) );
		
		[...]

	}
	
}

Par contre, tu risques d'avoir un problème de précision des float sur le long terme.

Si tu veux t'en affranchir, le mieux serait d'ajouter une variable du nombre d'impulsion qui ne serait jamais remise à 0.

Tu pourras ensuite en déduire la distance de façon plus précise avec : distance = nbimpulsions * 2 * pi * rayon

OK merci mais je crois que je vais m'absenter d'avoir une présicion sinon je risque de ne plus comprends. 

Aussi t'aurais pas une idée de comment je pourrais avoir une vitesse constante puisque ma roue roule à une même vitesse car avec mon programme j'ai des vitesses qui varient. J'avais essayé de mettre un while (1)  à la fin de mon programme mais lorsque je le fais il ne m'affiche plus rien.

Enfin je dois créer une application avec App Inventor pour afficher la vitesse sur mon smartphone mais je ne sais pas m'en servir. 

Si tu mets un while (1) à la fin de ton programme, tu vas bloquer la fonction loop et donc arrêter les affichages.

Si tu veux quelque chose de plus lisse, il y a plusieurs façon de faire :

- Calculer une moyenne entre les différents affichages et afficher la moyenne

- Comparer la vitesse précédente avec le nouvelle vitesse et afficher la vitesse précédente si l'écart est faible

- Baser l'affichage sur un nombre de pulse et non sur une durée

- Mettre plus d'aimants pour avoir plus d'impulsions et donc plus de précision sur un laps de temps court

j'avais refléchi à la 3éme proposition pour avoir une vitesse constante: celle de baser l'affichage sur un nombre de pulse et non sur une durée