Plus de sorties Arduino avec le registre à décalage 74HC595

Dans ce tutoriel, vous apprendrez comment utiliser le registre à décalage 74HC595 pour augmenter le nombre de sorties de votre Arduino.

L’Arduino UNO populaire dispose de 14 broches GPIO que vous pouvez utiliser pour la sortie (ou l’entrée) de données. Dans de nombreux cas, ce nombre de broches de sortie est suffisant, mais parfois ce n’est pas le cas. Vous pourriez acheter un Arduino plus cher et plus grand, par exemple Arduino Mega avec 54 broches GPIO ou un GPIO expander board. Mais la solution la moins coûteuse est d’utiliser un registre à décalage tel que le 74HC595.

Le 74HC595 fournit 8 sorties, ne nécessite que 3 broches de votre Arduino et peut être enchaîné pour créer autant de sorties que vous le souhaitez. Les seuls inconvénients sont qu’il est plus lent que l’utilisation directe des broches GPIO de l’Arduino et qu’il ne peut être utilisé que pour des sorties.

Mais si vous avez besoin de nombreuses sorties et que la vitesse n’est pas un critère important, alors le registre à décalage 74HC595 est fantastique. Commençons par les pièces nécessaires avant d’examiner plus en détail le fonctionnement d’un registre à décalage.

Pièces requises

Voici la liste des pièces nécessaires. J’ai utilisé un Arduino Uno pour ce projet, mais n’importe quelle autre carte Arduino, ou une carte ESP8266/ESP32 fonctionnera tout aussi bien. De plus, nous utiliserons le registre à décalage 74HC595, mais il existe quelques alternatives possibles comme le 74LS595, 74HC164 et le MCP23017.

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.

Fonction du registre à décalage 74HC595

Le registre à décalage 74HC595 est un circuit intégré (CI) qui convertit un flux de données série en données parallèles. Cela vous permet de contrôler beaucoup plus de sorties supplémentaires en utilisant seulement trois broches de votre Arduino.

Un registre à décalage comporte trois composants principaux : l’entrée série (SER), l’horloge série (SRCLK) et l’horloge de verrouillage (RCLK). La broche d’entrée série est utilisée pour entrer les bits de données un par un. L’horloge série déplace les données à travers les registres à chaque impulsion d’horloge. Enfin, la broche d’horloge de verrouillage est utilisée pour mettre à jour les sorties avec les données décalées.

Schéma fonctionnel

L’image ci-dessous montre le schéma fonctionnel avec les 8 registres internes du 74HC595. Vous pouvez voir les entrées de contrôle (OE, RCLK, SRCLR, SRCLK, SER) et les 8 sorties (Q _A … Q _H ).

Conversion des données série en sortie parallèle

Lorsque vous envoyez un octet de données au registre à décalage, il stocke les bits dans ses registres internes. Une fois tous les bits décalés, vous pouvez mettre à jour les sorties en basculant la broche d’horloge de verrouillage. Cela provoque le transfert des données stockées vers ses 8 broches de sortie.

Nous convertissons donc un flux de bits en série en une sortie parallèle de 8 bits. Vous pouvez voir ci-dessous une belle animation de Last Minute ENGINEERS qui montre ce processus. Notez le changement des bits de sortie rouges lorsque le signal de verrouillage des données passe à l’état haut.

Contrôle du 74HC595

Les étapes précises pour contrôler le 74HC595 via les broches RCLK, SER et SRCLK sont les suivantes :

1. Mettre la broche de verrouillage (RCLK) à LOW pour s’assurer que les sorties ne sont pas mises à jour pendant le décalage des données.
2. Envoyer les données bit par bit à la broche d’entrée série (SER).
3. Pour chaque bit, pulser la broche d’horloge (SRCLK) pour décaler les données dans le registre à décalage.
4. Répéter les étapes 2 et 3 jusqu’à ce que tous les bits soient décalés dans le registre.
5. Une fois tous les bits décalés, pulser la broche de verrouillage (RCLK) pour transférer les données du registre à décalage vers le registre de sortie.
6. Les données parallèles sont maintenant disponibles sur les broches de sortie (Q _A , …, Q _H ) du 74HC595, qui peuvent être connectées à des dispositifs externes tels que des LED, des relais ou d’autres composants numériques.

L’image ci-dessous montre le diagramme temporel de ces étapes :

En plus des broches RCLK, SER et SRCLK, vous pouvez utiliser la broche OE pour activer ou désactiver les sorties. Cela est utile si vous souhaitez envoyer un signal PWM. Nous en parlerons plus en détail plus tard. Le tableau ci-dessous liste les modes fonctionnels du 74HC595 selon les signaux de contrôle d’entrée.

Spécifications du 74HC595

Dans cette section, nous jetons un rapide coup d’œil aux spécifications du 74HC595. Pour plus d’informations, consultez la fiche technique du 74HC595.

Brochage

L’image ci-dessous montre le brochage du 74HC595. Notez que dans certaines autres fiches techniques, les broches sont nommées différemment, par exemple Q0, …, Q7 vs Q _A , …, Q _H pour les 8 broches de sortie. Mais l’agencement et la fonction des broches restent les mêmes.

En plus des broches de sortie, vous avez la masse (GND), les broches de contrôle d’entrée (RCLK, SER, SRCLK, SRCLR, OE) et la broche Q _H’ , qui permet d’enchaîner plusieurs 74HC595. Le tableau suivant liste toutes les broches et leurs fonctions.

Broche	Nom	Fonction
1	Q B	Sortie : B
2	Q C	Sortie : C
3	Q D	Sortie : D
4	Q E	Sortie : E
5	Q F	Sortie : F
6	Q G	Sortie : G
7	Q H	Sortie : H
8	GND	Masse
9	Q H’	Sortie : Enchaînement
10	SRCLR	Entrée : Effacement du registre à décalage
11	SRCLK	Entrée : Horloge du registre à décalage
12	RCLK	Entrée : Horloge de verrouillage, verrouille la sortie
13	OE	Entrée : Activation des sorties
14	SER	Entrée : Série, envoi des données série
15	Q A	Sortie : A
16	V CC	Alimentation (2V…6V)

Tensions et courants

Le 74HC595 fonctionne avec une tension d’alimentation (V _CC ) de 2V à 6V et ne nécessite que 80μA pour fonctionner. Au total, la charge sur le 74HC595 ne doit pas dépasser 70mA.

Vous pouvez alimenter le 74HC595 en 5V ou 3,3V (logique et alimentation). Il est donc facile à utiliser avec un ESP8266 ou un ESP32 également.

Bien que les sorties puissent fournir jusqu’à 35mA individuellement, la tension de sortie commence à chuter au-delà de 6mA. Même pour piloter des LED à faible courant, une résistance de limitation de courant est nécessaire. Typiquement, on choisira au moins 470Ω, voire mieux 560Ω.

Schéma d’application typique

L’image suivante montre un schéma d’application typique pour le 74HC595. Il utilise un microcontrôleur pour commander 8 LED avec des résistances de limitation de courant de 560Ω. Un petit condensateur de 0,1µF est également présent pour la protection contre les parasites.

Je vous montrerai comment monter ce circuit avec un Arduino dans la section suivante.

Câblage du registre à décalage 74HC595

L’image ci-dessous montre le câblage complet du registre à décalage 74HC595 avec un Arduino pour contrôler 8 LED. Il suit essentiellement le schéma d’application typique montré précédemment, à l’exception que j’utilise des résistances de 470Ω pour les LED et que j’omets le condensateur de 0,1µF. N’hésitez pas à ajouter le condensateur si vous observez un comportement instable du circuit.

Le câblage semble un peu complexe mais est en fait simple. Commencez par connecter le 5V et la masse (GND) de l’Arduino aux rails d’alimentation positifs et négatifs de la breadboard (fils rouge et noir).

Ajoutez ensuite les 8 LED en vous assurant que la patte la plus courte des LED est connectée au rail d’alimentation négatif (fil bleu). Pour chaque LED, insérez une résistance de 470Ω (ou 560Ω) dans la breadboard. Assurez-vous que chaque résistance est connectée à la patte la plus longue de la LED et qu’elle fait le pont sur la breadboard.

Connectez maintenant toutes les résistances aux broches de sortie Q _A , …, Q _H du 74HC595 (fils violets). Faites attention à la connexion inhabituelle à Q _A , qui se trouve sur le côté opposé du CI (broche 15).

Ensuite, connectez l’alimentation positive à la broche 16 (fil rouge) et la masse à la broche 8 (fil noir) du 74HC595. Il reste maintenant les broches de contrôle. OE, qui est à la broche 13, est reliée à la masse (fil noir) et SRCLR à la broche 10 est connectée à l’alimentation positive (fil rouge).

Enfin, connectez SER à la broche 14 du 74HC595 au pin 4 de l’Arduino (fil vert). RCLK à la broche 12 est connecté au pin 5 de l’Arduino (fil jaune). Et SRCLK à la broche 11 doit être connecté au pin 6 de l’Arduino (fil orange). Ci-dessous une photo du circuit complet sur une vraie breadboard.

Et voilà, le câblage est terminé. Dans la section suivante, nous écrirons un code simple pour tester le câblage.

Code pour contrôler les LED avec le registre à décalage 74HC595

Le code suivant utilise le 74HC595 pour allumer les 8 LED connectées en séquence. Jetez un coup d’œil rapide au code complet avant d’en examiner les détails.

// Light up LEDs in sequence using Shift Register
const int dataPin = 4;   // SER
const int latchPin = 5;  // RCLK
const int clockPin = 6;  // SRCLK

void setRegister(byte val) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, val); 
  digitalWrite(latchPin, HIGH);
  delay(1000);
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  byte leds = 0b00000000;
  setRegister(leds);
  
  for (int i = 0; i < 8; i++) {
    bitSet(leds, i);
    setRegister(leds);
  }
}

Constantes et variables

Nous commençons par définir les constantes dataPin, latchPin, et clockPin. Ces broches sont connectées aux broches correspondantes du registre à décalage. La broche dataPin sert à envoyer les données au registre, la broche latchPin sert à verrouiller les données sur les sorties, et la broche clockPin sert à décaler les données.

const int dataPin = 4;   // SER
const int latchPin = 5;  // RCLK
const int clockPin = 6;  // SRCLK

Fonction de réglage du registre

La fonction setRegister() est responsable de définir la valeur du registre à décalage. Elle prend en entrée un octet représentant l’état des 8 LED connectées au registre. Dans la fonction, on commence par mettre la broche latchPin à LOW pour préparer le décalage des données. Ensuite, on utilise la fonction shiftOut() pour envoyer les données au registre. Enfin, on met la broche latchPin à HIGH pour verrouiller les données et mettre à jour les sorties. On ajoute aussi un délai de 1000 ms pour ralentir l’allumage séquentiel des LED.

void setRegister(byte val) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, val); 
  digitalWrite(latchPin, HIGH);
  delay(1000);
}

Notez que vous pouvez inverser l’ordre d’envoi des bits de l’octet en changeant le paramètre bitOrder de MSBFIRST (bit de poids fort en premier) à LSBFIRST (bit de poids faible en premier). Les LED s’allumeront alors dans l’ordre inverse.

Fonction setup

Dans la fonction setup(), nous configurons les broches latchPin, dataPin, et clockPin comme sorties avec la fonction pinMode(). Cela est nécessaire pour que ces broches puissent envoyer des données au registre.

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

Fonction loop

Dans la fonction loop(), nous initialisons d’abord une variable octet leds avec la valeur 0b00000000. Cela représente l’état initial des LED, toutes éteintes. Nous appelons ensuite la fonction setRegister() pour définir cet état initial dans le registre.

Ensuite, nous entrons dans une boucle for allant de 0 à 7. À chaque itération, nous utilisons la fonction bitSet() pour définir un bit spécifique dans la variable leds, représentant la LED supplémentaire que nous voulons allumer.

Nous appelons ensuite à nouveau la fonction setRegister() pour mettre à jour l’état du registre et allumer la LED correspondante. En répétant ce processus dans la boucle, nous pouvons allumer séquentiellement toutes les LED connectées au registre. Et lorsque la boucle recommence, nous remettons toutes les LED à l’état éteint.

void loop() {
  byte leds = 0b00000000;
  setRegister(leds);

  for (int i = 0; i < 8; i++) {
    bitSet(leds, i);
    setRegister(leds);
  }
}

Si vous montez ce circuit et exécutez ce code, vous devriez voir la séquence d’allumage suivante.

Au lieu d’un ensemble de 8 LED individuelles, vous pouvez aussi utiliser une barre de LED. Consultez notre tutoriel : LED Bar Graph With Arduino UNO. Et si vous avez des difficultés avec le contrôle des LED en général, lisez How To Blink An LED Using Arduino (4 Different Ways) et Control Multiple LEDs With Different Delays with Arduino.

Notes

Notez que vous pouvez facilement envoyer des motifs (d’allumage) sous forme de nombres binaires pour activer les LED. Puisqu’un octet a 8 bits, on peut utiliser un octet pour décrire l’état de chacune de nos 8 LED (1 pour allumé, 0 pour éteint). Par exemple, pour activer chaque deuxième LED, vous pouvez utiliser la valeur binaire 0b10101010 et l’envoyer via setRegister.

void loop() {
  setRegister(0b10101010);
}

Ou, si vous voulez envoyer une séquence entière de motifs, c’est aussi facile :

byte patterns[] = { 0b00000000,
                    0b10101010,
                    0b11111111 };

void loop() {
  for (int i = 0; i < 3; i++) {
    setRegister(patterns[i]);
  }
}

Au lieu de coder en dur les motifs, vous pouvez aussi créer des motifs qui simulent un graphique en barres et les contrôler via un potentiomètre, voir How use Arduino to control an LED with a Potentiometer.

Enfin, notez qu’il existe une fonction bitClear() qui fonctionne en sens inverse de la fonction bitSet(), vous permettant de mettre des bits à zéro. Avec cela, vous pouvez implémenter un effet de lumière courante et d’autres effets.

void loop() {
  uint8_t leds = 0b00000000;

  for (int i = 0; i < 8; i++) {
    bitSet(leds, i);
    setRegister(leds);
  }

  for (int i = 7; i >=0; i--) {
    bitClear(leds, i);
    setRegister(leds);
  }  
}

Pour plus d’idées de motifs ou d’applications, consultez notre tutoriel Spin the Wheel Game.

Dans le code ci-dessus, nous avons allumé ou éteint complètement les LED. Bien que nous ne puissions pas graduer individuellement les LED, nous pouvons graduer toutes les LED actives en utilisant le signal OE (activation de sortie). C’est le sujet de la section suivante.

Signal PWM pour contrôler le registre à décalage 74HC595

La broche OE (Output Enable) du 74HC595 vous permet d’activer ou de désactiver toutes les broches de sortie Q _A , …, Q _H . Dans le circuit précédent, nous avons relié OE à la masse, ce qui active toutes les sorties. Notez la barre sur OE dans le brochage qui indique que la logique de la broche est inversée. Mettre OE à bas active les sorties, tandis que le mettre à haut les désactive.

Au lieu de commuter complètement les sorties, nous pouvons aussi envoyer un signal PWM à la broche OE, ce qui permet de « graduer » toutes les sorties. Notez que cela affectera toujours toutes les sorties Q _A , …, Q _H , donc nous ne pouvons pas graduer les LED individuellement.

Câblage

L’image suivante montre le câblage modifié. Au lieu de connecter la broche OE du 74HC595 à la masse (fil noir), nous devons la connecter à une broche PWM de l’Arduino. Ici, j’ai choisi la broche ~3. Tous les autres fils restent les mêmes.

Code

Dans le code, nous pouvons maintenant utiliser la broche 3 de l’Arduino pour envoyer un signal PWM à la broche OE du 74HC595 afin de graduer toutes ses sorties. Voici un exemple de code qui fait essentiellement la même chose que le précédent, mais qui à la fin du cycle diminue progressivement la luminosité des LED de pleine intensité à zéro, avant de recommencer le cycle.

int dataPin = 4;    // SER
int latchPin = 5;   // RCLK
int clockPin = 6;   // SRCLK
int enablePin = 3;  // OE

void setRegister(uint8_t val) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, val);  // LSBFIRST
  digitalWrite(latchPin, HIGH);
  delay(100);
}

void setBrightness(byte brightness) {
  analogWrite(enablePin, 255 - brightness);
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(enablePin, OUTPUT);
}

void loop() {
  uint8_t leds = 0b00000000;
  setRegister(leds);

  setBrightness(255);
  for (int i = 0; i < 8; i++) {
    bitSet(leds, i);
    setRegister(leds);
  }

  for (byte b = 255; b > 0; b--) {
    setBrightness(b);
    delay(2);
  }
}

La seule nouveauté est la fonction setBrightness() qui écrit le PWM sur la broche enablePin en utilisant la fonction analogWrite(). Habituellement, la pleine luminosité des LED est atteinte pour une valeur de 255. Mais puisque la logique de la broche OE est inversée, il faut soustraire la valeur souhaitée brightness de 255 pour compenser cette inversion.

Nous utilisons la fonction setBrightness() dans la deuxième boucle pour diminuer la luminosité b de 255 à 0 avec un délai très court de 2 ms.

  for (byte b = 255; b > 0; b--) {
    setBrightness(b);
    delay(2);
  }

Si vous téléversez ce code sur votre Arduino et l’exécutez, vous verrez l’effet suivant. Les LED s’allument en séquence et, lorsque toutes sont allumées, elles s’éteignent lentement jusqu’à zéro avant que le cycle ne recommence.

Dans la section suivante, nous verrons comment créer plus de 8 sorties en enchaînant plusieurs 74HC595.

Enchaînement de registres à décalage 74HC595

Un seul 74HC595 possède 8 sorties Q _A , …, Q _H et nécessite trois fils de contrôle. La bonne nouvelle est que vous pouvez enchaîner plusieurs registres à décalage 74HC595 pour ajouter autant de sorties que vous le souhaitez (dans des limites raisonnables) tout en utilisant seulement trois fils de contrôle.

L’enchaînement des 74HC595 est très simple. Par exemple, pour enchaîner deux 74HC595, il suffit de connecter la broche Q _H ‘ du premier 74HC595 à la broche SER du second. Voir l’image ci-dessous.

Câblage

Toutes les autres connexions restent les mêmes et sont dupliquées pour le second 74HC595. L’image ci-dessous montre le câblage complet de deux 74HC595 enchaînés permettant de contrôler 16 LED.

Code

Pour contrôler les 16 LED, vous pouvez utiliser le code suivant. Comme précédemment, il allume toutes les LED en séquence, les remet à zéro, puis recommence le cycle.

// Light up 16 LEDs in sequence using two Shift Registers
const int dataPin = 4;   // SER
const int latchPin = 5;  // RCLK
const int clockPin = 6;  // SRCLK

const int nRegister = 2;
const int nOutput = nRegister * 8;

void setRegister(byte vals[]) {
  digitalWrite(latchPin, LOW);
  for (int i = nOutput - 1; i >= 0; i--) {
    digitalWrite(clockPin, LOW);
    digitalWrite(dataPin, vals[i]);
    digitalWrite(clockPin, HIGH);
  }
  digitalWrite(latchPin, HIGH);
  delay(100);
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  byte leds[nOutput];

  for (int i = 0; i < nOutput; i++) {
    leds[i] = HIGH;
    setRegister(leds);
  }

  for (int i = 0; i < nOutput; i++) {
    leds[i] = LOW;
  }
  setRegister(leds);
}

Au lieu de définir les bits d’un octet représentant l’état de 8 LED, nous utilisons ici un tableau d’octets leds[]. Il stocke individuellement l’état de toutes les 16 LED. Cela utilise un peu plus de mémoire, mais c’est plus simple à utiliser et cela fonctionne pour un nombre arbitraire de registres à décalage enchaînés. Il suffit de définir la constante nRegister au nombre de registres connectés.

En conséquence, nous devons modifier un peu la fonction setRegister(). Elle prend maintenant un tableau d’octets et écrit les valeurs du tableau de manière itérative dans le dataPin. Notez que la boucle s’exécute en ordre inverse, pour imiter l’ordre MSBFIRST utilisé dans l’autre code.

void setRegister(byte vals[]) {
  digitalWrite(latchPin, LOW);
  for (int i = nOutput - 1; i >= 0; i--) {
    digitalWrite(clockPin, LOW);
    digitalWrite(dataPin, vals[i]);
    digitalWrite(clockPin, HIGH);
  }
  digitalWrite(latchPin, HIGH);
  delay(100);
}

Enfin, nous définissons l’état dans le tableau leds[] de manière itérative en le mettant à HIGH ou LOW, selon que nous voulons allumer ou éteindre la LED. La première boucle allume toutes les LED une par une, tandis que la seconde les éteint toutes en même temps. Notez que setRegister est appelé dans la première boucle mais après la seconde.

  for (int i = 0; i < nOutput; i++) {
    leds[i] = HIGH;
    setRegister(leds);
  }

  for (int i = 0; i < nOutput; i++) {
    leds[i] = LOW;
  }
  setRegister(leds);

Et voilà. Vous savez maintenant presque tout ce qu’il faut savoir sur le registre à décalage 74HC595 et pouvez l’utiliser pour ajouter des sorties à votre Arduino.

Résumé

Dans cet article, nous avons appris comment augmenter le nombre de sorties sur une carte Arduino en utilisant un registre à décalage 74HC595. En utilisant ce registre, nous pouvons augmenter significativement le nombre de dispositifs ou composants contrôlables par l’Arduino.

Nous avons commencé par discuter des pièces nécessaires pour ce projet, incluant une carte Arduino, un registre à décalage 74HC595, des résistances, des LED et des fils de connexion.

Ensuite, nous avons exploré le fonctionnement du registre à décalage 74HC595. Ce circuit intégré permet de convertir un signal d’entrée série en un signal de sortie parallèle, multipliant ainsi le nombre de sorties disponibles. Il fonctionne en décalant les bits de données à travers ses registres internes.

Nous avons ensuite abordé le câblage du registre à décalage 74HC595. Nous avons fourni un schéma détaillé et expliqué comment connecter le registre à la carte Arduino, aux LED et aux résistances.

Une fois le câblage terminé, nous avons implémenté le code nécessaire pour contrôler le registre à décalage 74HC595. Nous avons fourni un exemple de code montrant comment décaler les données dans le registre et contrôler les broches de sortie en conséquence. Le code est expliqué étape par étape, ce qui facilite sa compréhension et sa modification selon vos besoins.

De plus, nous avons exploré comment utiliser des signaux de modulation de largeur d’impulsion (PWM) pour contrôler le registre à décalage 74HC595. Le PWM permet de contrôler la luminosité des LED connectées aux broches de sortie du registre. Nous avons fourni un exemple de code et expliqué comment ajuster le signal PWM pour obtenir l’effet désiré.

Nous avons également discuté de la possibilité d’enchaîner plusieurs registres à décalage 74HC595 pour étendre encore davantage le nombre de sorties.

Si vous avez d’autres questions, veuillez consulter la section FAQ ci-dessous ou laisser un commentaire.

Bon bricolage 😉

Questions fréquemment posées

Voici quelques questions fréquemment posées sur l’utilisation du registre à décalage 74HC595 pour ajouter plus de sorties à votre Arduino :

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

R : Un registre à décalage est un circuit numérique capable de stocker et de décaler des données. Il est couramment utilisé pour augmenter le nombre de sorties sur un microcontrôleur comme l’Arduino. Le 74HC595 est un CI populaire qui peut contrôler jusqu’à 8 sorties en utilisant seulement 3 broches de l’Arduino.

Q : Comment fonctionne le registre à décalage 74HC595 ?

R : Le registre à décalage 74HC595 fonctionne en utilisant une entrée série pour charger les données dans ses registres internes. Les données peuvent ensuite être décalées vers les broches de sortie un bit à la fois. En enchaînant plusieurs registres à décalage, vous pouvez contrôler encore plus de sorties avec le même nombre de broches Arduino.

Q : Quels sont les avantages d’utiliser un registre à décalage ?

R : Utiliser un registre à décalage comme le 74HC595 présente plusieurs avantages. Premièrement, il permet de contrôler plusieurs sorties avec seulement quelques broches Arduino, ce qui est utile lorsque les broches disponibles sont limitées. Deuxièmement, il réduit la quantité de câblage nécessaire, rendant votre projet plus organisé et plus facile à gérer. Enfin, il libère des broches Arduino pour d’autres usages, vous permettant d’ajouter plus de fonctionnalités à votre projet.

Q : Puis-je contrôler la luminosité des LED avec le registre à décalage 74HC595 ?

R : Oui, vous pouvez contrôler la luminosité des LED avec le 74HC595. En utilisant la modulation de largeur d’impulsion (PWM), vous pouvez varier le rapport cyclique des broches de sortie connectées aux LED. Cela permet de contrôler les niveaux de luminosité des LED, créant des effets comme le fondu ou le clignotement.

Q : Puis-je enchaîner plusieurs registres à décalage 74HC595 ?

R : Oui, vous pouvez enchaîner plusieurs registres à décalage 74HC595 pour contrôler encore plus de sorties. En connectant la sortie série (Q7′) d’un registre à l’entrée série (SER) du suivant, vous créez une configuration en chaîne. Cela permet de contrôler un grand nombre de sorties avec un nombre minimal de broches Arduino.

Q : Y a-t-il des limites à l’utilisation du registre à décalage 74HC595 ?

R : Bien que le 74HC595 soit un composant polyvalent et utile, il présente quelques limites. Premièrement, il ne contrôle que des sorties numériques, il n’est donc pas adapté pour contrôler directement des dispositifs analogiques. Deuxièmement, sa capacité de courant est limitée, donc pour piloter des dispositifs à fort courant comme des moteurs ou des relais, un circuit supplémentaire est nécessaire. Enfin, le registre nécessite une configuration, il peut donc ne pas convenir aux projets très simples où la simplicité est prioritaire.

Q : Puis-je utiliser le 74HC595 avec d’autres microcontrôleurs que l’Arduino ?

R : Oui, le 74HC595 peut être utilisé avec d’autres microcontrôleurs que l’Arduino. Tant que le microcontrôleur peut communiquer avec des signaux numériques et dispose des broches nécessaires, vous pouvez utiliser le registre pour étendre le nombre de sorties.

Q : Comment connecter le 74HC595 à mon Arduino ?

R : Pour connecter le 74HC595 à votre Arduino, vous devez connecter les broches suivantes : SER (entrée série) à une broche numérique Arduino, SRCLK (horloge registre à décalage) à une autre broche numérique, RCLK (horloge registre) à une troisième broche numérique, et OE (activation sortie) à la masse. De plus, si vous enchaînez plusieurs registres, connectez la sortie QH’ d’un registre à l’entrée SER du suivant.

Q : Puis-je utiliser le 74HC595 pour lire des entrées aussi ?

R : Non, le 74HC595 est conçu uniquement pour le contrôle des sorties. Il ne peut pas lire des entrées. Pour lire des entrées, vous devez utiliser un autre composant, comme un registre à décalage avec capacités d’entrée ou une broche microcontrôleur dédiée.

Q : Puis-je utiliser le 74HC595 avec d’autres composants numériques que des LED ?

R : Oui, vous pouvez utiliser le 74HC595 avec d’autres composants numériques que des LED. Le registre peut contrôler tout composant numérique nécessitant un signal numérique pour s’allumer ou s’éteindre, comme des transistors, relais ou autres circuits intégrés.

Q : Puis-je utiliser le 74HC595 avec d’autres CI de registres à décalage ?

R : Oui, vous pouvez utiliser le 74HC595 avec d’autres CI de registres à décalage tant qu’ils ont des brochages et exigences de tension compatibles. Cependant, différents CI peuvent avoir des fonctionnalités différentes, il faudra donc consulter les fiches techniques et adapter votre code en conséquence.

Q : Puis-je utiliser le 74HC595 avec d’autres langages de programmation que l’IDE Arduino ?

R : Oui, le 74HC595 est un composant matériel contrôlable avec n’importe quel langage de programmation capable de communiquer avec le microcontrôleur. Vous devrez cependant adapter votre code à la syntaxe et aux bibliothèques spécifiques du langage utilisé.

Q : Puis-je utiliser le 74HC595 avec des microcontrôleurs fonctionnant à des tensions différentes ?

R : Oui, mais vous devez vous assurer que les niveaux de tension sont compatibles. Si le microcontrôleur fonctionne à une tension plus élevée que le registre, vous devrez utiliser des convertisseurs de niveau ou des diviseurs de tension pour assurer une communication correcte.

Q : Combien de registres à décalage puis-je enchaîner ?

R : Le nombre de registres que vous pouvez enchaîner dépend de plusieurs facteurs, notamment les broches disponibles sur votre microcontrôleur et les fonctionnalités souhaitées. Théoriquement, vous pouvez enchaîner un nombre illimité de registres. Cependant, plus vous enchaînez, plus le circuit devient complexe et le temps de décalage augmente. Il est recommandé de tester et valider votre conception pour garantir un fonctionnement fiable.

Q : Puis-je utiliser le 74HC595 avec d’autres types de registres à décalage, comme le 74HC164 ?

R : Oui, vous pouvez utiliser le 74HC595 avec d’autres types de registres à décalage comme le 74HC164. Cependant, ils peuvent avoir des brochages et fonctionnalités différents. Vous devrez consulter les fiches techniques des deux et adapter vos connexions et votre code en conséquence.

Q : Puis-je utiliser le 74HC595 pour contrôler d’autres types d’afficheurs numériques, comme des afficheurs 7 segments ou des LCD ?

R : Oui, vous pouvez utiliser le 74HC595 pour contrôler d’autres types d’afficheurs numériques, comme des afficheurs 7 segments ou des LCD. Cependant, vous aurez besoin de circuits supplémentaires et de code spécifique pour interfacer ces afficheurs. Par exemple, vous devrez peut-être utiliser des techniques de multiplexage pour les afficheurs 7 segments ou une bibliothèque LCD dédiée pour les écrans LCD.

Q : Puis-je utiliser le 74HC595 pour contrôler des servos ou moteurs pas à pas ?

R : Non, le 74HC595 n’est pas adapté pour contrôler directement des servos ou moteurs pas à pas. Ces dispositifs nécessitent un timing précis et des signaux de contrôle spécifiques. Vous devrez utiliser des modules pilotes moteurs ou contrôleurs de servos dédiés conçus pour ces besoins.

Q : Puis-je utiliser le 74HC595 dans des projets alimentés par batterie ?

R : Oui, le 74HC595 consomme très peu d’énergie, il n’affectera donc pas significativement l’autonomie de votre batterie. Cependant, il est important de considérer la consommation des composants connectés au registre, comme les LED ou autres dispositifs numériques, qui peuvent avoir un impact plus important sur la durée de vie de la batterie.

Voici quelques-unes des questions fréquemment posées sur l’utilisation du registre à décalage 74HC595 pour ajouter plus de sorties à votre Arduino. Si vous avez d’autres questions, n’hésitez pas à les poser dans la section commentaires ci-dessous.