Forums LR PRESSE

Où il est question de trains, petits et grands

  • Advertisement

Feux tricolores de carrefour : montage multiprocesseurs

Toutes les discussions sur l'Arduino !

Modérateur: MOD

Feux tricolores de carrefour : montage multiprocesseurs

Publié: Sam 15 Oct 2016, 15:13 
La série d’articles publiés sur ce forum et se terminant par « … pour moins de cinq euros » vous a appris à programmer des microcontrôleurs ATtiny45. Si vous ne l’avez pas déjà fait, je vous invite à lire cette série d’articles jusqu’à ce que la programmation des ATtiny avec un module Arduino Uno, procédure extrêmement simple par ailleurs, vous soit acquise. En effet, dans cet article, nous allons étudier un montage électronique à base de deux µC ATtiny45, c’est-à-dire un montage multiprocesseurs.

Principe du montage multiprocesseurs

Un carrefour routier présente quatre feux tricolores pour gérer la circulation des deux routes qui se croisent. En fait, pour une même route, les deux feux sont branchés en parallèle et commandés en même temps. Il n’y a donc au total que deux feux tricolores à commander (un pour chaque route) soit 6 ampoules (deux vertes, deux oranges et deux rouges).

Le µC ATtiny45 étant doté de six sorties, un seul microcontrôleur pourrait suffire pour gérer les feux d’un carrefour, mais il faudrait alors le programmer avec un programmateur industriel. Si on veut pouvoir utiliser les moyens du bord, c’est-à-dire un simple module Arduino Uno comme cela était suggéré dans les articles déjà cités, le µC ATtiny45 n’offre plus que cinq sorties puisque la sixième est utilisée pour le reseter, procédure nécessaire à sa programmation avec le module Uno.

L’idée est d’utiliser deux microcontrôleurs ATtiny45 (un par feu) et de réaliser une synchronisation entre eux pour que chaque feu fasse sa séquence quand il doit la faire. Cela ressemble donc à une forme de communication entre deux microcontrôleurs comme vous allez le voir.

Principe de fonctionnement

Un des feux doit commencer sa séquence le premier ; comme ils sont alimentés en même temps sur le montage, il est nécessaire que le deuxième feu soit retardé par rapport au premier. Chaque microcontrôleur reçoit le même programme, à une petite différence près, le délai de synchronisation qui est de 1 seconde pour le feu A et de 3 secondes pour le feu B. En conséquence, le feu B devrait commencer son cycle deux secondes après le feu A. Mais entre-temps, le feu A a pris la main et empêche le feu B de commencer son cycle. Lorsque le feu A a terminé son cycle, il autorise le feu B à faire le sien. Celui-ci empêche alors le feu A de continuer son cycle.

Un cycle est constitué uniquement des séquences feu au vert (10 s) et feu à l’orange (3 s) car dès que le feu passe au rouge, il autorise l’autre feu à travailler et maintiendra son feu au rouge puisqu’il sera empêché par l’autre feu de continuer son travail. La temporisation du chauffard (2 s) fait que les deux feux sont au rouge pendant ce court délai, ce qui permet au chauffard qui a accéléré à l’orange et passé au rouge de dégager le carrefour avant d’autoriser les automobilistes de l’autre route à redémarrer.

Les DEL sont sur les sorties 0, 1 et 2. Les E/S 3 et 4 sont utilisées pour « communiquer ». En effet, lorsqu’un microcontrôleur prend la main sur l’autre, il positionne la sortie 4 à HIGH (5 V). Cette sortie est reliée à une entrée 3 de l’autre microcontrôleur qui sait que s’il y a 5 V sur cette entrée, il ne doit rien faire. Comme vous le constatez, chaque microcontrôleur utilise 5 E/S (numérotées de 0 à 4) et la sixième est conserver pour le reset du µC.

Cycle de fonctionnement

Le setup se termine par les deux feux au rouge puis l’attente de synchronisation (1 s pour feu A et 3 s pour feu B). Le feu A commence avant le feu B.

Pour chaque feu, le cycle réalise cela :
- Vérifie qu’il peut travailler, ou attend que l’autre feu ait terminé (état de l’entrée 3)
- Prend la main pour bloquer l’autre feu
- Attend la temporisation du chauffard
- Eteint le rouge et allume le vert
- Attend délai du vert (10 s)
- Eteint le vert et allume l’orange
- Attend le délai de l’orange (3 s)
- Eteint l’orange et allume le rouge
- Passe la main à l’autre feu en mettant sa sortie 4 à LOW (qui est l’entrée 3 de l’autre feu)

Le feu B qui commence en retard, sera empêché de travailler par le feu A jusqu’à ce que celui-ci lui passe la main.

Programme

Code: Tout sélectionner
/*
Ce programme fait fonctionner un feu tricolore A qui est
synchronise avec un feu tricolore B, chaque feu etant
commande par un µC ATtiny45.
Trois LED (verte, orange et rouge) sont reliées aux sorties 0 à 2.
L entree 3 recoit le signal d inhibition de la part de l autre feu.
La sortie 4 envoit le signal d inhibition vers l autre feu.
Trois LED (verte, orange et rouge) sont reliées aux sorties 0 à 2.
*/

// Initialisation des variables

const byte vert = 0 ;
const byte orange = 1 ;
const byte rouge = 2 ;
const byte line_IN = 3 ;
const byte line_OUT = 4 ;
const int attente_synchro = 1000 ; // 3000 pour deuxième feu B
const int attente_vert = 10000 ;
const int attente_orange = 3000 ;
const int attente_chauffard = 2000 ;

// Initialisation des lignes 0 a 4
void setup () {
  pinMode (vert, OUTPUT) ;
  pinMode (orange, OUTPUT) ;
  pinMode (rouge, OUTPUT) ;
  pinMode (line_IN, INPUT) ;
  pinMode (line_OUT, OUTPUT) ;
  // Extinction de toutes les LED au depart sauf rouge
  digitalWrite (vert, LOW) ;
  digitalWrite (orange, LOW) ;
  digitalWrite (rouge, HIGH) ;
  // decalage des sequences de chaque feu
  delay (attente_synchro) ;
}

// Fonction loop
void loop () {
   
  // Attente fin du cycle de l autre feu
  while (digitalRead (line_IN) == HIGH) {
    // Ne rien faire
  }
  // Cycle du feu tricolore

  // Ce feu prend la main
  digitalWrite (line_OUT, HIGH) ;

  // Debut de cycle
  delay (attente_chauffard) ;
  digitalWrite (rouge, LOW) ;
  digitalWrite (vert, HIGH) ;
  delay (attente_vert) ;
  digitalWrite (vert, LOW) ;
  digitalWrite (orange, HIGH) ;
  delay (attente_orange) ;
  digitalWrite (orange, LOW) ;
  digitalWrite(rouge, HIGH) ;

  // Ce feu rend la main
  digitalWrite (line_OUT, LOW);
  delay (500) ;

  // L autre feu peut travailler, line_IN sera a HIGH, ce feu va attendre
 
}



Vous pouvez régler les différents temps d’allumage pour chaque couleur de feu. Comme chaque feu a son propre programme, il est également possible de régler des temps d’allumage du vert différents entre le feu A et le feu B, cas particulier d’une route secondaire croisant une route principale à fort trafic. Avec l’électronique programmable, tout se fait très simplement.

Programmation des µC ATtiny45

Il n’y a rien de compliqué si vous suivez à la lettre la procédure de programmation décrite dans la série d’articles citée plus haut. Vous n’aurez besoin que d’une plaque d’essai, d’un module Uno relié à votre ordinateur par un câble USB et de quatre fils de liaison pour réaliser un petit programmateur de fortune avec votre module Uno.

Le premier µC sera programmé avec un délai attente_synchro de une seconde (soit 1000 ms) et le deuxième avec un délai de 3 secondes (soit 3000 ms). Cette différence de programmation sera repérée sur les µC avec une étiquette autocollante ou bien une touche de peinture ; l’interversion des deux µC n’empêchera pas le montage de fonctionner mais par contre, il est indispensable que les deux µC soient programmés avec des valeurs différentes.

Montage sur une plaque d’essai

La figure ci-dessous montre le montage sur une plaque d’essai. Comme on le voit, la sortie 4 d’un ATtiny45 est reliée à l’entrée 3 de l’autre et réciproquement. L’alimentation de 5 V peut être prise sur le module Uno pour un montage temporaire.

Image

Pour chaque feu, une seule DEL est allumée en même temps ; le montage est prévu pour un feu tricolore ayant ses DEL à cathodes communes. En modifiant un peu le montage et le programme, on peut bien sûr commander des feux à anodes communes.

La vidéo de ce montage est accessible en cliquant ICI.

Montage définitif sur circuit imprimé

Le plus simple est d’utiliser les plaques à bandes cuivrées en vous inspirant du schéma donné pour une plaque d’essai. Penser à souder des supports de CI pour recevoir les deux µC. Remplacer les LED par des borniers qui vous serviront à brancher vos LED (mettez les LED en série pour chaque couleur de manière à recréer deux feux pour chaque route). Vous pouvez ajuster la luminosité des LED selon vos goûts en jouant sur la valeur des résistances. Alimentez votre montage avec une petite alimentation de 5 V.

Au final, voici un petit montage électronique simple à réaliser et qui ne vous aura coûté que quelques euros.
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1617
Inscrit le: Mer 25 Sep 2013, 17:14

Retour vers Arduino

Qui est en ligne ?

Utilisateur(s) parcourant actuellement ce forum : Aucun utilisateur inscrit et 5 invité(s)