Une croix de pharmacie animée avec Arduino UNO

. Par : Christian. URL : https://www.locoduino.org/spip.php?article254

Cet article décrit comment mettre en œuvre une matrice de LED avec une carte Arduino dans le but de reproduire l’animation lumineuse d’une croix de pharmacie. Il complète l’article éponyme paru dans Loco-Revue N° 875 de juin 2020. La matrice de LED utilisée dans cet article a pour référence 1588ASRG et sa taille convient bien pour l’échelle Zéro. Les principes sont les mêmes si on utilise une matrice de LED A-788BPG dont la taille convient mieux pour l’échelle H0.

La matrice de LED sera incorporée à un bâtiment représentant une pharmacie que vous aurez construite à partir d’un kit ou bien à partir de feuilles de cartons ou autres matériaux. Voici pour commencer une petite vidéo qui montre le résultat obtenu ; les différentes phases de construction ont été expliquées dans l’article de Loco-Revue.

Transformer une matrice de LED en croix de pharmacie

Des recherches sur internet montrent qu’une croix de pharmacie a généralement une envergure comprise entre 0,80 et 1,30 m. En général, la croix de pharmacie est posée perpendiculairement à la façade du bâtiment pour que ses deux faces soient visibles. Parfois, la croix n’a qu’une seule face active et elle est alors simplement posée sur le mur. Dans un tel cas, on peut la représenter en utilisant une matrice de LED vertes. On peut trouver ce genre de composant sur internet ; c’est évidemment la taille de la matrice qui dictera notre choix en fonction de l’échelle pratiquée.

Pour chaque bras, il faut utiliser au moins trois lignes ou trois colonnes pour que l’animation soit intéressante. De plus la croix doit être symétrique. Comme les matrices de LED sont généralement organisées en 8 lignes et 8 colonnes, la largeur des bras pourrait être de 4 lignes ou 4 colonnes, mais dans ce cas, la croix peut sembler trop massive par rapport à son envergure, comme le montre le tracé en bleu de la figure 1. Il est alors préférable de n’utiliser que 7 lignes et 7 colonnes de la matrice pour dessiner une croix dont la largeur des bras est de 3 lignes ou colonnes comme le montre le tracé en rouge de la figure 1. Dans ces conditions, l’envergure de la croix est 6 fois l’espace entre deux LED auxquels il faut rajouter le diamètre d’une LED et la largeur de bras est 2 fois l’espace entre deux LED auxquels il faut ajouter le diamètre d’une LED.

Figure 1
Figure 1
Partie utile de la matrice de LED

Quelle matrice de LED choisir ?

La première chose à faire est donc de se procurer une matrice de LED vertes dont les dimensions permettront de reproduire une croix en fonction de l’échelle pratiquée. Ce genre de composant dispose de 16 broches reliées aux 8 lignes et aux 8 colonnes.

La référence A-788BPG convient parfaitement pour l’échelle H0 puisque sa dimension est de 20 x 20 mm et de plus, on n’utilise que 7 x 7 LED. Selon la formule mentionnée plus haut, cela représente une largeur de bras de 7,5 mm et une envergure de 17 mm, ou encore 1,47 m à l’échelle, ce qui est un peu plus que désiré tout en restant cohérent.

Comme je l’ai dit dans l’introduction, j’ai utilisé pour écrire cet article une matrice ayant pour référence 1588ASRG qui convient mieux pour l’échelle 0 puisque sa dimension est de 37,8 x 37,8 mm, ce qui donne une largeur de bras de 14 mm et une envergure de 32 mm en arrondissant, soit 1,40 m à l’échelle. La figure 3 montre la géométrie de la croix ainsi obtenue.

Figure 2
Figure 2
Dimension du composant 1588ASRG et géométrie de la croix

La matrice A-788BPG dispose de 16 broches correspondant aux 8 lignes et 8 colonnes. On peut être surpris de voir que le composant 1588ASRG dispose de 24 broches. La datasheet montre qu’il s’agit en fait de LED bicolores (vertes et rouges) en montage à anodes communes sur les 8 lignes et avec les 16 cathodes (8 rouges et 8 vertes) sur les colonnes. Dans la suite de cet article, nous n’utiliserons que les LED vertes de ce composant.

Vous pouvez utiliser d’autres références de matrices de LED que les deux fournies dans cet article. La seule condition est que les LED soient vertes puisque l’idée est d’utiliser ce composant pour créer une croix de pharmacie et que la taille du composant puisse donner une croix de pharmacie dont l’envergure est comprise entre 0,80 m et 1,50m. Il vous faudra alors repérer le brochage du composant en lignes et colonnes et le mieux est de taper sa référence dans un moteur de recherche pour télécharger sa datasheet à partir du site du constructeur.

Principe de commande d’une LED

La figure 3 montre notre matrice de LED. Supposons qu’on veuille allumer la LED verte située en ligne 3 et colonne 3. Il suffit de mettre la ligne 3 à l’état HIGH (+5 V) et la colonne 3 à l’état LOW (0 V) pour qu’un courant traverse la LED, courant qu’il faut calibrer à 20 mA maximum par une résistance en série dans ce circuit (par exemple en série sur la broche du composant reliée à la colonne 3). La LED est entourée par un carré sur la figure 3. Si on veut aussi allumer la LED verte située en ligne 3 et colonne 4, il suffit de mettre à l’état LOW la colonne 4 avec une résistance de limitation de courant en série. Tout cela semble assez simple pour peu qu’on connaisse la correspondance entre les broches du composant et les lignes et colonnes de la matrice de LED.

Figure 3
Figure 3
Câblage des LED de la matrice

Supposons maintenant qu’on veuille allumer en même temps que ces deux LED, la LED verte située ligne 5 et colonne 5. On peut se dire qu’il suffit de mettre la ligne 5 à l’état HIGH et la colonne 5 à l’état LOW avec la résistance de limitation de courant en série, mais on se rend compte que les LED situées ligne 3, colonne 5 et ligne 5, colonnes 3 et 4 s’allument également. Ces LED sont entourées par un cercle sur la figure 3. Or, ce n’est pas ce qu’on veut.
La solution pour se sortir de cette situation est d’allumer alternativement la ligne 3, puis la ligne 5, à une fréquence suffisamment élevée pour que la persistance rétinienne fasse croire qu’elles sont allumées en même temps. En effectuant un balayage à fréquence élevée des lignes de notre matrice de LED, on peut ainsi accéder à toutes les LED. Pour allumer toutes les LED d’une ligne, il suffit de mettre la broche de la ligne à l’état HIGH et toutes les broches des colonnes à l’état LOW, avec des résistances de limitation de courant en série sur chaque broche de colonne. La broche d’Arduino reliée à la ligne de la matrice doit fournir suffisamment de courant pour alimenter toutes les LED, or cette broche est limitée à 40 mA maximum et on conseille de se limiter à 20 mA seulement. Avec cette dernière valeur, cela représente 2,5 mA par LED si on allume 8 LED et 3 mA si on n’allume que 7 LED, comme dans le cas de notre croix de pharmacie et ainsi la limitation du microcontrôleur n’est pas dépassée.

Calcul des résistances de limitation

Le calcul des résistances de limitation de courant est très simple car comme le balayage de la matrice se fait ligne par ligne, à tout moment il n’y a qu’une seule LED allumée par colonne. La tension aux bornes d’une LED verte est de 2,1 V et de 1,85 V aux bornes d’une LED rouge d’après la datasheet du composant 1588ASRG. Pour que le courant soit de 3 mA dans les LED, il faut une résistance de 967 Ω pour une LED verte et 1050 Ω pour une rouge. On optera pour des résistances de 1 kΩ. La luminosité de la LED est suffisante bien que le courant qui la traverse ne fasse que 3 mA.

Fréquence de balayage des lignes

Pour utiliser la persistance rétinienne, on peut partir de la fréquence des images de télévision, soit 25 images par seconde. Cela veut dire que l’ensemble de la matrice de 8 par 8 doit être balayée en 40 ms ou encore qu’une ligne reste allumée seulement 5 ms. Une ligne est donc allumée pendant 5 ms puis éteinte pendant 35 ms. Un essai avec la LED incluse sur le module UNO montre un scintillement de cette dernière avec ces valeurs. Si on monte à 30 images par seconde, la ligne reste allumée 4 ms puis éteinte pendant 29 ms (les nombres sont arrondis) et le scintillement devient imperceptible. Sur la matrice de LED reliées à des résistances de 1 kΩ, il faut au moins 40 images par seconde pour ne plus voir de scintillement. Dans ce cas, les LED restent allumées 3 ms et éteintes 22 ms.

Le principe de balayage est assez simple : on met la première ligne à l’état HIGH et les colonnes nécessaires à l’état LOW, les autres colonnes étant à l’état HIGH, ce qui allume les LED voulues, on attend 3 ms, puis on éteint tout (toutes les colonnes à l’état HIGH) et on passe à la ligne suivante pour faire de même. Lorsque la dernière ligne a effectué son cycle d’allumage, on revient à la première ligne.

Toutes les LED qu’on veut allumer sur une même ligne doivent être commandées en même temps. Pour cette raison, on ne peut pas utiliser la fonction digitalWrite() d’Arduino qui ne s’applique qu’à une seule sortie à la fois. Pour commander les sorties de la carte Arduino, il faut agir directement sur les ports d’entrée-sortie du microcontrôleur (des E/S fonctionnant ensemble). Les sorties d’Arduino reliées aux colonnes de la matrice doivent donc appartenir au même port d’entrée-sortie de la carte Arduino UNO.

Les ports de la carte Arduino UNO

La carte Arduino UNO est construite autour du microcontrôleur ATmega328. Comme le montre la figure 4, nous trouvons trois ports appelés respectivement B (entouré en vert), C (entouré en bleu), et D (entouré en orange). Certaines lignes de certains ports servent à des fonctions particulières (Reset (entouré en violet), et cristal de quartz (PB6 et PB7)). Face aux broches du microcontrôleur, on trouve la correspondance en rouge des broches d’E/S du module UNO, ce qui permet de voir que la carte UNO dispose de vingt entrées-sorties (8 du port D, 6 du port C et 6 du port B). C’est donc les 8 E/S du port D (digital pin 0 à 7 de la carte UNO) que nous connecterons aux 8 colonnes de notre matrice de LED.

Figure 4
Figure 4
Structure des E/S de la carte UNO

Affichage d’un motif sur la matrice

Comme on n’utilise que 7 lignes et 7 colonnes de la matrice, un motif est représentable par un carré de 49 pixels, chaque pixel étant une LED allumée ou non. On peut représenter une LED allumée avec un 0 (car il faut un état LOW sur la colonne) et éteinte avec un 1. Par exemple, si on souhaite allumer toute la ligne 3 et la colonne 3, notre motif est représenté comme cela :

1 1 0 1 1 1 1
1 1 0 1 1 1 1
0 0 0 0 0 0 0
1 1 0 1 1 1 1
1 1 0 1 1 1 1
1 1 0 1 1 1 1
1 1 0 1 1 1 1

Chaque ligne de ce motif est exactement ce qui doit être écrit en binaire sur le port D pour que les colonnes de la matrice soient à l’état LOW pour allumer les LED adéquates. Pour afficher le motif sur la matrice, il suffit de le reconstituer ligne par ligne comme on l’a vu plus haut, en entrant à chaque fois la bonne valeur en binaire sur le port D. Le digit le plus à droite de cette valeur en binaire correspond au bit 0 du port D, et est relié à la colonne 7 de la matrice. Le bit 7 du port D n’est pas utilisé puisqu’on se limite à 7 colonnes.

Pour écrire une valeur binaire sur le port D, il suffit d’écrire :
PORTD = 0b1101111 ;
Ici, l’exemple reprend la première ligne du motif représenté ci-dessus.

Réalisation d’une animation lumineuse sur la croix

Pour réaliser une animation lumineuse sur la croix, il suffit d’afficher plusieurs images les unes après les autres, comme le fait un film. La principale difficulté est de coder ces différentes images sans se tromper, comme cela a été expliqué au paragraphe précédent. La figure 5 montre les différentes images qui tracent le contour de la croix à partir de quatre points différents. Il ne faut que six images pour tracer tout le contour alors qu’il en aurait fallu quatre fois plus si le tracé ne partait que d’un seul point du contour.

Figure 5
Figure 5
Un exemple d’animation

Pour modifier la rapidité de l’animation, il suffit de jouer sur la durée d’affichage de chaque image. Pour cette raison, cette valeur n’est pas donnée sous forme numérique : on utilise une variable déclarée en début de programme, ce qui est plus facile à modifier si on veut accélérer ou ralentir le rythme. Si vous voulez profiter du dessin créé par l’animation, il faut penser à afficher plus longtemps la dernière image. Par exemple, pour l’animation de la figure 5, chaque image de 1 à 5 est affichée 50 ms, ce qui donne un rythme d’animation élevé, mais la dernière image (image 6) est affichée 500 ms.

Montage n’utilisant que les LED vertes d’une matrice 1588ASRG

La figure 6 montre le brochage de la matrice de LED 1588ASRG. Si on tient le composant pour avoir l’inscription 1588ASRG en bas et qu’on le regarde du côté LED, la broche 1 (V8) est située dans le coin inférieur gauche. On voit que les 24 broches (rectangles blancs) sont organisées en trois groupes de huit ; les lignes sont repérées par la lettre V (rectangle bleu), les colonnes par G pour les LED vertes (rectangle vert) ou R pour les LED rouges (rectangle rouge). Nous avons donc la correspondance broches-matrice mais si vous utilisez une autre référence de matrice de LED, il vous faudra déterminer le brochage du composant en examinant sa notice comme nous l’avons déjà dit.

Figure 6
Figure 6
Brochage de la matrice de LED 1588ASRG

La figure 7 montre comment relier Arduino et la matrice de LED si on n’utilise que les LED vertes d’une matrice 1588ASRG. Les 7 colonnes de la matrice sont reliées aux E/S numériques 0 à 6 de la carte UNO (7 lignes du port D). Les 7 lignes de la matrice sont reliées aux sorties numériques 8 à 13 ainsi qu’à la broche A0. Cette dernière, bien que ça ne soit pas inscrit sur la carte, porte le numéro 14 [1].

Figure 7
Figure 7
Câblage de la matrice 1588ASRG à une carte UNO

La figure 7bis montre comment relier Arduino et n’importe quelle matrice de LED. Le tableau ci-dessous donne la correspondance broches-lignes-colonnes de la matrice de LED A-788BPG plus adaptée à l’échelle H0. Pour cette matrice, la broche 1 est celle qui se trouve la plus à gauche quand on regarde la face où est inscrite la référence du composant. Si vous voulez utiliser d’autres matrices, il vous faudra reconstituer ce tableau en vous basant sur les indications de datasheet.

Correspondance lignes-colonnes-broches de la matrice A-788BPG
Ligne ou colonneBroche
colonne 1 13
colonne 2 3
colonne 3 4
colonne 4 10
colonne 5 6
colonne 6 11
colonne 7 15
colonne 8 16
Ligne 1 9
Ligne 2 14
Ligne 3 8
Ligne 4 12
Ligne 5 1
Ligne 6 7
Ligne 7 2
Ligne 8 5
Figure 7bis
Figure 7bis
Câblage d’une matrice de LED à une carte UNO

La figure 8 montre un prototype monté avec deux petites breadboards recevant les broches de la matrice de LED et fixées à l’adhésif double face sur une petite plaque d’époxy. On voit l’inscription 1588ASRG au bas du composant ce qui permet de repérer la broche 1 : le fil jaune qui part de la sortie A0 de la carte UNO relie la broche 2 (V7 ou encore ligne 7).

Figure 8
Figure 8
Montage provisoire

Le programme

Le programme ci-dessous donne un exemple d’animation de croix de pharmacie dont vous pouvez vous inspirer pour créer votre propre animation. Les motifs sont définis au début sous la forme de matrices binaires. La fonction affiche(,) réalise l’affichage d’un motif sur la matrice pendant un certain temps (variable « duree »). La fonction loop() utilise la fonction affiche(,) pour reproduire les motifs sur la matrice de LED les uns après les autres, un peu comme les images d’un film qui se succèdent pour créer le mouvement. Le programme est très bien commenté et sa compréhension ne devrait pas poser de problème.

  1. /* Ce programme réalise une animation de plusieurs motifs sur une matrice de LED
  2.  * par un balayage de lignes à la fréquence de 40 images par seconde.
  3.  * Dispose d'une animation complexe à 33 motifs et une à 35 motifs.
  4.  * Premier motif : remplissage centre vers extérieur
  5.  * Dernier motif : remplissage en diagonal
  6.  * Colonnes de matrice : broches 0 à 6
  7.  * Lignes de matrice : broches 8 à 14 (A0)
  8.  * résistances de limitation de courant : 1 kilo
  9.  * ------------------------------------------------------------------------------
  10.  * Version 9 - 11 mars 2018
  11.  * ------------------------------------------------------------------------------
  12.  */
  13.  
  14. // Déclaration des variables
  15. static const unsigned long dureeBarres = 200; // en millisecondes
  16. static const unsigned long dureeBord = 50;
  17. static const unsigned long dureeCentre = 100;
  18. static const unsigned long dureeSpiral = 50;
  19. static const unsigned long dureeCarre = 50;
  20. static const unsigned long dureeBranche = 100;
  21. static const unsigned long dureeCligno = 100;
  22. static const unsigned long dureeDiago = 50;
  23.  
  24. // Les motifs de barre horizontale et verticale
  25. const byte barres01[7] = {0b1101111, 0b1101111, 0b0000000, 0b1101111, 0b1101111, 0b1101111, 0b1101111};
  26. const byte barres02[7] = {0b1110111, 0b1110111, 0b1110111, 0b0000000, 0b1110111, 0b1110111, 0b1110111};
  27. const byte barres03[7] = {0b1111011, 0b1111011, 0b1111011, 0b1111011, 0b0000000, 0b1111011, 0b1111011};
  28.  
  29. // Les motifs de tracé des bords
  30. const byte bord1[7] = {0b1101111, 0b1111111, 0b1111110, 0b1111111, 0b0111111, 0b1111111, 0b1111011};
  31. const byte bord2[7] = {0b1100111, 0b1111111, 0b1111110, 0b0111110, 0b0111111, 0b1111111, 0b1110011};
  32. const byte bord3[7] = {0b1100011, 0b1111111, 0b0111110, 0b0111110, 0b0111110, 0b1111111, 0b1100011};
  33. const byte bord4[7] = {0b1100011, 0b1111011, 0b0011110, 0b0111110, 0b0111100, 0b1101111, 0b1100011};
  34. const byte bord5[7] = {0b1100011, 0b1111011, 0b0001010, 0b0111110, 0b0101000, 0b1101111, 0b1100011};
  35. const byte bord6[7] = {0b1100011, 0b1101011, 0b0001000, 0b0111110, 0b0001000, 0b1101011, 0b1100011};
  36.  
  37. // Le motifs de remplissage depuis le centre vers l'extérieur
  38. const byte centre1[7] = {0b1111111, 0b1111111, 0b1111111, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  39. const byte centre2[7] = {0b1111111, 0b1111111, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  40. const byte centre3[7] = {0b1111111, 0b1100011, 0b1000001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  41. const byte centre4[7] = {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  42.  
  43. // Les motifs de remplissage par mouvement en spiral depuis le centre
  44. const byte spiral01[7] = {0b1111111, 0b1111111, 0b1111111, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  45. const byte spiral02[7] = {0b1111111, 0b1111111, 0b1110111, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  46. const byte spiral03[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  47. const byte spiral04[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1111111, 0b1111111, 0b1111111};
  48. const byte spiral05[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1111011, 0b1111111, 0b1111111};
  49.  
  50. const byte spiral06[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1110011, 0b1111111, 0b1111111};
  51. const byte spiral07[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1100011, 0b1111111, 0b1111111};
  52. const byte spiral08[7] = {0b1111111, 0b1111111, 0b1110011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  53. const byte spiral09[7] = {0b1111111, 0b1111111, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  54. const byte spiral10[7] = {0b1111111, 0b1101111, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  55.  
  56. const byte spiral11[7] = {0b1111111, 0b1100111, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  57. const byte spiral12[7] = {0b1111111, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  58. const byte spiral13[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  59. const byte spiral14[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1100011, 0b1111111, 0b1111111};
  60. const byte spiral15[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1100001, 0b1111111, 0b1111111};
  61.  
  62. const byte spiral16[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1100001, 0b1111011, 0b1111111};
  63. const byte spiral17[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1100001, 0b1110011, 0b1111111};
  64. const byte spiral18[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1100001, 0b1100011, 0b1111111};
  65. const byte spiral19[7] = {0b1111111, 0b1100011, 0b1100001, 0b1100001, 0b1000001, 0b1100011, 0b1111111};
  66. const byte spiral20[7] = {0b1111111, 0b1100011, 0b1100001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  67.  
  68. const byte spiral21[7] = {0b1111111, 0b1100011, 0b1000001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  69. const byte spiral22[7] = {0b1101111, 0b1100011, 0b1000001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  70. const byte spiral23[7] = {0b1100111, 0b1100011, 0b1000001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  71. const byte spiral24[7] = {0b1100011, 0b1100011, 0b1000001, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  72. const byte spiral25[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000001, 0b1000001, 0b1100011, 0b1111111};
  73.  
  74. const byte spiral26[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000001, 0b1100011, 0b1111111};
  75. const byte spiral27[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000000, 0b1100011, 0b1111111};
  76. const byte spiral28[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000000, 0b1100011, 0b1111011};
  77. const byte spiral29[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000000, 0b1100011, 0b1110011};
  78. const byte spiral30[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000000, 0b1100011, 0b1100011};
  79.  
  80. const byte spiral31[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b0000000, 0b1100011, 0b1100011};
  81. const byte spiral32[7] = {0b1100011, 0b1100011, 0b1000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  82. const byte spiral33[7] = {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  83.  
  84. // Les motifs de remplissage par carré
  85. const byte carre01[7] = {0b1111111, 0b1111111, 0b1111111, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  86. const byte carre02[7] = {0b1111111, 0b1111111, 0b1110111, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  87. const byte carre03[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110111, 0b1111111, 0b1111111, 0b1111111};
  88. const byte carre04[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1111111, 0b1111111, 0b1111111};
  89. const byte carre05[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1111011, 0b1111111, 0b1111111};
  90. const byte carre06[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1110011, 0b1111111, 0b1111111};
  91. const byte carre07[7] = {0b1111111, 0b1111111, 0b1110011, 0b1110011, 0b1100011, 0b1111111, 0b1111111};
  92. const byte carre08[7] = {0b1111111, 0b1111111, 0b1110011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  93. const byte carre09[7] = {0b1111111, 0b1111111, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  94. const byte carre10[7] = {0b1111111, 0b1111011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  95. const byte carre11[7] = {0b1111111, 0b1110011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  96. const byte carre12[7] = {0b1111111, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  97. const byte carre13[7] = {0b1101111, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  98. const byte carre14[7] = {0b1100111, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  99. const byte carre15[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  100. const byte carre16[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100001, 0b1111111, 0b1111111};
  101. const byte carre17[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100001, 0b1100001, 0b1111111, 0b1111111};
  102. const byte carre18[7] = {0b1100011, 0b1100011, 0b1100001, 0b1100001, 0b1100001, 0b1111111, 0b1111111};
  103. const byte carre19[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100001, 0b1100001, 0b1111111, 0b1111111};
  104. const byte carre20[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100001, 0b1111111, 0b1111111};
  105. const byte carre21[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1111111, 0b1111111};
  106. const byte carre22[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1101111, 0b1111111};
  107. const byte carre23[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1100111, 0b1111111};
  108. const byte carre24[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1100011, 0b1111111};
  109. const byte carre25[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1100011, 0b1111011};
  110. const byte carre26[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1100011, 0b1110011};
  111. const byte carre27[7] = {0b1100011, 0b1100011, 0b1100000, 0b1100000, 0b1100000, 0b1100011, 0b1100011};
  112. const byte carre28[7] = {0b1100011, 0b1100011, 0b1000000, 0b1100000, 0b1100000, 0b1100011, 0b1100011};
  113. const byte carre29[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1100000, 0b1100011, 0b1100011};
  114. const byte carre30[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b1000000, 0b1100011, 0b1100011};
  115. const byte carre31[7] = {0b1100011, 0b1100011, 0b1000000, 0b1000000, 0b0000000, 0b1100011, 0b1100011};
  116. const byte carre32[7] = {0b1100011, 0b1100011, 0b1000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  117. const byte carre33[7] = {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  118.  
  119. // Les motifs de remplissage par branches verticale horizontale
  120. const byte branche01[7] = {0b1100011, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  121. const byte branche02[7] = {0b1100011, 0b1100011, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  122. const byte branche03[7] = {0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  123. const byte branche04[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111, 0b1111111};
  124. const byte branche05[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111, 0b1111111};
  125. const byte branche06[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1111111};
  126. const byte branche07[7] = {0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011, 0b1100011};
  127. const byte branche08[7] = {0b1100011, 0b1100011, 0b0100011, 0b0100011, 0b0100011, 0b1100011, 0b1100011};
  128. const byte branche09[7] = {0b1100011, 0b1100011, 0b0000011, 0b0000011, 0b0000011, 0b1100011, 0b1100011};
  129. const byte branche10[7] = {0b1100011, 0b1100011, 0b0000001, 0b0000001, 0b0000001, 0b1100011, 0b1100011};
  130. const byte branche11[7] = {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  131.  
  132. // Les motifs de clignotement bord-centre
  133. const byte bord[7] = {0b1100011, 0b1101011, 0b0001000, 0b0111110, 0b0001000, 0b1101011, 0b1100011};
  134. const byte centre[7] = {0b1111111, 0b1110111, 0b1110111, 0b1000001, 0b1110111, 0b1110111, 0b1111111};
  135.  
  136. // Les motifs de remplissage en diagonale
  137. const byte diago01[7]= {0b1101111, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  138. const byte diago02[7]= {0b1101111, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  139. const byte diago03[7]= {0b1101111, 0b1111111, 0b0111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  140. const byte diago04[7]= {0b1100111, 0b1111111, 0b0111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  141. const byte diago05[7]= {0b1100111, 0b1101111, 0b0111111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  142. const byte diago06[7]= {0b1100111, 0b1101111, 0b0011111, 0b1111111, 0b1111111, 0b1111111, 0b1111111};
  143. const byte diago07[7]= {0b1100111, 0b1101111, 0b0011111, 0b0111111, 0b1111111, 0b1111111, 0b1111111};
  144. const byte diago08[7]= {0b1100011, 0b1101111, 0b0011111, 0b0111111, 0b1111111, 0b1111111, 0b1111111};
  145. const byte diago09[7]= {0b1100011, 0b1100111, 0b0011111, 0b0111111, 0b1111111, 0b1111111, 0b1111111};
  146. const byte diago10[7]= {0b1100011, 0b1100111, 0b0001111, 0b0111111, 0b1111111, 0b1111111, 0b1111111};
  147. const byte diago11[7]= {0b1100011, 0b1100111, 0b0001111, 0b0011111, 0b1111111, 0b1111111, 0b1111111};
  148. const byte diago12[7]= {0b1100011, 0b1100111, 0b0001111, 0b0011111, 0b0111111, 0b1111111, 0b1111111};
  149. const byte diago13[7]= {0b1100011, 0b1100011, 0b0001111, 0b0011111, 0b0111111, 0b1111111, 0b1111111};
  150. const byte diago14[7]= {0b1100011, 0b1100011, 0b0000111, 0b0011111, 0b0111111, 0b1111111, 0b1111111};
  151. const byte diago15[7]= {0b1100011, 0b1100011, 0b0000111, 0b0001111, 0b0111111, 0b1111111, 0b1111111};
  152. const byte diago16[7]= {0b1100011, 0b1100011, 0b0000111, 0b0001111, 0b0011111, 0b1111111, 0b1111111};
  153. const byte diago17[7]= {0b1100011, 0b1100011, 0b0000011, 0b0001111, 0b0011111, 0b1111111, 0b1111111};
  154. const byte diago18[7]= {0b1100011, 0b1100011, 0b0000011, 0b0000111, 0b0011111, 0b1111111, 0b1111111};
  155. const byte diago19[7]= {0b1100011, 0b1100011, 0b0000011, 0b0000111, 0b0001111, 0b1111111, 0b1111111};
  156. const byte diago20[7]= {0b1100011, 0b1100011, 0b0000001, 0b0000111, 0b0001111, 0b1111111, 0b1111111};
  157. const byte diago21[7]= {0b1100011, 0b1100011, 0b0000001, 0b0000011, 0b0001111, 0b1111111, 0b1111111};
  158. const byte diago22[7]= {0b1100011, 0b1100011, 0b0000001, 0b0000011, 0b0000111, 0b1111111, 0b1111111};
  159. const byte diago23[7]= {0b1100011, 0b1100011, 0b0000001, 0b0000011, 0b0000111, 0b1101111, 0b1111111};
  160. const byte diago24[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000011, 0b0000111, 0b1101111, 0b1111111};
  161. const byte diago25[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000001, 0b0000111, 0b1101111, 0b1111111};
  162. const byte diago26[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000001, 0b0000011, 0b1101111, 0b1111111};
  163. const byte diago27[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000001, 0b0000011, 0b1100111, 0b1111111};
  164. const byte diago28[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000001, 0b0000011, 0b1100111, 0b1101111};
  165. const byte diago29[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000011, 0b1100111, 0b1101111};
  166. const byte diago30[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000001, 0b1100111, 0b1101111};
  167. const byte diago31[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000001, 0b1100011, 0b1101111};
  168. const byte diago32[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000001, 0b1100011, 0b1100111};
  169. const byte diago33[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100111};
  170. const byte diago34[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100111};
  171. const byte diago35[7]= {0b1100011, 0b1100011, 0b0000000, 0b0000000, 0b0000000, 0b1100011, 0b1100011};
  172.  
  173. void setup() {
  174. // On met toutes les broches en sorties
  175. for (int broche=0; broche<=14; broche++){
  176. pinMode (broche, OUTPUT);
  177. } // fin boucle for
  178. // On met les lignes de la matrice à l'état LOW
  179. for (int ligne=1; ligne<=7; ligne++){
  180. digitalWrite(ligne+7, LOW); // N° broche = N° ligne + 7
  181. } // fin boucle for N°2
  182. // On met les colonnes à l'état HIGH
  183. PORTD = 0b11111111;
  184. } // fin de setup
  185.  
  186. void affiche(const byte motif[7], const unsigned long duree){
  187. // Réalise l'affichage d'un motif sur la matrice pendant un certain temps (duree)
  188. unsigned long topDuree;
  189. topDuree = millis();
  190. while(millis() - topDuree < duree){
  191. // tant que la durée n'est pas réalisée, on affiche une trame de 7 lignes
  192. for(int ligne=1; ligne<=7; ligne++){
  193. // On met la broche à l'état HIGH. N° broche = N° ligne + 7
  194. digitalWrite(ligne+7, HIGH);
  195. // On met les colonnes comme il se doit
  196. PORTD = motif[ligne-1]; // la première ligne est l'indice 0 du tableau !
  197. delay(3);
  198. // On éteint la ligne avant de passer à la suivante
  199. digitalWrite(ligne+7, LOW);
  200. PORTD = 0b11111111; // On met les colonnes à l'état HIGH
  201. } // fin de boucle for
  202. } // fin du while
  203. } // fin de la fonction affiche
  204.  
  205. void loop() {
  206. // On appelle la fonction affiche avec les motifs et pour la durée d'affichage
  207. for(int i=1; i<=3; i++){
  208. // Remplissage depuis le centre vers l'extérieur
  209. affiche(centre1, dureeCentre);
  210. affiche(centre2, dureeCentre);
  211. affiche(centre3, dureeCentre);
  212. affiche(centre4, 200);
  213. affiche(centre3, dureeCentre);
  214. affiche(centre2, dureeCentre);
  215. affiche(centre1, dureeCentre);
  216. } // fin de boucle for
  217. affiche(centre1, dureeCentre);
  218. affiche(centre2, dureeCentre);
  219. affiche(centre3, dureeCentre);
  220. affiche(centre4, 1000);
  221. for(int i=1; i<=3; i++){
  222. // Barre horizontale et verticale oscillantes
  223. affiche(barres01, dureeBarres);
  224. affiche(barres02, dureeBarres);
  225. affiche(barres03, dureeBarres);
  226. affiche(barres02, dureeBarres);
  227. } // fin de boucle for
  228. delay(500);
  229. for(int i=1; i<=3; i++){
  230. // Tracé des bords de la croix
  231. affiche(bord1, dureeBord);
  232. affiche(bord2, dureeBord);
  233. affiche(bord3, dureeBord);
  234. affiche(bord4, dureeBord);
  235. affiche(bord5, dureeBord);
  236. affiche(bord6, 500);
  237. } // fin de boucle for
  238. affiche(bord6, 2000);
  239. delay(500);
  240. // Remplissage par carrés
  241. affiche(carre01, dureeCarre);
  242. affiche(carre02, dureeCarre);
  243. affiche(carre03, dureeCarre);
  244. affiche(carre04, dureeCarre);
  245. affiche(carre05, dureeCarre);
  246. affiche(carre06, dureeCarre);
  247. affiche(carre07, dureeCarre);
  248. affiche(carre08, dureeCarre);
  249. affiche(carre09, dureeCarre);
  250. affiche(carre10, dureeCarre);
  251. affiche(carre11, dureeCarre);
  252. affiche(carre12, dureeCarre);
  253. affiche(carre13, dureeCarre);
  254. affiche(carre14, dureeCarre);
  255. affiche(carre15, dureeCarre);
  256. affiche(carre16, dureeCarre);
  257. affiche(carre17, dureeCarre);
  258. affiche(carre18, dureeCarre);
  259. affiche(carre19, dureeCarre);
  260. affiche(carre20, dureeCarre);
  261. affiche(carre21, dureeCarre);
  262. affiche(carre22, dureeCarre);
  263. affiche(carre23, dureeCarre);
  264. affiche(carre24, dureeCarre);
  265. affiche(carre25, dureeCarre);
  266. affiche(carre26, dureeCarre);
  267. affiche(carre27, dureeCarre);
  268. affiche(carre28, dureeCarre);
  269. affiche(carre29, dureeCarre);
  270. affiche(carre30, dureeCarre);
  271. affiche(carre31, dureeCarre);
  272. affiche(carre32, dureeCarre);
  273. affiche(carre33, 2000);
  274. delay(500);
  275. for(int i=1; i<=3; i++){
  276. // Clignotement des bords de la croix
  277. affiche(bord6, 500);
  278. delay(500);
  279. } // Fin de boucle for
  280. affiche(bord6, 2000);
  281. delay(500);
  282. // Remplissage depuis le centre en spirale
  283. affiche(spiral01, dureeSpiral);
  284. affiche(spiral02, dureeSpiral);
  285. affiche(spiral03, dureeSpiral);
  286. affiche(spiral04, dureeSpiral);
  287. affiche(spiral05, dureeSpiral);
  288. affiche(spiral06, dureeSpiral);
  289. affiche(spiral07, dureeSpiral);
  290. affiche(spiral08, dureeSpiral);
  291. affiche(spiral09, dureeSpiral);
  292. affiche(spiral10, dureeSpiral);
  293. affiche(spiral11, dureeSpiral);
  294. affiche(spiral12, dureeSpiral);
  295. affiche(spiral13, dureeSpiral);
  296. affiche(spiral14, dureeSpiral);
  297. affiche(spiral15, dureeSpiral);
  298. affiche(spiral16, dureeSpiral);
  299. affiche(spiral17, dureeSpiral);
  300. affiche(spiral18, dureeSpiral);
  301. affiche(spiral19, dureeSpiral);
  302. affiche(spiral20, dureeSpiral);
  303. affiche(spiral21, dureeSpiral);
  304. affiche(spiral22, dureeSpiral);
  305. affiche(spiral23, dureeSpiral);
  306. affiche(spiral24, dureeSpiral);
  307. affiche(spiral25, dureeSpiral);
  308. affiche(spiral26, dureeSpiral);
  309. affiche(spiral27, dureeSpiral);
  310. affiche(spiral28, dureeSpiral);
  311. affiche(spiral29, dureeSpiral);
  312. affiche(spiral30, dureeSpiral);
  313. affiche(spiral31, dureeSpiral);
  314. affiche(spiral32, dureeSpiral);
  315. affiche(spiral33, 2000);
  316. delay(500);
  317. // Remplissage par branches verticale puis horizontale
  318. affiche(branche01, dureeBranche);
  319. affiche(branche02, dureeBranche);
  320. affiche(branche03, dureeBranche);
  321. affiche(branche04, dureeBranche);
  322. affiche(branche05, dureeBranche);
  323. affiche(branche06, dureeBranche);
  324. affiche(branche07, dureeBranche);
  325. affiche(branche08, dureeBranche);
  326. affiche(branche09, dureeBranche);
  327. affiche(branche10, dureeBranche);
  328. affiche(branche11, 2000);
  329. delay(500);
  330. // Clignotement bord-centre
  331. for(int i=1; i<=10; i++){
  332. affiche(bord, dureeCligno);
  333. affiche(centre, dureeCligno);
  334. } // Fin de boucle i
  335. affiche(bord, 2000);
  336. delay(500);
  337. // Remplissage en diagonale
  338. affiche(diago01, dureeDiago);
  339. affiche(diago02, dureeDiago);
  340. affiche(diago03, dureeDiago);
  341. affiche(diago04, dureeDiago);
  342. affiche(diago05, dureeDiago);
  343. affiche(diago06, dureeDiago);
  344. affiche(diago07, dureeDiago);
  345. affiche(diago08, dureeDiago);
  346. affiche(diago09, dureeDiago);
  347. affiche(diago10, dureeDiago);
  348. affiche(diago11, dureeDiago);
  349. affiche(diago12, dureeDiago);
  350. affiche(diago13, dureeDiago);
  351. affiche(diago14, dureeDiago);
  352. affiche(diago15, dureeDiago);
  353. affiche(diago16, dureeDiago);
  354. affiche(diago17, dureeDiago);
  355. affiche(diago18, dureeDiago);
  356. affiche(diago19, dureeDiago);
  357. affiche(diago20, dureeDiago);
  358. affiche(diago21, dureeDiago);
  359. affiche(diago22, dureeDiago);
  360. affiche(diago23, dureeDiago);
  361. affiche(diago24, dureeDiago);
  362. affiche(diago25, dureeDiago);
  363. affiche(diago26, dureeDiago);
  364. affiche(diago27, dureeDiago);
  365. affiche(diago28, dureeDiago);
  366. affiche(diago29, dureeDiago);
  367. affiche(diago30, dureeDiago);
  368. affiche(diago31, dureeDiago);
  369. affiche(diago32, dureeDiago);
  370. affiche(diago33, dureeDiago);
  371. affiche(diago34, dureeDiago);
  372. affiche(diago35, 2000);
  373. delay(500);
  374. } // fin de loop

Pour le télécharger, c’est ici :

Le programme version 9

Intégration de la croix dans le bâtiment

En général, les croix de pharmacie sont posées perpendiculairement à la façade du bâtiment mais il arrive parfois qu’elles soient simplement posées sur le mur. C’est ce que nous allons faire pour cette croix qui est illuminée de toute façon sur une seule face. Commencez par ouvrir le mur de la pharmacie par une ouverture en forme de croix dont les dimensions, qui dépendent de la matrice que vous avez choisie, suivent le contour rouge de la figure 1. Collez votre matrice de LED derrière le mur et un entourage de la croix sur le côté extérieur du mur. Peignez cet entourage en vert foncé. Pour ne pas voir les LED lorsqu’elles sont éteintes, collez sur cet entourage une feuille de plastique dépoli comme un papier calque (mais ne pas utiliser de papier calque trop sensible à l’hygrométrie de l’air).

Reliez ensuite les broches de la matrice de LED à votre Arduino en utilisant des câbles de liaison pour le prototypage (mâle-mâle et mâle-femelle) ou mieux des nappes de câbles multi-couleurs et des résistances de 1 kΩ (quelques soudures sont nécessaires). Si vous voulez décorer l’intérieur de la pharmacie, cachez la carte Arduino dans le toit du bâtiment et arrangez-vous pour cacher le fil d’alimentation en le faisant descendre le long d’un angle pour qu’il ne se remarque pas. Arrangez-vous tout de même pour laisser accessible la prise jack (si vous alimentez la carte Arduino par ce moyen) et la prise USB (ce qui permet de modifier le programme où d’alimenter la carte Arduino). La figure 9 montre l’ensemble du montage intégré dans le bâtiment : remarquez les rideaux en papier de soie ou papier calque qui masque cette électronique lorsqu’on regarde le bâtiment de l’extérieur.

Figure 9
Figure 9
Intégration de l’électronique dans le bâtiment

Amélioration de ce montage

Si vous estimez que la luminosité des LED est insuffisante, vous pouvez amplifier le courant sur les lignes de la matrice avec des transistors qui amplifieront les signaux des sorties d’Arduino (8 à 13 plus A0). Ceci vous permet alors de changer les résistances de 1 kΩ par des résistances plus faibles calculées en fonction du courant que vous voulez faire passer.

Enfin, si vous utilisez une matrice de LED bicolores (cas de la matrice 1588ASRG), vous pouvez commander chaque LED soit en vert, soit en rouge, voire même les deux couleurs en même temps ce qui vous donnera du jaune. L’animation lumineuse n’en sera évidemment que plus belle (en trois couleurs) mais nécessitera un nombre plus important de broches de commande et il devient alors nécessaire d’utiliser une carte MEGA à la place de la carte UNO. En effet, il faut 21 sorties pour commander toutes les LED bicolores d’une matrice de 7 x 7, 14 si on se limite uniquement aux LED vertes, et 17 si on rajoute la couleur rouge pour le cœur de la croix uniquement (3 x 3 LED). Les deux dernières options tiennent sur une carte Arduino UNO qui dispose de 20 E/S numériques mais une carte Arduino MEGA est indispensable pour commander la totalité des 64 LED bicolores.

Faites jouer votre imagination et votre sens artistique

À vous de modifier le programme donné en exemple afin de personnaliser votre croix de pharmacie. Les plus belles animations sont celles qui font appel à un nombre élevé d’images. Cela peut paraître fastidieux de coder ces différentes images en matrices binaires, mais en prenant votre temps et en vérifiant bien ce que vous faites, vous finirez par y arriver. Votre sens artistique vous permettra de dynamiser le rythme des séquences et de les enchaîner les unes aux autres pour obtenir un résultat qui vous plaît. Quelle satisfaction ensuite quand l’animation se déroule sur votre croix de pharmacie et quelle fierté de posséder une croix qui est unique. C’est un des avantages du DIY (Do It Yourself ou faites-le vous-même) qui permet de créer ce qui n’existe pas dans le commerce.

[1Les broches dites analogiques sont également des E/S numériques (sauf A6 et A7 sur une carte Nano) portant les numéros 14 (A0) à 19 (A5)