Plus d’entrées avec le registre à décalage 74HC165

Dans ce tutoriel, je vais vous montrer comment ajouter plus d’entrées à votre Arduino ou ESP8266/ESP32 grâce au registre à décalage 74HC165.

L’Arduino UNO populaire dispose de 14 broches GPIO que vous pouvez utiliser pour lire (ou écrire) des données. Souvent, cela suffit, mais parfois vous avez besoin de plus. Vous pourriez acheter un Arduino plus cher comme un  Arduino Mega  avec 54 broches GPIO ou un  GPIO expander board . Mais la solution la plus économique consiste à utiliser un registre à décalage comme le  74HC165 .

Le 74HC165 offre 8 entrées, n’utilise que 3 broches de votre Arduino et peut être chaîné pour lire autant d’entrées que vous le souhaitez. Le seul inconvénient est qu’il est plus lent que l’utilisation directe des broches GPIO de l’Arduino. Il est couramment utilisé pour décoder des claviers ou si vous avez de nombreux capteurs numériques.

Commençons par la liste des composants nécessaires avant de voir en détail le fonctionnement du 74HC165.

Composants nécessaires

J’ai utilisé un Arduino Uno pour ce projet, mais n’importe quelle autre carte Arduino ou carte ESP8266/ESP32 fonctionnera tout aussi bien. J’ai listé un ensemble de boutons-poussoirs, mais pour mon montage réel, j’ai utilisé un DIP switch, car il est plus compact. Mais les boutons-poussoirs conviennent aussi.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Fonctionnement du registre à décalage 74HC165

Le 74HC165 est un registre à décalage 8 bits à chargement parallèle qui lit 8 entrées numériques en parallèle puis les transmet en série sur une seule broche. Il nécessite une entrée d’horloge pour cadencer le décalage des 8 entrées numériques vers la sortie série, et un autre signal pour contrôler le chargement des données d’entrée.

Cela signifie qu’avec trois broches et un seul 74HC165, vous pouvez lire jusqu’à 8 entrées numériques. Cependant, il est aussi possible de chaîner plusieurs 74HC165 et ainsi lire un nombre pratiquement illimité d’entrées numériques, toujours en utilisant seulement trois broches de votre microcontrôleur !

Schéma fonctionnel

L’image ci-dessous montre le schéma fonctionnel du registre à décalage 74HC165. Vous pouvez voir les 8 entrées numériques parallèles (A…H) en haut. La sortie série Q _H et son complément Q̅ _H se trouvent à droite. Au centre, vous trouvez les verrous ( flip-flops ) dans lesquels les données d’entrée sont chargées.

Les entrées de contrôle sont à gauche. SH/L̅D̅ active les 8 entrées numériques lorsqu’il est à l’état bas. CLK (ou CLK INH) décale les données une par une vers la sortie série Q _H . Et SER est l’entrée série utilisée lors du chaînage de plusieurs registres à décalage 74HC165.

Schéma logique

L’image suivante montre le schéma logique du processus. Le signal CLK cadence le décalage des entrées numériques (A…H) vers la sortie série Q _H et son inverse Q̅ _H .

Le signal d’horloge est désactivé tant que clock-inhibit (CLK INH) est à l’état haut. De même, pour charger les entrées numériques, SH/L̅D̅ doit être à l’état bas. SER n’est utilisé que lors du chaînage de plusieurs registres à décalage.

En résumé, pour décaler les 8 entrées numériques A…H vers la sortie série Q _H il faut effectuer les étapes suivantes.

1. Mettre SH/L̅D̅ à l’état bas pour charger les données
2. Remettre SH/L̅D̅ à l’état haut
3. Répéter 8 fois les étapes suivantes
   • Mettre CLK à l’état haut pour décaler les données
   • Remettre CLK à l’état bas

CLK INH n’est pas nécessaire et peut rester à l’état bas tout le temps. De plus, si vous utilisez un seul registre à décalage 74HC165, l’entrée SER n’est pas utilisée.

Brochage

Sur l’image ci-dessous, vous trouverez le brochage du registre à décalage 74HC165. L’alimentation se fait via V _CC et GND. La tension d’alimentation V _CC peut varier entre 2V et 6V, et la tension de sortie sur la broche Q _H dépend de V _CC .

La fonction des autres broches a déjà été expliquée ci-dessus, mais le tableau suivant résume les fonctions de toutes les broches. Vous trouverez plus de détails dans la Datasheet for the 74HC165 Shift Register .

Dans la section suivante, nous allons connecter le registre à décalage 74HC165 à un Arduino.

Connexion du registre à décalage 74HC165 à un Arduino

Pour simplifier, nous allons d’abord connecter le 74HC165 à l’Arduino sans aucun signal sur les broches d’entrée A…H. L’image ci-dessous montre le câblage de cette première étape.

Commençons par les connexions d’alimentation. Reliez un fil noir de la broche GND de l’Arduino au rail négatif de la breadboard. Ensuite, utilisez un fil rouge pour connecter le 5V de l’Arduino au rail positif. Ensuite, reliez les deux rails négatifs de la breadboard avec un fil noir. Nous n’utilisons pas le second rail positif, donc pas besoin de connexion de ce côté.

Maintenant, connectons l’alimentation du 74HC165. Reliez la broche 8 (GND) du 74HC165 au rail négatif (fil noir) et la broche 16 (V _CC ) au rail positif (fil rouge).

Enfin, les fils de signal. Nous n’utilisons pas CLK INH sur la broche 15, donc on le connecte directement au rail négatif (fil noir). SH/L̅D̅ sur la broche 1 est relié à la broche 3 de l’Arduino (fil vert). Le signal CLK sur la broche 2 est relié à la broche 2 de l’Arduino (fil orange). Et la sortie série Q _H sur la broche 9 est reliée à la broche 4 (fil jaune).

Et voilà les connexions nécessaires pour contrôler le 74HC165 et récupérer ses données. Dans la section suivante, nous allons connecter des boutons comme entrées numériques sur les broches d’entrée.

Connexion de boutons au registre à décalage 74HC165

On pourrait connecter n’importe quel type de signal numérique aux broches d’entrée (A…H) du 74HC165. Mais pour tester, nous allons connecter quelques boutons. Nous allons commencer par un seul bouton. Le schéma ci-dessous montre le même circuit que précédemment, avec en plus le câblage pour un bouton.

Le bouton est câblé en pull-down configuration avec une résistance de 10KΩ. Cela signifie que lorsque le bouton est appuyé, le signal est tiré vers la masse. Pour cela, on connecte une broche du bouton au rail positif (fil rouge) et l’autre broche au rail négatif via la résistance de 10KΩ.

La sortie du bouton est reliée à l’entrée numérique A sur la broche 11 du 74HC165 (fil violet). Notez que l’autre extrémité du fil violet est connectée à la même broche que la résistance, car le câblage interne du bouton est le suivant :

Assurez-vous d’insérer le bouton dans le bon sens sur la breadboard. Et si vous souhaitez plus d’informations sur les boutons-poussoirs, consultez notre tutoriel How to use a Push Button with Arduino.

Notez que vous pouvez aussi câbler le bouton en mode pull-up, mais la sortie sur Q _H serait alors inversée. Pour compenser, vous pouvez utiliser la sortie complémentaire Q̅ _H pour l’inverser à nouveau ou gérer l’inversion dans le code.

Connexion de plusieurs boutons

Le schéma ci-dessous montre comment connecter 7 boutons supplémentaires pour créer des signaux sur les 8 entrées numériques A…H du 74HC165. Ils sont tous câblés de la même façon que le bouton unique ci-dessus, seules les sorties sont reliées aux autres entrées B…H du 74HC165 (fils violets).

Comme vous pouvez le voir, cela fait pas mal de fils ; ) Voyons maintenant comment lire l’état de ces boutons.

Code pour lire les boutons avec le registre à décalage 74HC165

Dans cette section, nous lisons l’état des boutons connectés au 74HC165. Le code est simple et suit les étapes définies par le schéma logique du 74HC165 :

1. Mettre SH/L̅D̅ à l’état bas pour charger les données
2. Remettre SH/L̅D̅ à l’état haut
3. Répéter 8 fois les étapes suivantes
   • Mettre CLK à l’état haut pour décaler les données
   • Remettre CLK à l’état bas

Regardez d’abord le code complet ci-dessous, puis nous en discuterons les détails.

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD
  
void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}
 
void loop() {
  // Load input bits into latches
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);
 
  for (int i = 0; i < 8; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    // Shift out the next bit to QH
    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }
 
  Serial.println();
  delay(1000);
}

Dans l’exemple de code ci-dessus, nous lisons 8 bits d’entrée numérique depuis le registre à décalage 74HC165 et nous les affichons chaque seconde.

Constantes et variables

Nous commençons par définir les constantes dataPin , clockPin , et latchPin qui représentent les broches connectées aux broches data (QH), clock (CLK) et latch (SH/LD) du registre à décalage 74HC165. Notez que vous pouvez utiliser d’autres broches Arduino si vous le souhaitez. Assurez-vous simplement que le câblage et le code correspondent.

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD

Fonction setup

Dans la fonction setup() , nous initialisons la communication série à un débit de 9600 bauds. Nous configurons aussi dataPin en INPUT et clockPin et latchPin en OUTPUT, car nous allons lire les données sur la broche data et contrôler les broches clock et latch.

void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}

Fonction loop

Dans la fonction loop() , nous chargeons d’abord les bits d’entrée dans les verrous du registre à décalage en basculant la broche latch.

void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);

  ...
}

Ensuite, nous parcourons chacun des 8 bits, lisons leur valeur sur la broche data, les affichons (en ‘1’ ou ‘0’), et décalons le bit suivant en basculant la broche clock. Enfin, nous ajoutons un délai d’une seconde entre chaque lecture.

void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);

  for (int i = 0; i < 8; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }

  Serial.println();
  delay(1000);
}

Avec ce code et ce montage, vous pouvez maintenant lire 8 entrées numériques en utilisant seulement trois broches de votre Arduino. Et bien sûr, cela fonctionne aussi avec un ESP8266 ou un ESP32. Si vous lancez ce code, vous devriez voir une sortie comme celle-ci sur votre moniteur série.

Le motif de bits réel dépendra des boutons que vous appuyez pendant l’exécution du programme. Comme mentionné, j’ai en fait utilisé un DIP switch et câblé seulement les quatre premiers interrupteurs pour tester le circuit et le code. La photo ci-dessous montre ma breadboard avec le montage.

Avec le circuit et le code ci-dessus, vous pouvez lire jusqu’à 8 entrées numériques. Si vous avez besoin de plus d’entrées, vous pouvez chaîner plusieurs registres à décalage 74HC165. Comment faire, c’est le sujet de la section suivante.

Chaînage de registres à décalage 74HC165

Vous pouvez connecter la sortie série Q _H d’un registre à décalage 74HC165 à l’entrée série SER d’un autre 74HC165 pour les chaîner ensemble. Cela vous permet de lire 16 entrées numériques au lieu de 8.

Et vous n’êtes pas obligé de vous arrêter là. Vous pouvez continuer à chaîner autant de registres que vous le souhaitez, ce qui vous permet d’avoir un nombre pratiquement illimité d’entrées numériques. Et la bonne nouvelle, c’est que tous ces registres à décalage 74HC165 sont contrôlés via les mêmes trois broches.

Le schéma ci-dessous montre comment connecter 16 boutons comme entrées à un Arduino en utilisant deux registres à décalage 74HC165. Cela semble compliqué, mais ce n’est qu’une duplication du câblage précédent.

Notez que les broches CLK et SH/LD des 74HC165 sont connectées en parallèle et que la seule différence par rapport au câblage d’un seul 74HC165 est le chaînage via Q _H et les broches SER.

Code pour lire des registres à décalage 74HC165 chaînés

Le code pour lire les données de deux registres à décalage 74HC165 chaînés est une simple extension du code pour un seul 74HC165. Voir ci-dessous :

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD

const byte numBits = 16;  
  
void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}
 
void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);
 
  for (int i = 0; i < numBits; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }
 
  Serial.println();
  delay(1000);
}

On ajoute simplement une constante numBits qui permet de définir combien de bits on souhaite lire. Dans le cas d’un seul 74HC165, cela fait 8 bits. Si on utilise deux registres à décalage, on peut lire 8 * 2 = 16 bits, et ainsi de suite.

Utiliser ArduinoShiftIn pour lire un registre à décalage 74HC165

Si vous ne souhaitez pas écrire votre propre code pour gérer le 74HC165, il existe une petite bibliothèque bien pratique. Elle s’appelle ArduinoShiftIn mais devrait aussi fonctionner sur un ESP32 ou ESP8266. Elle est particulièrement utile si vous chaînez plusieurs registres à décalage 4HC165 et souhaitez lire les données d’entrée dans une seule variable.

Pour installer la bibliothèque ArduinoShiftIn, allez dans le ArduinoShiftIn github repo , téléchargez le Zip file puis ajoutez-le à votre Arduino IDE via : Sketch > Include Library > Add .ZIP > sélectionnez le fichier zip.

L’exemple de code suivant est tiré d’un des exemples ArduinoShiftIn et montre comment lire deux registres à décalage 74HC165 :

#include "ShiftIn.h"

ShiftIn<2> shift;  // 2 = two 74HC165 

void setup() {
  Serial.begin(9600);
  // pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print(shift.state(i));
  Serial.println();
}

void loop() {
  if(shift.update()) 
    displayValues();
  delay(1);
}

Vous devez spécifier le nombre de registres à décalage 74HC165 chaînés lors de la déclaration de l’objet shift :

ShiftIn<2> shift;

Dans la fonction setup, on initialise la communication série et on définit les broches pour contrôler le 74HC165.

void setup() {
  Serial.begin(9600);
  // pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

Notez que la bibliothèque ArduinoShiftIn utilise les quatre broches, alors que dans les exemples précédents nous avons connecté CLK INH à la masse sans l’utiliser. Ici, il faut définir clockEnablePin (= CLK INH) et le connecter.

La fonction displayValues() , comme son nom l’indique, affiche les valeurs d’entrée lues depuis le

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print(shift.state(i));
  Serial.println();
}

La fonction shift.getDataWidth() reçoit le nombre de bits à lire. Vous n’avez pas besoin de multiplier vous-même le nombre de registres à décalage par 8. Et shift.state() retourne l’état de l’entrée numéro i .

Enfin, la fonction loop. Elle appelle displayValues() , mais seulement si l’état d’une des entrées a changé, ce qui est signalé par la fonction shift.update() .

void loop() {
  if(shift.update()) 
    displayValues();
  delay(1);
}

Notez cependant que shift.update() n’est pas événementielle et interroge simplement l’état des registres à décalage 74HC165 à la vitesse de la boucle – dans cet exemple avec un délai d’1 microseconde.

Le câblage nécessaire est essentiellement le même qu’avant, à la différence que d’autres broches de contrôle sont utilisées et que vous devez connecter CLK INH à l’Arduino.

En résumé, la bibliothèque ArduinoShiftIn simplifie le code pour lire les entrées de registres à décalage 74HC165 chaînés, mais a le léger inconvénient d’occuper une broche GPIO supplémentaire (CLK INH). Cependant, si vous chaînez beaucoup de registres (jusqu’à 8), ce n’est généralement pas un problème, car vous disposez de nombreuses entrées supplémentaires.

Conclusions

Dans ce tutoriel, vous avez appris à utiliser le registre à décalage 74HC165 pour ajouter un nombre arbitraire d’entrées numériques à votre microcontrôleur. Le circuit et le code présentés utilisent un Arduino, mais cela fonctionne aussi sur un ESP32 ou un ESP8266.

Contrairement à GPIO expanders qui peut lire et écrire des entrées et sorties analogiques, le 74HC165 est limité à la lecture d’entrées numériques uniquement. Cependant, le 74HC165 est généralement bien moins cher qu’une carte d’extension GPIO.

Si vous souhaitez aussi écrire de nombreuses sorties, consultez notre tutoriel More Arduino Outputs With 74HC595 Shift Register , qui utilise un autre type de registre à décalage pour écrire des données au lieu de les lire.

Si vous avez besoin d’entrées et de sorties analogiques, un expander GPIO comme le MCP23017, par exemple, est un meilleur choix. Consultez notre tutoriel Using GPIO Expander MCP23017 With Arduino , pour plus d’informations à ce sujet.

Et maintenant, n’hésitez pas à réaliser des projets avec un nombre massif d’entrées et de sorties ; )

Foire aux questions

Voici quelques questions fréquemment posées sur l’utilisation du registre à décalage 74HC165.

Q : Qu’est-ce qu’un registre à décalage 74HC165 ?

R : Le 74HC165 est un registre à décalage parallèle-série qui vous permet d’augmenter le nombre d’entrées numériques de votre Arduino en utilisant seulement trois broches.

Q : Combien d’entrées le registre à décalage 74HC165 peut-il gérer ?

R : Le registre à décalage 74HC165 peut gérer jusqu’à 8 entrées numériques, ce qui est utile pour les projets nécessitant plusieurs dispositifs d’entrée.

Q : Comment connecter le registre à décalage 74HC165 à mon Arduino ?

R : Vous pouvez connecter le 74HC165 à votre Arduino en reliant les entrées parallèles à vos dispositifs d’entrée et en connectant la broche de sortie série à une broche numérique de l’Arduino.

Q : Puis-je chaîner plusieurs registres à décalage 74HC165 ensemble ?

R : Oui, vous pouvez chaîner plusieurs registres à décalage 74HC165 pour augmenter encore le nombre d’entrées, ce qui vous permet de connecter plus de dispositifs d’entrée à votre Arduino.

Q : Quels sont les principaux avantages d’utiliser le 74HC165 dans des projets Arduino ?

R : Les principaux avantages du 74HC165 sont d’augmenter le nombre d’entrées sans utiliser toutes les broches de votre Arduino, de simplifier le câblage en réduisant le nombre de connexions nécessaires, et de permettre d’interfacer efficacement plusieurs dispositifs d’entrée.

Q : Le 74HC165 peut-il être utilisé avec d’autres microcontrôleurs qu’Arduino ?

R : Oui, le 74HC165 peut être utilisé avec d’autres microcontrôleurs qui supportent les opérations d’entrée/sortie numériques.

Q : Puis-je utiliser le 74HC165 dans des projets nécessitant une surveillance en temps réel des entrées ?

R : Oui, le 74HC165 convient aux projets nécessitant une lecture en temps réel de plusieurs entrées numériques, car il permet une lecture rapide de plusieurs entrées.

Q : Y a-t-il des conseils de dépannage courants pour travailler avec le 74HC165 ?

R : Les conseils de dépannage courants pour le 74HC165 incluent de bien vérifier les connexions, de s’assurer que les signaux d’horloge et de latch sont corrects, et de vérifier le format des données d’entrée dans votre code pour qu’il corresponde à la configuration du registre à décalage.