Sujet : tableau de bord de moto avec arduino

Bonjour tout le monde,
Pour mon second projet arduino, j'avais prévu un découpeur plasma automatisé (ou fraiseuse, ou tout ce qu'on peut mettre dans l'emplacement de découpe...) mais je ne me sens pas encore prêt pour un tel projet. En attendant, je me suis mangé un peu le bitume avec ma moto, et dans l'accident, le cable de mon compteur de vitesse / km parcourus s'est arraché salement. Comme ma moto ne disposait que de deux cadrans avec compte-tour d'un coté et vitesse/km parcourus de l'autre, je me suis dit que le moment était donc venu d'ajouter quelques fonctionnalités à celle-ci.
Les fonctions qui me manquaient le plus étant une horloge, et une jauge à essence. En effet, le témoin de réserve s’avère un peu short pour anticiper, surtout depuis que je ne vois plus combien de km j'ai parcouru depuis le dernier plein.

Voici donc comment se compose ce projet aujourd'hui :
Un arduino Uno (prochainement remplacé soit par un atmega 328p sur une pcb custom, soit par un arduino mini)
Un afficheur 16x2 rétroéclairé bleu
Un capteur à effet Hall pour compter les tours de roue (avec aimant sur la jante)
Un capteur de température ambiante TMP36 (pur gadget)
Une sonde de thermocouple K avec son ampli pour la température moteur (ya pas de radiateur sur ma moto, la température peut être intéressante à surveiller)
Un DS1307 pour avoir l'heure
Une jauge à liquides à résistance variable (56? / cm) de 25 cm
Une carte micro-SD pour enregistrer le nombre de KM parcourus entre deux coupures de circuits (la memoire EEPROM à un nombre limité d'écritures, et il faut écrire assez souvent sur la carte SD pour ne pas rater trop de km)

Vu que tout le monde aime les illustrations de projet :
Bazar de fils
http://s13.postimg.org/gqg4dr5tf/photo_1.jpg

Le capteur à effet Hall
http://s14.postimg.org/u0idx47ul/photo_2.jpg


Le tout allumé (les infos avec l'heure s'affichent toutes les deux secondes)
http://s21.postimg.org/3kxfrs7v7/photo_3.jpg

La ou ça doit rentrer (le boitier blanc)
http://s24.postimg.org/4w9bumbxt/photo.jpg

L'heure n'est pas encore connectée (breadboard trop petite) et la jauge est simulée par une resistance variable pour le moment. Le thermocouple est aussi en attente de branchement.

Re : tableau de bord de moto avec arduino

beau travail, l'affichage est vraiment sympa. j'ai hâte de voir l'intégration du matériel dans le compteur.

Re : tableau de bord de moto avec arduino

Voici la suite. Donc tout d'abord le coût :
Un arduino mini 16€
Un afficheur 16x2 rétroéclairé bleu 7,50€
Un capteur à effet Hall 3,40€
Une sonde de thermocouple K 7,70€
Un ampli max31855 13,50€
Un DS1307 pour avoir l'heure 6,90€
Une jauge à liquides à résistance variable (56? / cm) de 25 cm 30€
Une carte micro-SD  et son lecteur 5,50€
Différents composants (résistances,LEDs,fils, pcb, pins mâles et femelles...) autour de 10€

Total environ 84€
Disons avec ce que j'ai pu oublier 100€
Sur le commerce, un ordinateur de bord pour moto coute en moyenne 300€

Et le code actuel, presque terminé, et complétement sale :


moto.ino

// Inclusion des librairies
#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(9, 8, 7, 6, 5, 4); // Initialisation de la librairie Liquid Crystal
#include <SD.h>
#include "RTClib.h"
#include "LcdBigFont.h"


RTC_DS1307 RTC; //initialisation de la librairie du module RTC

int tmpPin = A0;    // Selection de l'entrée analogique pour la sonde température TMP36
int jaugePin = A1; // Jauge d'essence sur A1
int lastJauge=500000; // initialisation impossible pour la comparaison de jauge
float vitesse = 0; // initialisation de la vitesse float
int intVitesse=0; // initialisation de la vitesse à afficher (int)
float temperature[10]; // tableau de valeur pour stocker 10 echantillons de température
int index=0 ;          // index du tableau pour s'y retrouver
long previousMillis = 0;       
long interval = 3000; // interval de defilement des parametres sur le lcd
int lcdState = 0;  // parametre en cours d'affichage
volatile byte rpmcount; // compteur tours de roues
float kmcount=0; // compteur de km
char kmprev[10]; // tableau pour lire la carte SD
int bufPos = 0; // buffer pour lire la carte SD
char byteIn = 0; // byte de la carte SD
String erreur=""; // code erreur

unsigned int rpm;
unsigned long timeold; // marqueur de temps
const int chipSelect = 10; // pin cs de la carte SD

void setup() {
// Configuration de l'afficheur 16 caractères en 2 lignes 
lcd.begin(16, 2);
// creation des caracteres speciaux
bigFontBegin();

// Lien avec l'horloge RTC
Wire.begin();
RTC.begin();

memset(kmprev,0,sizeof(kmprev)); 

erreur = "Init";//initialize
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);

// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
  erreur = "SD";//Card failed, or not present"
  // don't do anything more:
  return;
}

// on lit le nombre de km parcouru jusqu'ici
File dataFile = SD.open("datalog.txt");

// if the file is available, write to it:
if (dataFile) {
  while (dataFile.available()) {

     byteIn = dataFile.read();
if (bufPos < sizeof(kmprev))
kmprev[bufPos++] = byteIn;
  }
  dataFile.close();
  kmcount = strtod(kmprev, NULL);
}  
// if the file isn't open, pop up an error:
else {
  erreur = "File";//error opening datalog.txt
} 
// On verifie la présence de l'horloge, de sa pile...
if (! RTC.isrunning()) 
{
    erreur = "RTC";
    //RTC.adjust(DateTime(__DATE__, __TIME__));//Décommenter pour initialiser l'heure
}

 attachInterrupt(0, rpm_fun, RISING); // LA fonction qui compte les tours de roues en background

 rpmcount = 0;
 rpm = 0;
 timeold = 0;
}

void loop() {
DateTime now = RTC.now();
if (rpmcount >= 10) { 
   //Update RPM every 10 counts, increase this for better RPM resolution,
   //decrease for faster update
   rpm = 30*1000/(millis() - timeold)*rpmcount;
   timeold = millis();
   rpmcount = 0;
   vitesse= rpm*60;
   vitesse= vitesse*2.10;
   intVitesse = vitesse/1000;

   File dataFile = SD.open("datalog.txt", FILE_WRITE); // on ecrit le nombre de km parcourus dans un fichier
    // if the file is available, write to it:
if (dataFile) {
  dataFile.seek(0);
  dataFile.print(kmcount);
  dataFile.close();
}  
// if the file isn't open, pop up an error:
else {
 erreur = "File"; //error opening datalog.txt
} 
 }

//acquisition de la valeur analogique dans sensorValue
// de 0 à 1023 -> 0 à 5V
int sensorValue = analogRead(tmpPin); 


//transformation en milliVolts dans outputValue
float outputValue = (((float)(sensorValue))*5000.0)/1023.0;

//Calcul de la température en fonction des milliVolts
float outputTemp = ( (float) outputValue - 500.0) /10.0;

//insertion de la température dans le tableau
temperature[index] = outputTemp;

//incrémentation de l'index modulo 10
index = (index + 1) % 10;

// calcul de la moyenne ( Méthode barbare, une boucle for l'aurait mieux fait)  
int tempMoy = (temperature[0]+temperature[1]+temperature[2]+temperature[3]+temperature[4]+temperature[5]+temperature[6]+temperature[7]+temperature[8]+temperature[9])/10;

lcd.setCursor(0, 0);
bigFont(intVitesse); // affichage de la vitesse en gros, fonctionne seulement si inferieur a 999!

int jaugeValue = analogRead(jaugePin); // lecture de la jauge
jaugeValue = map(jaugeValue, 500, 1000, 0, 5); 
if (lastJauge != jaugeValue) // si le niveau à bougé, on update l'affichage
{
lastJauge = jaugeValue;
lcd.setCursor(11, 1);
lcd.write(byte(1));
lcd.write(byte(4));
lcd.write(byte(4));
lcd.write(byte(4));
lcd.write(byte(2));
lcd.setCursor(11, 1);
int i=0;
while ( i < jaugeValue){
    lcd.write(byte(3));
    i++;
 } 
}
// on gere l'affichage des options heure et temperature
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
  lcdState ++;


  previousMillis = currentMillis;   

  }
  lcd.setCursor(11, 0);
  if(erreur=="")
  {
  if(lcdState == 0){//affichage de l'heure
    lcd.print(now.hour());
    lcd.print(":");
    lcd.print(now.minute());

  }
  else if(lcdState == 1){//affichage de la temperature moyenne exterieur
    lcd.print("  ");
    lcd.print(tempMoy);
lcd.setCursor(15, 0);
lcd.write(byte(0));
  }
  else if(lcdState == 2){//affichage de la température moteur
    lcd.print("  ");
    lcd.print(tempMoy+(tempMoy*272)/100);//Cette partie est simulée tant que je n'ai pas cablé le thermocouple
lcd.setCursor(15, 0);
lcd.write(byte(0));
  }
  else{

    lcdState = 0;
  }
  }
  else
  {
    if(erreur == "Init")
    {
      lcd.print(erreur);
      delay(700);
      lcd.setCursor(11, 0);

      lcd.print(".");
      delay(700);
      lcd.print(".");
      delay(700);
      lcd.print(".");
      delay(700);
      lcd.print(".");
      delay(700);
      lcd.print(".");
      delay(700);
    erreur = "";

    }
    lcd.print(erreur);
    
  }
delay(30); // un petit delais pour ne pas trop mouliner

}

void rpm_fun()
{
 rpmcount++;
 kmcount= kmcount + 0.0021;
}

Re : tableau de bord de moto avec arduino

La seconde page de code :

LcdBigFont.h

#ifndef LcdBigFont_h
#define LcdBigFont_h

byte degre[8] = { B01000, B10100, B01000, B00000, B00000, B00000, B00000, B00000}; // °
byte endJauge[8] = { B11111, B00001, B00001, B00001, B00001, B00001, B00001, B11111 }; // ]
byte startJauge[8] = { B11111, B10000, B10000, B10000, B10000, B10000, B10000, B11111 }; // [
byte fullJauge[8] = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 }; // carré plein
byte emptyJauge[8] = { B11111, B00000, B00000, B00000, B00000, B00000, B00000, B11111 }; // carré vide
byte haut[8] = { B11111, B11111, B00000, B00000, B00000, B00000, B00000, B00000 }; // trait en haut
byte bas[8] = { B00000, B00000, B00000, B00000, B00000, B00000, B11111, B11111 }; // trait en bas
byte lesDeux[8] = { B11111, B11111, B00000, B00000, B00000, B00000, B11111, B11111 }; // les deux

void bigFontBegin(){
lcd.createChar(0, degre);
lcd.createChar(1, startJauge);
lcd.createChar(2, endJauge);
lcd.createChar(3, fullJauge);
lcd.createChar(4, emptyJauge);
lcd.createChar(5, haut);
lcd.createChar(6, bas);
lcd.createChar(7, lesDeux);
}

void unHaut(){
lcd.write(byte(5));
lcd.write(byte(3));
lcd.print(" ");
}
void unBas(){
lcd.write(byte(6));
lcd.write(byte(3));
lcd.write(byte(6));
}

void deuxHaut(){
lcd.write(byte(7));
lcd.write(byte(7));
lcd.write(byte(3));
}
void deuxBas(){
lcd.write(byte(3));
lcd.write(byte(6));
lcd.write(byte(6));
}
void troisHaut(){
lcd.write(byte(5));
lcd.write(byte(7));
lcd.write(byte(3));
}
void troisBas(){
lcd.write(byte(6));
lcd.write(byte(6));
lcd.write(byte(3));
}
void quatreHaut(){
lcd.write(byte(3));
lcd.write(byte(6));
lcd.write(byte(3));
}
void quatreBas(){
lcd.print(" ");
lcd.print(" ");
lcd.write(byte(3));
}
void cinqHaut(){
lcd.write(byte(3));
lcd.write(byte(7));
lcd.write(byte(7));
}
void cinqBas(){
lcd.write(byte(6));
lcd.write(byte(6));
lcd.write(byte(3));
}
void sixHaut(){
lcd.write(byte(3));
lcd.write(byte(7));
lcd.write(byte(7));
}
void sixBas(){
lcd.write(byte(3));
lcd.write(byte(6));
lcd.write(byte(3));
}
void septHaut(){
lcd.write(byte(5));
lcd.write(byte(5));
lcd.write(byte(3));
}
void septBas(){
lcd.print(" ");
lcd.print(" ");
lcd.write(byte(3));
}
void huitHaut(){
lcd.write(byte(3));
lcd.write(byte(7));
lcd.write(byte(3));
}
void huitBas(){
lcd.write(byte(3));
lcd.write(byte(6));
lcd.write(byte(3));
}
void neufHaut(){
lcd.write(byte(3));
lcd.write(byte(7));
lcd.write(byte(3));
}
void neufBas(){
lcd.write(byte(6));
lcd.write(byte(6));
lcd.write(byte(3));
}
void zeroHaut(){
lcd.write(byte(3));
lcd.write(byte(5));
lcd.write(byte(3));
}
void zeroBas(){
lcd.write(byte(3));
lcd.write(byte(6));
lcd.write(byte(3));
}

int bigFont(int x)//fonctionne uniquement si x toujours inferieur a 999 et x un chiffre
{
int a = x/100;
int b = (x/10)-(a*10);
int c = x-(a*100)-(b*10);

switch (a) {

case 0 :
  zeroHaut();  break;
case 1 :
  unHaut();  break;
case 2 :
  deuxHaut();  break;
case 3 :
  troisHaut();  break;
case 4 :
  quatreHaut();  break;
case 5 :
  cinqHaut();  break;
case 6 :
  sixHaut();  break;
case 7 :
  septHaut();  break;
case 8 :
  huitHaut();  break;
case 9 :
  neufHaut();  break;
}  
lcd.print(" ");
switch (b) {  
case 0 :
  zeroHaut();  break;
case 1 :
  unHaut();  break;
case 2 :
  deuxHaut();  break;
case 3 :
  troisHaut();  break;
case 4 :
  quatreHaut();  break;
case 5 :
  cinqHaut();  break;
case 6 :
  sixHaut();  break;
case 7 :
  septHaut();  break;
case 8 :
  huitHaut();  break;
case 9 :
  neufHaut();  break;
}  
lcd.print(" ");
switch (c) {  
case 0 :
  zeroHaut();  break;
case 1 :
  unHaut();  break;
case 2 :
  deuxHaut();  break;
case 3 :
  troisHaut();  break;
case 4 :
  quatreHaut();  break;
case 5 :
  cinqHaut();  break;
case 6 :
  sixHaut();  break;
case 7 :
  septHaut();  break;
case 8 :
  huitHaut();  break;
case 9 :
  neufHaut();  break;
}
lcd.setCursor(0, 1);

switch (a) {  
case 0 :
  zeroBas();  break;
case 1 :
  unBas();  break;
case 2 :
  deuxBas();  break;
case 3 :
  troisBas();  break;
case 4 :
  quatreBas();  break;
case 5 :
  cinqBas();  break;
case 6 :
  sixBas();  break;
case 7 :
  septBas();  break;
case 8 :
  huitBas();  break;
case 9 :
  neufBas();  break;
}  
lcd.print(" ");
switch (b) {  
case 0 :
  zeroBas();  break;
case 1 :
  unBas();  break;
case 2 :
  deuxBas();  break;
case 3 :
  troisBas();  break;
case 4 :
  quatreBas();  break;
case 5 :
  cinqBas();  break;
case 6 :
  sixBas();  break;
case 7 :
  septBas();  break;
case 8 :
  huitBas();  break;
case 9 :
  neufBas();  break;
}  
lcd.print(" ");
switch (c) {  
case 0 :
  zeroBas();  break;
case 1 :
  unBas();  break;
case 2 :
  deuxBas();  break;
case 3 :
  troisBas();  break;
case 4 :
  quatreBas();  break;
case 5 :
  cinqBas();  break;
case 6 :
  sixBas();  break;
case 7 :
  septBas();  break;
case 8 :
  huitBas();  break;
case 9 :
  neufBas();  break;
}


}
#endif

Re : tableau de bord de moto avec arduino

merci d'avoir partager ton code c'est très intéressant. Surtout pour la procédure a suivre avec la carte sd.
Par contre je comprend pas tout a fait la partie Calcul de la température. Je pensais faire un simple map(); pour mon projet. Du coup je suis un peu perdu ...

Re : tableau de bord de moto avec arduino

Tout dépend des caractéristiques de ta sonde. (on parle bien de la température ambiante dans mon code, pas de la température moteur, que je simule en fonction de la t° ambiante le temps des essais)
J'utilise map quand j'ai un calibrage à faire dans le setup. Pour la température, les sondes ont des caractéristiques détaillées, le calcul est alors simple!

Re : tableau de bord de moto avec arduino

ok merci, je crois que j'y vois un peu plus clair.

Re : tableau de bord de moto avec arduino

Wahou !!! Joli projet n'oublies pas si tu souhaites le mettre en avant tu peut le mettre sur le blog en guest-blogging...
Je vais de suite le faire partager à mes potes motard. big_smile

Re : tableau de bord de moto avec arduino

Je le soumettrais au guest-blogging dés qu'il sera posé. Pour ça j'attends encore les pièces commandées sur la boutique. Mais il semble que la poste ne sache plus acheminer les lettres 48h en moins de 4 jours...

Dernière modification par Rovhell (17-04-2013 14:18:48)

10

Re : tableau de bord de moto avec arduino

Bon, je viens donner des nouvelles.
Le projet avance bien, malgré plusieurs ralentissements. Il ne me reste que le thermocouple à programmer pour la température du moteur, et la jauge à essence à câbler et calibrer à la main, vu que la doc fournit les info pour lire un niveau d'eau, et que le tout se base sur la pression. Je suppute que l'essence ne me fournira pas la même pression sur la jauge.
Une fois tout ça fait, je monte le tout sur mon cheval d'acier, en prenant plein de photos de toutes les parties avant qu'elles ne soient cachées dans des carters.
Ça avance, ça avance, malgré mes 12h de boulot par jour.

11

Re : tableau de bord de moto avec arduino

Hé hé, j'ai pas eu le temps de tester sur route, mais c'est monté  XD

http://www.youtube.com/watch?v=blnMZIcGmsw

Re : tableau de bord de moto avec arduino

Super projet !!
Je suis très intéressé , car je roule en Yamaha 600 XJs diversion et donc, pas de jauge d'essence, ni de température d'huile .
La montre me manque aussi souvent .

Le capteur de niveau de carburant résistera a la " corrosion " de l'essence ?
Et le compteur kilométrique ne doit pas pouvoir être modifié, donc je ne pense pas que ton système soit bon pour les force de l'ordre .
Quoi que, il faudrait qu'il démonte pour savoir lol ! big_smile

En tout cas, bravo . Je vais suivre ton projet avec plaisir .
Ce serai super d'avoir une jauge de carburant sur ma div' !!

13

Re : tableau de bord de moto avec arduino

Bin le projet est terminé, je posterais une vidéo du système en fonctionnement quand je trouverais un moyen de me filmer en roulant.

14

Re : tableau de bord de moto avec arduino

super, l'intégration est très réussie. On dirai que c'est d'origine!

15

Re : tableau de bord de moto avec arduino

Déjà merci beaucoup de nous fournir les sources en même temps que tu nous fais partager ce projet.
mais si tu peux nous en donner plus, schema meme papier, emplacement des sondes cela serait super cool,
pour la partie alimentation sur le blog tu parle de l'utilisation régulateur du type 7805, je vais lire un peu plus ce qu'il faut autour avant de poser une question car c'est ce qui me fait le plus peur...
edit : j'ai trouvé http://arduino.cc/forum/index.php/topic,33002.0.html

16

Re : tableau de bord de moto avec arduino

J'ai utilisé un module complet avec régulateur et les Condo. Il accepte jusqu'à 30v en entrée, ce qui est cool pour les pics de mon alternateur.

17

Re : tableau de bord de moto avec arduino

Merci ;-)

Re : tableau de bord de moto avec arduino

ou peut on trouver le schéma de cablage svp? je fait des recherches afin de créer mon afficheur de sondes pour ma corrado

19

Re : tableau de bord de moto avec arduino

Y'a pas vraiment besoin d'un schéma de câblage ici. L'attribution des pins est donnée dans le haut du code. Cré un post avec ton projet, et on va t'aider à mettre tout ça sur pieds.

20

Re : tableau de bord de moto avec arduino

Hello !
Superbe projet !
Où as tu trouvé ta jauge à essence ?
smile

21

Re : tableau de bord de moto avec arduino

Alors, je suis en train de faire la v2.0 donc je l'ai virée, mais c'est le e-tape de chez adafruit.

22

Re : tableau de bord de moto avec arduino

Bon, je viens de finir de coder la V2.0 du compteur. J'avais un petit soucis avec le capteur à effet hall : au dessus de 100km/h environ, il loupait des tours de roue. Donc ma vitesse affichée faisait des "bonds" (74, 101, 122...) alors que je restais a vitesse constante.
J'ai donc pris une puce GPS (MT3339) qui me donne du coup quelques infos supplémentaires (comme l'heure, j'ai viré aussi le module RTC du coup).
J'ai aussi viré la jauge à essence, parce que trop de code et trop de fils, fallait que ça rentre dans un arduino mini et dans l'emplacement du compteur sur la moto. Du coup j'ai gagné en place sur l’écran, je peux maintenant afficher la distance parcourue (avant je ne l'affichait que pendant l'initialisation).
Des tas de soucis pour passer en dessous des 28 600KB, mais j'ai enfin réussi, et ça fonctionne !

Voici le code, et une vidéo du truc en marche bientôt, quand j'aurais remonté le tout.


// Inclusion des librairies
#include <SoftwareSerial.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 4, 5, 6, 7, 8); // Initialisation de la librairie Liquid Crystal
#include <SD.h>
#include <Adafruit_MAX31855.h>
/*-----------------------------------------------------------------------------------
 ============================GPS======================================================
 -----------------------------------------------------------------------------------*/
#include <TinyGPS.h>
TinyGPS gps;
SoftwareSerial nss(A4, A5);
unsigned long chars;
unsigned short sentences, failed;
char b;
float flat, flon;
unsigned long age;
int year;
byte month, day, hour, minute, second, hundredths;
bool newData;
int z = 0;
/*-----------------------------------------------------------------------------------
 ============================GPS=END==================================================
 -----------------------------------------------------------------------------------*/
byte NO[8] = { 
  B11110,
  B11000,
  B10100,
  B10010,
  B00001,
  B00000,
  B00000,
  B00000 }; 
byte N[8] = { 
  B00100,
  B01110,
  B10101,
  B00100,
  B00100,
  B00000,
  B00000,
  B00000 }; 
byte NE[8] = { 
  B01111,
  B00011,
  B00101,
  B01001,
  B10000,
  B00000,
  B00000,
  B00000 }; 
byte E[8] = { 
  B00100,
  B00010,
  B11111,
  B00010,
  B00100,
  B00000,
  B00000,
  B00000 }; 
byte SUDEST[8] = { 
  B10000,
  B01001,
  B00101,
  B00011,
  B01111,
  B00000,
  B00000,
  B00000 };  
byte S[8] = { 
  B00100,
  B00100,
  B10101,
  B01110,
  B00100,
  B00000,
  B00000,
  B00000 }; 
byte SO[8] = { 
  B00001,
  B10010,
  B10100,
  B11000,
  B11110,
  B00000,
  B00000,
  B00000 }; 
byte O[8] = { 
  B00100,
  B01000,
  B11111,
  B01000,
  B00100,
  B00000,
  B00000,
  B00000 }; //*/

const int tmpPin = A0;    // Selection de l'entrée analogique pour la sonde température TMP36

unsigned int intVitesse=0; // initialisation de la vitesse à afficher (int)
unsigned long previousMillis = 0;      
const int interval = 3000; // interval de defilement des parametres sur le lcd
int lcdState = 0;  // parametre en cours d'affichage
int kmState = 0;
float kmcount;
int intkm;
char kmprev[10]; // tableau pour lire la carte SD
int bufPos = 0; // buffer pour lire la carte SD
char byteIn = 0; // byte de la carte SD
float lastLat=0;
float lastLon=0;


short unsigned int val=0;
String unite="N/C";




// Initialize the Thermocouple
Adafruit_MAX31855 thermocouple(A1, A2, A3);

void enregistrer(int km)
{
  File dataFile = SD.open("datalog.txt", FILE_WRITE); // on ecrit le nombre de km parcourus dans un fichier
  // if the file is available, write to it:
  if (dataFile) 
  {
    dataFile.seek(0);
    dataFile.print(km);
    dataFile.close();
  }
  // if the file isn't open, pop up an error:
  //*/
}


void setup() 
{
  //Serial.begin(115200);
  nss.begin(9600);

  // Configuration de l'afficheur 16 caractères en 2 lignes 
  lcd.begin(16, 2);
  // creation des caracteres speciaux

  lcd.createChar(8, NO);
  lcd.createChar(1, N);
  lcd.createChar(2, NE);
  lcd.createChar(3, E);
  lcd.createChar(4, SUDEST);
  lcd.createChar(5, S);
  lcd.createChar(6, SO);
  lcd.createChar(7, O);//*/


  lcd.clear();

  lcd.print("Init");
  delay(100);


  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);

  // see if the card is present and can be initialized:
  if (SD.begin(10)) 
  {
    memset(kmprev,0,sizeof(kmprev)); 
    // on lit le nombre de km parcouru jusqu'ici
    File dataFile = SD.open("datalog.txt");
    // if the file is available, write to it:
    if (dataFile) 
    {
      while (dataFile.available()) 
      {
        byteIn = dataFile.read();
        if (bufPos < sizeof(kmprev))
          kmprev[bufPos++] = byteIn;
      }
      dataFile.close();
      kmcount = strtod(kmprev, NULL);
      delay(100);
    }  
    // if the file isn't open, pop up an error:

  }
  else 
  {
    lcd.setCursor(0, 1);
    lcd.print("SD");
    delay(500);
  }//*/

  newData = false;
  lcd.clear();
  lcd.print("No GPS");
  // For one second we parse GPS data and report some key values
  while (newData==false)
  {
    while (nss.available())
    {
      b = nss.read();
      //Serial.write(b); // uncomment this line if you want to see the GPS data flowing
      if (gps.encode(b)) 
      {
        // Did a new valid sentence come in?
        newData = true;
        gps.f_get_position(&flat, &flon, &age);
        lastLat=flat;
        lastLon=flon;
      }
    }
  }
  lcd.clear();

  delay(10);
}




void loop() 
{
  /*-----------------------------------------------------------------------------------
   ============================GPS======================================================
   -----------------------------------------------------------------------------------*/
  newData = false;

  // For one second we parse GPS data and report some key values
  for (unsigned long start = millis(); millis() - start < 1000;)
  {
    while (nss.available())
    {
      b = nss.read();
      //Serial.write(b); // uncomment this line if you want to see the GPS data flowing
      if (gps.encode(b)) // Did a new valid sentence come in?
        newData = true;
    }
  }

  if (newData == true)
  {
    gps.f_get_position(&flat, &flon, &age);


    intVitesse=(gps.f_speed_kmph())*1.10;

    if (kmState>=5) 
    {
      kmcount=kmcount+(TinyGPS::distance_between(flat, flon, lastLat, lastLon) / 1000);
      kmState=0;
      lastLat=flat;
      lastLon=flon;
      intkm = kmcount;
      enregistrer(intkm);
    }

    /*-----------------------------------------------------------------------------------
     ============================GPS=END==================================================
     -----------------------------------------------------------------------------------*/


    //bigFont(intVitesse); // affichage de la vitesse en gros, fonctionne seulement si inferieur a 999!

    //lcd.print("Km/h");

    String point = TinyGPS::cardinal(gps.f_course());
    lcd.setCursor(0, 0);
    delay(10);

    if (point.equalsIgnoreCase("NO")) 
    {
      lcd.write(2);
    }
    else if (point.equalsIgnoreCase("NE")) 
    {
      lcd.write(8);
    }
    else if (point.equalsIgnoreCase("E")) 
    {
      lcd.write(7);
    }
    else if (point.equalsIgnoreCase("SE")) 
    {
      lcd.write(6);
    }
    else if (point.equalsIgnoreCase("S")) 
    {
      lcd.write(5);
    }
    else if (point.equalsIgnoreCase("SO")) 
    {
      lcd.write(4);
    }
    else if (point.equalsIgnoreCase("O")) 
    {
      lcd.write(3);
    }
    else
    {
      lcd.write(1);
    }


    delay(10);

    // on gere l'affichage des options heure et temperature
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > interval) 
    {
      lcdState ++;
      previousMillis = currentMillis;   
    }


    gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);


    switch (lcdState) 
    {
    case 1: 
      val = gps.satellites();
      unite = (" Sat");
      break;

    case 2: 
      unite = ("'A ");
      val = (( (float) ((((float)(analogRead(tmpPin)))*5000.0)/1023.0) - 500.0) /10.0);
      break;


    default: 
      kmState++;
      unite = ("'M ");
      val=thermocouple.readCelsius();
      lcdState = 0;
    }

    //sprintf(ligneA, "%03dkm/h %02d:%02d", intVitesse , hour+2, minute);
    //sprintf(ligneB, "%dkm %d%s", intkm, val, unite);
    String ligneA=" ";
    String ligneB="";
    ligneA += showDigits(intVitesse, 3);
    ligneA += "km/h  ";
    ligneA += showDigits(hour+2, 2);
    ligneA += ":";
    ligneA += showDigits(minute, 2);
    ligneB += showDigits(intkm, 5);
    ligneB += "km   ";
    ligneB += showDigits(val, 2);
    ligneB += unite;
    lcd.print(ligneA);
    Serial.println(ligneA);
    delay(10);
    lcd.setCursor(0, 1);
    delay(10);
    lcd.print(ligneB);
    Serial.println(ligneB);
    delay(10);
    lcd.home();

  }

  delay(40);
}

String showDigits(int digits, int n)
{
  String string;
  // utility function for digital clock display: prints leading 0
  if(digits < 1)
  {
    for (int r=0; r<n; r++)
    {
      string += '0';
    }
  }
  else if(digits < 10)
  { 

    for (int r=0; r < (n-1); r++)
    {
      string += '0';
    }
    string += digits;
  }
  else if(digits < 100)
  {
    for (int r=0; r < (n-2); r++)
    {
      string += '0';
    }
    string += digits;
  }
  else if(digits < 1000)
  {
    for (int r=0; r < (n-3); r++)
    {
      string += '0';
    }
    string += digits;
  }
  else if(digits < 10000)
  {
    for (int r=0; r < (n-4); r++)
    {
      string += '0';
    }
    string += digits;
  }
  else if(digits < 100000)
  {
    for (int r=0; r < (n-5); r++)
    {
      string += '0';
    }
    string += digits;
  }
  else
  {
    string += digits;
  }

  return string;
}

23

Re : tableau de bord de moto avec arduino

Merci pour l'info du e-tape wink
Dommage d'avoir viré la jauge, j'aurai bien vu une fonction pour afficher l'autonomie de manière fiable tongue

24

Re : tableau de bord de moto avec arduino

super travail, et merci d'avoir partagé ton code.  j'aurai une question,  es ce que la TMP36 tient le coup face a la chaleur du bloc? elle te donne quel température? j'ai usiné un support en alu avec filetage pour utiliser les to-92 directement dans le liquide de refroidissement. Mais je ne sais pas comment se comporte la sonde à plus de 100 degrés.