Rappels sur l’ATtiny45

Cette série d’articles a été consacrée au microcontrôleur ATtiny45 et à ses possibilités en matière de modélisme ferroviaire. Quand on parle d’ATtiny45, on parle de la même façon de ses frères et sœurs les ATtiny25 ou ATtiny85 dont les possibilités sont identiques et qui ne diffèrent que par leur capacité dans les différentes mémoires possibles (flash, SRAM et EEPROM). Si vous n’êtes pas trop familiarisés avec les caractéristiques de la famille ATtiny25/45/85, nous vous conseillons de lire (ou relire) cette série d’articles depuis le N°1 avant d’aborder la branche cousine de la famille, la série des ATtiny24/44/84.

Bien que l’ATtiny45 n’ait que 8 broches (dont 2 pour l’alimentation), ce petit microcontrôleur nous a permis de réaliser de nombreux montages pour un réseau de trains miniatures ; animations lumineuses, PWM, conversion analogique-digitale, interruptions, commande de servomoteur, commande de moteur pas à pas, etc. Nous allons voir aujourd’hui que l’ATtiny44 a des possibilités encore supérieures grâce à ses 14 broches (dont 2 pour l’alimentation) et il vous sera possible de reprendre avec ce nouveau microcontrôleur les montages que vous aviez réalisés pour les améliorer comme nous le ferons sur un exemple.

Un air de famille

La figure 1 montre le brochage des microcontrôleurs ATtiny24/44/84 ; elle est à comparer avec la figure 1 de l’article Le microcontrôleur ATtiny45 (1). On remarque déjà que les broches d’alimentation sont les broches 1 (Vcc) et 14 (GND) ce qui les place l’une en face de l’autre et non plus diamétralement opposées comme pour la série ATtiny25/45/85 (broche 8 pour Vcc et broche 4 pour GND).

Faites particulièrement attention à ce point lorsque vous alimentez le microcontrôleur car toute erreur serait fatale !

La tension d’alimentation est la même que pour la série ATtiny25/45/85 soit entre 2,7 et 5,5 V pour les ATtiny24/44/84 ou entre 1,8 et 5,5 V pour les séries ATtiny24V/44V/84V.

Figure 1

Brochage de l’ATtiny24/44/84 (extrait de la notice du composant)

Le nombre augmenté de broches du circuit permet d’avoir deux Ports d’Entrées-Sorties, un Port A de 8 lignes (PA0:PA7) et un Port B de 4 lignes (PB0:PB3) ; cela fait donc 12 lignes au total d’E/S mais comme pour l’ATtiny45, nous n’utiliserons pas la dernière ligne du Port B car elle sert au RESET du circuit (PB3 qui se situe sur la broche 4), et nous en avons besoin pour le programmer.

Nous voyons également que nous disposons de 8 entrées analogiques (ADC0:ADC7) alors qu’il n’y en avait que 4 sur l’ATtiny45, deux canaux de PWM (OC0 et OC1, A ou B) soit 4 broches possibles (5, 6, 7 et 8), et que chaque ligne des Ports A et B permettent de générer des interruptions par changement d’état (PCINT0:PCINT11). Enfin, une interruption externe est possible sur la broche 5 (INT0) soit sur un front montant, soit sur un front descendant, soit sur un niveau LOW.

Les capacités mémoires de la famille ATtiny24/44/84 sont les mêmes que pour la famille ATtiny25/45/85 ; le tableau 1 résume d’ailleurs les caractéristiques principales de la famille ATtiny.

Comme le montre ce tableau, ce n’est pas sur la capacité mémoire que nous gagnons en utilisant la série ATtiny24/44/84 mais sur le nombre d’entrées ou de sorties que nous pouvons utiliser pour communiquer avec l’extérieur.

Programmation du microcontrôleur ATtiny24/44/84

L’article 2 de cette série avait expliqué comment on pouvait programmer un ATtiny45 avec une simple carte Uno : les signaux utilisés étaient des signaux de type SPI (Serial Peripheral Interface) soit MOSI, MISO et SCK. En fait, le microcontrôleur ATtiny25/45/85 possède une USI (Universal Serial Interface) qui permet de communiquer soit avec deux fils (interface de type I2C) soit avec 3 fils (interface de type SPI) et c’est cette solution qui était retenue pour programmer le composant. La série ATtiny24/44/84 possède la même interface comme on peut le voir en consultant la datasheet du composant. La figure 2 montre cette interface USI utilisée pour programmer l’ATtiny24/44/84.

Figure 2

Signaux de type SPI servant à programmer un ATtiny24/44/84
(Figure extraite de la notice du composant)

La procédure consistant à utiliser une carte Uno (expliquée dans l’article Le microcontrôleur ATtiny45 (2)) convient parfaitement pour programmer une puce ATtiny24/44/84 à condition d’envoyer les signaux sur les bonnes broches du composant. La figure 3 montre quelles sont ces broches.

Figure 3

Les broches servant à programmer l’ATtiny24/44/84
(Figure extraite de la notice du composant)

La figure 4 montre comment relier la carte Uno au composant ATtiny24/44/84 pour le programmer.

Cette figure est différente de la figure 1 de l’article Le microcontrôleur ATtiny45 (2) et le branchement n’est pas le même, ne serait-ce que pour alimenter le composant en 5 V !

Figure 4

Programmateur d’ATtiny24/44/84 à base de module Uno

En dehors du branchement qui diffère, la procédure de programmation reste la même, à condition de choisir ATtiny24/44/84 comme type de carte et le bon processeur (24, 44 ou 84) : reportez-vous à l’article Le microcontrôleur ATtiny45 (2).

Premier montage à base d’ATtiny24/44/84

Dans l’article Le microcontrôleur ATtiny45 (3), nous avons décrit une enseigne d’hôtel à base d’ATtiny45 dont le nombre de sorties ne permettait qu’une enseigne de 5 lettres (HOTEL). Reprenons cet exemple tout en profitant du nombre de sorties plus important d’un ATtiny24/44/84 pour écrire le mot RESTAURANT qui comporte 10 lettres.

Comme pour l’ATtiny45, nous réservons la broche 4 (PB3) du microcontrôleur au RESET et nous ne l’utilisons pas. Les sorties 0 à 7 sont sur les broches PA0 à PA7, la sortie 8 est sur PB2, 9 sur PB1 et 10 sur PB0. À titre d’exemple, nous utilisons au maximum le Port B (donc PB0 à PB2) et nous complétons avec le Port A (de PA7 à PA1). C’est la sortie PB0 qui est reliée à la première lettre de l’enseigne et la sortie PA1 qui est reliée à la dernière ; les flashes se propagent de la droite vers la gauche jusqu’à écrire complètement le mot RESTAURANT.

La figure 5 montre le schéma à réaliser sur une platine d’essai. Pour des questions de lisibilité, la sortie PB0 (fil orange) passe par la ligne soulignée en bleu qui dans ce cas ne sert pas à l’alimentation ; attention à ne pas vous tromper avec la ligne soulignée en rouge qui véhicule bien le 5 V ! Bien évidemment, vous pouvez faire autrement avec des câbles ou des nappes Dupont. Les résistances font 220 Ω mais suivant la luminosité qu’on veut donner à l’enseigne, on pourra adopter une valeur plus forte.

Figure 5

Montage de l’enseigne RESTAURANT avec un bargraph

Attention à la position de la broche 1 repérée par le point blanc

Photo 1

Le montage à base d’ATtiny84 et deux platines d’essai

Le programme à téléverser dans la puce ATtiny est inspiré de celui donné pour l’ATtiny45 : l’enseigne a 10 LED, la sortie 0 n’est pas utilisée et les délais d’attente ont été raccourcis pour dynamiser un peu l’enseigne.

/*
ATtiny84_enseigne_restaurant
----------------------------
Ce programme réalise le clignotement d'une enseigne publicitaire.
Il fait clignoter selon un certain rythme des LED.
La première LED est reliée à la sortie led1 (derniere lettre RESTAURANT)
nbre_led indique le nombre de LED à faire clignoter.
Il utilise des fonctions pour alterner les rythmes.
*/

const int led1 = 1 ;         // Position de la première LED 
const int nbre_led = 10 ;    // Nombre de LED dans l'enseigne
const int nbre_chen = 3 ;    // Nombre de fois pour le chenillard
const int nbre_cligno = 3 ;  // Nombre de clignotement

void setup () {
// Initialisation des lignes de LED en sortie
for (byte i = 0; i <= (nbre_led - 1) ; i++)      // Moins 1 car on part de zéro
{
  pinMode ((i + led1), OUTPUT) ;
}
  // Extinction de toutes les LED au départ du programme
  for (byte i = 0 ; i <= (nbre_led - 1) ; i++) 
  {
    digitalWrite ((i + led1), LOW) ; // éteint la LED reliée à la broche i + led1
  }
}

// Fonction loop
void loop () {
    
  // Séquence N°1 ; chenillard
  sequence_Un () ;
  delay (100) ; // attente avant autre sequence

  // Séquence N° 2 : cumul sur la gauche du mouvement de LED
  sequence_Deux () ;
  delay (200) ;  // attente avant autre sequence
  
  // Séquence N°3 : clignotement de l'ensemble 3 fois
  sequence_Trois () ;
  delay (2000) ;  // temps pour lire enseigne

  // Séquence 4 : extinction successive de la gauche vers la droite
  sequence_Quatre () ;
  delay (200) ;  // attente avant autre sequence 
  
  // Recommence la séquence
}

void sequence_Un ()
{
  // Séquence N°1 ; chenillard
  
  for (byte n = 1 ; n <= nbre_chen ; n++)
  {
    for (byte i = 0 ; i <= (nbre_led - 1) ; i++)
    {
      digitalWrite ((i + led1), HIGH) ;    // allume la LED sur broche i
      delay (100) ;                        // durée du flash 
      digitalWrite ((i + led1), LOW) ;     // éteint la LED sur broche i
    }
  }
}

void sequence_Deux ()
{
  // Séquence N° 2 : cumul sur la gauche du mouvement de LED
  
  for (byte n = 0 ; n <= (nbre_led - 1) ; n++)
  {
    for (byte i = led1 ; i <= ((led1 + nbre_led - 1)-n) ; i++)
    {
      digitalWrite (i, HIGH) ;   // allume la LED sur broche i
      delay (100) ;              // durée du flash
      digitalWrite (i, LOW) ;    // éteint la LED sur broche i
    }
    digitalWrite ( ((led1 + nbre_led - 1) - n) , HIGH ) ; //dernière LED reste allumée
  }
}

void sequence_Trois ()
{
  // Séquence N°3 : clignotement de l'ensemble
  
  for (byte j = 1 ; j <= nbre_cligno ; j++) 
  {
    for (byte k = 0 ; k <= (nbre_led - 1) ; k++) 
    {
      digitalWrite ((k + led1) , LOW) ;
    }
    delay (100) ;
    for (byte l = 0 ; l <= (nbre_led - 1) ; l++) 
    {
      digitalWrite ((l + led1), HIGH) ;
    }
    delay (100) ;
  }
}

void sequence_Quatre ()
{
  // Séquence 4 : extinction successive de la gauche vers la droite

  const byte derniereLed = led1 + nbre_led - 1;
  for (byte i = led1 ; i <= derniereLed ; i++) 
  {
    digitalWrite ((derniereLed - i), LOW) ;
    delay (100);
  }
}

La vidéo suivante montre le résultat obtenu : le bargraph est recouvert de l’inscription RESTAURANT écrite pour l’exemple en blanc sur fond noir, mais vous pouvez faire différemment. La police et l’espacement des caractères sont à choisir pour que chaque lettre soit bien au-dessus d’une LED.

Les timers de l’ATtiny24/44/84

Au niveau des timers, le microcontrôleur ATtiny24/44/84 offre plus de possibilités que l’ATtiny25/45/85 car il y a un timer de 8 bits et un autre de 16 bits au lieu de deux timers de 8 bits. Le premier timer de 8 bits s’appelle timer/counter0. La figure 6 montre son schéma synoptique ; on retrouve exactement la figure 1 de l’article Les Timers (IV) décrivant un timer 8 bits du microcontrôleur de la carte Uno (ATmega328).

Figure 6

Architecture du bloc timer0 de l’ATtiny24/44/84
(Figure extraite de la notice du composant)

Le deuxième timer de 16 bits s’appelle timer/counter1. La figure 7 montre son schéma synoptique ; on retrouve cette fois la figure 1 de l’article Les Timers (V) décrivant le timer 16 bits du microcontrôleur de la carte Uno (ATmega328). Ces similitudes n’ont rien d’étonnant puisque tous ces microcontrôleurs font partie d’une même et grande famille, mais c’est plutôt une bonne aubaine car les timers du microcontrôleur ATtiny24/44/84 ressemblent énormément aux timers de la carte Uno ou Nano. On peut donc penser que certaines bibliothèques utilisant les timers de ces cartes pourraient fonctionner sur ce composant moyennant peut-être quelques adaptations. Toutes les bibliothèques que vous pourrez trouver sur le Web ne fonctionneront sans doute pas avec ce composant, mais cela vaut la peine de faire des essais. Une autre solution est d’écrire ses propres programmes, comme nous l’avions fait lorsque nous avons commandé un servomoteur avec un ATtiny25/45/85 (voir l’article Le microcontrôleur ATtiny45 (7)).

Ceux que les timers de microcontrôleurs intéressent peuvent lire la série d’articles qui leur est consacrée et qui commence par Les Timers (I).

Figure 7

Architecture du bloc timer1 de l’ATtiny24/44/84
(Figure extraite de la notice du composant)

ATtiny24/44/84 et PWM

Les figures 6 et 7 montrent les blocs « Waveform Generation » qui fabriquent la PWM (pour plus d’information, se reporter à l’article Les Timers (IV)). Cette PWM se retrouve sur les broches OC0A et OC0B pour le timer0 et OC1A et OC1B pour le timer1, donc sur les broches 5, 6, 7 et 8 (PB2, PA7, PA6 et PA5) de l’ATtiny24/44/84 (voir figure 1). Par exemple, le programme « Fade » donné en exemple avec l’IDE fonctionne très bien sur ATtiny24/44/84 à condition de changer la sortie led et de mettre 6 à la place de 9.

Conclusion

Nous venons de faire un rapide survol des possibilités des microcontrôleurs de la série ATtiny24/44/84 et nous avons démontré que leurs possibilités sont supérieures à celles de la série ATtiny25/45/85. Vous pouvez maintenant reprendre les montages proposés dans cette série d’articles afin de les améliorer en utilisant ces composants. Mais seule une lecture attentive de la notice du composant vous donnera un panorama complet de ses possibilités. N’hésitez pas à expérimenter et tenez-nous au courant de ce que vous aurez découvert.