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

Schéma électronique des feux tricolores

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

Montage sur une platine d’essai

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.

// Feu_carrefour_5_sorties_ATtiny
//
// Feux de carrefour routier n utilisant que 5 sorties
// Montage special des LED, pas de feux du commerce
//
// Vert feu 1 ==> S1 HIGH
// Orange feu 1 ==> S3 HIGH ET S4 LOW
// Rouge feu 1 ==> S4 HIGH
// Vert feu 2 ==> S2 HIGH
// Orange feu 2 ==> S3 HIGH ET S5 LOW
// Rouge feu 2 ==> S5 HIGH

// Declaration de constantes
const byte S1 = 0;
const byte S2 = 1;
const byte S3 = 2;
const byte S4 = 3;
const byte S5 = 4;
const int temps_vert = 10000;
const int temps_orange = 3000;
const int temps_chauffard = 2000;

void setup() {
  // Initialisation des sorties
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(S4, OUTPUT);
  pinMode(S5, OUTPUT);
  digitalWrite(S1, LOW);
  digitalWrite(S2, LOW);
  digitalWrite(S3, LOW);
  digitalWrite(S4, LOW);
  digitalWrite(S5, LOW);
}

void loop() {
  // Debut du sequenceur
  // Feu 1 vert, feu 2 rouge
  digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  digitalWrite(S4, LOW); // eteint rouge feu 1
  digitalWrite(S1, HIGH); // allume vert feu 1
  digitalWrite(S5, HIGH); // allume rouge feu 2
  delay(temps_vert);
  // Feu 1 orange, feu 2 rouge
  digitalWrite(S1, LOW); // eteint vert feu 1
  digitalWrite(S4, LOW);
  digitalWrite(S3, HIGH); // allume orange feu 1
  delay(temps_orange);
  // Feu 1 rouge, feu 2 rouge (tempo chauffard)
  digitalWrite(S4, HIGH); // eteint orange feu 1, allume rouge feu 1
  delay(temps_chauffard);
  // Feu 1 rouge, feu 2 vert
  digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  digitalWrite(S5, LOW); // eteint rouge feu 2
  digitalWrite(S2, HIGH); // allume vert feu 2
  delay(temps_vert);
  // Feu 1 rouge, feu 2 orange
  digitalWrite(S2, LOW); // eteint vert feu 2
  digitalWrite(S5, LOW);
  digitalWrite(S3, HIGH); // allume orange feu 2
  delay(temps_orange);
  // Feu 1 rouge, feu 2 rouge
  digitalWrite(S3, LOW); // eteint orange feu 2
  digitalWrite(S5, HIGH); // allume rouge feu 2
  delay(temps_chauffard);
  // Cycle peut recommencer
}

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.

// Feux_alternes_5_sorties_ATtiny
//
// Feux de carrefour routier n utilisant que 5 sorties
// Montage special des LED, pas de feux du commerce
//
// Vert-orange feu 1 ==> S1 HIGH
// Orange feu 1 ==> S3 HIGH ET S4 LOW
// Rouge feu 1 ==> S4 HIGH
// Vert-orange feu 2 ==> S2 HIGH
// Orange feu 2 ==> S3 HIGH ET S5 LOW
// Rouge feu 2 ==> S5 HIGH

// Declaration de constantes
const byte S1 = 0;
const byte S2 = 1;
const byte S3 = 2;
const byte S4 = 3;
const byte S5 = 4;
const int temps_vert = 500;
const int temps_orange = 3000;
const int temps_chauffard = 8000; // temps pour degager la zone de travaux
const byte nbr_clignotement = 10;

void setup() {
  // Initialisation des sorties
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(S4, OUTPUT);
  pinMode(S5, OUTPUT);
  digitalWrite(S1, LOW);
  digitalWrite(S2, LOW);
  digitalWrite(S3, LOW);
  digitalWrite(S4, LOW);
  digitalWrite(S5, LOW);
}

void loop() {
  // Debut du sequenceur
  // Feu 1 vert-orange, feu 2 rouge
  digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  digitalWrite(S4, LOW); // eteint rouge feu 1
  digitalWrite(S5, HIGH); // allume rouge feu 2
  // clignotement feu vert-orange
  for(byte i = 1; i <= nbr_clignotement; i++){
    digitalWrite(S1, HIGH); // allume vert-orange feu 1
    delay(temps_vert);
    digitalWrite(S1, LOW); // eteint vert-orange feu 1
    delay(temps_vert);
  }
  
  // Feu 1 orange, feu 2 rouge
  digitalWrite(S1, LOW); // eteint vert-orange feu 1
  digitalWrite(S4, LOW);
  digitalWrite(S3, HIGH); // allume orange feu 1
  delay(temps_orange);
  // Feu 1 rouge, feu 2 rouge (tempo chauffard)
  digitalWrite(S4, HIGH); // eteint orange feu 1, allume rouge feu 1
  delay(temps_chauffard);
  // Feu 1 rouge, feu 2 vert-orange
  digitalWrite(S3, LOW); // eteint orange feux 1 et 2
  digitalWrite(S5, LOW); // eteint rouge feu 2
  for(byte i = 1; i <= nbr_clignotement; i++){
    digitalWrite(S2, HIGH); // allume vert-orange feu 2
    delay(temps_vert);
    digitalWrite(S2, LOW); // eteint vert-orange feu 2
    delay(temps_vert);
  }
  
  // Feu 1 rouge, feu 2 orange
  digitalWrite(S2, LOW); // eteint vert-orange feu 2
  digitalWrite(S5, LOW);
  digitalWrite(S3, HIGH); // allume orange feu 2
  delay(temps_orange);
  // Feu 1 rouge, feu 2 rouge
  digitalWrite(S3, LOW); // eteint orange feu 2
  digitalWrite(S5, HIGH); // allume rouge feu 2
  delay(temps_chauffard);
  // Cycle peut recommencer
}

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.