Un afficheur 4x7 segments pour ma moto

Le but de cette 1ère étape est de monter un afficheur 4 digits très compact.

Je vais utiliser un afficheur à anodes communes 4x7+1 segments (https://www.gotronic.fr/art-afficheur-7-segments-jaunes-4-digits-20371.htm). Vous trouverez le brochage sur mon dessin.
Neuf résistances de 330 ohms (10mA / segments) sont soudées côte à côte sur une plaque à bandes, percées au pas de 2,54mm. Les pattes sont espacées avec 1 seul trou de séparation, ce qui est à peine suffisant, même pour des 1/4W déjà très petites, mais ça loge.

La qualité des soudures ne souffre aucun défaut, la place est comptée et le retour sur une erreur ne sera pas possible. Je conseille l'utilisation d'une station de soudage de qualité et la vérification de chaque soudure à la loupe.

Les bandes de la plaque sont découpée à l'aide d'un disque diamanté monté sur une mini perceuse (type Dremel).
Une première découpe doit être faite au milieu des résistances et une deuxième immédiatement sur les bords d'un côté. On gardera les pattes de résistances de ce côté là pour y souder l'Arduino à venir. Il ne reste qu'une pastille pour faire tenir la résistance.

On va maintenant souder l'afficheur au dessus des résistances en faisant coïncider les broches 9 à 16, on garde la 9ème résistance du côté des broches 8-9 de l'afficheur.
Pour faciliter le repérage, j'inscris au marqueur le brochage de l'afficheur sur les côtés de celui-ci.
Les cathodes des segments B, G, A, C, ":", F,  vont recevoir immédiatement une résistance dont l'autre patte se retrouvera sur l'Arduino lui-même.
Noter que les broches 9 et 10 qui alimentent un "dot" unique situé sur sur le 3ème digit, ne seront pas utilisés, coupez les pour libérer les résistances adjacentes. Ces résistances seront utilisées pour les segments D et E situés sur l'autre bord de l'afficheur.
La 9ème résistance servira pour le "dp" (dot point).
Vous remarquerez que la 5ème résistance se trouve connectée à la cathode du ":" qui n'est pas utilisé dans mon montage, mais qui peut vous servir pour un affichage de l'heure par exemple.

Les broches 1 à 8 de l'afficheur se retrouvent isolées sur l'autre bord. Il va falloir relier les segments D, E, "dp", aux résistances libres.

Les pattes des résistances du côté des segments B, G, A, C, ":", F sont coupées, On conserve les 3 autres qui elles sont coupées à l'opposé (contrairement à ma photo. Ben ouais, on peut se rater, j'ai dû compenser par des fils libres).

Voilà pour la 1ère étape. Pas très difficile sur le principe, mais qui demande une grosse attention et une certaine dextérité pour la réalisation.

-nota : les photos et schémas correspondent à 2 projets distincts. Le 2ème optimise l'utilisation des broches de l'Arduino.

La 2ème étape de la réalisation de notre afficheur est l'ajout de l'Arduino.
J'ai opté pour un A-Star3101 (https://www.gotronic.fr/art-carte-a-star-3101-21704.htm) de chez Polulu, pour sa compacité (je crois que c'est le plus petit que j'ai trouvé !). Il assez complet en entrées/sorties et gros avantage, tout un côté n'est fait que de broches d'I/O (v. brochage).

L'A-Star est un 2x10 broches. Les broches 0 à 7 sont soudées sur les pattes des résistances (conservées... J'espère !) avec la correspondance suivante :
(Ard. | aff.) 0|B, 1|G, 2|A, 3|C, 4|:, 5|F, puis 9|D, 8|E, et enfin 7|"dp". Les 3 derniers sont câblés à la "main", c.à d. à l'aide de straps.
(Vérifiez les correspondances en fonction de l'implantation choisie, ce qui est indiqué ici correspond à mon projet)

Il nous reste à connecter les anodes de nos 4 digits, plus l'anode du ":" si on veut l'utiliser.
Le câblage se fera par des straps, de l'afficheur à l'Arduino directement. J'ai choisi l'association suivante :
(Ard. | aff.) 18|[4], 19|[3], 10|[2], 11|[1], si on utilise le ":", sont anode peut utiliser la broche 16|[:] sur l'ISP.

MARS 2018 : J'ai ajouté un PCB commandable chez Aisler : https://aisler.net/p/VNOETYPI
Vous trouverez le fichier FZZ en document joint

BONUS... Une autre implantation

Dans un deuxième temps, j'ai réalisé un autre afficheur en améliorant son implantation (2ème schéma). Vous remarquerez que j'ai volontairement libéré les broches 0, 1, 14 et 15, ce qui permet de garder la fonction "port série" de notre Arduino, utile dans le cas d'une utilisation de ce montage, dans une pure utilisation de type contrôleur d'affichage, en liaison avec un autre Arduino ou un Raspberry Pi, par exemple.
On peut aussi récupérer la fonction du bus SPI, ce qui suppose l'abandon du ":".
Si la fonction "RTS" du port série est nécessaire, il faudra libérer la broche 11 , avec là aussi l'abandon du ":".
Les broches 6 & 11 sont aussi des broches d'entrée analogiques, pratique pour un barregraphe.
Enfin les broches 0 et 1 de l'Arduino permettront une programmation par interruption.

Tout ceci n'est pas très simple, mais les usages sont variés en fonction des options choisies.

Pour mon projet d'indicateur de rapport de boîte, je n'utilise pas les ":" et je dois trouver 1 broche pour le bus 1-Wire et 3 broches pour le capteur à effet Hall. J'aurai pu réduire à 2, avec un peu plus d'électronique extérieure.
Mais ce sera l'objet de ma deuxième étape.

Pour la partie programme, c'est relativement simple, mais on va utiliser des astuces pour minimiser le programme et en faire un afficheur générique, tout à fait utilisable dans tout un tas de projets.

DÉCLARATIONS

// DÉCLARATIONS
// pour allumer un segment il faut positionner l'anode commune de l'afficheur à 1 et la cathode du segment à 0.
// une résistance de 330 ohms est insérée entre la broche de l'arduino et le segment pour une limitation du courant à 10ma.
const byte SEG[8]={1,5,8,9,3,0,2,7};
  // déclare un tableau de 8 constantes de broches segments (G,F,E,D,C,B,A,dp) les poids forts sont à droite

const byte AFF[4]={11,10,19,18};
  // déclare un tableau de 4 constantes des broches afficheurs - ANODES

  // --- tableau des valeurs numériques en segments ---
const byte CODE[10]={126,48,109,121,51,91,31,112,127,115};
  //                                   0   1    2     3   4   5   6    7     8     9
// les 10 chiffres de (base en décimal) (ex.: 7 == segments "A,B,C" == 01110000 = 64+32+16=112)

La déclaration du tableau "CODE" mérite peut-être quelques éclaircissements.
Si vous maîtrisez le binaire vous avez le droit de passer le chapitre qui suit.

petit rappel sur le binaire

L'idée est d'affecter un bit à chaque segment. Ça tombe bien nous avons 7+1 segments, ce qui nous fait tout juste 1 octet (byte).
nous donnons de manière arbitraire (enfin, pas tout à fait !), un bit pour chaque segment : ["dp"ABCDEFG] avec les poids faibles à droite.
Donc le segment G "pèse" 0 ou 1(10), le segment F "pèse" 0 ou 2(10), le segment E "pèse" 0 ou 4(10), etc...
Si un segment est utilisé, on le met à 1(binaire) sinon à 0(binaire). En fonction de sa place dans l'octet, son poids est ajouté à la somme total.

exemples : le chiffre "7" == segments "A,B,C" == 01110000(2) =       64+32+16(10) = 112(10)
                 le chiffre "4" == segm.     "B,C,F,G" == 01100110(2) =       32+16+2+1 = 51(10)
Vous retrouverez toutes les valeurs dans le tableau "CODE".

Il nous reste à trouver une commande Arduino, capable d'extraire les bits de l'octet de codage, elle existe, c'est :
bitRead( octet , positionDuBit )

Une boucle de 0 à 7 suffira à "lire" l'octet que l'on récupérera dans la table "CODE[chiffre]".
Concernant le "dp", il suffira d'ajouter +128 à notre valeur renvoyée par "CODE[chiffre]".

Le programme est optimisé.

Fin de la digression... Vous pouvez reprendre la lecture à partir de là >

INITIALISATION

void setup() {
      // met les 8 broches des segments en sortie à 1 (éteint)
    for (int i=0; i<8; i++) { // boucle de défilement des 8 broches
      pinMode(SEG[i], OUTPUT); //met la broche en sortie
      digitalWrite(SEG[i],1);
    }
      // met les 4 broches des afficheurs en sortie à 0 (éteint)
    for (int i=0; i<4; i++) { // boucle de défilement des 4 broches
      pinMode(AFF[i], OUTPUT); //met la broche en sortie
      digitalWrite(AFF[i],0);
    }
}

FONCTION D'AFFICHAGE

void affichage(byte mot[4]) {
 
    for (byte af = 0; af <= 3; af++) {                                     // balayage des 4 afficheurs
      digitalWrite(AFF[af],1);                                                // activation des afficheurs à leur tour
      for (byte sg = 0; sg <8; sg++) {  // balayage des 8 segments
        // "mot" contient les 4 caractères à afficher. On récupère dans CODE la séquence des segments à afficher
        // attention les bits sont inversés, c'est un 0 qui allume le segment, d'où le "!"
       digitalWrite(SEG[sg],!bitRead(CODE[mot[af]],sg)); // Voilà, tout le secret est ici !

// EXPLICATION : le chiffre contenu dans "mot[n]", indexe la table "CODE["chiffre"], qui renvoie la séquence des
// bits qui allument ou non, les segments utilisés pour le chiffre concerné. OUF !
      }
      delay(5);                                                                      // 5ms par digit,

// la séquence d'affichage dure 20ms (4x5ms), ça suffit pour tromper notre œil qui croit voir les 4 digits allumés en
// même temps. Merci la persistance rétinienne.
      digitalWrite(AFF[af],0);                                                // l'afficheur en cours est éteint
    }
  }

loop

Enfin dans le programme principal, il suffit d'appeler la fonction :
void loop() {

byte MOT[4]={1,2,3,4}; // c'est un exemple

affichage ( MOT);

}

Vous apprécierez avec moi la concision du programme ;).

Cet afficheur en l'état peut déjà servir bien des projets : compteur, horloge, etc...
On peut jouer avec la table "CODE" pour par exemple, créer des caractères de l'alphabet. Bon c'est vrai avec quelques manquements et un mélange de minuscules et majuscules. Mais notre cerveau s'en accommode et est capable de lire des phrases défilantes (v. programme "alphanumerique.ino" proposé ci-dessous).
Une autre idée de l'utilisation pourrait aussi être un barregraphe stéréo (v. programme "barregraphe.ino"), ou un défilé de barres et de traits dans des séquences esthétiques.

Comme je suis sympa ;)  Je vous donne 4 programmes, l'un utilise l'afficheur en mode barregraphe, un autre propose un chronomètre, le 3ème nous fait un texte défilant et enfin le programme de mon afficheur pour la moto.
Attention l'affectation des segments et anodes ne sont pas identiques, car j'ai utilisé là mon montage optimisé (v. le 2ème schéma) pour les 3 programmes de démonstration et le 1er schéma pour ma moto.

Passons aux capteurs à effet Hall...

PARTIE ÉLECTRONIQUE

J'ai choisi d'utiliser un A3144 (https://www.gotronic.fr/art-capteur-a3144-21003.htm), en gros c'est un transistor dont la base est remplacé par un détecteur de champ magnétique.

Il fonctionne à peu près comme un interrupteur, sans la mécanique, sans les rebonds, sans les problèmes de fiabilité. C'est quasi idéal comme outil.

Le fonctionnement est simple, on balance une tension, comprise entre 4,5v à 24v, on glisse une résistance de 10k entre Vcc et la sortie "data" et on connecte la dernière broche à la masse et le tour est joué.
La présence d'un champ magnétique met la sortie "data" à 0v.

Mon détecteur est fait de 2 capteurs à effet Hall, placés à 3cm d'espacement, 2 résistance de 10k 1/4W sont placés à côté, un connecteur est ajouté et le tout est fixé sur un "board" (v. schéma).
Ce détecteur est placé au niveau du sélecteur de vitesse de la moto. Comme ce n'est pas un endroit idéal pour de la petite électronique, l'ensemble est noyé dans de la colle à chaud pour étanchéifier le détecteur et solidifier le tout.

J'alimente volontairement en 12v pour limiter l'apparition de parasites. Il faudra donc ramener le signal à 5v, avant de l'injecter dans l'Arduino.
Là encore le simple est le mieux, un 2N2222 reçoit le signal 12v, à travers une résistance de 10k sur sa base, le collecteur est directement connecté à l'entrée de l'Arduino, qui est IMPÉRATIVEMENT paramétrée en "INPUT_PULLUP", la résistance interne va mettre le collecteur à 5v, l’émetteur est relié à la masse.

Le signal au repos (12v) sature le 2N2222 et l'entrée de l'Arduino est à 0v.
La détection d'un mouvement va faire passer le signal à 5v, 2N2222 bloqué.

Je récupère le 12v qui apparaît sur le voyant de "point mort", que je réduis à l'aide d'un simple pont diviseur. Une résistance de 680 Ohm, plus une 330 Ohm devront suffire pour amener un 5v sur l'entrée 0 de l'Arduino.

PROGRAMMATION

On peut utiliser les interruptions pour détecter un front montant.
Si on n'utilise pas la détection par interruption, il faudra lire l'état du capteur régulièrement, ce qui pause un problème pour assurer une détection unique. La solution est de positionner un booléen à la 1ère détection et de le remettre à 0 uniquement lorsque le signal retombera.
C'est cette dernière méthode que l'on va utiliser, car elle est plus générale et n'impose pas l'utilisation de certaines broches précises, comme la 0, 1, 2, 3 ou 7.

Le passage des vitesses sur une moto est spécifique. 1ère en bas, puis on monte les vitesses en relevant le sélecteur. Le point mort (PM) ne se trouve qu'à partrir de la seconde ou la 1ère. Les boites ont 4, 5 ou 6 vitesses.

Déclaration

const byte HT=15;    // capteur mouv. vers le haut du sélecteur
bool htState=true;     // maintien de l'état "en cours de lecture"
bool bsState=true;    // idem
const byte BS=14;    // broche sélecteur vers le bas
const byte PM=16;   // broche Point Mort
const byte rapMax=5; // nb max de vitesse de la boîte
const byte rapEng=0; // rapport engagé de boîte

Initialisation

  pinMode(HT, INPUT_PULLUP);  // OBLIGATOIRE de positionner en pull_up pour avoir une ...
  pinMode(BS, INPUT_PULLUP);  // résistance sur le collecteur du 2N2222
  pinMode(PM, INPUT);                // Le pull_up n'est pas utile ici

Fonction rapport()

byte rapport() {
  if (!digitalRead(PM)) {  // le signal PM est à 0 == la boîte est au PM
    rapEng = 0 ;             // Le PM allumé est prioritaire
    }
   else {
    if (!digitalRead(BS))                                          { bsState =true; } // retour du maintien
    if (!digitalRead(HT))                                          { htState =true; } // idem
    if (digitalRead(BS) && rapEng==0)                   { rapEng=1; }       // La descente du sélecteur fait "monter" la 1ère
    if (digitalRead(BS) && rapEng >1 && bsState)  { rapEng--; bsState=false; } // descente des vitesses
    if (digitalRead(HT) && rapEng==0)                   { rapEng=2; htState=false; } // passage direct en 2ème depuis PM
    if (digitalRead(HT) && rapEng <rapMax && htState)       { rapEng++; htState=false;} // montée des vitesses
   }
  return rapEng; // La vitesse sélectionner est renoyée pour affichage
  }

Un peu de technique concernant le One-Wire

Le bus One-Wire ou 1-Wire, est le plus simple d'un point de vue câblage. Il n'utilise qu'une seule broche et les composants peuvent être alimentés par la broche "data". Donc si l'on considère le branchement avec une masse répartie, comme sur une moto par exemple, il est possible de n'utiliser qu'un seul fil de liaison avec le capteur 1-Wire.
De plus, il s'agit vraiment d'un "bus", avec dialogue entre le "maître" (l'Arduino) et le ou les élément(s) (esclave(s)).
Le 1er dessin représent un câblage classique avec alimentation (3v3 ou 5v) et le 2ème un câblage en mode dit "parasite" avec alimentation par la broche "data".
Il faut une résistance de "pull_up" de 4k7 sur la ligne de bus.

L'Arduino dispose d'une bibliothèque 1-Wire, à inclure, qui va nous faciliter l'interrogation de notre capteur.

Le capteur DS18B20

Le DS18B20 (https://www.gotronic.fr/art-ds18b20-14094.htm) est un classique du genre. Celui-ci intègre évidemment un capteur de température, mais aussi un régulateur de tension interne et toute la partie dialogue avec le maître. La précision de la mesure est très au dessus de nos besoin. Le prix est dérisoire.
Que demander de plus ?

Pour la réalisation, j'ai juste fixer le DS18B20 sur un connecteur 3 broches (oui ! j'utilise le mode 3 fils) et je fixe le tout en glissant par dessus une gaine thermo-rétractable. C'est propre et étanche.
On peut aussi noyer le capteur et son connecteur dans de la colle chaude.

La partie programmation

Nous avons besoin de la bibliothèque OneWire.h que l'on   trouvera ici https://github.com/PaulStoffregen/OneWire

// BIBLIOTHÈQUES
#include <OneWire.h>

// DÉCLARATIONS
  // ONE WIRE
const byte OW=12; // cappteur 1-Wire sur la broche 12
const int DS18B20_ID = 0x28;

// FONCTION temperature()
void temperature() {
   byte data[12];
  byte addr[8];
  float temp = 0.0;
  byte TEMP = 0;
    // Déclaration de l'objet ds
  OneWire ds(OW);  // initialisation du capteur
    //Il n'y a qu'un seul capteur, donc on charge l'unique adresse.
  ds.search(addr);
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);   // la 1ère lecture sera erronée car le capteur n'aura pa eu le temps de faire la mesure (850ms)
    // Le MOT reçu du capteur fait 9 octets, on les charge donc un par un dans le tableau data[]
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
    // Puis on converti la température (*0.0625 car la température est stockée sur 12 bits)
  temp = ( (data[1] << 8) + data[0] ) * 0.0625;
  TEMP = int(10*temp); // on exprime en dixième de degré
  MOT[1] = TEMP /100 ;   // récupération des dizaines de degrés
  MOT[2] = TEMP /10 \u0010; // récupération des degrés
  MOT[3] = TEMP \u0010;     // récupération des dixième de degrés

  // préparation pour la prochaine visite dans 10"
    // Demander au capteur de mémoriser la température et lui laisser au moins 850ms pour le faire (voir datasheet)
  ds.reset();
  ds.select(addr);
  ds.write(0x44);
}

Petit commentaire concernant la lecture de température. Le DS18B20 nécessite 85Oms pour établir une lecture fiable.
Si je mets un delay(850) à l'intérieur de la fonction, mon afficheur ne sera pas rafraîchi durant cette période, ce qui occasionnera un "noir" de presque 1", beaucoup trop long.
L'idée est donc de préparer le capteur en fin de fonction, comme nous reviendrons 10" plus tard pour la lecture, le temps sera largement suffisant pour notre thermomètre.
La 1ère lecture est donc fausse, sauf si je mets une 1ère lecture à l'initialisation. J'ai omis cette initialisation, vous avez le droit de la rajouter.

Pour présenter la température, j'exprime la valeur en dixième de degré et j'allume systématiquement le "dp" du 3ème digit.

Côté matériel

Il reste quelques composants à installer.
Je prends une "board" pré percée qui va venir se souder sur les broches d'alimentation de l'Arduino.
Je fixe en 1er un connecteur 2x5 broches, qui me permettra d'établir les liaisons avec les autres éléments.
Je réserve ensuite la place nécessaire pour les connecteurs de l'Arduino.
Et enfin sur la place restante j'installe les 2 transistors et les qq résistances (v. schéma électronique du début de tuto). Le 2 résistances de 10k des capteurs à effet Hall sont intégrées à l'intérieur du capteur lui même.

1er branchement : L'alimentation 12V de la moto est stabilisée par un régulateur (EF03060 - 8€90) en amont, lui-même protégé par un fusible de 5A.
Je ne l'ai pas pris en compte dans le matériel, car il peut servir pour d'autres fonctions et qu'il n'est pas obligatoire. Bien que la tension de la batterie puisse facilement varier de 11V à 13V et des broutilles.
L'Arduino peut accepter jusqu'à 15V.

2eme branchement : Pour les capteurs à effet Hall, j'utilise un câble plat multi-conducteurs (type câble de téléphone de qualité). J'amène toutes les tensions : 12V régulée, masse, 2 sorties "data". Je n'utilise pas de connexion au châssis de la masse qui suppose un grattage de la peinture, un trou pour vissage et des risques de mauvais contact.

3eme branchement : Le même câble multi-conducteurs est utilisé pour les 3 fils du bus 1-Wire. Le capteur est placé quelque part sous la selle, loin des remontée calorifique du V4 de la machine et dans un endroit qui ne reçoit pas de flux d'air important, dû au déplacement.

4eme branchement : Il nous reste à collecter la tension d'allumage du voyant PM. J'utilise pour ça un raccord à sertir qui sera enrobé d'un tissu collant (scotch ! pour ne pas citer de marque) pour l'isoler de l'humidité.

Parlons d'humidité. Tous les connecteurs sont noyés dans de la colle chaude pour créer une gangue étanche et solide. L'inconvénient, c'est que les réparations ne seront pas possibles. Il est impératif de bien tester tous les circuits  avant de se lancer dans un encollage général.

Évidemment, tous ces passages de câbles nécessites le démontage d'une partie de la moto (tableau de bord, carénage dans mon cas, etc...). La fixation du capteur à effet Hall est à adapter à la machine, ce qui n'est pas forcément simple. Il faut donc aussi donner dans la mécanique et de la créativité.

 Côté logiciel 

Nous avons nos 3 fonctions (affichage(), rapport(), temperature()), il nous suffit maintenant de les appeler dans la boucle finale :

void loop() {
  // boucle principale
  // chaque boucle donne le tempo désiré aux appels de fonctions (comme un oignon !)
  for (int i=0; i<50; i++) {          // boucle de 50*10*4*5ms=10" pour lecture de la température
    for (int j=0; j<10; j++) {        // boucle de 10*4*5ms=200ms pour lecture du capteur de vitesse
      affichage(MOT);                 // affichage est relancé ttes les 20ms
    }
    MOT[0]=rapport();                 // lecture du rapport de vitesse engagée ttes les 200ms
  }
  temperature();                      // lecture de la température sur bus 1-WIRE ttes les 10"
} 

Comme vous le constatez, le programme principal est très simple.
L'affichage doit se faire aussi souvent que possible, pratiquement toutes les 20ms, l'appel se fait au cœur des boucles.
Ensuite, je créai des boucles en fonction des délais convenables pour chaque fonction.
  - 200ms pour la lecture des capteurs à effet Hall.
  - 10" pour l'appel de la lecture de la température... C'est suffisant, d'autant plus que la lecture de la température génère une petite interruption visible dans l'affichage.

Je crois que j'ai fait le tour du projet.

Bonne réalisation.