[ Arduino 205] Afficheurs 7 segments

Vous connaissez les afficheurs 7 segments ? Ou alors vous ne savez pas que ça s’appelle comme ça ? Il s’agit des petites lumières qui forment le chiffre 8 et qui sont de couleur rouge ou verte, la plupart du temps, mais peuvent aussi être bleus, blancs, etc. On en trouve beaucoup dans les radio-réveils, car ils servent principalement à afficher l’heure. Autre particularité, non seulement de pouvoir afficher des chiffres (0 à 9), ils peuvent également afficher certaines lettres de l’alphabet.

Matériel

Pour ce chapitre, vous aurez besoin de :

  • Un (et plus) afficheur 7 segments (évidemment)
  • 8 résistances de \(330\Omega\)
  • Un (ou deux) décodeurs BCD 7 segments
  • Une carte Arduino ! Mais dans un premier temps on va d’abord bien saisir le truc avant de faire du code 🙂

Nous allons commencer par une découverte de l’afficheur, comment il fonctionne et comment le branche-t-on. Ensuite nous verrons comment l’utiliser avec la carte Arduino. Enfin, le chapitre suivant amènera un TP résumant les différentes parties vues.

Première approche : côté électronique

Un peu (beaucoup) d’électronique

Comme son nom l’indique, l’afficheur 7 segments possède… 7 segments. Mais un segment c’est quoi au juste ? Et bien c’est une portion de l’afficheur, qui est allumée ou éteinte pour réaliser l’affichage. Cette portion n’est en fait rien d’autre qu’une LED qui au lieu d’être ronde comme d’habitude est plate et encastré dans un boiter. On dénombre donc 8 portions en comptant le point de l’afficheur (mais il ne compte pas en tant que segment à part entière car il n’est pas toujours présent). Regardez à quoi ça ressemble :

Afficheur 7 segments

Des LED, encore des LED

Et des LED, il y en a ! Entre 7 et 8 selon les modèles (c’est ce que je viens d’expliquer), voir beaucoup plus, mais on ne s’y attardera pas dessus. Voici un schéma vous présentant un modèle d’afficheur sans le point (qui au final est juste une LED supplémentaire rappelez-vous) :

Schéma de l'afficheur 7segments Les interrupteurs a,b,c,d,e,f,g représentent les signaux pilotant chaque segments

Comme vous le voyez sur ce schéma, toutes les LED possèdent une broche commune, reliée entre elle. Selon que cette broche est la cathode ou l’anode on parlera d’afficheur à cathode commune ou… anode commune (vous suivez ?). Dans l’absolu, ils fonctionnent de la même façon, seule la manière de les brancher diffère (actif sur état bas ou sur état haut).

Cathode commune ou Anode commune

Dans le cas d’un afficheur à cathode commune, toutes les cathodes sont reliées entre elles en un seul point lui-même connecté à la masse. Ensuite, chaque anode de chaque segment sera reliée à une broche de signal. Pour allumer chaque segment, le signal devra être une tension positive. En effet, si le signal est à 0, il n’y a pas de différence de potentiel entre les deux broches de la LED et donc elle ne s’allumera pas ! Si nous sommes dans le cas d’une anode commune, les anodes de toutes les LED sont reliées entre elles en un seul point qui sera connecté à l’alimentation. Les cathodes elles seront reliées une par une aux broches de signal. En mettant une broche de signal à 0, le courant passera et le segment en question s’allumera. Si la broche de signal est à l’état haut, le potentiel est le même de chaque côté de la LED, donc elle est bloquée et ne s’allume pas ! Que l’afficheur soit à anode ou à cathode commune, on doit toujours prendre en compte qu’il faut ajouter une résistance de limitation de courant entre la broche isolée et la broche de signal. Traditionnellement, on prendra une résistance de 330 ohms pour une tension de +5V, mais cela se calcul (cf. chapitre 1, partie 2). Si vous voulez augmenter la luminosité, il suffit de diminuer cette valeur. Si au contraire vous voulez diminuer la luminosité, augmenter la résistance.

Choix de l’afficheur

Pour la rédaction j’ai fait le choix d’utiliser des afficheurs à anode commune et ce n’est pas anodin. En effet et on l’a vu jusqu’à maintenant, on branche les LED du +5V vers la broche de la carte Arduino. Ainsi, dans le cas d’un afficheur à anode commune, les LED seront branchés d’un côté au +5V, et de l’autre côté aux broches de signaux. Ainsi, pour allumer un segment on mettra la broche de signal à 0 et on l’éteindra en mettant le signal à 1. On a toujours fait comme ça depuis le début, ça ne vous posera donc aucun problème. 😉

Branchement « complet » de l’afficheur

Nous allons maintenant voir comment brancher l’afficheur à anode commune.

Présentation du boîtier

Les afficheurs 7 segments se présentent sur un boîtier de type DIP 10. Le format DIP régie l’espacement entre les différentes broches du circuit intégré ainsi que d’autres contraintes (présence d’échangeur thermique etc…). Le chiffre 10 signifie qu’il possède 10 broches (5 de part et d’autre du boitier). Voici une représentation de ce dernier (à gauche) :

Boitier du 7 segments7 segments

Voici la signification des différentes broches :

  1. LED de la cathode E
  2. LED de la cathode D
  3. Anode commune des LED
  4. LED de la cathode C
  5. (facultatif) le point décimal.
  6. LED de la cathode B
  7. LED de la cathode A
  8. Anode commune des LED
  9. LED de la cathode F
  10. LED de la cathode G

Pour allumer un segment c’est très simple, il suffit de le relier à la masse !

Nous cherchons à allumer les LED de l’afficheur, il est donc impératif de ne pas oubliez les résistances de limitations de courant !

Exemple

Pour commencer, vous allez tout d’abord mettre l’afficheur à cheval sur la plaque d’essai (breadboard). Ensuite, trouvez la broche représentant l’anode commune et reliez la à la future colonne du +5V. Prochaine étape, mettre une résistance de \(330 \Omega\) sur chaque broche de signal. Enfin, reliez quelques une de ces résistances à la masse. Si tous se passe bien, les segments reliés à la masse via leur résistance doivent s’allumer lorsque vous alimentez le circuit. Voici un exemple de branchement :

7 segments schéma 7 segments breadboard

Dans cet exemple de montage, vous verrez que tous les segment de l’afficheur s’allument ! Vous pouvez modifier le montage en déconnectant quelques unes des résistance de la masse et afficher de nombreux caractères.

Pensez à couper l’alimentation lorsque vous changer des fils de place. Les composants n’aiment pas forcément être (dé)branchés lorsqu’ils sont alimentés. Vous pourriez éventuellement leur causer des dommages.

Seulement 7 segments mais plein de caractère(s) !

Vous l’avez peut-être remarqué avec « l’exercice » précédent, un afficheurs 7 segments ne se limite pas à afficher juste des chiffres. Voici un tableau illustrant les caractères possibles et quels segments allumés. Attention, il est possible qu’il manque certains caractères !

Caractère seg. A seg. B seg. C seg. D seg. E seg. F seg. G
0 x x x x x x
1 x x
2 x x x x x
3 x x x x x
4 x x x x
5 x x x x x
6 x x x x x x
7 x x x
8 x x x x x x x
9 x x x x x x
A x x x x x x
b x x x x x
C x x x x
d x x x x x
E x x x x x
F x x x x
H x x x x x
I x x
J x x x x
L x x x
o x x x x
P x x x x x
S x x x x x
t x x x
U x x x x x
y x x x x x
° x x x x

Aidez-vous de ce tableau lorsque vous aurez à coder l’affichage de caractères ! 😉

Afficher son premier chiffre !

Pour commencer, nous allons prendre en main un afficheur et lui faire s’afficher notre premier chiffre ! C’est assez simple et ne requiert qu’un programme très simple, mais un peu rébarbatif.

Schéma de connexion

Je vais reprendre le schéma précédent, mais je vais connecter chaque broche de l’afficheur à une sortie de la carte Arduino. Comme ceci :

Afficheur 7 segments schema Afficheur 7 segments montage

Vous voyez donc que chaque LED de l’afficheur va être commandée séparément les unes des autres. Il n’y a rien de plus à faire, si ce n’est qu’à programmer…

Le programme

L’objectif du programme va être d’afficher un chiffre. Eh bien… c’est partit ! Quoi ?! Vous voulez de l’aide ? o_O Ben je vous ai déjà tout dit y’a plus qu’à faire. En plus vous avez un tableau avec lequel vous pouvez vous aider pour afficher votre chiffre. Cherchez, je vous donnerais la solution ensuite.

Secret: Réponse SelectionnerAfficher

Techniques d’affichage

Vous vous en doutez peut-être, lorsque l’on veut utiliser plusieurs afficheur il va nous falloir beaucoup de broches. Imaginons, nous voulons afficher un nombre entre 0 et 99, il nous faudra utiliser deux afficheurs avec \(2*7 = 14\) broches connectées sur la carte Arduino. Rappel : une carte Arduino UNO possède… 14 broches entrées/sorties classiques. Si on ne fais rien d’autre que d’utiliser les afficheurs, cela ne nous gène pas, cependant, il est fort probable que vous serez amener à utiliser d’autres entrées avec votre carte Arduino. Mais si on ne libère pas de place vous serez embêté. Nous allons donc voir deux techniques qui, une fois cumulées, vont nous permettre d’utiliser seulement 4 broches pour obtenir le même résultat qu’avec 14 broches !

Les décodeurs « 4 bits -> 7 segments »

La première technique que nous allons utiliser met en œuvre un circuit intégré. Vous vous souvenez quand je vous ai parlé de ces bêtes là ? Oui, c’est le même type que le microcontrôleur de la carte Arduino. Cependant, le circuit que nous allons utiliser ne fait pas autant de choses que celui sur votre carte Arduino.

Décodeur BCD -> 7 segments

C’est le nom du circuit que nous allons utiliser. Son rôle est simple. Vous vous souvenez des conversions ? Pour passer du binaire au décimal ? Et bien c’est le moment de vous en servir, donc si vous ne vous rappelez plus de ça, allez revoir un peu le cours. Je disais donc que son rôle est simple. Et vous le constaterez par vous même, il va s’agir de convertir du binaire codé sur 4 bits vers un « code » utilisé pour afficher les chiffres. Ce code correspond en quelque sorte au tableau précédemment évoqué.

Principe du décodeur

Sur un afficheur 7 segments, on peut représenter aisément les chiffres de 0 à 9. En informatique, pour représenter ces chiffres, il nous faut au maximum 4 bits. Comme vous êtes des experts et que vous avez bien lu la partie sur le binaire, vous n’avez pas de mal à le comprendre. (0000)2 fera (0)10 et (1111)2 fera (15)10 ou (F)16. Pour faire 9 par exemple on utilisera les bits 1001. En partant de se constat, des ingénieurs ont inventé un composant au doux nom de « décodeur » ou « driver » 7 segments. Il reçoit sur 4 broches les 4 bits de la valeur à afficher, et sur 7 autres broches ils pilotent les segments pour afficher ladite valeur. Ajouter à cela une broche d’alimentation et une broche de masse on obtient 13 broches ! Et ce n’est pas fini. La plupart des circuits intégrés de type décodeur possède aussi une broche d’activation et une broche pour tester si tous les segments fonctionnent.

Choix du décodeur

Nous allons utiliser le composant nommé MC14543B comme exemple (un equivalent utilisable et trouvable facilement est le CD4543BE). Tout d’abord, ouvrez ce lien dans un nouvel onglet, il vous menera directement vers le pdf du décodeur :

Les datasheets se composent souvent de la même manière. On trouve tout d’abord un résumé des fonctions du produit puis un schéma de son boîtier. Dans notre cas, on voit qu’il est monté sur un DIP 16 (DIP : Dual Inline Package, en gros « boîtier avec deux lignes de broches »). Si l’on continue, on voit la table de vérité faisant le lien entre les signaux d’entrées (INPUT) et les sorties (OUTPUT). On voit ainsi plusieurs choses :

  • Si l’on met la broche Bl (Blank, n°7) à un, toutes les sorties passent à zéro. En effet, comme son nom l’indique cette broche sert à effacer l’afficheur. Si vous ne voulez pas l’utiliser il faut donc la connecter à la masse pour la désactiver.
  • Les entrées A, B, C et D (broches 5,3,2 et 4 respectivement) sont actives à l’état HAUT. Les sorties elles sont actives à l’état BAS (pour piloter un afficheur à anode commune) OU HAUT selon l’état de la broche PH (6). C’est là un gros avantage de ce composant, il peut inverser la logique de la sortie, le rendant alors compatible avec des afficheurs à anode commune (broche PH à l’état 1) ou cathode commune (Ph = 0)
  • LD (n°1) sert à faire une mémoire de l’état des sorties, on ne s’en servira pas ici. Elle signifie « Latch Disable ». En la mettant à 1 on désactive donc le « latch » (verrou) et nos entrées sont alors bien prises en considération.
  • Enfin, les deux broches d’alimentation sont la 8 (GND/VSS, masse) et la 16 (VCC, +5V)

N’oubliez pas de mettre des résistances de limitations de courant entre chaque segment et la broche de signal du circuit!

Fonctionnement

C’est bien beau tout ça mais comment je lui dis au décodeur d’afficher le chiffre 5 par exemple ?

Il suffit de regarder le datasheet et sa table de vérité (c’est le tableau avec les entrées et les sorties). Ce que reçoit le décodeur sur ses entrées (A, B, C et D) défini les états de ses broches de sortie (a,b,c,d,e,f et g). C’est tout ! Donc, on va donner un code binaire sur 4 bits à notre décodeur et en fonction de ce code, le décodeur affichera le caractère voulu. En plus le fabricant est sympa, il met à disposition des notes d’applications à la page 6 pour bien brancher le composant :

Branchement du MC14543B

On voit alors qu’il suffit simplement de brancher la résistance entre le CI et les segments et s’assurer que PH à la bonne valeur et c’est tout ! En titre d’exercice afin de vous permettre de mieux comprendre, je vous propose de changer les états des entrées A, B, C et D du décodeur pour observer ce qu’il affiche. Après avoir réaliser votre schéma, regarder s’il correspond avec celui présent dans cette balise secrète. Cela vous évitera peut-être un mauvais branchement, qui sait ?

Secret: Réponse SelectionnerAfficher

L’affichage par alternance

La seconde technique est utilisée dans le cas où l’on veut faire un affichage avec plusieurs afficheurs. Elle utilise le phénomène de persistance rétinienne. Pour faire simple, c’est grâce à cela que le cinéma vous parait fluide. On change une image toutes les 40 ms et votre œil n’a pas le temps de le voir, donc les images semble s’enchainer sans transition. Bref… Ici, la même stratégie sera utilisée. On va allumer un afficheur un certain temps, puis nous allumerons l’autre en éteignant le premier. Cette action est assez simple à réaliser, mais nécessite l’emploi de deux broche supplémentaires, de quatre autres composants et d’un peu de code. Nous l’étudierons un petit peu plus tard, lorsque nous saurons géré un afficheur seul.

Utilisation du décodeur BCD

Nous y sommes, nous allons (enfin) utiliser la carte Arduino pour faire un affichage plus poussé qu’un unique afficheur. Pour cela, nous allons très simplement utiliser le montage précédent composé du décodeur BCD, de l’afficheur 7 segments et bien entendu des résistances de limitations de courant pour les LED de l’afficheur. Je vais vous montrer deux techniques qui peuvent être employées pour faire le programme.

Initialisation

Vous avez l’habitude maintenant, nous allons commencer par définir les différentes broches d’entrées/sorties. Pour débuter (et conformément au schéma), nous utiliserons seulement 4 broches, en sorties, correspondantes aux entrées du décodeur 7 segments. Voici le code pouvant traduire cette explication :

Ce code permet juste de déclarer les quatre broches à utiliser, puis les affectes en sorties. On les met ensuite toutes les quatre à zéro. Maintenant que l’afficheur est prêt, nous allons pouvoir commencer à afficher un chiffre !

Programme principal

Si tout se passe bien, en ayant la boucle vide pour l’instant vous devriez voir un superbe 0 sur votre afficheur. Nous allons maintenant mettre en place un petit programme pour afficher les nombres de 0 à 9 en les incrémentant (à partir de 0) toutes les secondes. C’est donc un compteur. Pour cela, on va utiliser une boucle, qui comptera de 0 à 9. Dans cette boucle, on exécutera appellera la fonction afficher() qui s’occupera donc de l’affichage (belle démonstration de ce qui est une évidence 😛 :mrgreen: ).

Fonction d’affichage

Nous touchons maintenant au but ! Il ne nous reste plus qu’à réaliser la fonction d’affichage pour pouvoir convertir notre variable en chiffre sur l’afficheur. Pour cela, il existe différentes solutions. Nous allons en voir ici une qui est assez simple à mettre en œuvre mais qui nécessite de bien être comprise. Dans cette méthode, on va faire des opérations mathématiques (tout de suite c’est moins drôle 😆 ) successives pour déterminer quels bits mettre à l’état haut. Rappelez-vous, nous avons quatre broches à notre disposition, avec chacune un poids différent (8, 4, 2 et 1). En combinant ces différentes broches ont peu obtenir n’importe quel nombre de 0 à 15. Voici une démarche mathématique envisageable :

Organigramme décodeur 7 segments

On peut coder cette méthode de manière assez simple et direct, en suivant cet organigramme :

Quelques explications s’imposent… Le code gérant l’affichage réside sur les valeurs binaires des chiffres. Rappelons les valeurs binaires des chiffres :

Chiffre DCBA
0 (0000)2
1 (0001)2
2 (0010)2
3 (0011)2
4 (0100)2
5 (0101)2
6 (0110)2
7 (0111)2
8 (1000)2
9 (1001)2

D’après ce tableau, si on veut le chiffre 8, on doit allumer le segment D, car 8 s’écrit (1000)2 ayant pour segment respectif DCBA. Soit D=1, C=0, B=0 et A=0. En suivant cette logique, on arrive à déterminer les entrées du décodeur qui sont à mettre à l’état HAUT ou BAS. D’une manière plus lourde, on aurait pu écrire un code ressemblant à ça :

Mais, c’est bien trop lourd à écrire. Enfin c’est vous qui voyez. 😉

Utiliser plusieurs afficheurs

Maintenant que nous avons affiché un chiffre sur un seul afficheur, nous allons pouvoir apprendre à en utiliser plusieurs (avec un minimum de composants en plus !). Comme expliqué précédemment, la méthode employée ici va reposer sur le principe de la persistance rétinienne, qui donnera l’impression que les deux afficheurs fonctionnent en même temps.

Problématique

Nous souhaiterions utiliser deux afficheurs, mais nous ne disposons que de seulement 6 broches sur notre Arduino, le reste des broches étant utilisé pour une autre application. Pour réduire le nombre de broches, on peut d’ores et déjà utilisé un décodeur BCD, ce qui nous ferait 4 broches par afficheurs, soit 8 broches au total. Bon, ce n’est toujours pas ce que l’on veut. Et si on connectait les deux afficheurs ensemble, en parallèle, sur les sorties du décodeur ? Oui mais dans ce cas, on ne pourrait pas afficher des chiffres différents sur chaque afficheur. Tout à l’heure, je vous ai parlé de commutation. Oui, la seule solution qui soit envisageable est d’allumer un afficheur et d’éteindre l’autre tout en les connectant ensemble sur le même décodeur. Ainsi un afficheur s’allume, il affiche le chiffre voulu, puis il s’éteint pour que l’autre puisse s’allumer à son tour. Cette opération est en fait un clignotement de chaque afficheur par alternance.

Un peu d’électronique…

Pour faire commuter nos deux afficheurs, vous allez avoir besoin d’un nouveau composant, j’ai nommé : le transistor !

Transistor ? J’ai entendu dire qu’il y en avait plusieurs milliards dans nos ordinateurs ?

Et c’est tout à fait vrai. Des transistors, il en existe de différents types et pour différentes applications : amplification de courant/tension, commutation, etc. répartis dans plusieurs familles. Bon je ne vais pas faire trop de détails, si vous voulez en savoir plus, allez lire la première partie de ce chapitre (lien à rajouter, en attente de la validation du chapitre en question).

Le transistor bipolaire : présentation

Je le disais, je ne vais pas faire de détails. On va voir comment fonctionne un transistor bipolaire selon les besoins de notre application, à savoir, faire commuter les afficheurs. Un transistor, cela ressemble à ça :

Photo d’un transistor

Pour notre application, nous allons utiliser des transistors bipolaires. Je vais vous expliquer comment cela fonctionne. Déjà, vous pouvez observer qu’un transistor possède trois pattes. Cela n’est pas de la moindre importance, au contraire il s’agit là d’une chose essentielle ! En fait, le transistor bipolaire à une broche d’entrée (collecteur), une broche de sortie (émetteur) et une broche de commande (base). Son symbole est le suivant :

Ce symbole est celui d’un transistor bipolaire de type NPN. Il en existe qui sont de type PNP, mais ils sont beaucoup moins utilisés que les NPN. Quoi qu’il en soit, nous n’utiliserons que des transistors NPN dans ce chapitre.

Fonctionnement en commutation du transistor bipolaire

Pour faire simple, le transistor bipolaire NPN (c’est la dernière fois que je précise ce point) est un interrupteur commandé en courant.

Ceci est une présentation très vulgarisée et simplifiée sur le transistor pour l’utilisation que nous en ferons ici. Les usages et possibilités des transistors sont très nombreux et ils mériteraient un big-tuto à eux seuls ! Si vous voulez plus d’informations, rendez-vous sur le cours sur l’électronique ou approfondissez en cherchant des tutoriels sur le web. 😉

C’est tout ce qu’il faut savoir, pour ce qui est du fonctionnement. Après, on va voir ensemble comment l’utiliser et sans le faire griller ! :mrgreen:

Utilisation générale

On peut utiliser notre transistor de deux manières différentes (pour notre application toujours, mais on peut bien évidemment utiliser le transistor avec beaucoup plus de flexibilités). A commencer par le câblage :

Câblage du transistor en commutation

Dans le cas présent, le collecteur (qui est l’entrée du transistor) se trouve être après l’ampoule, elle-même connectée à l’alimentation. L’émetteur (broche où il y a la flèche) est relié à la masse du montage. Cette disposition est « universelle », on ne peut pas inverser le sens de ces broches et mettre le collecteur à la place de l’émetteur et vice versa. Sans quoi, le montage ne fonctionnerait pas. Pour le moment, l’ampoule est éteinte car le transistor ne conduit pas. On dit qu’il est bloqué et empêche donc le courant \(I_C\) de circuler à travers l’ampoule. Soit \(I_C = 0\) car \(I_B = 0\). A présent, appuyons sur l’interrupteur :

L’ampoule est allumée

Que se passe-t-il ? Eh bien la base du transistor, qui était jusqu’à présent « en l’air », est parcourue par un courant électrique. Cette cause à pour conséquence de rendre le transistor passant ou saturé et permet au courant de s’établir à travers l’ampoule. Soit \(I_C \ne 0\) car \(I_B \ne 0\).

La résistance sur la base du transistor permet de le protéger des courants trop forts. Plus la résistance est de faible valeur, plus l’ampoule sera lumineuse. A l’inverse, une résistance trop forte sur la base du transistor pourra l’empêcher de conduire et de faire s’allumer l’ampoule. Rassurez_vous, je vous donnerais les valeurs de résistances à utiliser. 😉

Utilisation avec nos afficheurs

Voyons un peu comment on va pouvoir utiliser ce transistor avec notre Arduino. La carte Arduino est en fait le générateur de tension (schéma précédent) du montage. Elle va définir si sa sortie est de 0V (transistor bloqué) ou de 5V (transistor saturé). Ainsi, on va pouvoir allumer ou éteindre les afficheurs. Voilà le modèle équivalent de la carte Arduino et de la commande de l’afficheur :

LA carte Arduino va soit mettre à la masse la base du transistor, soit la mettre à +5V. Dans le premier cas, il sera bloqué et l’afficheur sera éteint, dans le second il sera saturé et l’afficheur allumé. Il en est de même pour chaque broche de l’afficheur. Elles seront au +5V ou à la masse selon la configuration que l’on aura définie dans le programme.

Schéma final

Et comme vous l’attendez surement depuis tout à l’heure, voici le schéma tant attendu (nous verrons juste après comment programmer ce nouveau montage) !

2*7 segments schéma 2*7 segments breadboard

Quelques détails techniques

  • Dans notre cas (et je vous passe les détails vraiment techniques et calculatoires), la résistance sur la base du transistor sera de \(2.2k\Omega\) (si vous n’avez pas cette valeur, elle pourra être de \(3.3k\Omega\), ou encore de \(3.9k\Omega\), voir même de \(4.7k\Omega\)).
  • Les transistors seront des transistors bipolaires NPN de référence 2N2222, ou bien un équivalent qui est le BC547. Il en faudra deux donc.
  • Le décodeur BCD est le même que précédemment (ou équivalent).

Et avec tout ça, on est prêt pour programmer ! 🙂

…et de programmation

Nous utilisons deux nouvelles broches servant à piloter chacun des interrupteurs (transistors). Chacune de ces broches doivent donc être déclarées en global (pour son numéro) puis régler comme sortie. Ensuite, il ne vous restera plus qu’à alimenter chacun des transistors au bon moment pour allumer l’afficheur souhaité. En synchronisant l’allumage avec la valeur envoyé au décodeur, vous afficherez les nombres souhaités comme bon vous semble. Voici un exemple de code complet, de la fonction setup() jusqu’à la fonction d’affichage. Ce code est commenté et vous ne devriez donc avoir aucun mal à le comprendre ! Ce programme est un compteur sur 2 segments, il compte donc de 0 à 99 et recommence au début dès qu’il a atteint 99. La vidéo se trouve juste après ce code.

Voilà donc la vidéo présentant le résultat final :

Contraintes des évènements

Comme vous l’avez vu juste avant, afficher de manière alternative n’est pas trop difficile. Cependant, vous avez surement remarqué, nous avons utilisé des fonctions bloquantes (delay). Si jamais un évènement devait arriver pendant ce temps, nous aurions beaucoup de chance de le rater car il pourrait arriver « pendant » un délai d’attente pour l’affichage. Pour parer à cela, je vais maintenant vous expliquer une autre méthode, préférable, pour faire de l’affichage. Elle s’appuiera sur l’utilisation de la fonction millis(), qui nous permettra de générer une boucle de rafraîchissement de l’affichage. Voici un organigramme qui explique le principe :

Comme vous pouvez le voir, il n’y a plus de fonction qui « attend ». Tout se passe de manière continue, sans qu’il n’y ai jamais de pause. Ainsi, aucun évènement ne sera raté (en théorie, un évènement trèèèèèès rapide pourra toujours passer inaperçu). Voici un exemple de programmation de la boucle principal (suivi de ses fonctions annexes) :

Si vous voulez tester le phénomène de persistance rétinienne, vous pouvez changer le temps de la boucle de rafraichissement (ligne 9). Si vous l’augmenter, vous commencerez à vois les afficheurs clignoter. En mettant une valeur d’un peu moins de une seconde vous verrez les afficheurs s’illuminer l’un après l’autre.

Ce chapitre vous a appris à utiliser un nouveau moyen pour afficher des informations avec votre carte Arduino. L’afficheur peut sembler peu utilisé mais en fait de nombreuses applications existe ! (chronomètre, réveil, horloge, compteur de passage, afficheur de score, etc.). Par exemple, il pourra vous servir pour déboguer votre code et afficher la valeur des variables souhaitées…

109 commentaires

  1. Autre approche du programme, j’aimerais savoir vos avis, critiques,… Merci

    • C’est une solution tout a fait élégante, l’utilisation du & logique est très pertinente et bien employée !

      (je me suis permis une petite modification de ton commentaire pour mettre en forme le code via la balise < pre >

  2. Le code du 10/02/2014 n’est pas complet !!!
    Voilà le code complet :

  3. Attends je test (et ferais le menage dans les commentaires tant pis) :

    chez moi ca a l’air de marcher…

  4. Bonsoir,
    J’en viens sur mes petits soucis du paragraphe « décodeur BCD » avec la focntion « delay ». Sur cette partie, les connections ont l’air bonnes et lors de l’envoi du programme il y a le comptage jusqu’à 99 qui se déroule normalement; Là où ca se complique c’est sur l’affichage. Je n’obtiens pas du tout des chiffres « visuellement stables » (ca clignote plein pot) à moins de passer à des vitesses de défilement qui font que je ne vois quasiment plus le comptage (comptage jusqu’à 99 en moins de 30s)… Bref problème sur la gestion de l’affichage pour que avec les données de 500ms et des delay de 10ms ce soit lisible et stable ?

    Sur la partie avec le « millis », l’affichage est nickel (avec le même montage) et les afficheurs se succèdent bien et avec un visuel stable… mais là c’est le comptage qui ne se fait pas ??? Tout reste à 0…

    Voilà, j’ai tenté pein de changements mais là je suis à cours d’idées … 😮
    Un peu d’aide serait la bienvenue.

    Je reste motivé et je m’attaque quand même au TP (sans avoir regardé la réponse… je joue le jeu. Mais j’aimerais bien finir les parties d’avant pour comprendre.

    A bientôt.

    Duplau

    • Tu as essayé en réduisant le delay(10) à delay(5) par exemple ?
      J’avoue ne pas trop voir pourquoi ca ne marche pas… Si tu peux faire une petite vidéo se sera bienvenue 😉 car comme tu vois sur celle que je propose ca fonctionne pas mal (même si je passe pas vraiment par un décodeur, j’ai des afficheurs un peu spéciaux…)
      Pour le deuxième (avec les millis) c’est le comportement normal, regarde bien la valeur envoyée (variable « valeur ») ne change jamais donc le nombre à afficher ne change pas non plus 😉
      Bon courage pour le TP !

      N.B.: La partie sur les afficheurs 7 segments n’est pas la plus fondamentale… Si des zones d’ombres reste ce n’est pas dramatique !

  5. Bonsoir Eskimon,
    Je reprends… Oui j’ai modifié les « delay »… dans tous les sens…En fait, encore plus étrange. Les « unités » déclarées sur la broche 6 dans le code sont en fait affichées à partir de la broche 7 et pareil pour l’autre broche. Là j’ai fait des mofifications de cablage du coup j’ai récupré ma broche et le comptage de la broche 6 pour les unités mais plus moyen… les dizaines ne s’affichent plus ??? Bref je ne comprends rien…

    Pour « millis »; merci, je ne suis donc pas si stupide…c’est bien ce que je pensais que sans fonction de comptage ça ne pouvez pas compter…. LOL Mais j’ai assayé d’en ajouter une mais pour l’instant sans succès…

    Duplau

  6. Je crois que j’ai grillé mon BCD, je peux quand même suivre le cours et revenir au décodeur plus tard quand ma commande sera arrivée ou je ne saurai pas suivre le reste du cours sans ce composant là?

  7. Bonjour,

    J’essaie de suivre le tuto sur les afficheurs. Aucun problème sans le décodeur BCD, mais je n’ai jamais obtenu un chiffre correct avec. Idem avec les transistors. Les segments défilent mais sans former un vrai chiffre. Le fait d’utiliser un décodeur Motorola MC14543B explique-t-il ça? J’ai le même résultat avec un BCD Texas Instrument CD4543BE.

    Pour le reste merci pour cette superbe initiation à arduino

    • Salut !

      Apparemment le décodeur est tout bon, j’ai regarde rapidement la doc. technique et les broches sont les mêmes (mêmes endroits etc…). Du coup je n’ai pas vraiment de réponse a part : vérifier les branchements.
      Si vraiment rien n’y fait, c’est dommage mais pas dramatique. Cette parti n’est pas la plus importante (hors des notions d’alternance et de persistance rétinienne). Si la théorie est OK mais que l’application technique ne veut pas passer, alors ne te tracasse pas plus et passe au chapitre suivant, a partir de la partie 3 les 7 segments seront assez peu utilisé.

  8. Bonjour, je me demande si, sur le schéma de l’affichage comportant deux 7 segments, le câblage des transistors n’est pas inversé. Les émetteurs sont reliés au 5 V et ce sont les collecteurs qui sont reliés à l’anode des afficheurs. Dans la présentation des transistors vous disiez pourtant que l’on ne pouvait inverser le collecteur et l’émetteur (en commutation) et que l’émetteur devait être relié à la masse.
    Sinon votre cours est un monument de pédagogie. Bravo…et merci.

  9. Salut Eskimon et merci beaucoup pour ton temps, ton tuto est vraiment super

    Avec le BCD, tout en HIGH, à la place du zéro, j’obtiens un 6 inversé!
    Les branchements sont identiques aux tiens. Et aussi copy/paste de ton code pour être sur, mais rien. Il n’y a que le 8 (1000) qui fonctionne!

    Je n’arrive pas à voir quel est le modèle de BCD que j’ai, mais c’est un 4543:

    http://www.abra-electronics.com/products/4543-IC-CMOS-BCD%252dto%252d7%252dSegment–Latch%7B47%7DDecoder%7B47%7DDriver-for-Liquid-Crystal-Displays.html

    Y a-t-il vraiment des différence entre les modèle 4543 si ils ont le même nombres de pin?

    Alex

    • Y a-t-il vraiment des différence entre les modèle 4543 si ils ont le même nombres de pin?

      Normalement non.

      Es tu sur de bien avoir branche les différentes sorties vers les bons segments et que la broche ph (6) est bien au 5V si tu utilises un afficheur a cathode commune (ou a la masse dans le cas d’un afficheur a anode commune) ?

  10. Bonjour,
    C’est mon premier commentaire, mais ça fait un bout de temps que je suis ce cours. D’abord sur openclass et maintenant ici. je suis mécanicien et je débute dans la programmation.
    J’aimerai faire un compteur pouvant aller jusqu’à 9999 en additionnant un nombre avec une virgule.
    le problème est que je n’arrive pas à récupérer les dizaines quand je passe la centaine ni les centaine quand je passe le millier. Les chiffres (dix et cent ) s’éteigne tout simplement, mais le calcul se poursuit. Pouvez-vous me donner un tuyau.
    En tout cas un grand BRAVO pour ce cours passionnant.
    Bonne soirée
    Eric

    • Hum… Peut-être un souci matériel (câblage ?) ou de code (par exemple modulo ne marche pas sur les flottants). Pourrais tu fournir un peu plus de détails pour t’aider a corriger ça ? Pour continuer a « debugguer » ton problème, je te propose que l’on se retrouve sur un forum plutôt que dans la zone de commentaire du tutoriel. Je suis souvent (avec plein d’autres gens plus compétents !) dans la rubrique « Système et Matériels » de Zeste de Savoir, les outils de redactions y sont meilleur que sur le blog et le format est plus adapte a l’échange 🙂 .

  11. Bonjour,
    Un grand merci pour toutes ces informations qui sont d’une grande richesse.
    Je commence à pendre en main les afficheurs, mais je me pose une question.
    Vous dites un peu plus haut dans la présentation du décodeur BCD qu’il est possible « en insistant un peu » d’afficher les lettres de A à F.
    Pourriez vous me donner un début de piste pour y arriver ?

    encore merci pour ce cours.
    Bruno.

  12. Excellent tuto. Débutant dans Aduino avec des petites bases en logique et en C, je me suis régalé à le réalisé et surtout à comprendre grâce aux explications. Un grand merci. J’ai utilisé des afficheurs TIL311 (comme dans la vidéo d’ailleurs), il n’y a plus que les bits ABCD à câbler. Par contre dans la vidéo tu n’as pas mis de transistors, tu alimentes les afficheurs directement par les sorties de Arduino (pattes 1 et 14 du TIL311) ou seulement la logic (14 du TIL) et le +5 sur la patte 1 ?

    • En fait les TIL se débrouillent tout seul pour l’alimentation des segments, ce n’est pas vraiment moi qui les gères. Il « suffit » d’une alimentation 5V, des signaux A B C D et ensuite il fait le décodage+affichage tout seul, donc pas besoin de transistor. On peut utiliser la broche 5 pour verrouiller ou non le décodeur, comme ca on peut jongler entre les deux. En activant ce verrou, l’afficheur utilisera les entrées ABCD sinon il les ignore et se contente de ce qu’il avait précédemment en mémoire.
      Ce sont vraiment des petits afficheurs bien pratiques 😀

    • Yep ca marchera, les leds éclaireront juste un peu plus fort. Attention a ne pas descendre trop bas cependant, sinon on finit par dépasser les limites de fonctionnement de la led (mais c’est costaud c’est pti machin la !). De la même façon, en augmentant les résistances on diminuera simplement l’intensité de l’affichage. Les segments se comportent exactement comme des leds (car ce sont des leds !)

  13. Salut, merci beaucoup pour ce tuto, je suis totalement débutant dans le domaine.

    Cependant j’ai une question : Peut t’on utiliser un  » shift register 8 bits  » le 74HC595 (celui que j’ai eu avec un kit) à la place d’un décodeur.

    Je ne vois pas la différence entre decodeur et shift register ;(

    Merci.

    • Le décodeur convertir 4 entrées parallèles (A, B, C, D) en 7 sorties (pour chacun des segments).
      Le registre a décalage convertit une entrée (8 bits en série) sur 8 sorties (« convertisseur série->parallèle)

      Cependant, avec un peu de ruse on peut très bien utiliser un registre a décalage pour faire un décodeur (on envoie 8 bits représentant l’état de chacun des segments). C’est un très bon exercice (et une bonne idée de tuto d’illustration 😀 )

  14. Salut Eskimon, merci énormément pour ce tuto très à la auteur
    J’ai un petit souci avec le schéma des 2 afficheurs 7 segments je crois que les émetteurs des 2 transistors ne devraient pas être reliés au 5v mais bien à la masse. j’ai lu les commentaires aux dessus et maquestion est la même que Pascal

  15. Bonjour,

    Nouveau et débutant.
    Félicitation pour « le bouquin » ….c’est un peu ma « bible »(attention!)
    Néanmoins page 6 ligne 15 on écrit:
    afficher_nombre(valeur, afficheur);
    je reçois:
    Code.ino:49: error: ‘valeur’ was not declared in this scope
    que faut-il déclarer ?
    Merci !
    Cdt

    • C’est vrai que ce n’est pas précisé, mais ce ne devrait pas être trop dur a deviner 😉 . valeur ici fait office de placeholder, cela peut-etre un nombre statique ou n’importe que nombre entre 0 et 99 (car on affiche pas au delà).

  16. Je ne comprends pas à quoi servent les transistors. J’ai simplement relié les cathodes communes (j’ai des afficheurs à cathodes communes) à des broches que j’ai successivement mises aux états logiques HAUT et BAS. Et comme je m’y attendais, ça marche. Alors pourquoi utiliser des transistors?

    • En theorie, une broche Arduino n’est pas censée jouer avec plus de 40mA. Si l’on a 7 segments d’allumé, alors on a entre 70 et 150 mA (7*10 a 7*50) qui passe dans la broche, ce qui n’est pas franchement conseillé. C’est pourquoi il est recommande de mettre un transistor pour faire passer cette « puissance ».

      • Merci pour cette réponse. J’ai également une autre question (désolé pour le dérangement). J’ai fait un petit programme où l’on incrémente ou décrémente la valeur affichée par les afficheurs de 1 en 1 avec des boutons poussoirs. Cependant le programme se reset spontanément (à des intervalles de temps irréguliers il me semble), et la valeur affichée revient alors à 0. Sais-tu d’où cela peut-il venir?

        • Désolé pour le repost, mais j’obtiens ça à la fin de l’upload du programme: Taille binaire du croquis : 1 694 octets (d’un max de 32 256 octets)
          avrdude: stk500_getsync(): not in sync: resp=0x00

          • Ca c’est pas cool, ca signifie que la communication avec l’Arduino c’est mal effectue. Ca peut venir de plusieurs choses : Câble USB qui déconne (trop long, défectueux…), carte dans un état étrange (essaie d’appuyer sur le bouton reset avant d’envoyer le programme), mauvais port série de sélectionné…

      • Pourtant j’ai fais le même montage que Hugo (sans transistor) en allumant les 8 led de l’afficher (7 segm. + 1 point) et j’ai mesurer avec un multimètre l’intensité du courant traversant le pin et il était pas plus élevé que 40mA alors que mathématiquement « U=R*I » il devrait avoir une intensité de 100mA avec des résistance de 330 ohm..

  17. Salut Eskimon, je suis actuellement en Terminale S option SI et nous devons faire un projet pour le moi de mai. Celui-ci aura pour but de modifier un compteur d’eau et d’y inclure des technologies de types Arduino dont module XBEE pour le rendre « connecté ». Je ne t’en dis pas plus ici mais je voulais te demander si tu serais intéressé de m’aider pour la partie programmation du projet car je ne pense y arriver pas seul. Peux-tu me contacter par e-mail pour me donner ta réponse. Merci

  18. Bonjour,

    Lors de la première activité avec le décodeur, il y a quelque chose que je comprends mal concernant le branchement du décodeur BCD entre ce qui est expliqué et le schéma :

    Tu y dis que « si l’on met la broche Bl (Blank, n°7) à 1 (donc en HIGH/ +5V, si je comprends bien), toutes les sorties passent à zéro. Si vous ne voulez pas l’utiliser il faut donc la connecter à la masse pour la désactiver ». C’est ce que l’on peut constater dans ton schéma où la broche BI est effectivement connectée à la broche GND de l’Arduino.

    Cependant un peu plus bas, tu dis que « La broche BI (Blank Input, n°7) sers à inhiber les entrées. On ne s’en servira pas et donc on la mettra à l’état HAUT (+5V) ». C’est là que je ne comprends plus le lien entre ce que tu décris et le schéma.

    J’ai un peu le même problème avec la broche LD (n°1) : tu dis qu’elle sert à faire une mémoire de l’état des sorties et donc que l’on ne s’en servira pas ici, mais elle est connectée au 5V – donc est-ce qu’elle est mise à 1 (HIGH) et par conséquent est-elle active ? Je suis un peu perdu…

  19. Bonjour bonjour, J’ai fais moi même un 7 segments ( led soudées une à unes), tous les + en commun et j’ai 7 fils (négative) pour mes sorties de chaque segement! j’utilise une décodeur CD4543BE et des transistor PN2N2222 afin d’alimenter mes led en 12V! j’ai brancher le décodeur de cette façon Bornes 16 et 6 +5V bornes 7 et 8 0V, a la base de mes transistor j’ai une résistance 1K! tout mes EMITTER son relié ensemble 0V! et collecteur a chacune de mes sorties, quand je test mon décodeur BCB, il envoi bien l’info à la bas du transistor mais celui ci ce fonctionne pas que ce sois en HIGH ou LOW (carte arduino uno) … pourquoi ? j’ai tester mes segement a par en direct il fonctionne trés bien ( fils entre EMITTER et collecteur)

    Merciiiii 🙂

    • Hello Gui,

      Ayant été en congé la semaine dernière, je n’ai pas vraiment pu m’occuper des commentaires du blog pendant ce moment… De plus, ton commentaire n’est pas vraiment spécifique au tutoriel mais plutôt à un montage de transistor qui semble mal polarisé vu leur comportement.
      Afin de bien te répondre, je te propose d’aller ouvrir un sujet sur Zeste de Savoir dans la rubrique « Systèmes et Matériel » avec idéalement un bout de schéma pour bien comprendre où sont les choses 🙂 A bientôt !

  20. Bonsoir,

    Tout d’abord merci pour votre excellent site qui m’a permis de démarrer Arduino.
    J’ai fait un montage avec un afficheur 7 segments à 4 digits qui sont allumés alternativement en utilisant 4 sorties de l’Arduino mais sans transistors.
    J’ai une petite question concernant le contrôle de la luminosité d’un afficheur 7 segments : je souhaite contrôler la luminosité de l’afficheur en lien avec une photoresistance (plus la pièce est sombre, moins l’afficheur sera lumineux) et pour ce faire j’utilise les sorties PWM.
    Cela fonctionne bien à pleine luminosité mais plus elle diminue, plus un scintillement apparaît avec parfois un digit qui s’allume plus intensément une fraction de seconde (je suppose la durée d’un cycle).
    J’ai essayé d’ajouter des transistors sans que cela change le résultat.
    Auriez-vous une idée du problème ?
    Merci !

  21. Bonjour et merci pour ce tuto 🙂 j’ai enfin tout compris sur les 7 segments, les bcd et surtout les transistor 🙂

    Juste une question vraiment toute bête mais je n’ose pas le faire …

    Au lieu de brancher 7 ou 8 résistances entre les segments et le bcd, ne serait il pas possible d’en brancher une seule sur l’anode commune ?

    En réalité je souhaiterais pouvoir modifier l’intensité des afficheurs avec un potar et au lieu de devoir tourner 7 potar différent je me dis que je pourrais le faire avec un seul, d’où la question de mettre une seul résistance au niveau de l’anode commune (il me semble qu’un potentiomètre est une résistance variable)

    Merci par avance de votre aide 🙂

    • Il faudrait faire les deux 😉 Admettons tu n’en met qu’une seule sur la broche commune, dans ce cas tu as un certain courant si seulement un segment est allumée. Maintenant si tu allumes un autre segment, ou deux autres, ou tout les segments a la fois, alors ton courant par segment va diminuer et la luminosité diminuera a chaque fois.

      • D’accord mais en quoi le fait de faire les deux ( mettre une résistance fixe sur chaque segment et une résistance variable sur la broche commune) va changer le problème de la luminosité en fonction du nombre de segment allumer ? Surtout si j’utilise plusieurs segments..
        Je comprend pas bien…

        Pour moi la solution serait de mettre 7 potar a la place des 7 résistances fixe et de devoir régler segment par segment.

        • Effectivement j’ai parle trop vite. Ca ne changera rien de mettre un potar sur la broche commune. Une solution simple serait un transistor relie a une broche PWM. Plus le rapport cyclique sera grand et plus il y aura de luminosite (et vice versa)

  22. bonjour,

    juste une petite question avant de tout faire griller ^^

    concernant un montage avec des afficheurs a cathode commune, quels transistor il faut utiliser (NPN ou PNP) et comment les brancher

    merci par avance 🙂

  23. Bonjour, pouur le travail je dois effectuer un écran avec 3 afficheurs 7 segments. On doit pouvoir incrémenter et décrémenter avec 2 boutons différents. Vu que je suis débutant avec Arduino j’ai fait un programme, mais ça ne marche pas du tout. Un peu d’aide de votre part ne me ferai pas de mal.

    int CountUp = 22;
    int CountDown = 23;
    int Reset = 24;
    int S1A = 25;
    int S1B = 26;
    int S1C = 27;
    int S1D = 28;
    int S1E = 29;
    int S1F = 30;
    int S1G = 31;
    int S2A = 32;
    int S2B = 33;
    int S2C = 34;
    int S2D = 35;
    int S2E = 36;
    int S2F = 37;
    int S2G = 38;
    int S3A = 39;
    int S3B = 40;
    int S3C = 41;
    int S3D = 42;
    int S3E = 43;
    int S3F = 44;
    int S3G = 45;
    bool ButtonState;
    unsigned int ButtonPushCounter = 0;
    bool lastButtonState = 0;
    unsigned long int lastMillis = 0;
    bool ButtonState2;
    bool lastButtonState2 = 0;
    unsigned int lastMillis2 = 0;

    void setup() {

    pinMode(22 , INPUT); //Incrémentation
    pinMode(23 , INPUT); //Décrémentation
    pinMode(24 , INPUT); //Reset

    pinMode(25 , OUTPUT); //27 segments 1.a
    pinMode(26 , OUTPUT); //27 segments 1.b
    pinMode(27 , OUTPUT); //27 segments 1.c
    pinMode(28 , OUTPUT); //27 segments 1.d
    pinMode(29 , OUTPUT); //27 segments 1.e
    pinMode(30 , OUTPUT); //27 segments 1.f
    pinMode(31 , OUTPUT); //27 segments 1.g

    pinMode(32 , OUTPUT); //27 segments 2.a
    pinMode(33 , OUTPUT); //27 segments 2.b
    pinMode(34 , OUTPUT); //27 segments 2.c
    pinMode(35 , OUTPUT); //27 segments 2.d
    pinMode(36 , OUTPUT); //27 segments 2.e
    pinMode(37 , OUTPUT); //27 segments 2.f
    pinMode(38 , OUTPUT); //27 segments 2.g

    pinMode(39 , OUTPUT); //27 segments 3.a
    pinMode(40 , OUTPUT); //27 segments 3.b
    pinMode(41 , OUTPUT); //27 segments 3.c
    pinMode(42 , OUTPUT); //27 segments 3.d
    pinMode(43 , OUTPUT); //27 segments 3.e
    pinMode(44 , OUTPUT); //27 segments 3.f
    pinMode(45 , OUTPUT); //27 segments 3.g

    }

    void loop() {

    ButtonState2 = digitalRead(CountDown); //Décrémentation

    if ( ButtonState2 == HIGH && lastButtonState2 == LOW && ButtonPushCounter > 0 ) {
    ButtonPushCounter–;
    lastButtonState2 = HIGH;
    lastMillis2 = millis();
    }

    if ( (ButtonState2 == LOW) && (lastButtonState2 == HIGH) && (lastMillis2 + 400 < millis()) ) {
    lastButtonState2 = LOW;
    }

    ButtonState = digitalRead(CountUp); //Incrémentation

    if ( ButtonState == HIGH && lastButtonState == LOW && ButtonPushCounter < 999 ) {
    ButtonPushCounter++;
    lastButtonState = HIGH;
    lastMillis = millis();
    }

    if ( (ButtonState == LOW) && (lastButtonState == HIGH) && (lastMillis + 400 < millis()) ) {
    lastButtonState = LOW;
    }

    if ( digitalRead(Reset) == HIGH ) {
    ButtonPushCounter = 0;
    }

    switch (ButtonPushCounter)

    {

    case 0:
    digitalWrite(25, HIGH);
    digitalWrite(26, HIGH);
    digitalWrite(27, HIGH);
    digitalWrite(28, HIGH);
    digitalWrite(29, HIGH);
    digitalWrite(30, HIGH);
    digitalWrite(31, LOW);

    digitalWrite(32, HIGH);
    digitalWrite(33, HIGH);
    digitalWrite(34, HIGH);
    digitalWrite(35, HIGH);
    digitalWrite(36, HIGH);
    digitalWrite(37, HIGH);
    digitalWrite(38, LOW);

    digitalWrite(39, HIGH);
    digitalWrite(40, HIGH);
    digitalWrite(41, HIGH);
    digitalWrite(42, HIGH);
    digitalWrite(43, HIGH);
    digitalWrite(44, HIGH);
    digitalWrite(45, LOW);
    break;

    case 1:
    digitalWrite(25, HIGH);
    digitalWrite(26, HIGH);
    digitalWrite(27, HIGH);
    digitalWrite(28, HIGH);
    digitalWrite(29, HIGH);
    digitalWrite(30, HIGH);
    digitalWrite(31, LOW);

    digitalWrite(32, HIGH);
    digitalWrite(33, HIGH);
    digitalWrite(34, HIGH);
    digitalWrite(35, HIGH);
    digitalWrite(36, HIGH);
    digitalWrite(37, HIGH);
    digitalWrite(38, LOW);

    digitalWrite(39, LOW);
    digitalWrite(40, HIGH);
    digitalWrite(41, HIGH);
    digitalWrite(42, LOW);
    digitalWrite(43, LOW);
    digitalWrite(44, LOW);
    digitalWrite(45, LOW);
    break;

  24. Bonjour,

    Merci pour ce super tuto qui me redonne goûte à l’électronique.

    Sur le schéma final, pourquoi les afficheurs 7 segments sont-ils alimentés par le collecteur du transistor et non par l’émetteur? Le collecteur « tirant » du courant, comment peut-il fournir du courant à l’afficheur 7 segments?

  25. Bonjour 😀
    Pour un projet je dois réaliser un afficher 2 digits qui s’incrémente suite à un capteur.
    J’ai tenter de reprendre ce montage mais il ne va pas :/
    Voici le lien :
    et

    Merci de jeter un coup d’œil 😉
    Merci pour le tuto

  26. Hello !
    Juste une question sur la partie « Utiliser plusieurs afficheurs ».
    Est-ce pour une question de coûts, ou pour présenter le transistor que tu as utilisé cette approche?

    J’aurais pensé utiliser deux MC14543B, un pour chaque afficheur.

    Les sorties D2, D3, D4 et D5 de l’arduino connectées sur les deux MC1543B en parallèles, et les D6 connecté sur l’entrée LD d’un MC14543B, et D7 sur l’autre.

    L’idée étant de mettre LD à 1 sur le MC1543B de l’afficheur que l’on veut modifier, et 0 l’autre. on le met a jour avec la valeur souhaitée, puis on passe LD à 0, il garde donc l’affichage en mémoire.
    on passe à 1 le second afficheur, et on le met a jour. ensuite on met à 0.

    Plus besoin de persistance rétinienne, et donc de switch toutes les 10 millisecondes.
    J’imagine que ça fatigue moins le matériel.

    Ou bien il y a-t-il un problème que je n’aurais pas vu dans cette solution?

  27. Bonjour,

    J’ai un problème avec mon montage. Lorsque que je branche mon afficheur 7 segments sur le décodeur CD4545BE toutes les leds s’allument sans même avoir branché les quatre bits venant de l’arduino uno. Lorsque je branche les quatre sorties sur DCBA rien ne change. J’ai refait le branchement une dizaine de fois, je suis sur qu’il est conforme à ton dessin. Que peut-il se passer ?
    Merci pour ton aide.
    Cordialement,
    Alain

  28. Bonjour,
    J’ai exactement copier coller votre programme pour le décodeur BCD, mais quand je clique sur vérifier, il me dit qu’il y a un problème sur la ligne 6 : afficher (i), on appelle la fonction d’affichage. Est ce que vous auriez une idée pour remplacer : afficher. Merci 😉

  29. Bonjour,

    J’aimerais dans mon cas utiliser 8 afficheurs 7 segments (2*4) sur un seul Arduino.
    Je vais compter des cycles allant jusqu’à 1500. Le premier afficheur m’affichera le nombre total de cycles, le second pourra être remis à zéro périodiquement avec un BP. Ça va demander beaucoup de broches…
    Serait-il possible de combiner les solutions à la fois du décodeur BCD et de la persistance rétinienne?

    Merci. 🙂

  30. Bonjour,
    Si tu as acheté un afficheur 7 segments à anode commune, alors c’est normal à ma connaisance, puisque l’anode doit-être reliée au potentiel bas soit le ground.
    Bonne journée,
    Alexis.

  31. Merci pour le tuto. J’ai appris plein de choses sur le pilotage d’un afficheur LED.

    Sinon, à supposer qu’on utilise les pins 2 à 5 pour piloter le MC14543B, on peut faire, à la place de la fonction afficher(chiffre) :

    for(pin=2;pin<6;pin++) digitalWrite(pin,bitRead(chiffre,pin-2));

  32. Bonjour, tout nouveau dans le monde de l’arduino, je passe beaucoup de temps à me documenter sur son fonctionnement et les exercices pratiques que je vais pouvoir réaliser. Pour le moment, l’aspirine est mon ami. 😀 Je n’y connais pas grand chose en électronique et n’ai pas encore reçu ma commande de matériels Arduino. Ce tuto m’intéresse énormément.

    Pensez-vous que ce projet puisse être à la portée d’un novice en Arduino ou faut-il avoir une bonne expérience? Je suis accessoiriste et aimerais utiliser les bases de ce tuto pour créer un compteur de balles pour la réplique d’un fusil de science-fiction.

    Je souhaite ajouter un interrupteur A (la gachette de tir) et un interrupteur B (le chargeur). En gros, quand j’appuie sur la gachette en continue (A) , le compteur défile de « 36 à 0 » et temporise lorsque je relache A. Arrivé à « 0 », le compteur se bloque. Le chargeur (interrupteur B) permet la remise à « 36 » du compteur et servira d’interrupteur d’alimentation. L’interrupteur B en ON (chargeur enclenché) laisse défiler le compteur. Interrupteur B en OFF (chargeur retiré), pas de courant. Remise du chargeur (Interrupteur B sur ON), le compteur repart de 36. Pensez-vous possible de réaliser ces fonctions en partant de ce tuto?
    Il y a t’il besoin de matériel supplémentaire (en dehors des interrupteurs)?

    Merci d’avance et bravo pour vos tutos d’une grande aide (même si je n’en suis pas encore là pour le moment. 😉

    Arnaud (Padawan de l’Arduino).

  33. J’ai un problème pour le premier montage avec le décodeur BCD. Je ne sais pas comment brancher les broches A; B; C; D; et lorsque j’essaie l’afficheur affiche n’importe quoi. J’utilise le programme que tu as fait.

Laisser un commentaire