calcul de vitesse de rotation avec capteur optique et arduino uno

[invite412a68f8]

Bonjour,

J'aimerai calculer la vitesse de rotation d'un disque avec un capteur optique. Le capteur envoie un faisceau lumineux entre sa partie émettrice et sa partie réceptrice. Il est capable de détecter si un objet est présent etre ces deux parties. Principe de mon algorithme: j'ai fait un trou dans mon disque. Je compte le nombre de fois où le trou passe entre la partie émettrice et réceptrice du capteur durant un laps de temps et je calcule ainsi la vitesse de rotation de mon disque. Malheureusement, mon programme ne fonctionne pas et il affiche en boucle une vitesse de 0 tr/min. Je suis débutante en code arduino, je me suis inspirée de plusieurs codes existants et j'ai essayé d'utiliser la fonction millis(), le problème vient peut être de là. Il n'y a pas de faute de syntaxe.

Voici mon code:

// Pins utilisé
const int capteur=5; //capteur port OUT relié au pin5 de l'arduino

// Initialisation des variables
int lumiere; // affiche si le faisceau lumineux est coupé ou non par le disque. Si la lumière est allumé la partie trouée est devant le capteur
int tour=0; //variable qui compte le nombre de fois où la partie trouée du disque passe devant le capteur
float trmin; // variable qui affichera la vitesse du disque en tour/min
unsigned long temps;  //sert à enregistrer le temps écoulé depuis la dernière mise à jour du compteur

void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(capteur, INPUT); //connection du capteur à l'arduino
  temps=millis();
}

void loop() {
  //Vérifie si le trou arrive à hauteur du capteur
  lumiere = digitalRead(capteur);
  if (lumiere == LOW) {
    // on ajoute 1 à la variable qui compte le nombre de tours
    tour=tour+1;

    // si il s'est passé plus d'une seconde depuis le début du calcul du nombre de tours
    if ((millis() - temps) > 1000){
    // trmin= (nb de tours depuis le dernier calcul)/ (temps écoulé entre les deux caculs en minute 1min=60 000ms
    trmin=tour/(millis()-temps)*60000.0;
    
    Serial.print("vitesse en tour/min: ");
    Serial.println(trmin);
    
    //Réinitialisation du temps et du nombre de tours
    temps=millis();
    tour=0;
    }
  }
  delay(500);
}

Si vous trouvez ce qui cloche ça m'aiderait beaucoup!
-----

[Forhorse]

Déjà, tu ne précise pas à quelle vitesse tourne ton disque, et donc quelle va être la fréquence sur ton entrée de comptage, mais passé une certaines vitesse ça va bloquer...
Ensuite, là dans ton compteur, tu ne comptes pas le nombre de fois que ton capteur voit le trou, mais le nombre de boucle de programme effectuée à chaque fois que le ta condition de comptage était vraie.
Il faut que tu fasse un comptage sur le changement d'état... donc détecter les changement d'état, puis compter ces changement d'états.

Ensuite je vois que tu divises le nombre de tour compté pendant 1 seconde (1000ms) par un dénominateur d'au moins 60000... donc hormis si ton disque tourne très très vite (et dans ce cas la méthode de comptage n'est pas la bonne) il y a de grande chance que le résultat soit toujours aux environs de 0.000000...

[Forhorse]

Oups, j'avais mal vu la parenthèse de la division, donc la fin de mon message précédent ne doit pas être pris en compte.

[invite412a68f8]

Mon disque tourne environ à 1500 tr/min mais la capacité du moteur est de 3000tr/min. Cette méthode est peut être pas assez efficace alors, mais je ne vois pas trop comment régler cette fréquence de comptage

[A voir en vidéo sur Futura]

[invite412a68f8]

J'avais aussi testé cet algorithme en tentant d'utiliser la bibliothèque FreqCount mais cela me renvoie aussi 0. Je me suis renseignée sur les fréquences que la bibliothèque peut capter jusqu'à 25kHz ce qui serait amplement suffisant dans mon cas.
Le programme qui pose problème:

#include <FreqCount.h>  //Inclure la librairie de fréquence
// le pin utilisé pour cette bibliothèque est le 5 par défaut

// Variables utilisées
unsigned long frq;    //fréquence mesurée
int encoches=1;   //nombre d'encoches du disque 
float trmin;  //vitesse de rotation en tour/min

// Initialisation
void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(5,OUTPUT);
  FreqCount.begin(5000); //intervalle de mesure 5 secondes
}

//Boucle de mesures
void loop() {
  

  frq= FreqCount.read(); //renvoie la dernière mesure

  trmin = frq/encoches*60*5;  //Vitesse de rotation en tour/min
  Serial.print("fréquence");
  Serial.println(frq);
  Serial.print("  tour/min: ");
  Serial.println(trmin);
  delay(500);
  
}

Là encore je n'ai pas mentionné la fréquence d'entrée de comptage, je ne vois pas trop comment faire.

[invite6c250b59]

Si vous trouvez ce qui cloche ça m'aiderait beaucoup!

Plusieurs choses! D'abord, ton programme devrait compter les alternances low/high plutot que de simplement detecter un des deux etat (sinon un meme passage de trou risque d'etre compte plusieures fois). Ensuite, le delay(500) fait que ta carte ne lira rien pendant 500 ms. Si la vitesse de rotation est superieure a 2Hz, c'est un probleme. Finalement je soupconne un probleme supplementaire soit dans le typage, soit dans les regles de priorite de calcul. Pourrais-tu 1) changer tour pour un type float 2) mettre la multiplication par 60000 devant la division et 3) faire un print de tour en plus de trmin, puis rapporter l'impact de ces differents changements?

(Croisement)

[invite412a68f8]

Plusieurs choses! D'abord, ton programme devrait compter les alternances low/high plutot que de simplement detecter un des deux etat
(Croisement)

Il ne me reste que cela à changer, mais je ne vois pas comment le coder

[invite6c250b59]

Je te suggererais de faire le point 3) en premier, sans aucun autre changement, afin de voir pas a pas ce qui change versus ce qui ne change rien. Pour les alternances, une fàcon simple est a) d'ajouter un booleen initialise a faux, b) remplacer la condition lumiere=low par une condition (lumiere low et booleen faux)ou(lumiere haute et booleen vrai) et c) ajouter booleen=!booleen apres le if (tu auras compris que c'est du pseudocode )

[Forhorse]

J'avais aussi testé cet algorithme en tentant d'utiliser la bibliothèque FreqCount mais cela me renvoie aussi 0.

Dans ton code tu dis que l'entrée de comptage est la pin 5, et pourtant dans ton setup tu declare cette pin comme une sortie... normal que ça ne fonctionne pas.

[sandrecarpe]

Salut,
Il faut travailler avec les interruptions ! Ton programme sera plus simple et plus fiable.
A chaque interruption tu refais le calcul de vitesse et tu incrémentes ta variable tour. Mais pas plus : millis() s'arrête de compter pendant l'interruption
---> voit du côté de la fonction attachInterrupt()

[invite412a68f8]

J'ai modifié les 3 points proposés par Jiav en utilisant la fonction attachInterrupt au lieu du boléen (j'ai vu le message de sandrecarpe avant le celui de Jiav). Maintenant j'ai des valeurs farfelus: si le disque est à l'arrêt le premier print revoit bien 0 tr/min mais les suivants ont un nombre de tour non nul fluctuant entre 60 et 85 et une vitesse associée allant de 3600 à 5000 tr/min ce qui est impossible. Lorsque le disque tourne les vitesses dépassent 10 000tr/min ce qui est aussi impossible.

//capteur port OUT relié au pin5 de l'arduino

// Initialisation des variables
volatile float tour; //variable qui compte le nombre de fois où la partie trouée du disque passe devant le capteur
float trmin; // variable qui affichera la vitesse du disque en tour/min
unsigned long temps;  //sert à enregistrer le temps écoulé depuis la dernière mise à jour du compteur

//comptabilise le nombre de tour effectué par le disque
void nb_tour() {
  tour++;
}

void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(5, INPUT); //connection du capteur à l'arduino

  //Initialisation des variables
  trmin=0;
  tour=0;
  temps=0; 
  
  //on appelle la fonction tour dès qu'il y a un changement d'état présence/abscence de trou
  //attachInterrupt(interruption,fonction,mode)
  attachInterrupt(0,nb_tour,CHANGE);
}

void loop() {

  //on arrête l'interruption pendant le calcul
  detachInterrupt(0);
  
  // si il s'est passé plus d'une seconde depuis le début du calcul du nombre de tours
  if ((millis() - temps) > 1000){
    // trmin= (nb de tours depuis le dernier calcul)/ (temps écoulé entre les deux caculs en minute 1min=60 000ms
    trmin= 60000.0*tour/(millis()-temps); 
    
    Serial.print("tour");
    Serial.print(tour);
    Serial.print("vitesse en tour/min: ");
    Serial.println(trmin);

     //Réinitialisation du temps et du nombre de tours
    temps=millis();
    tour=0;
  }
  //on recommence les interruptions
  attachInterrupt(0,nb_tour,CHANGE);
    
}

[invite6c250b59]

Details: temps devrait etre initialise avec millis() plutot qu'a zero; il serait possiblement plus lisible de mettre void nb_tour ´a la fin

Erreur: (ma faute) l'interruption devrait etre a rising ( ou falling) plutot qu'a change, ou alors il faut corriger le calcul d'un facteur 2

Gnie?? Pourquoi mettre une ligne d'attachinterupt dans void loop()?

Pas clair: est-ce que tu vois un nb de tour different de zero alors que c'est a l'arret ou la vitesse te semble juste trop rapide? 60 tours en 1000 ms, c'est bien 3600 tour par minute alors pourquoi le second te choque alors que le premier non?

Merci: pour la suggestion sandrecarpe

[Forhorse]

Je n'ai jamais utilisé les interruptions avec un arduino, mais moi je vois que tu désactive ton interruption à chaque tour du main, c'est à dire des millions de fois par secondes... peut être que ça doit perturber un peu le bazar

moi je ferrais

void loop() {

 
  
  // si il s'est passé plus d'une seconde depuis le début du calcul du nombre de tours
  if ((millis() - temps) > 1000){
    //on arrête l'interruption pendant le calcul
    detachInterrupt(0);
    // trmin= (nb de tours depuis le dernier calcul)/ (temps écoulé entre les deux caculs en minute 1min=60 000ms
    trmin= 60000.0*tour/(millis()-temps);

[sandrecarpe]

Voilà comment je ferais

const int pinCapteur = 2; //pin 2 OU 3 seulement pour les interruptions avec un arduino uno
volatile bool nouveauTour;
unsigned int tour;
unsigned long temps1, temps2; //temps1 antérieur à temps2
float trmin;

void setup()
{

  nouveauTour = false;
  temps1, temps2 = millis();
  trmin = 0;
  tour = 0;
  
  pinMode(pinCapteur, INPUT);
  
  
  attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
  /*
    équivalent à 
    attachInterrupt(0, nouveauTour, RISING); si la pin 2 est utilisée

    et à
    attachInterrupt(1, nouveauTour, RISING); si la pin 3 est utilisée
   
   */


   


}

void loop() 
{

    if(nouveauTour)
    {
        detachInterrupt(digitalPinToInterrupt(pinCapteur));
        
        trmin = ((unsigned long)60000)/(temps2-temps1);
        tour++;
        
        temps1 = millis();

        
        nouveauTour = false;

        attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
    }
}


void nouveauTourInterrupt()
{
  temps2 = millis();
  nouveauTour = true;
}

[invite412a68f8]

Details:

Pas clair: est-ce que tu vois un nb de tour different de zero alors que c'est a l'arret ou la vitesse te semble juste trop rapide? 60 tours en 1000 ms, c'est bien 3600 tour par minute alors pourquoi le second te choque alors que le premier non?

Lorsque le disque est à l'arrêt j'avais une vitesse et un nombre de tour non nul. Le second me choque car il faut une alimentation 24V pour que mon moteur tourne à plein régime (3000tr/min) et actuellement il est alimenté avec l'arduino le temps que mon programme fonctionne, sa vitesse ne peut donc pas être aussi élevée

[invite412a68f8]

J'ai testé ton code sandrecarpe, il n'affiche rien je crois que la condition pour entrer dans le if n'est pas vérifié. Je ne l'ai pas totalement compris.
Premièrement, je ne comprends pas bien les valeurs que prennent temps1 et temps2. Si les deux sont initialisées en même temps, elles ne valent pas la même valeur dans le 1er calcul de trmin du void loop?
Ensuite, dans le calcul de trmin l'entier tour n'apparaît plus. Un oubli?
Pour le if: on entre dans la boucle si nouveauTour= True? Si oui, comme on a initialisé False le problème vient peut être de là. Si on entre dans le if quand nouveauTour= False, pourquoi incrémenter nouveauTour=True après le if?
Enfin, j'ai du mal à voir les variables à "INPUT" dans void setup. Si les interruptions sont en 2, je dois brancher mon capteur au pin2 de l'arduino ou je le laisse au pin5? Et du coup, mettre que pinMode(2,INPUT) ou aussi pinMode(5,INPUT)?

[sandrecarpe]

Mon programme ne suit pas la même logique que le tient.
Dans ton programme, tu comptes le nombre de tour durant une seconde et tu te bases sur ce nombre pour calculer la vitesse de rotation (loop())

Le miens fonctionne avec des interruptions. Lorsque qu'un front montant est détectée sur la pin 2 ou 3 (selon celle que tu as choisie, et pas une autre), le programme est suspendu, et la fonction nouveauTourInterrupt() est lancée.

L'interruption est initialisée avec la fonction attachInterrupt() et supprimé avec la fonction detachInterrupt()

Voici la fonction nouveauTourInterrupt() :

void nouveauTourInterrupt()
{
  temps2 = millis();
  nouveauTour = true;
}

Lorsque nouveauTourInterrupt() est appelée, ça signifie que ton machin qui tourne à fait UN (et un seul) nouveau tour.
Dans cette fonction, je mets nouveauTour à true pour pouvoir entrer dans la condition du loop et faire mon calcul de vitesse une fois l'interruption terminée (c'est à dire quand on sort de nouveauTourInterrupt()).
Dans la condition du loop, je calcule la vitesse de rotation en me basant sur un seul tour (c'est pour que ça que je ne me sers plus de tour). J'ai donc besoin juste de la différence de temps (temps2 et temps1) entre les deux derniers fronts montants.

J'ai pas demandé à mon programme d'afficher quelque chose donc c'est normal qu'il n'affiche rien

[invite412a68f8]

Je n'ai jamais utilisé les interruptions avec un arduino, mais moi je vois que tu désactive ton interruption à chaque tour du main, c'est à dire des millions de fois par secondes... peut être que ça doit perturber un peu le bazar

Avec ta proposition ça me renvoie 0tour 0tr/min

[invite412a68f8]

Merci, j'ai compris maintenant. Ca à l'air de marcher, mais les mesures défilent vite. Où est ce que je peux placer le delay pour ne pas fausser les mesures?

[invite412a68f8]

Rectification: ça ne marche pas. J'ai des valeurs qui semblent cohérentes et des valeurs farfeluEs du style 60 000 tr/min ou 10 000tr/min .. Je pense que ton idée de code est bien, mais pour plus de précision il faudrait entrer dans le loop tous les 100tours du disque et pas exactement 1. Je vois pas comment coder cela

[sandrecarpe]

mais pour plus de précision il faudrait entrer dans le loop tous les 100tours du disque et pas exactement 1. Je vois pas comment coder cela

C'est ce que je pensais, j'y réfléchis

[sandrecarpe]

Re moi,

const int pinCapteur = 2; //pin 2 OU 3 seulement pour les interruptions avec un arduino uno


unsigned int tour;
unsigned long temps1, temps2; //temps1 antérieur à temps2
float trmin;

void setup()
{

  temps1, temps2 = millis();
  trmin = 0;
  tour = 0;
  
  
  pinMode(pinCapteur, INPUT);
  digitalWrite(pinLed, HIGH);

  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
  /*
    équivalent à 
    attachInterrupt(0, nouveauTour, RISING); si la pin 2 est utilisée

    et à
    attachInterrupt(1, nouveauTour, RISING); si la pin 3 est utilisée
   
   */


   


}

const int n = 10;
const int nbrFrontMontantParTour = 7;
void loop() 
{

    if(tour >= nbrFrontMontantParTour*n) //si le ventilo à fait n tour
    {
        detachInterrupt(digitalPinToInterrupt(pinCapteur));
        
        trmin = ((unsigned long)60000*n)/(millis() - temps1);
        
        
        temps1 = millis();

        Serial.println(trmin);
        
        
        tour = 0;
        attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
    }
}


void nouveauTourInterrupt()
{
  tour++;
}

La variable nbrFrontMontantParTour correspond au nombre de front montant qu'il faut à mon ventilo pour faire un tour. (en gros le nombre de trou).
La variable n c'est le nombre de tour que je demande à mon programme d'attendre avant de faire le calcul de vitesse. Plus n est grand, plus la mesure semble précise et ne pas osciller
J'ai testé avec un p'tit ventilo de pc qui tourne à 4500tr/min nominal sous 12V et ça fonctionne nickel.

Je n'utilise plus temps2. J'appelle millis() directement dans la condition. A voir quel est le mieux

[sandrecarpe]

Ne pas oublier de déclarer la variable tour comme volatile (ce que j'avais oublié de faire)

[invite6c250b59]

Sandre, pourrais-tu enlever les detach/attach de la void loop pour voir ce que cela fait sur le comportement du compteur?

[sandrecarpe]

Avec les attach/detach
avec attach.png



Sans les attach/detach
sans attach.png

Je ne sais pas quoi en conclure

[invite6c250b59]

Merci. Perso je conclue que cela ne change pas grand chose, du moins dans cette plage de régime. Une chose embêtante c'est les quelques mesures à 6000+ qu'on retrouve de temps en temps. Si tu ajoutais un delay(1) dans la void nouveauTourInterrupt(), est-ce que cela ne supprimerait pas ce problème?

[sandrecarpe]

Oui
Mais je pense qu'il est plus judicieux de les laisser.
Par contre le delay dans l'interruption risque d'en faire éternuer quelques uns ici

C'est reparti pour une semaine de cours, va falloir attendre pour les tests

[antek]

Par contre le delay dans l'interruption risque d'en faire éternuer quelques uns ici

Dans un Arduino ça ne choquera personne . . .

[jiherve]

Bonsoir
Encore et encore il faut passer par la fonction timer capture donc vraisemblablement l'assembleur mais il semble y avoir une librairie arduimachin qui supporte la fonction..
L'ayant fait en assembleur je sais que cela fonctionne.

JR

[invite6c250b59]

L'ayant fait en assembleur je sais que cela fonctionne.

Je te crois sur parole mais... n'est-ce pas un peu longuet de faire ce genre de chose en assembleur? C'est une vrai question, i.e. si cela permet de faire des choses impossibles autrement (et que ces choses m'interessent assez), ou si le surcout en temps reste raisonnable, j'envisagerais serieusement de m'y mettre.