LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

mercredi 26 juillet 2017

28 visiteurs en ce moment

Le microcontrôleur ATtiny45 (6)

Un feu tricolore de circulation alternée

. Par : Christian Bézanger

Certaines applications pour un réseau de trains miniatures ne requièrent pas toute la puissance d’un module Arduino/Genuino Uno et on peut trouver dommage de monopoliser un tel module pour si peu. La solution est de les confier à un microcontrôleur moins puissant, donc moins coûteux. Cette série d’articles vous présente le microcontrôleur ATtiny45 du constructeur Atmel et ses possibilités dans le domaine du modélisme ferroviaire.
Nous avons déjà décrit la réalisation d’un feu tricolore de carrefour routier dans le quatrième volet de cette série d’articles. Le montage faisait appel à deux microcontrôleurs travaillant ensemble pour gérer les six sorties nécessaires à deux feux tricolores. Aujourd’hui, nous vous proposons de réaliser la même chose avec un seul microcontrôleur. Comment est-ce possible puisqu’il faut 6 sorties et qu’un seul microcontrôleur n’en dispose que de 5 ? Evidemment, il y a un truc…

Un feu tricolore de carrefour routier avec 5 sorties seulement

Avant toute chose, je vous invite à prendre connaissance de l’article Feux tricolores qui vous explique les grands principes d’un feu tricolore, ainsi que l’article Le microcontrôleur ATtiny45 (4) qui donne un montage à base d’ATtiny45. Comme il y a deux feux tricolores sur un carrefour (ou plutôt deux fois deux feux identiques pour chaque route), un montage nécessite six sorties pour gérer les différents feux. C’est la raison pour laquelle nous avions fait appel à deux microcontrôleurs ATtiny45, chacun gérant son propre feu, et les deux travaillant ensemble mais l’un après l’autre. L’avantage d’un tel montage est qu’il accepte les feux routiers qu’on trouve dans le commerce qui, comme les signaux à trois feux SNCF, sont montés à anodes communes ou bien à cathodes communes. L’article Signaux lumineux et Arduino rappelle comment raccorder des feux ou signaux du commerce d’un certain type sur un montage électronique prévu pour l’autre type.

Ceux qui fabriquent eux-mêmes leurs feux ou signaux sont avantagés car ils peuvent monter les DEL   comme ils le veulent ou plutôt comme l’exige le programme du microcontrôleur, que ce soit celui d’une carte Arduino ou un ATtiny. Le dernier paragraphe de l’article Signaux lumineux et Arduino montre qu’il est possible de n’utiliser qu’une seule sortie pour commander deux DEL  , à conditions que les DEL n’aient jamais à être allumées en même temps.

C’est en s’appuyant sur ce principe de commande qu’on peut économiser une sortie et faire tenir deux feux tricolores sur un seul ATtiny. En effet, pour un même feu tricolore, l’orange et le rouge ne sont jamais allumés ensemble ; on peut donc penser les commander avec une seule sortie, selon le montage de la figure 6 de l’article Signaux lumineux et Arduino. Ainsi, pour gérer deux feux tricolores, il faut deux sorties pour gérer les feux verts, et deux autres sorties pour gérer les feux oranges-rouges, soit quatre sorties au total. Le problème est qu’une sortie qui gère le feu orange ou le feu rouge allume une des deux couleurs, mais ne permet pas de les éteindre toutes les deux, ce qui doit être le cas lorsque le feu tricolore est vert. Il faudrait presque un interrupteur sur la ligne d’alimentation en 5 V pour éteindre la DEL alimentée par cette tension !

Cet interrupteur, nous l’avons puisqu’il nous reste sur notre ATtiny45 une sortie numérique que nous pouvons commander pour qu’elle fournisse du 5 V ou du 0 V. La figure 1 montre le montage de DEL à réaliser pour câbler nos deux feux ; les sorties 0 et 1 commandent les feux verts, la sortie 2 commande la ligne d’alimentation en 5 V (représentée en orange), les sorties 3 et 4 gèrent les feux orange ou rouge.

Figure 1


Le feu vert s’allume en mettant la sortie 0 (ou 1) à l’état HIGH.

Le feu rouge s’allume en mettant la sortie 3 (ou 4) à l’état HIGH.

Le feu orange s’allume en mettant la sortie 2 à l’état HIGH ET la sortie 3 à l’état LOW (ou la sortie 2 à l’état HIGH ET la sortie 4 à l’état LOW). Les feux oranges s’éteignent en mettant la sortie 2 à l’état LOW ; en effet, si la sortie 3 (ou 4) est à LOW, il n’y a pas de différence de potentiel aux bornes de la DEL qui reste éteinte et si la sortie 3 (ou 4) est à HIGH, la DEL est polarisée en inverse et reste éteinte puisque le courant ne passe pas.

Ceci est résumé par le tableau suivant :

Tableau 1


Bien entendu, avant d’allumer une couleur de feu, il faut penser à éteindre les autres couleurs !

Sur la figure 1, intervertir les DEL oranges avec les rouges conduit à une mauvaise solution. En effet, les feux oranges des deux feux tricolores de chaque route, ne sont jamais allumés en même temps. Par contre, les feux rouges peuvent être allumés en même temps ; c’est ce que nous avons appelé la temporisation du chauffard. Dans les conditions de la figure 1, deux sorties au lieu d’une seule alimentent les deux DEL rouges, tandis que la sortie 2 n’alimente qu’une seule DEL orange. Ceci permet de s’éloigner de la limitation en courant pour une sortie numérique (20 mA conseillé pour 40 mA maximum). Chaque sortie n’allume qu’une seule DEL à la fois, ce qui permet de faire circuler un courant de 20 mA pour chaque DEL si on le souhaite. Pour notre part, nous avons fait le calcul des résistances pour un courant de 10 mA à peu près (ce qui est bien suffisant), ce qui donne une résistance de limitation de 330 Ω. La figure 2 montre le montage sur une platine d’essai.

Figure 2


Programme de feux tricolores de carrefour routier

Le programme gérant les feux n’est pas compliqué à comprendre puisque c’est un simple séquenceur, ce qui signifie que les actions d’allumage des différentes couleurs sont réalisées les unes à la suite des autres. Le tableau suivant donne les différentes phases d’allumage :

Tableau 2


Deux variables sont intéressantes : la durée du feu vert (ici, elles sont identiques (10 secondes) pour les deux routes, mais elles pourraient être différentes si on a une route à fort trafic et une route secondaire), et la durée du feu orange (en général, identique pour les deux routes (3 secondes)). Enfin, il faut aussi fixer la durée de la temporisation du chauffard (2 secondes). Il va sans dire que vous pouvez choisir d’autres valeurs.

Les sorties de notre ATtiny45 sont numérotées de 1 à 5 (S1 à S5) et correspondent aux sorties numériques 0 à 4.

  1. // Feu_carrefour_5_sorties_ATtiny
  2. //
  3. // Feux de carrefour routier n utilisant que 5 sorties
  4. // Montage special des LED, pas de feux du commerce
  5. //
  6. // Vert feu 1 ==> S1 HIGH
  7. // Orange feu 1 ==> S3 HIGH ET S4 LOW
  8. // Rouge feu 1 ==> S4 HIGH
  9. // Vert feu 2 ==> S2 HIGH
  10. // Orange feu 2 ==> S3 HIGH ET S5 LOW
  11. // Rouge feu 2 ==> S5 HIGH
  12.  
  13. // Declaration de constantes
  14. const byte S1 = 0;
  15. const byte S2 = 1;
  16. const byte S3 = 2;
  17. const byte S4 = 3;
  18. const byte S5 = 4;
  19. const int temps_vert = 10000;
  20. const int temps_orange = 3000;
  21. const int temps_chauffard = 2000;
  22.  
  23. void setup() {
  24. // Initialisation des sorties
  25. pinMode(S1, OUTPUT);
  26. pinMode(S2, OUTPUT);
  27. pinMode(S3, OUTPUT);
  28. pinMode(S4, OUTPUT);
  29. pinMode(S5, OUTPUT);
  30. digitalWrite(S1, LOW);
  31. digitalWrite(S2, LOW);
  32. digitalWrite(S3, LOW);
  33. digitalWrite(S4, LOW);
  34. digitalWrite(S5, LOW);
  35. }
  36.  
  37. void loop() {
  38. // Debut du sequenceur
  39. // Feu 1 vert, feu 2 rouge
  40. digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  41. digitalWrite(S4, LOW); // eteint rouge feu 1
  42. digitalWrite(S1, HIGH); // allume vert feu 1
  43. digitalWrite(S5, HIGH); // allume rouge feu 2
  44. delay(temps_vert);
  45. // Feu 1 orange, feu 2 rouge
  46. digitalWrite(S1, LOW); // eteint vert feu 1
  47. digitalWrite(S4, LOW);
  48. digitalWrite(S3, HIGH); // allume orange feu 1
  49. delay(temps_orange);
  50. // Feu 1 rouge, feu 2 rouge (tempo chauffard)
  51. digitalWrite(S4, HIGH); // eteint orange feu 1, allume rouge feu 1
  52. delay(temps_chauffard);
  53. // Feu 1 rouge, feu 2 vert
  54. digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  55. digitalWrite(S5, LOW); // eteint rouge feu 2
  56. digitalWrite(S2, HIGH); // allume vert feu 2
  57. delay(temps_vert);
  58. // Feu 1 rouge, feu 2 orange
  59. digitalWrite(S2, LOW); // eteint vert feu 2
  60. digitalWrite(S5, LOW);
  61. digitalWrite(S3, HIGH); // allume orange feu 2
  62. delay(temps_orange);
  63. // Feu 1 rouge, feu 2 rouge
  64. digitalWrite(S3, LOW); // eteint orange feu 2
  65. digitalWrite(S5, HIGH); // allume rouge feu 2
  66. delay(temps_chauffard);
  67. // Cycle peut recommencer
  68. }

Télécharger

La procédure de programmation de l’ATtiny est expliquée dans l’article Le microcontrôleur ATtiny45 (2).

Feu tricolore de circulation alternée

L’avantage du montage que nous venons de faire est qu’il tient sur un seul ATtiny45 puisqu’il n’a besoin que de 5 sorties. Son inconvénient est qu’il vous oblige à fabriquer vous-même votre feu tricolore puisque les DEL doivent être montées d’une certaine façon que vous ne trouverez jamais dans le commerce. Puisque vous aurez le montage du feu à faire, je vous propose de fabriquer un objet que vous ne trouverez jamais dans le commerce : un feu tricolore de circulation alternée.

Ces feux se rencontrent lorsque des travaux de voirie obligent à fermer une des deux voies de circulation, laissant l’autre voie pour une circulation alternée qu’il faut gérer. Un feu orange clignotant remplace le feu vert, comme le montre la figure 3. On peut donc partir du montage précédent et remplacer la DEL verte par une orange (on l’appellera vert-orange pour la différencier de la couleur orange qui prévient de l’imminence du feu rouge). Cette DEL devra clignoter, ce qui implique de l’allumer et de l’éteindre à intervalle régulier un certain nombre de fois. Enfin, il faut penser à augmenter la durée où les deux feux sont rouges (temporisation du chauffard) pour laisser le temps aux voitures de libérer l’espace de travaux (dépend de la longueur de la zone de travaux).

Figure 3 - Version actuelle du feu de circulation alternée


Maintenant que nous avons modifié le montage par la couleur de deux DEL, voyons comment modifier le programme. Les DEL vert-orange sont commandées chacune par une sortie numérique ; il est donc facile de les faire clignoter. Il suffit de les allumer, d’attendre un peu, de les éteindre, d’attendre un peu, et ainsi de suite. Pour fixer à 10 s la durée totale de clignotement de ce feu, il suffit de partir d’une période d’une seconde et de la répéter 10 fois, ce qui fait que le feu vert-orange est allumé une demi-seconde, puis éteint une demi-seconde, ceci étant répété dix fois grâce à une simple boucle. On a donc introduit une nouvelle variable fixant le nombre de clignotement (10 dans ce programme) et le temps d’allumage au vert (qui en fait est orange !) est d’une demi-seconde, soit 500 ms. La temporisation du chauffard a été augmentée à 8 secondes, mais encore une fois tous ces nombres ne sont que des exemples.

  1. // Feux_alternes_5_sorties_ATtiny
  2. //
  3. // Feux de carrefour routier n utilisant que 5 sorties
  4. // Montage special des LED, pas de feux du commerce
  5. //
  6. // Vert-orange feu 1 ==> S1 HIGH
  7. // Orange feu 1 ==> S3 HIGH ET S4 LOW
  8. // Rouge feu 1 ==> S4 HIGH
  9. // Vert-orange feu 2 ==> S2 HIGH
  10. // Orange feu 2 ==> S3 HIGH ET S5 LOW
  11. // Rouge feu 2 ==> S5 HIGH
  12.  
  13. // Declaration de constantes
  14. const byte S1 = 0;
  15. const byte S2 = 1;
  16. const byte S3 = 2;
  17. const byte S4 = 3;
  18. const byte S5 = 4;
  19. const int temps_vert = 500;
  20. const int temps_orange = 3000;
  21. const int temps_chauffard = 8000; // temps pour degager la zone de travaux
  22. const byte nbr_clignotement = 10;
  23.  
  24. void setup() {
  25. // Initialisation des sorties
  26. pinMode(S1, OUTPUT);
  27. pinMode(S2, OUTPUT);
  28. pinMode(S3, OUTPUT);
  29. pinMode(S4, OUTPUT);
  30. pinMode(S5, OUTPUT);
  31. digitalWrite(S1, LOW);
  32. digitalWrite(S2, LOW);
  33. digitalWrite(S3, LOW);
  34. digitalWrite(S4, LOW);
  35. digitalWrite(S5, LOW);
  36. }
  37.  
  38. void loop() {
  39. // Debut du sequenceur
  40. // Feu 1 vert-orange, feu 2 rouge
  41. digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  42. digitalWrite(S4, LOW); // eteint rouge feu 1
  43. digitalWrite(S5, HIGH); // allume rouge feu 2
  44. // clignotement feu vert-orange
  45. for(byte i = 1; i <= nbr_clignotement; i++){
  46. digitalWrite(S1, HIGH); // allume vert-orange feu 1
  47. delay(temps_vert);
  48. digitalWrite(S1, LOW); // eteint vert-orange feu 1
  49. delay(temps_vert);
  50. }
  51.  
  52. // Feu 1 orange, feu 2 rouge
  53. digitalWrite(S1, LOW); // eteint vert-orange feu 1
  54. digitalWrite(S4, LOW);
  55. digitalWrite(S3, HIGH); // allume orange feu 1
  56. delay(temps_orange);
  57. // Feu 1 rouge, feu 2 rouge (tempo chauffard)
  58. digitalWrite(S4, HIGH); // eteint orange feu 1, allume rouge feu 1
  59. delay(temps_chauffard);
  60. // Feu 1 rouge, feu 2 vert-orange
  61. digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  62. digitalWrite(S5, LOW); // eteint rouge feu 2
  63. for(byte i = 1; i <= nbr_clignotement; i++){
  64. digitalWrite(S2, HIGH); // allume vert-orange feu 2
  65. delay(temps_vert);
  66. digitalWrite(S2, LOW); // eteint vert-orange feu 2
  67. delay(temps_vert);
  68. }
  69.  
  70. // Feu 1 rouge, feu 2 orange
  71. digitalWrite(S2, LOW); // eteint vert-orange feu 2
  72. digitalWrite(S5, LOW);
  73. digitalWrite(S3, HIGH); // allume orange feu 2
  74. delay(temps_orange);
  75. // Feu 1 rouge, feu 2 rouge
  76. digitalWrite(S3, LOW); // eteint orange feu 2
  77. digitalWrite(S5, HIGH); // allume rouge feu 2
  78. delay(temps_chauffard);
  79. // Cycle peut recommencer
  80. }

Télécharger

La procédure de programmation de l’ATtiny est expliquée dans l’article Le microcontrôleur ATtiny45 (2).

Conclusion

Une fois encore, l’électronique programmable nous a permis de créer un feu tricolore avec quelques composants : un ATtiny45, quelques résistances et quelques DEL. De plus, ce feu tricolore peut avoir deux fonctions : gérer la circulation d’un carrefour ou bien la circulation d’une route en travaux. La vidéo qui suit montre les différences entre les deux cas. Ceux qui possèdent un réseau de trains miniatures en ambiance urbaine sont aujourd’hui comblés.

L’astuce qui consiste à commander deux DEL ne devant pas être allumées en même temps, avec une seule ligne nous permet d’économiser des ressources du microcontrôleur. C’est pourquoi il est essentiel de toujours bien étudier les ressources nécessaires à un montage électronique pour bien choisir le microcontrôleur qui en sera le cerveau. Malgré sa petite taille, notre microcontrôleur ATtiny45 n’a pas fini de nous étonner.

2 Messages

Réagissez à « Le microcontrôleur ATtiny45 (6) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Matériel »

Fonctionnement et pilotage d’une DEL

Qu’est ce qu’une carte Arduino ?

Amplifier le signal de sortie d’un ARDUINO avec un ULN 2803

Résistances, kézako ?

Relais électromagnétique

Les diodes classiques

Détecteurs à ultrasons

La carte Arduino Uno

Bouton poussoir

Les différents types de mouvements d’un servo-moteur

Les encodeurs en quadrature

Les écrans LCD alphanumériques

Des bus de communication pour l’Arduino

Les interrupteurs

Signaux lumineux et Arduino

Les shields de prototypage et de connexion

Commande de moteur à courant continu

Les derniers articles

Le microcontrôleur ATtiny45 (7)


Christian Bézanger

Commande de moteur à courant continu


Christian Bézanger

Le microcontrôleur ATtiny45 (6)


Christian Bézanger

Les shields de prototypage et de connexion


Christian Bézanger

Le microcontrôleur ATtiny45 (5)


Christian Bézanger

Signaux lumineux et Arduino


Christian Bézanger

Le microcontrôleur ATtiny45 (4)


Christian Bézanger

Le microcontrôleur ATtiny45 (3)


Christian Bézanger

Le microcontrôleur ATtiny45 (2)


Christian Bézanger

Le microcontrôleur ATtiny45 (1)


Christian Bézanger

Les articles les plus lus

Les écrans LCD alphanumériques

La carte Arduino Uno

Commande de moteur à courant continu

Les diodes classiques

Qu’est ce qu’une carte Arduino ?

Les encodeurs en quadrature

Amplifier le signal de sortie d’un ARDUINO avec un ULN 2803

Bouton poussoir

Le microcontrôleur ATtiny45 (1)

Les différents types de mouvements d’un servo-moteur