compteur de vitesse

Tu risques de perdre en précision, reste en flottant pour le calcul et affiche avec zéro chiffre après la virgule

Serial.print (vitesse, 0);

OK c'est fait. J'ai fait un code qui affiche la vitesse et la distance sur l'écran oled ( sans les unitées de km et km/h )mais mon écriture prend trop de temps donc je ne peux pas mesurer plus de 11km/h. Comment-y remédier ? :slightly_frowning_face:

Mais si par exemple j'enlève l'écriture de la distance, je peux mesurer jusqu'à 21 km/h

Poste ton code...

J’avais oublié !!! désolé

#include <Adafruit_SSD1306.h>
#include <splash.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>

#define OLED_RESET 4
Adafruit_SSD1306 display( OLED_RESET );



void setup () {
  display.begin( SSD1306_SWITCHCAPVCC, 0x3C );
  display.clearDisplay();
  
}

void loop() {

unsigned long temps = millis();
int perimetre = 2;  //entrer le périmètre de la roue en m, le périmètre est égal à   pi*diamètre     ou      pi*2* rayon                       !!!!! EN METRE !!!!!
static unsigned long dernierPassage;
static bool flagMesure = false;
int tempstrouve;
float vitesse;
float distance;

  if (analogRead(A0) <= 410  || analogRead(A0) >= 615) { //si un aimant pole nord ou un aimant pole sud passe devant le capteur
    if (flagMesure)
    { tempstrouve = temps - dernierPassage;
      dernierPassage = temps;
      vitesse = (perimetre / (tempstrouve / 1000.0)) * 3.6; //donne la vitesse en km/h grace à v = d/t
      flagMesure = false;     // pour attente cycle suivant
      distance = distance + (perimetre / 1000.0);

      display.clearDisplay();   //efface l'écran pour le réactualiser
    }
  }
  else
  {
    flagMesure = true;  // prêt pour une nouvelle mesure
  }

display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(40, 2);  //essai donc placement on s'en fout
display.print(distance, 1);
display.display();

display.setTextSize(4);
display.setTextColor(WHITE);
display.setCursor(0, 2);  //essai donc placement on s'en fout
display.print(vitesse,0);
display.display();



}

Il faut exécuter les commandes d'affichage uniquement lorsque tu fais le calcul de la vitesse, pas à chaque tour de la loop. C'est ça qui te ralentit

Il est possible que ton clear display finisse par faire clignoter l'affichage... Mais on verra plus tard

Maintenant que j'ai mis tout ça dans le if et avec les calculs, je peux monter à 21km/h max.

Je peux t'aider à optimiser ton code, mais j'aurais besoin de savoir ce que donnent les valeurs du analogRead. Peux-tu faire tourner ta roue et afficher ces valeurs ?

Déjà, pour que ce soit plus clair, mon capteur n’est pas monté, je passe juste un aimant “à la main” comme ça en essayant d’être régulier et de faire varier la vitesse. Tout est monté sur breadboard avec un arduino uno.

Mon analogRead me donne environ 515 sans aimant, cela oscille un peu mais c’est normal, c’est comme ça sur la fiche technique. En fait quand le champs magnétique est à peu près nul, il donne 2.5v en sortie.

Quand je passe un aimant pôle sud à environ 1-2 cm, ça descend en dessous de 2v environ ( d’où le 410 ( 1024/5 = 204.8 et 204.82 = environ 410)).
Quand je passe un aimant pôle nord à environ 1-2 cm, ça monte eau dessus de 3v environ ( d’où le 615 ( 1024/5 = 204.8 et 204.8
3 = environ 815)).

Attention, tant que je laisse l’aimant devant le capteur, sa tension reste de <2v ou >3v.

C’est un capteur analogique du coup, pas comme la majorité des autres capteurs à effet hall ou comme les capteurs reed (switch magnétique, équivalent capteur ILS si j’ai bien compris… :confused: ).

21km/h ça fait près de 6 m/s donc 3 tours de roue par seconde. C'est très peu, à mon avis tu dois monter bien plus haut. Comment evalues tu cette valeur ?

Alors voila un code, que je pense un peu plus optimisé

/*
   Compteur de vitesse
   Lesept 08/2019
*/
#include <Adafruit_SSD1306.h>
#include <splash.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>

#define OLED_RESET 4
Adafruit_SSD1306 display( OLED_RESET );

// Définir ici les seuils min et max du analogRead
#define valMin 410
#define valMax 615
// Définir ici les coordonnées pour l'effacement du texte
// x : abscisse min, y : ordonnée min, w : largeur, h : hauteur du rectangle
// Voiri :https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives 
#define xDist 40
#define yDist 20
#define wDist 40
#define hDist 20
#define xVit  00
#define yVit  20
#define wVit  40
#define hVit  20

const int valMoy = (valMin + valMax) / 2;
const int seuil = (valMax - valMin) / 2;
const int perimetre = 2;  //entrer le périmètre de la roue en m, le périmètre est égal à   pi*diamètre     ou      pi*2* rayon                       !!!!! EN METRE !!!!!
bool flagMesure = false;
unsigned long tempstrouve = 0;
unsigned long dernierPassage = 0;
float vitesse = 0;
float distance = 0;

void Affiche (float distance, float vitesse) {
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.fillRect (xDist,yDist,wDist,hDist,BLACK);
  display.setCursor(40, 2);  //essai donc placement on s'en fout
  display.print(distance, 1);

  display.setTextSize(4);
  display.setTextColor(WHITE);
  display.setCursor(0, 2);  //essai donc placement on s'en fout
  display.fillRect (xVit,yVit,wVit,hVit,BLACK);
  display.print(vitesse, 0);
  
  display.display();
}

void setup () {
  display.begin( SSD1306_SWITCHCAPVCC, 0x3C );
  display.clearDisplay();
  Affiche (distance, vitesse);
}

void loop() {
  int diff = abs(analogRead(A0) - valMoy);
  if (diff >= seuil) { //si un aimant pole nord ou un aimant pole sud passe devant le capteur
    if (flagMesure) {
      tempstrouve = millis() - dernierPassage;
      dernierPassage = millis();
      vitesse = (perimetre / (tempstrouve / 1000.0)) * 3.6; //donne la vitesse en km/h grace à v = d/t
      flagMesure = false;     // pour attente cycle suivant
      distance = distance + (perimetre / 1000.0);
      Affiche (distance, vitesse);
    }
  }
  else
  {
    flagMesure = true;  // prêt pour une nouvelle mesure
  }
}

Au lieu d’effacer l’écran entier à chaque fois, je trace un rectangle aux endroits ou tu affiches la distance et la vitesse. Ces endroits sont définis par

#define xDist 40
#define yDist 20
#define wDist 40
#define hDist 20
#define xVit  00
#define yVit  20
#define wVit  40
#define hVit  20

Mais il faut que tu trouves les bonnes valeurs sur ton écran.

Pour le capteur, j’ai modifié le test afin de ne plus avoir de OU. Le principe c’est de calculer la distance de la valeur mesurée à la moyenne. Par exemple, si un passage correspond à une valeur mesurée inférieure à 400 ou supérieure à 600 (c’est plus facile à voir avec des nombres entiers), on peut faire

if (valeur <=400 || valeur >= 600)

mais on peut aussi se dire que la distance de la valeur à 500 doit être supérieure à 100, ce qui donne

diff = abs(valeur - 500);
if (diff >= 100)

500 est la valeur moyenne de 400 et 600, et 100 et la moitié de la distance entre 400 et 600.

Si vraiment c’est encore trop lent (mais il faudrait le tester sur une vraie roue,en vraie grandeur) on peut afficher les valeurs moins souvent, par exemple toutes les secondes. On pourra voir ça plus tard…

Chouette une petite routine d'interruption en vue :wink:

Au lieu de colorer un rectangle on peu mémoriser la vitesse et la réécrire dans la couleur du fond. Mémoriser la vitesse peut aussi servir pour savoir si la vitesse est diffèrente à la nouvelle vitesse calculée et donc de la écrire ou pas.

P.s. on est sur que le font utilisé nécessite de effacer avant de réécrire ?

Merci beaucoup lesept, ton code marche à merveille, j’arrive à monter vers 40 km/h mais seulement à cause de mes bras que je ne peux pas bouger à la vitesse de la lumière !!!( je suis drôle )
Je vais donc bientôt mettre en place le capteur et tout sur le vélo et puis fixer la valeur du vrai périmètre.

J’ai changé les coordonnées du rectangle vitesse et distance et c’est bon.

Il n’y a juste un truc que je ne comprends pas ( et pas uniquement sur ce code ), pourquoi utiliser vous ( les “pros” ) #define … au lieu d’une variable “normale” ( int par exemple )?

Mais aussi, un truc me casse la tête; j’aimerais stocker la distance totale depuis la première activation et utilisation du code grâce à l’EEPROM mais je ne sais pas comment faire. Déjà, la mémoire EEPROM à une durée de vie limitée à environ 100 000 cycles d’écritures par emplacement ( selon le site officiel arduino ) donc je ne veux pas réécrire la distance totale toutes les deux secondes.( je pensais la réécrire tous les km )???
Mon second problème est comment calculer cette distance totale car si on ajoute à cette distance
totale la distance, il faudrait remettre à zéro cette distance etc, etc…

J’ai donc créé une variable distancebis qu’on remet à 0 quand on l’écrit dans l’EEPROM, cette variable est du coup la même que distance. Comme dit dans le code, ce programme ne gère pas l’affichage des variables.

/*  Ce programme est totalement open-source, je remercie la communauté du forum arduino qui m'a aidé à construire ce code.

Ce programme permet de calculer la vitesse en km/h d'un vélo ou autre à partie d'un capteur à effet hall numérique
 *  Il permet donc de calculer la vitesse instantanée, la distance du trajet, la vitesse max, la vitesse max totale ainsi que la distance totale. 
 *   
 *  On stocke la vitesse max totale et la distance totale dans la mémoire EEPROM et on calcule la vitesse ( donc la distance, etc.. ) en mesurant le temps entre 
 *  chaque interruptions ( donc passage de l'aimant devant le capteur == un tour de roue ) et en appliquant la formule v = d/t.
 *  
 *  Avant d'utiliser ce programme, il faut calculer le périmètre de la roue et le rentrer dans " int perimetre = (ici la valeur du périmètre en m)" Dans la ligne suivi de points d'exclamations.
 *  ((( Pour rappel le périmètre est égal à      pi x 2 x rayon       ou        pi x diamètre.   )))
 *  
 *  Ce programme ne permet pas l'affichage sur écran ou port série ou autres de ces valeurs. Il utilise un capteur à effet hall analogique UGN3503 qui envoie du 2.5v quand aucun champs magnétique, 
 *  augmente quand un champs magnétique "nord" se rapproche ( quand il passe environ 3v ) et diminue quand un  champs magnétique "sud" se rapproche.
 */
#include <EEPROM.h>

void setup(){

  
}

void loop() {

  //les variables pour les calculs des variables finales
  float perimetre = 2;                      //!!!!!!!!!!!!!!!!!EN METRES!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  static unsigned long dernierPassage;
  static bool flagMesure = false;
  int tempstrouve;                          //le temps trouvé entre deux passage de l'aimant ( le temps trouvé pour un tour de roue )
  float distancebis;                        //la variable distancebis pour calculer la varible distance totale

  //les variables finales pour l'affichage : vitesse, distance, vitesse max, vitesse max totale et distance totale
  float vitesse;                            //la variable vitesse
  float distance;                           //la variable distance
  byte vitessemax;                          //la variable vitesse maximum                        //byte car moitié moins d'octet et suffisant ( à moins d'aller à plus de 255 km/h )
  byte vitessemaxtotale = EEPROM.read(0);   //la variable vitesse max totale pour l'EEPROM       //byte car moitié moins d'octet ( à moins d'aller à plus de 255 km/h )
  int distancetotale = EEPROM.get(1, distancetotale);      //la variable distance totale pour l'EEPROM




  

  
  if(analogRead(A0) <= 410  || analogRead(A0) >= 615) {     //si un aimant pole nord ou un aimant pole sud passe devant le capteur
    if(flagMesure)
    {
      unsigned long temps = millis();
      tempstrouve = temps - dernierPassage;
      dernierPassage = temps;
      vitesse = (perimetre / (tempstrouve / 1000.0)) * 3.6; //donne la vitesse en km/h grace à v = d/t
      flagMesure = false;                                   // pour attente cycle suivant
      distance = distance + perimetre;
      distancebis = distancebis + perimetre; 
    }
  }
  else
  {
    flagMesure = true;                    // prêt pour une nouvelle mesure
  }

 if(vitesse > vitessemax){                //calcule la vitesse max du trajet
  vitessemax = vitesse;
 }
 if(vitessemax > vitessemaxtotale){       //calcule la vitesse max totale
  vitessemaxtotale = vitessemax;
  EEPROM.update( 0, vitessemaxtotale);    //on écrit la variable vitesse max totale dans l'EEPROM
 }
 if(distancebis >= 1.0){
  distancetotale = distancetotale + distancebis;     //on calcule la variable distance totale
  distancebis = 0;                                   //on remet la variable distancebis à 0 pour le calcul suivant ( dans 1 km )
  EEPROM.put( 1, distancetotale);                 //on écrit la variable distance totale dans l'EEPROM
 }
}

Mais j’ai un doute pour EEPROM.get et EEPROM.put, j’ai mis ça car je veux écrire pas un octet mais deux ( distance totale est un int donc 2 octets ), car je compte parcourir plus de 255km avec mon vélo au total ( je ne fais pas le tour de France non plus… :slight_smile: )
Je pense qu’il y a une erreur ( ou plusieurs ) dans le code, surtout pour l’utilisation de l’EEPROM que je n’ai jamais utilisé auparavant. Si vous voyez des erreurs, n’hésitez surtout pas à me le dire.

J’aimerais mettre ce programme en même temps sauf que il y a tellement de mesures et tout que je ne peux pas mesurer plus de 3 km/h, comment faire ???

/*                                                    programme pour afficher et mesurer une tension max de 30VDC pour batteries
 *schema de montage pont diviseur de tension         VIN 30vdc        R1 = 10kOhm     R2 = 2KOhm    Vout = 5V quand Vin 30v
 * 
 * pour plus de précision mesurer avec précision les résistances r1 et r2 et calculer   Vout    sur digikey___calcul_pont_diviseur_de_tension faire 204,6 / ( VIN / Vout )
 * 
 * 
 * les valeurs de capacité selon tensions sont trouvées sur internet et à peu près vrai ( la capacité ne dépent pas que de la tension )  
 */

 
 
#include <Adafruit_SSD1306.h>
#include <splash.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>

#define OLED_RESET 4
Adafruit_SSD1306 display( OLED_RESET );



void setup () {
  display.begin( SSD1306_SWITCHCAPVCC, 0x3C );
  display.clearDisplay();
  
  
  
}

void loop(){


   //partie bitmap affiché continuellement
  display.display();
  display.drawRect( 101,  0,  27,  11,  WHITE);  //changer les x et y ( la position)              ligne 1
  display.drawRect( 96,  3,  5,  5,  WHITE);  //si ligne 1 changé de position, faire 2 premieres valeurs -3 et les recopier
  display.display();


  
 float tension = analogRead(A0);  //définie la broche mesurant la tension
  tension = ( tension / 34.1 );   //calcule la tension réelle

  int restant;
  if ( tension >= 25.46 ) {
    restant = 100;
  }

  else if ( tension >= 25.24 ) {
    restant = 90;
  }

  else if ( tension >= 25 ) {
    restant = 80;
  }

  else if ( tension >= 24.74 ) {
    restant = 70;
  }

  else if ( tension >= 24.48 ) {
    restant = 60;
  }

  else if ( tension >= 24.20 ) {
    restant = 50;
  }

  else if ( tension >= 23.92 ) {
    restant = 40;
  }

  else if ( tension >= 23.63 ) {
    restant = 30;
  }

  else if ( tension >= 23.32 ) {
    restant = 20;
  }

  else if ( tension >= 23.02 ) {
    restant = 10;
  }
  
  delay(750);
  display.fillRect( 102,  1,  25,  9,  BLACK);
  
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(103, 2);
  display.print(restant);
  display.print("%");
  display.display();


}

Tu supprimes le delay(750)
Tu mémorises la dernière valeur de restant et tu ne réaffiche que si la valeur a changé.

Même chose pour la batterie.
Comme j’ai dit plus haut, peut être que il ne faut par effacer avant de récrire.

Si, j'ai testé et il faut effacer avant d'écrire à chaque fois sinon on écrit sur l'écriture et donc ça fait un truc chelou illisible.

Et c'est vrai que je n'avais pas pensé à supprimer le delay car c'était un programme seul à la base !.

j'ai testé et il faut effacer avant d'écrire

Ok,
Plus réduire le blinking tu peux
Mémoriser la dernière valeur de vitesse et récrire seulement si nouvelle vitesse != ancienne vitesse.
Pour effacer plus rapidement tu peux écrire l'ancienne vitesse avec la couleur de fond: je pense que sera plus rapide.
Pour la batterie tu peux rafraîchir la valeur toute le minutes. Je pense que peut suffire.

Belo:
Si, j’ai testé et il faut effacer avant d’écrire à chaque fois sinon on écrit sur l’écriture et donc ça fait un truc chelou illisible.

Tu peux aussi écrire avec le fond en précisant la couleur du fond dans setColor()

 display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(103, 2);
  display.print(restant);
  display.print("%");
  if (restant<100)
  display.print(" ");
  display.display();

En général on traite le cas des valeurs inférieures à 10 et à 100 en écrivant un espace à gauche, et pas à droite, pour éviter que le chiffre bouge bizarrement au passage de 9 à 10 par exemple.
Le plus simple serait d'utiliser un tableau de char pour écrire le texte formaté dedans puis d'afficher ce tableau sur l'écran.