Utiliser le composant 74HC595 8 Bit Shift Register avec un Arduino

Introduction

Aujourd’hui j’ai fait des recherches sur les matrices de LED afin de pouvoir faire un LED cube 3D de 512 leds (8x8x8) en me basant sur un Arduino.

Tout de suite je me suis aperçu d’un probème: comment controler 512 Ledsindividuellement lorsqu’un arduino ne possède que 54 pins au maximum (pour la version Mega2560 par exemple) ?

La première astuce consiste à lier les différentes anodes entre elles par couche. Par contre on est toujours bloqué concernant les cathodes qui sont au nombre de 64 (8×8).

C’est là que j’ai découvert qu’il existe des composants Bit Shift Register et plus particulièrement le composant 74HC595 8-bit Shift Register qui a la particularité d’être pas cher et assez simple à utiliser.

Crédits: je tiens à préciser que l’ensemble des informations ont été trouvée sur le site anglais bildr (dont certains exemples) donc merci à eux.

Qu’est ce que le Shift Register ?

Avant même d’essayer d’utiliser des 74HC595 pour multiplexer des leds, il faut comprendre ce qu’est le Shift Register et comment il fonctionne.

Et ben c’est simple: un composant Shift Register permet tout simplement d’étendre le nombre de sortie digitales d’un microcontrôleur tel qu’un RaspberryPi ou un Arduino.

Ainsi un composant comme les 74HC595 vont permettre de contrôler 8 sorties digitales avec en plus la possibilité de lier plusieurs composants 74HC595 les uns aux autres.

Pour mon cube led 3d de 8x8x8, je vais ainsi pouvoir lier 8 composants 74HC595 entre eux afin de disposer de 64 sorties digitales.

Comment fonctionne le Shift Register ?

Pour comprendre le fonctionnement d’un Shift Register (et notamment le 74HC595), le plus simple est d’imaginer que l’on a une ligne de 8 chaises.

Ces 8 chaises sont soit vides (valeur 0), soit occupées (valeur 1).

Maintenant considérons que toutes les 5 secondes une sonnerie retentit et les personnes assises doivent se déplacer d’une chaise sur leur droite.

Si la chaise la plus à droite était occupée, alors on considère que la personne s’en va. Pour la chaise la plus à gauche, elle peut soit rester vide soit quelqu’un vient y prendre place.

Prenons un cas concret, celui de notre Shift Register 74HC595.

https://www.zem.fr/wp-content/uploads/2012/12/Shift-Register.png 500w" sizes="(max-width: 228px) 100vw, 228px" class="clear" data-reader-unique-id="40" style="max-width: 100%; margin: 0.5em auto; display: block; height: auto; clear: both;">

Le composant 74HC595 dispose de 8 pins de sortie (Qa, Qb, Qc, Qd, Qe, Qf, Qg, Qh) qui peuvent soit avoir la valeur 0 (Low) soit la valeur 1 (High).

Lorsque l’on met le pin SRCLK (Serial Clock) en valeur 1 (High, qui est l’équivalent du retentissement d’une sonnerie), alors les 8 pins de sorties se décalent vers la droite.

Alors le dernier Pin (Qh) est supprimé et une nouvelle valeur est définie dans le pin Qa lorsque le pin SER (Serial) a une valeur de 1 (High). Si SER a une valeur de 0 (Low) alors Qa reste à 0.

Exemple de fonctionnement du Shift Register 74HC595

Essayons d’appliquer l’utilisation d’un Shift Register sur 8 Leds.
Imaginons que l’on souhaite allumer les leds 1, 3 et 8.

Tout d’abord, nous allons éteindre toutes les leds (Clear, via le pin SRCLR) en passons tous les registres à 0.

Ensuite, on passe la première valeur en High puis on décale de 4.  Ensuite on passe de nouveau la première valeur en High puis on décale de 1. Enfin on passe de nouveau la première valeur en High.

L’image ci-dessous illustre parfaitement cet exemple

https://www.zem.fr/wp-content/uploads/2012/12/74HC595-Shift-Register.png 574w" sizes="(max-width: 287px) 100vw, 287px" class="clear" data-reader-unique-id="54" style="max-width: 100%; margin: 0.5em auto; display: block; height: auto; clear: both;">

Un des avantages des Shift Registers est qu’ils disposent d’un pin appelé RCLK (Register Clock) qui permet de n’effectuer aucune modification tant qu’il est maintenu en LOW.

Ainsi tant que RCLK sera a LOW vous pourrez affecter les valeurs que vous souhaitez aux 8 pins de sortie sans que l’affichage ne change.
Une fois que vous avez mis les bonnes valeurs pour vos pins de sortie, il ne vous reste plus qu’à passer RCLK en High et le Shift Register 74HC595affichera les modifications.

On peut ainsi modifier nos différents registres plusieurs fois (en 8 étapes par exemple), mais l’on ne verra qu’une seule modification, ce qui laissera penser que tout s’est fait en une seule étape.

Comment connecter le Shift Register 74HC595 ?

Après avoir regardé la documentation technique du 74HC595 disponible ici, il s’avère que le composant 74HC595 est relativement simple à connecter.

Voici le détail de connections des pins:

• Vcc : alimentation jusqu’à 6V qui doit être la même que celle du microcontroleur.
• QA à QH: sorties Shift Register.
• SER (Serial): entrée pour le prochain pin qui sera déplacé.
• SRCLK (Serial Clock): déplace le registre lorsqu’il est mis à 1 (High).
• RCLK (Register Clock): doit être mis en High pour valider les nouveaux shifts register.
• SRCLR (Serial Clear): vide complètement le Shift Register sil est mis en Low. Doit être passé en High pour être activé.
• OE (Output Enable): ce pin permet d’activer la sortie lorsqu’il est sur la masse (GND) et la désactive lorsqu’il est en High.

Utiliser les Shift Register 74HC595 avec un Arduino

Le schéma suivant vous montre comment connecter un Shift Register 74HC595 à un Arduino Uno.

https://www.zem.fr/wp-content/uploads/2012/12/Connecting-74HC595-Arduino.png 828w" sizes="(max-width: 300px) 100vw, 300px" class="clear" data-reader-unique-id="81" style="max-width: 100%; margin: 0.5em auto; display: block; height: auto; clear: both;">

Quand le signal sur le pin SERCLK devient High, toutes les valeurs sont déplacées vers la droite et les nouvelles valeurs sont settées (si le pin SER est activé).

Après avoir affecté les nouvelles valeurs, il faut passer le pin RCLK en High pour que la mise à jour soit affichée sur les sorties.

Cascade de Shift Register 74HC595 avec un Arduino

Un des points forts des Shift Register 74HC595 est qu’ils peuvent se monter en cascade.

Ainsi l’on peut chainer autant de Shift Register 74HC595 que l’on souhaite.

Comme on l’on vu, le Shift Register 74HC595 supprime la dernière valeur (Qh) lorsque l’on déplace les registres vers la droite. Pour chainer un second Shift Register, il suffirait donc d’utiliser cette valeur dans le registre suivant qui serait le premier registre d’un second composant 74HC595.

On aurait alors 2 composants 74HC595 chainés.

Pour faire cela, on va relier les pins SERCLK entre eux, les pins RCLK entre eux et le pins Qh’ du premier 74HC595 au pins Qa du second 74HC595. Simple non ?

Le schéma suivant illustre parfaitement cela:

https://www.zem.fr/wp-content/uploads/2012/12/Cascading-74HC595-Arduino.png 913w" sizes="(max-width: 300px) 100vw, 300px" class="clear" data-reader-unique-id="101" style="max-width: 100%; margin: 0.5em auto; display: block; height: auto; clear: both;">

Code Arduino pour utiliser les Shift Register 74HC595

Maintenant que la connectique est faite, voici un exemple de code pour utiliser les Shift Register 74HC595 avec votre Arduino Uno :

int SER_Pin = 8;   //pin 14 on the 75HC595
int RCLK_Pin = 9;  //pin 12 on the 75HC595
int SRCLK_Pin = 10; //pin 11 on the 75HC595
 
//How many of the shift registers - change this
#define number_of_74hc595s 1 
 
//do not touch
#define numOfRegisterPins number_of_74hc595s * 8
 
boolean registers[numOfRegisterPins];
 
void setup(){
  pinMode(SER_Pin, OUTPUT);
  pinMode(RCLK_Pin, OUTPUT);
  pinMode(SRCLK_Pin, OUTPUT);
 
  //reset all register pins
  clearRegisters();
  writeRegisters();
}               
 
//set all register pins to LOW
void clearRegisters(){
  for(int i = numOfRegisterPins - 1; i >=  0; i--){
     registers[i] = LOW;
  }
} 
 
//Set and display registers
//Only call AFTER all values are set how you would like (slow otherwise)
void writeRegisters(){
 
  digitalWrite(RCLK_Pin, LOW);
 
  for(int i = numOfRegisterPins - 1; i >=  0; i--){
    digitalWrite(SRCLK_Pin, LOW);
 
    int val = registers[i];
 
    digitalWrite(SER_Pin, val);
    digitalWrite(SRCLK_Pin, HIGH);
 
  }
  digitalWrite(RCLK_Pin, HIGH);
 
}
 
//set an individual pin HIGH or LOW
void setRegisterPin(int index, int value){
  registers[index] = value;
}
 
void loop(){
 
  setRegisterPin(2, HIGH);
  setRegisterPin(3, HIGH);
  setRegisterPin(4, LOW);
  setRegisterPin(5, HIGH);
  setRegisterPin(7, HIGH);
 
  writeRegisters();  //MUST BE CALLED TO DISPLAY CHANGES
  //Only call once after the values are set how you need.
}

Vous noterez que cet exemple gère le cascading (le chainage des 74HC595). Il vous suffit d’éditer la ligne:

#define number_of_74hc595s 1