Go Down

Topic: compteur de vitesse  (Read 480 times) previous topic - next topic

supercc

Chouette une petite routine d'interruption en vue ;-)

savoriano

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 ?
Pardonnez moi pour mon français, ce n'ai pas ma langue maternelle.

Belo

#32
Aug 18, 2019, 11:45 am Last Edit: Aug 18, 2019, 05:35 pm by Belo
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.


Code: [Select]



/*  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... :)  )
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.

Belo

#33
Aug 18, 2019, 07:40 pm Last Edit: Aug 18, 2019, 07:41 pm by Belo
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 ???

Code: [Select]

/*                                                    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();


}




kamill

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é.

savoriano

#35
Aug 18, 2019, 09:13 pm Last Edit: Aug 18, 2019, 09:18 pm by savoriano
Même chose pour la batterie.
Comme j'ai dit plus haut, peut être que il ne faut par effacer avant de récrire.
Pardonnez moi pour mon français, ce n'ai pas ma langue maternelle.

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.

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


savoriano

Quote
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.
Pardonnez moi pour mon français, ce n'ai pas ma langue maternelle.

kamill

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()
Code: [Select]
 display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(103, 2);
  display.print(restant);
  display.print("%");
  if (restant<100)
  display.print(" ");
  display.display();

lesept

#39
Aug 19, 2019, 10:26 am Last Edit: Aug 19, 2019, 10:26 am by lesept
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.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

kamill

Oui, c'est mieux.
J'avais respecté le cadrage initial.

savoriano

Quote
Tu peux aussi écrire avec le fond en précisant la couleur du fond dans setColor()
Je n'avais pas vu ça!
Donc il faut refaire le test s'il faut effacer avant d'écrire en définissant la couleur du fond. 
Pardonnez moi pour mon français, ce n'ai pas ma langue maternelle.

Belo

J'ai donc effacé toute la partie carrée à remplacer et j'ai continué mon programme qui permet d'afficher toutes les variables.  J'ai fait en m'inspirant de ce que vous aviez dit et alélioré et à partie de deux programmes que je vais nommer 1 et 2


programme1
Code: [Select]

#define valMin 410                          // Définir ici les seuils min
#define valMax 615                          // et max de l'analogRead.

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, BLACK);
  display.setCursor(53, 2);
  display.print(distance, 1);

  display.setTextSize(4);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(vitesse, 0);
 
  display.display();
}

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


void loop() {
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(74, 2);
  display.print("km");

  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(52, 18);
  display.print("km/h");
  
  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
  }
}




programme 2
Code: [Select]



/*  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 1 seul 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 1 seul 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
 }
}









Belo

( second message car limite de caractères )

ce qui donne un programme final comme ceci :

Code: [Select]

/*  Ce programme permet de calculer la vitesse en km/h d'un vélo ou autre à partie d'un capteur à effet hall numérique et d'afficher ces variables suivantes.
 *  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 utilise un bouton poussoir pour changer de menu ( il n'y en a que deux )  le premier menu affiche la vitesse instantanée et la distance du trajet, le second menu affiche quant à lui
 *  l'affichage de la vitesse max du trajet, de la vitesse max totale et de la distance totale depuis la première activation et utilisation du programme et du système.
 * 
 *  Le système 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.
 *               
 *                        - un écran oled 0.96" 128*64 piloté en I2C par un driver intégré SSD1306.
 */

#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 );

#include <EEPROM.h>



#define valMin 410                          // Définir ici les seuils min
#define valMax 615                          // et max de l'analogRead.

const int valMoy = (valMin + valMax) / 2;
const int seuil = (valMax - valMin) / 2;
const float 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 distancebis;
int boutonpoussoir = digitalRead(0);
bool menu2 = false;

//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 1 seul 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 1 seul octet ( à moins d'aller à plus de 255 km/h )
unsigned int distancetotale = EEPROM.get(1, distancetotale);      //la variable distance totale pour l'EEPROM


void Affichemenu1 (float distance, float vitesse) {            //paragraphe fini
  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(53, 2);
  display.print(distance, 1);

  display.setTextSize(4);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(vitesse, 0);
 
  display.display();
}

void Affichemenu2 (byte vitessemax, byte vitessemaxtotale, unsigned int distancetotale){             //paragraphe à finir / non fini

  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print("vitesse max =    km/h ");

  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print("vitesse max totale =    km/h ");

  display.setTextSize(2);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print("distance totale =     km");

  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(vitessemax);

 
 
  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(vitessemax);

  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(vitessemaxtotale);

  display.setTextSize(2);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(0, 2);
  display.print(distancetotale, 0);
 
  display.display();
}

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


void loop() {
 
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(74, 2);
  display.print("km");

  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(52, 18);
  display.print("km/h");
 
  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);
      distancebis = distance + (perimetre / 1000.0);
      Affichemenu1 (distance, vitesse);
    }
  }
  else
  {
    flagMesure = true;  // prêt pour une nouvelle mesure
  }

  if(boutonpoussoir == 1 and menu2 == false){
    delay(100);                                    //anti-rebond
    display.clearDisplay();
    Affichemenu2;
    menu2 = true;
  }
  else if(boutonpoussoir == 1 and menu2 == true){
    delay(100);                                     //anti-rebond
    display.clearDisplay();
    Affichemenu2;
    menu2 = false;
  }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 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
 }
}





Il y a sans aucun doute un bon ptit millier d'erreurs et je m'excuse de la lisibilité atroce du programme ( le bordel quoi 8)
Je l'ai testé sans changer de mode mais j'ai l'impression que ça ralentit tout du coup !... :smiley-cry: En gros, j'ai l'impression de retourner à la case départ: l'affichage est plus lent et je peux mesurer 19 km/h max.
Je n'ai pas changé de mode car je n'ai simplement pas de bouton-poussoir mais je vais sans doute en trouver un sur un vieux circuit type autoradio ou n'importe quoi ( ça se trouve partout de toute façon !!! ).

Go Up