ModelleisenbahN

Accueil > La technologie > Arduino > Manœuvre des aiguilles avec des servo-moteurs > Témoins de positions : le Charlieplexing

Manœuvre des aiguilles en analogique avec des servo-moteurs

Témoins de positions : le Charlieplexing

publié par Jean-Luc, le lundi 2 décembre 2013

Tags arduino - led

La dernière fonction à mettre en œuvre est la gestion des témoins de position. 16 LED sont nécessaires et il nous reste 6 broches. La broche numérique 13 ayant déjà une LED soudée sur la carte de l’Arduino n’est pas très commode à utiliser. Il nous reste donc en réalité 5 broches.

Comment faire ?

Il existe une technique connue sous le nom de Charliplexing [1] qui permet de multiplexer des LED sur des entrées/sorties numériques. Examinons tout d’abord le cas de deux LED connectées à 2 broches avec 2 résistances de 150Ω.

PNG - 10.3 ko
Charlieplexing avec 2 broches
dont l’intérêt est plus que discutable.

Si la broche 0 est en sortie à 5V et la broche 1 en sortie à 0V, la LED rouge est allumée. Si la broche 0 est en sortie à 0V et la broche 1 en sortie à 5V, la LED verte est allumée. Toute autre configuration, une des broches ou les deux en entrée ou les deux en sortie au même potentiel, éteint les deux LED.

Ça ne nous avance pas beaucoup me direz vous.

Rajoutons donc une broche 2 et une résistance et ajoutons une paire de LED entre la broche 2 et la broche 1 mais aussi entre la broche 2 et la broche 0, soit 6 LED au total.

PNG - 27.2 ko
Charlieplexing avec 3 broches

Pour allumer la LED D5 par exemple, il faut mettre la broche 0 en sortie à 5V, la broche 2 en sortie à 0V et pour que ni D1, ni D3 ne s’allument, mettre la broche 1 en entrée (donc en haute impédance). On peut remarquer que D1 et D3 sont également alimentées mais comme elle sont en série, elles présentent une tension de seuil 2 fois supérieure [2] et le courant empruntera le chemin de plus faible tension de seuil.

Pour la suite on va noter le fait de mettre une sortie à 5V : 1, à 0V, 0 et en entrée : Z.

La table correspondant à l’allumage de chaque LED est la suivante.

  broche 0 broche 1 broche 2
D0 0 1 Z
D1 1 0 Z
D2 Z 0 1
D3 Z 1 0
D4 0 Z 1
D5 1 Z 0

De manière générale, avec N broches, on peut piloter N × N-1 LED. Avec nos 5 broches disponible, on pourra donc piloter 5 × 4 = 20 LED.

Programme de démonstration

Évidemment, seule une LED peut être allumée à un instant. C’est donc l’Arduino qui va s’occuper de balayer les LED et, pour chacune les allumer ou non à une vitesse suffisamment grande pour que l’œil ait l’impression que l’allumage de chaque LED est permanent grâce à la persistance rétinienne. Avant de nous lancer dans l’allumage de 16 LED, voyons comment fonctionne le programme pour 3 broches et 6 LED. Dans un premier temps, nous allons balayer et allumer les 6 LED pour juger de l’effet rendu.

Il faut tout d’abord transposer le table d’états en C dont les lignes correspondront aux LED et les colonnes aux sortie. Les états eux même sont définis par un enum, une manière de donner un nom symbolique à une constante numérique :

  1. enum { OUT0, OUT1, INZ };
  2.  
  3. const byte etatSortiePourLED[6][3] = {
  4. { OUT0, OUT1, INZ }, /* D0 */
  5. { OUT1, OUT0, INZ }, /* D1 */
  6. { INZ, OUT0, OUT1 }, /* D2 */
  7. { INZ, OUT1, OUT0 }, /* D3 */
  8. { OUT0, INZ, OUT1 }, /* D4 */
  9. { OUT1, INZ, OUT0 } /* D5 */
  10. };

Télécharger

OUT0 signifie que le broche est en sortie et à 0, OUT1 qu’elle est en sortie et à 1 et INZ en entrée et à haute impédance, c’est à dire sans résistance de pull-up.

Ajoutons une fonction pour programmer une broche en fonction de ce code :

  1. void programmeBroche(int numBroche, byte etat)
  2. {
  3. switch (etat) {
  4. case OUT0:
  5. digitalWrite(numBroche,LOW);
  6. pinMode(numBroche,OUTPUT);
  7. break;
  8. case OUT1:
  9. digitalWrite(numBroche,HIGH);
  10. pinMode(numBroche,OUTPUT);
  11. break;
  12. case INZ:
  13. pinMode(numBroche,INPUT);
  14. digitalWrite(numBroche,LOW); /* pas de pullup */
  15. break;
  16. }
  17. }

Télécharger

Pour que l’on puisse tour à tour allumer une LED ou non, il nous faut un tableau qui, pour chaque LED, va indiquer son état, ALLUME ou ETEINT. De nouveau nous allons utiliser un enum.

  1. enum { ALLUME, ETEINT };
  2.  
  3. byte etatLED[6] = {
  4. ETEINT, ETEINT, ETEINT, ETEINT, ETEINT, ETEINT
  5. };

Télécharger

Enfin, il nous faut une fonction qui, pour un numéro de LED, va chercher son état et, si elle elle allumée, appelle, pour chaque broche, programmeBroche avec les états de broche correspondant à l’allumage de cet LED. Si elle est éteinte, toutes les sorties sont mises dans l’état INZ.

  1. void gereLED(int num)
  2. {
  3. if (etatLED[num] == ALLUME) {
  4. programmeBroche(10,etatSortiePourLED[num][0]);
  5. programmeBroche(11,etatSortiePourLED[num][1]);
  6. programmeBroche(12,etatSortiePourLED[num][2]);
  7. }
  8. else {
  9. programmeBroche(10,INZ);
  10. programmeBroche(11,INZ);
  11. programmeBroche(12,INZ);
  12. }
  13. }

Télécharger

Il suffit ensuite dans loop() de balayer les LED, de 0 à 5, en donnant leur état avec une période de 2ms.

  1. int numLED = 0;
  2.  
  3. void loop()
  4. {
  5. gereLED(numLed);
  6.  
  7. numLED++;
  8. if (numLED > 5)
  9. numLED = 0;
  10.  
  11. delay(2);
  12. }

Télécharger

Par dessus on superpose une séquence d’allumage comme, par exemple, un chenillard.

  1. int numLED = 0;
  2.  
  3. int LEDAllumee = 0;
  4. int compteur1s = 0;
  5.  
  6. void setup()
  7. {
  8. /* Au début la LED 0 est allumée */
  9. etatLED[LEDAllumee] = ALLUME;
  10. }
  11.  
  12. void loop()
  13. {
  14. compteur1s++;
  15. if (compteur1s == 500) {
  16. /* Au bout de 1s, on allume la LED suivante */
  17. compteur1s = 0;
  18. /* Éteint la LED qui était allumée */
  19. etatLED[LEDAllumee] = ETEINT;
  20. /* Passe à la LED suivante */
  21. LEDAllumee++;
  22. if (LEDAllumee > 5)
  23. LEDAllumee = 0;
  24. /* Allume la nouvelle LED */
  25. etatLED[LEDAllumee] = ALLUME;
  26. }
  27.  
  28. gereLED(numLed);
  29.  
  30. numLED++;
  31. if (numLED > 5)
  32. numLED = 0;
  33.  
  34. delay(2);
  35. }

Télécharger

Voici le programme de chenillard en Charlieplexing sur 3 broches et 6 LED.

Zip - 969 octets
Sketch du chenillard en Charlieplexing
(clic sur l'image pour agrandir ou télécharger)

Ainsi que la vidéo de démonstration

Démonstration du sketch de chenillard

Notes

[1Le Charlieplexing est une technique proposée en 1995 par Charlie Allen, voir l’article sur Wikipedia

[2La tension de seuil dépend de la couleur de la LED mais même en mettant en série 2 LED rouge dont la tension de seuil est la plus faible, 1,6V, 2 × 1,6V = 3,2 V reste supérieure à la tension de seuil des LED violettes, 3,1V

Répondre à cet article

Les thèmes

Archives

Informations

ModelleisenbahN | publié sous licence Creative Commons by-nc-nd 2.0 fr | généré dynamiquement par SPIP & Blog'n Glop