shiftOut()

---

Description :

Décale un octet de données bit par bit. L’opération commence par le bit de poids fort (le plus à gauche) ou le bit de poids faible (le plus à droite). Chaque bit est écrit successivement sur une broche de données, puis une broche d’horloge est pulsée (passée à l’état haut, puis à l’état bas) pour indiquer que le bit est disponible.

Remarque : Si vous interagissez avec un périphérique cadencé par fronts montants, vous devez vous assurer que la broche d’horloge est à l’état bas avant d’appeler shiftOut(), par exemple digitalWrite(clockPin, LOW).

Il s’agit d’une implémentation logicielle ; voir également la bibliothèque SPI, qui propose une implémentation matérielle plus rapide, mais qui ne fonctionne que sur certaines broches.

Syntaxe :

Utilisez la fonction suivante pour écrire des données de manière synchrone via une broche :

shiftOut(dataPin, clockPin, bitOrder, value)

Paramètres :

La fonction admet les paramètres suivants :

• dataPin : broche sur laquelle chaque bit doit être envoyé. Types de données autorisés : int.
• clockPin : broche qui fournit le signal de synchronisation. Types de données autorisés : int.
• bitOrder : ordre de décalage des bits : MSBFIRST ou LSBFIRST (bit de poids fort en premier ou bit de poids faible en premier).
• value : données à décaler. Types de données autorisés : byte.

Retours :

La fonction ne renvoie rien.

Exemple de code :

Pour le circuit d’accompagnement, consultez le tutoriel sur le contrôle d’un registre à décalage 74HC595.

//**************************************************************//
//  Name    : shiftOutCode, Hello World                         //
//  Author  : Carlyn Maw,Tom Igoe                               //
//  Date    : 25 Oct, 2006                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a 74HC595 Shift Register           //
//          : to count from 0 to 255                            //
//****************************************************************

//Broche connectée à ST_CP of 74HC595
int latchPin = 8;
//Broche connectée à SH_CP of 74HC595
int clockPin = 12;
////Broche connectée à DS of 74HC595
int dataPin = 11;

void setup() {
  //définir les broches en sortie car elles sont adressées dans la boucle principale
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
  //count up routine
  for (int j = 0; j < 256; j++) {
    //Verrou latchPin et maintenu bas aussi longtemps que vous transmettez
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);
    //remettre latchPin haut pour signaler à la puce qu'elle
    //n'a plus besoin d'écouter les informations
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
}

Remarques et avertissements :

Les broches dataPin et clockPin doivent déjà être configurées comme sorties par un appel à pinMode().

shiftOut est actuellement écrit sur une sortie de 1 octet (8 bits). Il nécessite donc une opération en deux étapes pour générer des valeurs supérieures à 255.

// Faites ceci pour MSBFIRST en série
int data = 500;
// shift out highbyte
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// shift out lowbyte
shiftOut(dataPin, clock, MSBFIRST, data);

// Ou fais ça pour LSBFIRST en série
data = 500;
// shift out lowbyte
shiftOut(dataPin, clock, LSBFIRST, data);
// shift out highbyte
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

---

Source : https://docs.arduino.cc/language-reference/en/functions/advanced-io/shiftOut/