Compteur

Le compteur digital (tripmaster) de mon Africa Twin a rendu l’âme. Vu le prix de la chose chez le concessionnaire Honda, j’ai trouvé que cela pourrait-être un bon exercice d’en fabriquer un avec un microcontrolleur (atmega168).

Objectif

L’objectif est d’avoir plusieurs infos :

compteur de vitesse
compteur KM total
compteurs KM journaliers
compteur KM journalier rapidement remis à 0 après un plein
heure

avec éventuellement

consommation moyenne (on indique combien de litres on a mis lors d’un plein)
durée du dernier trajet
moyenne horaire
indicateur visuel en cas de dépassement de la vitesse limite
…

pleins de trucs quoi.

Alimentation

Premier problème le courant. Là pas de soucis, les câbles de l’ancien tripmaster nous fournissent tout ce dont on a besoin, comme j’ai trouvé sur le site http://www.qsl.net/iz7ath/moto/Trip/ :

Masse (vert!)
+12v permanent, derrière un fusible de 10A (rouge/vert)
+12v au contact (noir!)
+12v à l’allumage des phares (marron)

Il faudra ramener ces 12v en 5v pour l’électronique. L’éclairage du LCD sera sur le + à l’allumage des phares, et l’électronique ~~sur le + permanent. Le + au contact nous permettra de mettre la carte en mode veille ou réveil~~. Après avoir discuté sur fr.sci.electronique il apparaît que le plus simple est de tout mettre au contact, avec un gros condensateur pour sauver les donner à la coupure. Les détails plus tard.

Ensuite il nous faut un indicateur pour savoir à quelle vitesse on va. La aussi, le site ci dessus nous indique :

senseur+ (blanc/bleu)
senseur- (vert/noir)

Mais j’ai bien été incapable de tirer quoique ce soit de ces signaux 🙁 Peut-être avec un oscilloscope, mais je n’en ai pas… et je ne sais pas m’en servir.

Capteur

Donc premier problème, capter le nombre de tours de roue que fait la moto. Je vais pour cela utiliser comme sur les vélos un aimant que je collerais sur la jante, et un capteur hall fixé sur la fourche. Et ça tombe bien, j’ai un capteur en stock, le US5881LUA. Je vais donc faire un proto avec une carte arduino, d’après le schéma trouvé sur le datasheet du composant.

Je n’ai pas de condensateur 4.7nF, mais j’ai un 10nF… testons.

capteurhallUS5881

Et le code arduino :

const int capteur = 2;
volatile int compteur = 0;

void setup() {
  pinMode(capteur, INPUT);    // pin2 en entrée
  // interruption : inter_incremente_compteur est appelé à chaque changement d'état de pin2
  attachInterrupt(0, inter_incremente_compteur, CHANGE);  // interruption 0 = pin2

  Serial.begin(9600);      // Ouverture de la communication série avec le PC
}
void loop() {
  Serial.println(compteur);    // Affiche l'état du compteur sur la console du PC
}
void inter_incremente_compteur(){
  if(!digitalRead(capteur)){    // S'il l'état de pin2 est bas, c'est qu'on a un aimant devant notre capteur
    compteur++;                 // et donc on le comptabilise
  }
}

const int capteur = 2;

volatile int compteur = 0;

void setup() {

pinMode(capteur, INPUT); // pin2 en entrée

// interruption : inter_incremente_compteur est appelé à chaque changement d'état de pin2

attachInterrupt(0, inter_incremente_compteur, CHANGE); // interruption 0 = pin2

Serial.begin(9600); // Ouverture de la communication série avec le PC

}

void loop() {

Serial.println(compteur); // Affiche l'état du compteur sur la console du PC

}

void inter_incremente_compteur(){

if(!digitalRead(capteur)){ // S'il l'état de pin2 est bas, c'est qu'on a un aimant devant notre capteur

compteur++; // et donc on le comptabilise

}

Et ça marche ! Fin de la première étape 🙂

Voici le montage avec des condensateurs en CMS (c’est dur à souder ces petites choses). J’avais en CMS un condensateur à 4.7nF que j’ai donc mis. J’ai un petit tube en plastique rigide qui provient d’une bobine d’étiquettes. J’ai noyé le tout dans de la résine (colle à deux composants) à l’intérieur de ce tube pour le protéger une fois qu’il sera en place sur la fourche.
Le tout fonctionne à merveille.

u58resine u5881cms

L’étape suivante est de pouvoir afficher les données recueillies. Pour cela je vais utiliser un grand afficheur LCD que j’ai en stock, et qui semble compatible avec le HD44780. Je suis passé au stade de l’Atmega168 indépendant et j’utilise la libraire LCD de Peter Fleury en 4bits.
Le fait d’utiliser l’Atmega sans bénéficier de l’environnement si confortable de l’Arduino complique un peu les choses, mais ça permet d’apprendre. Pour le LCD, pas de souci. Par contre il faut que je m’attaque aux interruptions :
– Les impulsions du capteur seront détectées par INT0 (sur la broche PD2 selon le datasheet)
– La coupure du contact sera détectée par INT1 (PD3)
– Il me faut un compteur de temps
– Je ne sais pas encore si je gère les boutons par interruptions (PCINT) ou sur la boucle principale.

Voici comment l’interruption du capteur est définie avec l’atmega168 seul :

volatile uint32_t Tour_de_roue=0;
void interruptions_init(void){
  // PD2 = entrée capteur Hall -> INT0 en change
  DDRD &= ~(1<<DDD2);           // PD2 en entrée
  EIMSK = (1<<INT0);            // Autorise l'interruption extérieure INT0
  EICRA = (1<<ISC01);           // INT0 déclenché sur front descendant
}
ISR (INT0_vect){
  // Routine appelée à chaque interruption
  Tour_de_roue++;
}
int main(void){
	interruptions_init();   // Initialisation des interruptions
	sei();                  // Autorisation des interruptions
	while(1);               // On boucle sans fin
}

volatile uint32_t Tour_de_roue=0;

void interruptions_init(void){

// PD2 = entrée capteur Hall -> INT0 en change

DDRD &= ~(1<<DDD2); // PD2 en entrée

EIMSK = (1<<INT0); // Autorise l'interruption extérieure INT0

EICRA = (1<<ISC01); // INT0 déclenché sur front descendant

}

ISR (INT0_vect){

// Routine appelée à chaque interruption

Tour_de_roue++;

}

int main(void){

interruptions_init(); // Initialisation des interruptions

sei(); // Autorisation des interruptions

while(1); // On boucle sans fin

}

Prototype

Après quelques soucis de gestion de mémoire, voici le premier prototype fonctionnel :

proto1

Je sais c’est plein de cables, mais tout cela disparaitra avec le circuit imprimé, et puis c’est joli, ça impressionne. On peut y voir deux Atmega 168, mais il y en a un qui ne sert a rien : il était sur la plaque et je ne l’ai pas enlevé.

Pour programmer l’atmega j’utilise le programmateur MySmartUSB sous linux ~~avec Eclipse pour C et le plugin AVR Eclipse~~ en ligne de commande. J’ai trouvé Eclipse pratique, mais vraiment trop lourd pour mon petit portable. On a l’impression d’un gaspillage de ressources. Du coup, j’ai créé un makefile (après avoir galéré pour savoir comment faire, je mettrais tout ça une fois le projet fini), et compilation et chargement se font rapidement, le code étant tapé sur un simple éditeur de texte.

Donc il y a un DS1307 pour l’horloge en temps réel, avec sa pile de 3v en sauvegarde. Le DS1307 a la possibilité d’avoir un signal de sortie à différentes cadences. Je me sert du signal à 4096 hz relié à une entrée de l’atmega qui gère une interruption pour avoir un timer. Je gère donc un timer au 4096è de secondes, ce qui est largement suffisant pour compter le temps entre deux rotations de roues.
Une petite platine me transforme le 12v de la moto en 5v, avec une réserve pour sauver les données en eeprom lors de la coupure du contact. La détection de coupure se fait par une interruption au niveau de l’atmega.
Le LCD est géré par l’atmega, pas trop de soucis.

Première ligne :
– Compteur km journalier : a, b et c = compteurs journaliers, d = compteur km total.
– Vitesse en km/h
Deuxième ligne :
– date et heure
– une des trois vitesses limite : un dépassement de cette vitesse alume une led, un dépassement de plus de 10% fait clignoter la led

La gestion du compteur se fait avec deux boutons :
Bouton 1 :
– appui bref, changement de vitesse limite
– appui long, entrée dans le mode paramétrage
Bouton 2 :
– appui bref, changement de compteur km
– appui long, remise à zéro du compteur km (sauf le ‘d’).
Le compteur ‘a’ sert au suivit de la conso et d’indicateur de proximité de réserve. On le remet à zéro à chaque pleins. Je ne l’ai pas encore programmé, mais sa remise à zéro basculera l’affichage dans un mode de saisie de la quantité d’essence du plein. Je garderai un historique sur quelques pleins pour calculer la conso moyenne, et éventuellement une trace du km pour allumer un afficheur quelques km avant de passer en réserve.

Paramétrage

Dans le menu paramétrage, on peux (sans y être obligé) saisir alternativement :
– La date et l’heure
– Les 3 limites de vitesses maxi
– La taille de la roue (périmètre en mm)
– La valeur du compteur km total

Platine finale

Je n’ai pas laissé tomber le projet même si j’ai pris beaucoup de retard. J’en suis même presque au bout.
J’ai perdu énormément de temps à cause de mon afficheur LCD qui plantait ! Je pensais à une erreur de programmation, de conception du circuit ou autre. Les symptômes étaient un affichage de caractères bizarres au bout de quelques secondes, puis une extinction de l’affichage… En fait, au bout de quelques galères de recherche et un peu de désespérance, un simple changement de LCD et tout marche !
Les fonctions que j’ai implémentées sont :
– 3 compteurs journaliers. le ‘a’ et le ‘b’ normaux, le ‘r’ me servira pour le suivi de la réserve. Il sera remit à 0 à chaque plein et le compteur me demandera la quantité d’essence mise. La moyenne de consommation est affichée, et je garde une moyenne sur 5 pleins.
– 1 compteur totalisateur
– Une horloge
– Un thermomètre
– Un indicateur de dépassement de vitesse, avec 3 vitesses à choix programmables (pour la Suisse : 50, 80 et 120 km/h). En cas de dépassement une led s’allume et clignote pour un dépassement de +10%

platine_compteur

Le premier test sur la moto semble bien fonctionner. Quelques faux contacts sur les connecteurs m’ont fait douter, mais une fois bien enfoncés ça a marché. Pour le montage final, je supprimerais les connecteurs pin et je souderais les câbles directement sur la platine.

Boitier

J’ai choisi de faire un boîtier en plexiglas. J’ai une plaque de plexi de 4mm. Après quelques recherches sur le net, où tout le monde va de son conseil, j’ai décider de tenter de le couper avec ce que j’ai à la maison. J’ai donc opté pour la scie sauteuse, avec une lame pour le bois, et en vitesse mini. C’est parfait ! La découpe est nette et le plexi ne colle pas sur la lame. Seul problème, ma découpe n’est pas super droite…
J’ai acheté des boutons étanches chez seeedstudio. En demandant conseil à propos de connecteurs sur le forum fr.sci.electronique, j’ai même trouvé un généreux donateur de connecteurs qui seront parfaits pour brancher le boîtier au 12v et au capteur hall.
Il ne reste plus qu’à percer tout ça, à faire le montage et à coller le boîtier.

Conclusion (?)

Nous sommes en octobre 2010 est le compteur est terminé depuis 2 mois et dans l’ensemble je suis assez content. La finition du boîtier n’est pas terrible, mais c’est pas trop grave.
J’ai été exposé à quelques problèmes :
– led de dépassement de vitesse non visible en plein jour : elle a été remplacée par un laser (!) bon marché de chez dealextreme (+ transistor) placé à l’intérieur du boîtier -transparent- et dont le faisceau pointe sur un patin anti-dérapant de 5mm en silicone. C’est parfait en plein jour, un peu violent tout de même la nuit, il va falloir que je fasse quelque chose…
– capteur de température déporté, car dans le boîtier, la température mesurée était un peu fantaisiste, surtout en plein soleil 🙂
– LCD invisible en plein jour. J’avais pris initialement un lcd rétro-éclairé à affichage jaune sur fond bleu foncé. Très contrasté en temps normal, mais avec le soleil dessus c’est totalement illisible. On m’a conseillé à raison un lcd à fond gris clair, et c’est parfait.

Si j’ai le courage je ferais quelques améliorations sur le soft…

Bleaug

Pense bête et idées en vrac

Compteur moto