Programme Arduino avec capteur à effet hall

[ludwig64]

Bonjour à tous, voilà je suis en train de fabriquer un tachymètre avec un capteur à effet hall.
Le problème c'est que je ne suis pas très doué avec la programmation en C.
Voici déjà le circuit arduino que j'ai fait:

Et voici le code qui me permet déjà d'allumer la led si le capteur capte quelque chose.

const int ledPin = 13; 
const int hallPin = 2;

int sensorValue; 

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

void loop() {
  // lecture du capteur a Effet Hall
  sensorValue = digitalRead( hallPin );
  
  // senseurValue = HIGH sans aimant
  // senseurValue = LOW  quand POLE SUD aimant
  sensorValue = not( sensorValue );
  
  // Allumer eteindre la LED
  digitalWrite( ledPin, sensorValue );
}

Maintenant j'aimerai avoir un peu d'aide pour pouvoir modifier le code afin d'en faire un tachymètre. Bien sûr j'aimerai dans la mesure du possible conserver la capacité du système à faire s'allumer la led quand le capteur capte quelque chose.
-----

[Yvan_Delaserge]

Il faut utiliser la fonction millis() pour savoir quel est le temps écoulé entre deux activations du capteur Hall.

[ludwig64]

Voilà ce que j'ai fait avec la fonction millis(). Ca me donne des résultats mais totalement délirant, par exemple 39000 RPM alors que j'ai passé l'aimant qu'une seule fois. J'ai utilisé une partie d'un code déjà fait par quelqu'un d'autre.

int hallsensor = 2;                

volatile byte counter;

unsigned int rpm;

unsigned long passedtime;

void isr()

 {

      counter++;

 }
void setup()

 {Serial.begin(9600);

   attachInterrupt(0, isr, RISING);

   pinMode(hallsensor, INPUT); 

   counter = 0;

   rpm = 0;

   passedtime = 0; 

 }
 void loop()
 {
   delay(1000);

   detachInterrupt(0); 

   rpm = 60*1000/(millis() - passedtime)*counter;

   passedtime = millis();

   counter = 0;

   Serial.print("RPM=");

   Serial.println(rpm); 

   attachInterrupt(0, isr, RISING);   

  }

[Yvan_Delaserge]

J'ai utilisé une partie d'un code déjà fait par quelqu'un d'autre.

C'est pour ça que ça marche pas.
Il faut faire le programme toi-même.

[A voir en vidéo sur Futura]

[ludwig64]

Le problème c'est que je sais pas comment ça fonctionne. Quand ça ne marche pas, je sais pas si le problème vient du montage électrique ou du programme.

[ludwig64]

Voilà j'ai tout recommencé depuis le début mais là j'ai un problème avec la mesure du temps entre 2 "captages" car d'un côté je veux pouvoir afficher des valeurs toutes les 500ms mais je ne veux pas empêcher la mesure de la période.

const int ledPin = 13; 
const int hallPin = 2;
int sensorValue; 
int Senseur2;
int count=0;
unsigned long temps;
unsigned long tempspasse;

void setup(){
  Serial.begin(9600);
  pinMode( ledPin, OUTPUT ); 
  pinMode( hallPin, INPUT );
  }

void loop() {
  Senseur2=sensorValue;
  sensorValue = digitalRead( hallPin );
  sensorValue = not( sensorValue );
  digitalWrite( ledPin, sensorValue );
  if (sensorValue!=Senseur2)                  //Ca permet d'afficher les valeurs que si l'état du capteur à effet hall a changé entre temps
  {
      Serial.print("RPM=");
      Serial.println(60*1000/(tempspasse)*count); 
      delay(500);
  }
  if(sensorValue==HIGH)                     //Le but ici est de mesurer le temps entre 2 périodes où le capteur est en position HIGH
  {
    tempspasse=(millis()-temps);
    temps=millis();
  }
}

[Yvan_Delaserge]

Count = 0 pendant tout le programme.
Donc la ligne:

Serial.println(60*1000/(tempspasse)*count);

effectue une division par zéro.

[ludwig64]

À oui j'avais mis une condition avant avec

If (sensorValue==Senseur2)
{
Count=0;
}
else{
Count=1;
}

Comme ça soit ça multipliait par 1 quand le senseur changer d'état entre deux boucle soit ça mettait 0. Mais même avec ça quand je passe l'aimant j'ai des valeurs comme 2 450 000 qui apparaissent et 0 quand je ne passe plus l'aimant

[freepicbasic]

Ton algorithme est faux...

Si tu attend un basculement pendant 1ms ça signifie que ton signal sera plus rapide que 1ms soit 1Khz, tout ce qui est dessous ne sera pas compter.

Il faut compter les basculements pendant 1 seconde et en déduire la fréquence ou la période selon l'unité d'affichage désiré.

De plus généralement on utilise un capteur digital , le fait d'utiliser un analogique fait que 2 lecture successives risque d'être différentes ne serait ce que d'un point.
Il faut un seuil pour faire une hystérésis.
Lorsqu'on lit un basculement , il faut attendre la fin de cette état sous peine de compter à la vitesse du programme.
Donc après un basculement on traite puis on met un while tant que cette état persiste, pour passer à l'étape suivante.

[Yvan_Delaserge]

Et comme ça?

const int ledPin = 13; 
const int hallPin = 2;
int etat_actuel; 
int etat_precedent;
int count=0;
unsigned long temps;
unsigned long tempspasse;

void setup(){
  Serial.begin(9600);
  pinMode( ledPin, OUTPUT ); 
  pinMode( hallPin, INPUT );
  }

void loop() {
  
  etat_actuel = digitalRead( hallPin );
  digitalWrite( ledPin, etat_actuel );
  
  if (etat_actuel==1 && etat_precedent==0)                  //Ca permet d'afficher les valeurs que si l'état du capteur à effet hall a changé entre temps
  {
      tempspasse=(millis()-temps);
      Serial.print("duree d'une boucle en millisecondes= ");
      Serial.println(tempspasse);
      temps=millis();
  }
  etat_precedent = etat_actuel;
}

Lorsque le capteur Hall est activé par l'aimant, l'Arduino lit un niveau haut, sinon, un niveau bas.
L'Arduino fait une lecture à chaque tour de boucle loop(), c'est-à-dire plusieurs millions de fois par seconde.

Si le niveau est haut ET que lors de la boucle précédente il était bas, il calcule la différence entre la lecture de millis() actuelle et la lecture précédente.

Sinon, il mémorise l'état actuel dans la variable etat précedent et il repart pour une nouvelle boucle.

[freepicbasic]

oui comme ça, ç'est beaucoup mieux.

Dans son premier post, il y avait une confusion entre un comptage pendant un temps défini avec "count=0;"
Et la mesure en millis entre 2 basculements.

Mais ça mesure toujours en milli secondes , donc des fréquences < 1000hz, pas trop précis.
Pour mesurer un moteur ça va, pour du son c'est un peu court...

Je ne sais pas pourquoi, j'ai vu un analogread au lieu d'un digitalread , j'ai dû en utilisé un analogique un jour, ou alors j'ai confondu avec confondu capteur a effet hall et capteur de champs magnétiques.

D'ailleurs est il vraiment digital avec un hystérésis ?
Si la tension est analogique et qu'on lit sur une pin digital, attention le basculement n'est peut être pas franc ?
(c'est ce que j'ai pensé tout de suite en voyant le post #1)

[ludwig64]

Bonsoir, alors j'ai réécrit la fonction mais cette fois ci avec une interruption qui rajoute une incrémentation à un compteur à chaque fois que le capteur hall passe de l'état bas à haut. Comme ça ça compterait le nombre de passage par seconde, min,....
Voici mon code:

const int ledPin = 13; 
const int hallPin = 2;
int sensorValue; 
volatile int compteur;
unsigned long temps;
int tempspasse=1000;       //On choisit l'intervalle de temps sur lequel on veut mesurer le nombre de période (plus c'est petit mieux c'est)

void setup(){
  Serial.begin(9600);
  pinMode( ledPin, OUTPUT ); 
  pinMode( hallPin, INPUT );
  attachInterrupt(hallPin, increment,RISING); //fait une interruption dès que le senseur Hall passe de l'état bas à l'état haut
  }

void loop() {
  compteur=0;                                     //remets à 0 le compteur
  sensorValue=digitalRead(hallPin);               //lis l'état du capteur hall
  sensorValue = not( sensorValue );
  digitalWrite( ledPin, sensorValue );            //allume la led dès que le capteur capte l'aimant
  temps=millis();
  if (millis()-temps>tempspasse){                 //permet de ralentir le temps d'affichage des donnèes au temps qu'on veut (ici 1 seconde)
     Serial.print("RPM=");
     Serial.println(compteur*60*(1000/tempspasse));  //affiche le nombre de tour par minute en prenant en compte le tempspasse       
  }
}

void increment(){   //la fonction appelé par l'interruption
  compteur+=1;
}