Blog

  • Post category:E/S Avancées
  • Commentaires de la publication :0 commentaire
  • Dernière modification de la publication :mars 11, 2022
  • Temps de lecture :5 min de lecture

shiftOut()

Description :

Déplace un octet de données un bit à la fois. Commence à partir du bit le plus significatif (c’est-à-dire le plus à gauche) ou le moins significatif (le plus à droite). Chaque bit est écrit à tour de rôle sur une broche de données, après quoi une broche d’horloge est pulsée (prise élevée, puis faible) pour indiquer que le bit est disponible.

Remarque – si vous vous connectez à un appareil cadencé par des fronts montants, vous devez vous assurer que la broche d’horloge est basse avant l’appel à shiftOut() , par exemple avec un appel à digitalWrite(clockPin, LOW) .

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

Syntaxe :

shiftOut(dataPin, clockPin, bitOrder, value)

Paramètres :

dataPin : la broche sur laquelle sortir chaque bit. Types de données autorisés : int.
clockPin : la broche à basculer une fois que la dataPin a été définie sur la valeur correcte. Types de données autorisés : int.
bitOrder : dans quel ordre décaler les bits ; MSBFIRST ou LSBFIRST. (Bit le plus significatif en premier ou Bit le moins significatif en premier).
value: les données à déplacer. Types de données autorisés : byte.

Retour :

Rien

Exemple de code :

Pour le circuit d’accompagnement, voir 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 d'utilisation d'un 74HC595 Registre à décalage //
//          : 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() {
  //routine de comptage
  for (int j = 0; j < 256; j++) {
    //ground latchPin et maintenez bas aussi longtemps que vous transmettez
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);
    //remettre la sortie de verrouillage au niveau haut pour signaler à la puce qu'elle
    //n'a plus besoin d'écouter les informations
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
}

 

Remarques et avertissements :

Le dataPin et le clockPin doivent déjà être configurés comme sorties par un appel à pinMode() .

shiftOut est actuellement écrit pour sortir 1 octet (8 bits), il faut donc une opération en deux étapes pour sortir des valeurs supérieures à 255.

// Faites ceci pour MSBFIRST en série
int data = 500;
// décaler l'octet élevé
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// décaler les octets bas
shiftOut(dataPin, clock, MSBFIRST, data);

// Ou faites ceci pour LSBFIRST en série
data = 500;
// décaler les octets bas
shiftOut(dataPin, clock, LSBFIRST, data);
// décaler l'octet haut
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

 

 

Source : https://www.arduino.cc/reference/en/language/functions/advanced-io/shiftout/

 

Nombre de vues: 968

Laisser un commentaire