LOCODUINO

Le microcontrôleur ATtiny45

Le microcontrôleur ATtiny45 (4)

Un simulateur de soudure à arc et des feux tricolores de carrefour routier

.
Par : Christian

DIFFICULTÉ :

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.

Les deux animations proposées dans cet article ont chacune un point d’intérêt. Le simulateur de soudure à arc fait appel à la fonction random du « langage » d’Arduino, fonction que l’IDE sait tout à fait transformer en code exécutable pour ATtiny45 ; le résultat est une série de flashes émis de façon totalement aléatoire, ce qui ne serait pas possible en électronique câblée. Les feux tricolores de carrefour routier font appel à deux microcontrôleurs ATtiny45 qui communiquent entre eux de façon sommaire pour coordonner leur façon de travailler ; du multiprocesseurs en quelque sorte !

Le principe du simulateur de soudure à arc

Le principe du simulateur de soudure à arc a été décrit dans l’article Simulateur de soudure à arc. La lecture de cet article est donc un prérequis pour continuer, car je ne vais pas recommencer ce que j’ai déjà expliqué par ailleurs. La figure 1 rappelle simplement ce qu’on veut obtenir : chaque bande jaune est un flash émis par la DEL blanche haute intensité, et les termes employés comme cycle, événement, période de repos, sont bien représentés.

Figure 1
Figure 1
Train d’impulsions de flash

Vous pouvez réaliser ce montage en plusieurs exemplaires qui auront des comportements différents en jouant sur les valeurs minimum et maximum des variables ; c’est là qu’il est intéressant d’utiliser un ATtiny45 plutôt qu’un module Arduino/Genuino Uno ! Encore une fois, référez-vous à l’article Simulateur de soudure à arc pour comprendre le rôle de ces valeurs minimum et maximum. Voici une vidéo pour vous montrer l’effet obtenu.

Liste des composants nécessaires pour le chenillard

Un ATtiny45 que vous aurez programmé.
Une DEL blanche haute intensité.
Une résistance de 220 Ω.

Programme pour l’ATtiny45

Le programme pour le module Uno publié dans l’article Simulateur de soudure à arc a été modifié pour l’adapter à un ATtiny45 en choisissant la broche 3 pour brancher la DEL et sa résistance de limitation (au lieu de 13) et la broche analogique 2 pour la fonction randomSeed (au lieu de 2). Téléchargez ce programme puis téléversez-le dans une puce ATtiny en suivant la procédure décrite dans l’article Le microcontrôleur ATtiny45 (2).

/* Ce programme commande une LED blanche pour simuler un poste de soudure à l'arc. 
   Il fait appel à la fonction random qui génère des nombres aléatoires.
   Duree_flash est la durée d'un flash. Duree_int est la durée entre deux flashes.
   Duree_flash et Duree_int forment un événement. 
   Nbre_even est le nombre d'événements au cours d'un cycle de soudure. 
   P_repos est la durée entre deux cycles de soudure.
   Toutes ces données sont aléatoires mais bornées entre une valeur minimum et une 
   valeur maximum. En jouant sur l'intervalle, on peut simuler au mieux l'effet de 
   soudure à l'arc. Broche est la broche sur laquelle la LED est connectée, ici broche 3.
*/
// Initialisation des variables
byte Broche = 3 ;
long Duree_flash ;
long Duree_flash_mini = 10 ;
long Duree_flash_maxi = 101 ;
long Duree_int ;
long Duree_int_mini = 10 ;
long Duree_int_maxi = 31 ;
long Nbre_even ;
long Nbre_even_mini = 10 ;
long Nbre_even_maxi = 21 ;
long P_repos ;
long P_repos_mini = 1500 ;
long P_repos_maxi = 7001 ;
long i ;

// Fonction d'initialisation
void setup ()
{
  randomSeed (analogRead (2)) ;
  pinMode (Broche, OUTPUT) ;
}

// Corps du programme
void loop ()
{
 Nbre_even = random (Nbre_even_mini, Nbre_even_maxi) ;
 for (i = 1 ; i <= Nbre_even ; i++)
   {
     Duree_flash = random (Duree_flash_mini, Duree_flash_maxi) ;
     Duree_int = random (Duree_int_mini, Duree_int_maxi) ;
     digitalWrite (Broche, HIGH) ;
     delay (Duree_flash) ;
     digitalWrite (Broche, LOW) ;
     delay (Duree_int) ;
    }
 P_repos = random (P_repos_mini, P_repos_maxi) ;
 delay (P_repos) ;
}

Montage des composants sur une platine d’essai

La figure 2 montre comment monter les composants sur une platine d’essai.

Figure 2
Figure 2
Montage du simulateur de soudure à arc sur platine d’essai

L’alimentation en 5 V peut se satisfaire d’un bloc de pile délivrant 4,5 V ou bien être fournie par un module Arduino/Genuino Uno en récupérant le 5 V présent sur les connecteurs. Bien entendu, cette dernière solution ne se conçoit que pour essayer le montage ; lorsque celui-ci est à poste sur le réseau, une alimentation autonome est préférable.

Montage sur une plaque cuivrée

Le montage étant destiné à finir dans un bâtiment (garage, atelier, etc.), nous chercherons à le faire le plus petit possible. Découpez une plaque à bandes cuivrées de manière à avoir 6 rangées de 8 trous. La figure 3 montre le montage côté composants à gauche ; les bandes cuivrées sont visibles comme si le support était transparent. Si on regarde la plaque côté cuivre, cela revient à inverser l’image comme avec un miroir (à droite de la figure 3). Coupez les quatre bandes cuivrées entre le troisième et quatrième trou, ce qui est représenté en vert, en utilisant une petite fraise ou bien un foret ou encore un outil spécial. Vérifiez bien que le courant ne peut pas passer d’un coté à l’autre de la coupure, ni d’une bande à l’autre.

Figure 3
Figure 3
Montage recto-verso des composants sur une plaque à bandes cuivrées

Commencez par souder le support de CI avec l’encoche de repère en haut comme sur la figure, en laissant trois trous à gauche. On peut le maintenir bien appliqué sur le support avec un morceau de scotch.

Pliez les pattes de la résistance quasiment à ras du composant et introduisez-la dans le trou (2,3) (deuxième ligne, troisième colonne) et dans le trou (6,3). Soudez la résistance et coupez les pattes en excédant.

Introduisez l’anode de la LED (patte la plus longue) dans le trou (6,2) et la cathode dans le trou (4,2). Soudez les deux broches de la LED et coupez les pattes en excédant.

Soudez un fil rouge (+ alimentation de 5 V) dans le trou (1,8) : n’oubliez pas que les trous (1,5) et (1,6) correspondent à ce que vous avez coupé de la bande cuivrée.

Soudez un fil bleu ou noir (- de l’alimentation de 5V) dans le trou (4,1).

Immobilisez ces deux fils par un morceau de scotch le long des deux côtés de la plaque.

C’est fini ; il ne vous reste plus qu’à introduire la puce ATtiny45 dans le support en respectant bien son orientation, puis à bien vérifier votre montage avant de l’alimenter.

Photo 1
Photo 1
Le simulateur de soudure à arc terminé

Feux tricolores de carrefour routier

Nous avons déjà un peu évoqué les feux tricolores de carrefour routier dans le premier article de cette série Le microcontrôleur ATtiny45 (1). Nous pourrions utiliser un seul µC ATtiny45 en partant du principe que lorsque le feu est vert pour une route, il est rouge pour la route perpendiculaire et réciproquement, mais cette façon de faire ne permet pas d’afficher ce qu’il est convenu d’appeler la « temporisation du chauffard » qui consiste à laisser les deux feux allumés au rouge un court instant pour permettre le dégagement du carrefour par celui qui serait passé à l’orange bien mûre ! En tant que modéliste, nous cherchons au maximum à reproduire la réalité et c’est pourquoi nous allons faire le choix d’afficher cette temporisation du chauffard, mais cela demande deux feux indépendants l’un de l’autre ou encore 6 sorties numériques alors que notre µC ATtiny45 n’en offre que 5.

La solution est d’utiliser deux µC ATtiny45 et les faire travailler ensemble. La vidéo suivante montre l’effet obtenu.

Principe de fonctionnement

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.

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 (peu importe les valeurs, une doit simplement être plus grande que l’autre). 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 conservée 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, est empêché de travailler par le feu A jusqu’à ce que celui-ci lui passe la main.

Liste des composants nécessaires pour les feux tricolores

Deux µC ATtiny45 que vous aurez programmés avec des variables « attente_synchro » différentes.
Six DEL (deux vertes, deux oranges, deux rouges) ou bien deux feux tricolores à cathodes communes selon l’échelle que vous pratiquez.
Deux résistances de 220 Ω.

Programme pour ATtiny45

/*
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 envoie 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 ! Téléchargez ce programme puis téléversez-le dans une puce ATtiny en suivant la procédure décrite dans l’article Le microcontrôleur ATtiny45 (2).

Montage des composants sur une platine d’essai

La figure 4 montre comment monter les composants sur une platine d’essai.

Figure 4
Figure 4
Montage des feux tricolores sur une platine d’essai

L’alimentation en 5 V peut se satisfaire d’un bloc de pile délivrant 4,5 V ou bien être fournie par un module Arduino/Genuino Uno en récupérant le 5 V présent sur les connecteurs. Bien entendu, cette dernière solution ne se conçoit que pour essayer le montage, lorsque celui-ci est à poste sur le réseau, une alimentation autonome est préférable.

Montage sur une plaque cuivrée

La photo ci-dessous montre le montage terminé. Deux borniers de 3 contacts et un bornier de 2 contacts sont réunis en un seul réalisant huit sorties. Pour l’implantation des composants, on aligne les broches 5 des µC (sortie 0) avec le contact milieu d’un bornier de trois contacts (sortie pour le feu vert) ; en conséquence, les autres sorties ne sont pas dans l’ordre habituel et les cathodes des feux se branchent sur le bornier à deux contacts du milieu (lettres C). Une coupure des pistes est réalisée sous les supports de µC et sous les résistances. Si vous désirez avoir vos quatre feux de carrefour fonctionnels, vous pouvez mettre les DEL de deux feux en série pour chaque couleur, de manière à recréer deux feux pour chaque route, mais en général on se contente d’un seul feu fonctionnel par route, l’autre étant factice puisque vu de dos. Vous pouvez ajuster la luminosité des DEL selon vos goûts en jouant sur la valeur des résistances. Après avoir bien vérifié votre montage, alimentez-le avec une petite alimentation de 5 V. Vous pouvez repérer les sorties du bornier avec un peu de peinture verte, orange, rouge pour les anodes des feux et noire pour les cathodes. Les vis de fixation ne doivent pas créer de court-circuits entre bandes cuivrées conductrices. Plusieurs procédés sont possibles : isoler les zones de la vis, intercaler une rondelle en plastique entre la vis et la plaque, utiliser de la visserie nylon ou bien encore faire les trous ailleurs pour que les vis n’interfèrent pas avec des bandes cuivrées conductrices. Choisissez ce qui vous convient le mieux.

Photo 2
Photo 2
Montage des feux tricolores terminé

Vous voilà en possession de deux animations lumineuses de plus pour votre réseau, un simulateur de soudure à arc et un jeu de feux tricolores pour carrefour routier. Avec ces quatre montages déjà publiés, vous commencez à entrevoir les possibilités de ces petits microcontrôleurs extrêmement bon marché.

8 Messages

  • Le microcontrôleur ATtiny45 (4) 7 mars 2017 10:55, par Jean-Claude DRION

    Toujours très bien faits ces tutoriels...
    je vais me mette ceci de coté car cette idée d’installer des feux routiers ou balises de chantier (pourquoi pas ?)grâce a ce micro contrôleur me trotte dans la tête depuis qq temps...
    L’idée de la soudure a l’arc m’a séduit aussi mais sur mon petit réseau

    voir sur mon blog : http://papybricolo.over-blog.com/

    il n’y a plus beaucoup de place....

    encore merci de tous ces montages...

    Répondre

    • Le microcontrôleur ATtiny45 (4) 7 mars 2017 17:41, par Christian

      A l’origine, les montages ont été publiés pour des cartes Arduino UNO mais chaque animation prend à peine 10% des possibilités du module UNO. On peut bien évidemment mettre plusieurs animations dans un même module, nous l’avons aussi prouvé.
      L’avantage des µC ATtiny, c’est qu’ils ne vont recevoir qu’une seule animation et sont donc autonomes. Si un tombe en panne, le reste fonctionne quand même. Et on peut ainsi prévoir les animations au fur et à mesure de la construction du réseau.
      Même si cette série comporte le nom ATtiny45 dans son titre, il va sans dire qu’elle traite de tous les µC ATtiny qui peuvent se programmer de la même manière et ne diffèrent que par leur nombre de broches et tailles mémoires.

      Répondre

  • Le microcontrôleur ATtiny45 (4) 2 mai 2018 15:20, par THOUVENOT Hubert

    Bonjour,
    J’ai suivi pas à pas vos indications, mais j’ai toujours un message d’erreur lorsque je veux graver la séquence d’initialisation

    Il y a sans doute quelque chose que je fais mal mais quoi ?
    Quel doivent être les paramètres de "outils" lors de la graveure séquence d’initialisation ?
    Merci de votre aide
    Hubert

    Répondre

    • Le microcontrôleur ATtiny45 (4) 2 mai 2018 21:39, par Dominique

      Quel est le message d’erreur ? Il comporte en général la réponse à la question.
      SVP faites un copier-coller.

      Répondre

      • Le microcontrôleur ATtiny45 (4) 3 mai 2018 09:41, par THOUVENOT Hubert

        Voila le message que je reçois lorsque je veux graver une séquence d’initialisation avant de telecharger le programme.
        Le cablage et le paramétrage de tools est celui indiqué au chapitre 2

        avrdude : stk500_recv() : programmer is not responding
        avrdude : stk500_getsync() attempt 10 of 10 : not in sync : resp=0x00
        Erreur lors de la gravure de la séquence d’initialisation.

        HT

        Répondre

  • Le microcontrôleur ATtiny45 (4) 3 mai 2018 12:33, par Dominique

    C’est parce que l’Arduino n’est pas branché ou le port correspondant n’est pas sélectionné.

    Un grand classique : relisez les articles de base sur l’IDE, svp.

    Répondre

    • Le microcontrôleur ATtiny45 (4) 9 mai 2018 15:51, par THOUVENOT Hubert

      En fait j’avais tout simplement oublié de televerser arduinoisp au début de la manip
      Maintenant ça marche impeccablement
      HT

      Répondre

      • Le microcontrôleur ATtiny45 (4) 10 mai 2018 11:14, par Christian

        Tout ce que nous publions est monté et testé de notre côté. Si un montage ne fonctionne pas chez vous, la première question à se poser est : "Ai-je bien fait la même chose que l’auteur sans rien oublier ?"
        La plupart du temps, il s’agit d’un simple oubli qu’on peut ainsi vite réparer.
        Après deux ou trois programmations d’ATtiny, la procédure deviendra si familière que vous pourrez la réaliser les yeux fermés (ou presque !).
        En conclusion : il ne faut jamais se décourager car si cela fonctionne chez l’auteur, il n’y a aucune raison que cela ne fonctionne pas chez vous.
        Je vous souhaite à tous de bonnes réalisations ferroviaires.

        Répondre

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

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 »

Les derniers articles

Les articles les plus lus