Mesure de fréquence de pédalage d'un vélo

Bonjour à tous,

Pour un projet, je dois mesurer la fréquence de pédalage d'un vélo avec une erreur de maximum +- 1tr/min. J'ai acheté un capteur à effet hall pour réaliser la mesure.

Pour répondre à ma contrainte principale qui est l'erreur de mesure, j'ai commencé par calculer le nombre d'aimants nécessaire sur le plateau par exemple: on met un seul aimant sur le plateau, sur une durée d’acquisition d'une minute l'erreur est bien de +- 1tr/min, or j'ai besoin d'une durée d'acquisition beaucoup plus courte (sur 1 seconde il y aurait 67% d'écart).

Avec Labview, j'ai donc fait quelques simulations pour arriver au résultat suivant : il faudrait 10 aimants et sur une durée d’acquisition de 6 secondes.

Me voilà au moment de faire un programme arduino et je ne sais pas par quoi commencé s'il vous plaît est-ce que vous pourriez m'aider?

Bonsoir et Bienvenue sur ce forum !!

le mieux est de commencer à prendre connaissance des règles de fonctionnement de ce forum (messages épinglés en tête du forum)

Ensuite il faut progresser par étapes : maitriser le capteur, maitriser le comptage de passage d'aimants, maitriser la durée du comptage.

Ensuite parmi les tutoriels conseillés dans ces messages travailler en particulier ceux relatifs à la prise en compte de l'état d'un capteur 'tout ou rien' : bouton poussoir, interrupteur ....

Etudier la notice du capteur à effet hall et apprendre à le relier à le carte Arduino, faire apparaitre son état par exemple en modifiant l'état d'une LED; Essais d'allumer une led quand l'aimant (ou un de ses poles en particulier) est approché du capteur

Travailler en suite la mesure de vitesse, la mesure de fréquence... différentes méthodes seront proposées : pulsin(), interruptions...... les étudier, les comprendre , les pratiquer. Tu arrivera salors à compter le nombre de passage d'aimants sur une durée de 6 secondes (calcul que tu as éfféctué)

Un moteur de recherche donnera des liens intéressants avec les mots clefs' tachymetre Arduino'.... adapter tout cela au pédalier , aux aimants et au capteur utilisé

Il y a peu de chance que ce forum te donnes un programme tout fait !!!
ce n'est pas son rôle..... par contre des coups de pouce seront au rendez vous dès lors que tu montreras ton travail, tes problèmes....

Si tu googles "Arduino hall effetc sensor", tu trouveras plein d'exemples comme ici ou ...

mYrfak77:
on met un seul aimant sur le plateau, sur une durée d’acquisition d'une minute l'erreur est bien de +- 1tr/min

La cadence de pédalage n'est pas stable sur 1 minute. C'est juste une moyenne.

Ce qui est généralement mesuré et affiché sur un vélo, c'est la cadence de pédalage instantanée.

Avec un seul aimant il faut au plus 2 tours complets de pédalier pour faire une mesure, car 2 passages consécutifs de l'aimant sont nécessaires. (échantillonner à 2F pour mesurer la fréquence F, théorème de Shannon).

La précision dépendra du temps de réponse du capteur, de son hystérésis.

On peut à priori atteindre une forte précision sans mettre des dizaines d'aimants, l'Arduino peut mesurer des intervalles temporels très précisément en utilisant les interruptions.

Bonjour,

Pour les fréquences faibles il ne faut pas essayer de mesurer directement la fréquence mais la période (d'ou tu déduiras la fréquence).
Avec un seul aimant tu auras largement la précision souhaitée.

Bonjour,
Il eu été plus correct de dire de suite que c'est ton projet bac STI2D ou S-SI.

Pour ta précision de +/- 1 tour par minute je ne sais pas comment tu as fait ton calcul.

Si je prend un cas simple, histoire de fixer les idées :
J'ai un vélo avec des roues de 700 . 700 c'est exprimé en mm le diamètre moyen de la roue au niveau du pneu.
Je roule pépère = 5 km.h, toi qui est jeune tu devrais faire du 20 km.h en croisière.

1 tour de roue fait 2,2 m ( -->0,7m * PI)
En 1 heure je fait 5000/2,2 = 2273 tours de roue soit 38 tours de roue par minute.
Pour tomber à 2 tours de roue par minute il faudrait rouler à 300m à l'heure : a mon avis a cette vitesse tu t'es cassé la figure avant 10 s.

68tjs:
1 tour de roue fait 2,2 m ( -->0,7m * PI)
En 1 heure je fait 5000/2,2 = 2273 tours de roue soit 38 tours de roue par minute.
Pour tomber à 2 tours de roue par minute il faudrait rouler à 300m à l'heure : a mon avis a cette vitesse tu t'es cassé la figure avant 10 s.

Tu as oublié le rapport de vitesse pédalier/roue = nombre de dents du plateau/nombre de dents pignon, puisqu'il ne veut pas mesurer la vitesse du vélo mais la cadence de pédalage.

Il ne dit pas non plus qu'il veut veut mesurer des cadences très faibles de l'ordre de 2 tr/mn, il veut une précision de 1tr/mn. Si la cadence est de 50 tr/mn, ça doit afficher entre 49 et 51.

Comme conseil supplémentaire, et à mon sens indispensable, je dirais qu'avant de copier/coller un tutorial, et de demander de l'aide parce que ça ne le fait pas, il faut apprendre les bases du langage C.

Pour passer du nombre de tours de roues à celui du pédalier une simple règle de trois fait l'affaire, je pense que même à notre époque ce ne devrait pas être insurmontable.
Et puis c'est visiblement un sujet bac qui avance caché, on ne va pas tout faire !

Pour calculer la précision de +/- 1 tour par minute AMHA il faut avoir un ordre de grandeur du nombre sur lequel la précision va s'appliquer.

Pour le reste je suis d'accord : le tuto d'Eskimon répond à ses questions, il n'y a plus qu'à.

Merci de vos réponse, en effet je n'ai pas préciser qu'il s'agissait d'un projet en BAC S-SI, d'un dérailleur automatiser, qui prend en compte le couple de pédalage, le rythme cardiaque ainsi que la fréquence de pédalage qui est la dernière étape à réaliser

Voici le lien de mon VI labview que j'ai fais pour calculer l'erreur en fonction du nombre d'aimant et de la durée d'acquisition : usp=sharingPartage Google Drive

L'erreur de mesure provenant de l'Arduino sera minime (la carte tourne à plusieurs MHz, elle peut mesurer des temps très brefs).
Tout va dépendre du capteur utilisé (sensor à effet Hall + aimant) et de la reproductibilité de ses mesures (en gros, est ce que le front montant de chaque impulsion survient toujours au même moment de passage de l'aimant, ou avec un retard de quelque ms , c'est la dispersion des mesures qui va affecter la précision).

3 tr/min correspond à un cycliste proche du coma. :zipper_mouth_face:

Typiquement, on tourne entre 40 à 120 tr/min pour le pédalage à vélo.

Bonsoir à tous et merci pour vos réponses qui m'on bien aiguillé, j'ai réussi à faire un programme qui permet de définir la durée entre chaque passage d'aimant devant le capteur à effet hall (tout ou rien),
j'en déduis la fréquence et ensuite j'affiche la fréquence sur le moniteur en série (bientôt sur un écran ou un afficheur 7 segments).

Christian_R:
Avec un seul aimant il faut au plus 2 tours complets de pédalier pour faire une mesure, car 2 passages consécutifs de l'aimant sont nécessaires. (échantillonner à 2F pour mesurer la fréquence F, théorème de Shannon).

La précision dépendra du temps de réponse du capteur, de son hystérésis.

On peut à priori atteindre une forte précision sans mettre des dizaines d'aimants, l'Arduino peut mesurer des intervalles temporels très précisément en utilisant les interruptions.

J'ai donc suivi le conseil de Christian j'ai mis deux aimants, je connais le théorème de Shannon sur l’échantillonnage et je me demande donc comment connaître la précision de ces mesures et si il faudrait passer de 2 à 4 aimants car Fe⩾2Fmax , et plus on augmente Fe et mieux c'est.

pepe:
Avec un seul aimant sur le plateau du pédalier, avec une période de mesure inférieure ou égale à 1 seconde on peut mesurer des vitesses de pédalage supérieures ou égales de 60 tr/mn avec une erreur de l'ordre de ±0,06 tr/mn (hors erreur due au capteur) en utilisant la fonction millis().

Pour des vitesses de pédalage inférieures, on est obligé d'augmenter la période des mesures (pour que l'aimant ait le temps de faire un tour) mais en contrepartie la précision augmente : pour 3 tr/mn (changement de pédale toutes les 10 secondes) on obtient une mesure toutes les 20 secondes avec une erreur de ±0,00015 tr/mn (hors erreur capteur).

La multiplication des aimants trouverait donc plutôt son utilité dans le maintien d'une fréquence de mesure acceptable aux faibles vitesses de pédalage. Toutefois, quand on utilise plusieurs aimants, leur positionnement relatif introduit une cause d'erreur supplémentaire.

Je ne comprends pas comment calcules les erreurs comme ±0,06 tr/mn, ±0,00015 tr/mn, ... Est-ce que tu pourrais m'indiquer tes calculs je t'en serais très reconnaissant. et selon toi combien d'aimant devrais-je mettre afin d'avoir une erreur la plus petite possible tout en ayant le système le plus simple. Pour le placement des aimants j'ai fabriqué une maquette de pédalier, représenté par un disque dans lequel j'ai découpé des trous du diamètre des aimants avec la découpe laser et grâce à solidworks. Et je tiens à rappeler que les fréquences moyennes des cyclistes lambda sont de 60 à 90 tr/min

Je vous remercie tous pour votre aide merci

Voici mon programme, y aurait'il des erreurs ou des méthodes plus simples? :

const int ledPin = 2; 
const int hallPin = 4;
const int nombre_aimant = 1 ;
float a = 0;
float b = 0;
float c = 0;
float d = 0;
int sensorValue; 
unsigned long ot = 0;
unsigned long ft = 0;

bool reset = true;

void setup()
{
pinMode( ledPin, OUTPUT ); 
pinMode( hallPin, INPUT );

Serial.begin(9600);
}

void loop() 
{
// lecture du capteur a Effet Hall
sensorValue = digitalRead( hallPin );

// senseurValue = HIGH sans aimant
// senseurValue = LOW  quand POLE SUD aimant
sensorValue = not( sensorValue );

if (sensorValue == LOW && reset)
{
  float dt = millis() - ot;
  ot = millis();
  
  Serial.println("Temps entre deux impulsions:");
  Serial.print(dt);
  Serial.print(" ms\n");
  a= dt * nombre_aimant;
  
  b = a / 1000 ; 
  //Convertion des ms en s de la période T
  c = 1/b;
  //calcul de la fréquence F avec F=1/T, on a le résultat en Hz 
  d = c * 60;
  // Convertion de Hz en Tr/min
  Serial.println("Fréquence de pédalage:");
  Serial.println(d);
  reset = false;

  
}
else if (sensorValue != LOW && !reset)
  reset = true;

// Allumer eteindre la LED
digitalWrite( ledPin, sensorValue );

Et aussi je me demandais s'il fallait que je fasse une moyenne de deux valeurs pour avoir une fréquence plus stable, mais cela me ferait-il perdre en précision?

Merci pour tes conseils,

pepe:
Sinon, une technique pour empêcher l'affichage d'osciller entre deux valeurs du fait de très petites variations du résultat calculé consiste à introduire une hystérésis, de sorte que la valeur déjà affichée ne change que si la différence entre elle et le résultat dépasse une unité d'affichage.

Je vais essayer essayer de faire ça, et comme tu as dit que mon programme était perfectible comment l'améliorer?

Salut merci beaucoup pour ta réponse, ton programme fonctionne très bien

Je sais que cette question va paraître bête mais j'ai un problème avec ton écriture de la boucle while:

 // attente d'un niveau niveau bas sur l'entrée capteur
  while ( digitalRead( hallPin ) ) { }

Je ne comprends pas pourquoi en mettant ceci on met en attente d'un niveau bas et pas d'un niveau haut par exemple. Pourquoi ne pas mettre = 0 derrière pour le niveau bas?

  1. Et pourquoi ne rien mettre dans les accolades de la boucle while?
    C'est en fait juste un déclencheur le while?

C'est une bonne idée de mettre micros au lieu de millis ce qui permet de gagner en précision.

J'ai chercher des renseignements sur l'hystérésis mais je n'ai pas compris comment l'intégrer dans le programme

mYrfak77:

 // attente d'un niveau niveau bas sur l'entrée capteur

while ( digitalRead( hallPin ) ) { }




Je ne comprends pas pourquoi en mettant ceci on met en attente d'un niveau bas et pas d'un niveau haut par exemple. Pourquoi ne pas mettre = 0 derrière pour le niveau bas?

2) Et pourquoi ne rien mettre dans les accolades de la boucle while?

En fait, on pourrait tout à fait écrire:while ( digitalRead( hallPin ) == HIGH ) { }
Mais on exploite une convention du langage C: tout ce qui est nul est faux, tout ce qui n'est pas nul est vrai. Comme HIGH vaut 1, le test == HIGH devient inutile.
Tant que la valeur renvoyée par digitalRead est non-nulle, ... ne rien faire (et donc recommencer le test). Il n'y rien entre les accolages car on se contente d'attendre, tant que le test ne passe pas on ne fait rien.
On aurait aussi bien pu écrire

while ( digitalRead( hallPin ) );

Enfin, fais très attention à la différence entre =0 et ==0 !

Merci de ton aide, maintenant je suis en train de chercher comment je pourrait transmettre la fréquence à un écran qui est connecté sur une deuxième carte arduino par la liason i2c