APPROFONDIMENTO: SHIFT REGISTER 74HC595N

Lo shift register che utilizzeremo  (74HC595N) negli esempi seguenti è di tipo SIPO (serial input-parallel output - quindi i dati verranno caricati in forma seriale e verranno prelevati contemporaneamente in parallelo sulle uscite dell'integrato QA .. QH) e SISO (Serial Input - Serial Output). Tramite tale dispositivo è possibile controllare 8 uscite con solo 3 pin di Arduino. E' possibile connettere in cascata numerosi di questi integrati per pilotare un numero di porte maggiore come si vede nell'immagine sottostante.

 Qui sotto la pin function dell'integrato 74HC595N.

PIN 1-7 Pin di output (QB->QH o Q1->Q7) PIN 8 Terra - Vss (0V) PIN 9 Uscita seriale (QH') - Utilizzato per collegare + Shift register in cascata PIN 10 Serial Clear o Master reset (attivo quando è posto a LOW) - Pertanto attaccherò i 5V a tale pin se voglio evitare sempre il reset PIN 11 shift register clock input PIN 12 Storage register clock input (chiamato anche latch o RCK) - Usato per abilitare la scrittura PIN 13 Output abilitato - E' abilitato quando è posto a LOW quindi ci attacco la terra PIN 14 Ingresso seriale PIN 15 Pin di output QA o Q0 PIN 16 VCC (positive supply voltage 5V)

Il datasheet di 74HC595N lo identifica come “8-bit serial-in, serial or parallel-out shift register with output latches; 3-state”: questo integrato consente in breve di ricevere in modo seriale le informazioni che poi successivamente tramette in uscita in modo parallelo o seriale. Per iniziare la comunicazione seriale c’è bisogno di mettere l’integrato in uno stato di “ascolto” che avviene utilizzando un opportuno pin detto di “latch” (pin 12) e settandolo a LOW. Quando abbiamo terminato la comunicazione seriale basterà rimetterlo ad HIGH. Inoltre “3-state” fa riferimento al fatto che i dati in uscita possono essere oltre che ad HIGH o LOW anche ad “alta impedenza” ma non si può settare un singolo pin di uscita in questa modalità, ma bensì tutti insieme.

Terminato questo approfondimento sulla struttura dello SHIFT REGISTER e dei suoi componenti analizziamo il progetto di arduino. Costruiamo il seguente circuito:

Scriviamo il codice del nostro programma

/* -----------------------------------------------------------------------------------
Esempio creato partendo dal codice pubblicato all'indirizzo: 
http://englishjavadrinker.blogspot.it/2012/09/an-8-bit-waterfall.html "Code from an 
English Coffee Drinker" di pubblico dominio.
Legge un input di tipo analogico (valori da 0 a 7) sul pin 4, lo trasforma in binario
(8 bit) e li manda tramite la funzione shift out sui pin di output in parallelo
----------------------------------------------------------------------------------- */
int Pin_AbilitaScrittura = 2; // Pin 12 sullo SR - Cavo Bianco
int Pin_ClockRegister = 3;    // Pin 11 sullo SR - Cavo Blu
int Pin_SerialInput = 4;      // Pin 14 sullo SR - Cavo Marrone

void setup() 
{
   // Setto i pin come uscite
   pinMode(Pin_AbilitaScrittura, OUTPUT); 
   pinMode(Pin_ClockRegister, OUTPUT);
   pinMode(Pin_SerialInput, OUTPUT);
   Serial.begin(9600);
}

void loop() 
{
   int Valore;
   if (Serial.available()) // se ho caratteri disponibili sul monitor seriale
   {
       Valore=Serial.read()-48; // Leggi il dato sul Serial Monitor dell'IDE di Arduino
       if (Valore < 8 && Valore >= 0)
       {
           // Abilito la trasmissione del dato sull'ingresso seriale 
           digitalWrite(Pin_AbilitaScrittura, LOW);

           // Invio il dato sulla porta seriale
           shiftOut(Pin_SerialInput, Pin_ClockRegister , MSBFIRST, Valore); 

           // Disabilito la scrittura sull'ingresso seriale impostando il 
           // risultato del processo di shift sulle 8 uscite in parallelo
           digitalWrite(Pin_AbilitaScrittura, HIGH);
      }
   }
}

Quando utilizziamo il serial monitor ricordiamoci che solo l'ultimo carattere verrà visualizzato sui led

Dal codice si osservi:

Per scrivere un dato sullo shift register devo:

• Inizialmente devo porre a LOW (zero) il pin 12 (Storage Register Clock) dello Shift register (che è connesso al pin 2 di arduino) per abilitare la scrittura sulla linea seriale in ingresso (istruzione digitalWrite(Pin_AbilitaScrittura, LOW) );
• Il procedimento di scrittura seriale sul pin 14 (Serial Input) si compone di 2 step: A) generazione del segnale di clock sul pin 11 (Shift Register clock) dello shift register (connesso al pin 3 di arduino) B) serializzazione del dato  in ingresso sul pin 14 (Serial Input) dello shift register (connesso al pin 4 di arduino). ll procedimento di scrittura è implementato dalla funzione shiftout()
• Al termine occorre settare nuovamente a HIGH (1) il pin12 (Storage Register Clock) dello shift register. (istruzione digitalWrite(Pin_AbilitaScrittura, HIGH) );

Sintassi funzione:

shiftOut(dataPin, clockPin, bitOrder, Valore)

Shiftout() permette di serializzare il parametro Valore sul pin dataPin inviando il segnale di clock (necessario per il funzionamento dell’integrato) sul pin clockPin. Ogni bit di Valore viene scritto sul dataPin dopo un impulso del segnale di clock (corrisponde al fronte di discesa - da HIGH a LOW) che segnala che il bit è pronto.  Sulla base del dato serializzato prodotto dalla funzione Shiftout()e del segnale di clock lo Shift register parallelizza il dato serializzato in ingresso sul suo pin 14 (serial Input) impostando opportunamente le sue 8 uscite Q0...Q7.
I parametri della funzione sono:

• dataPin:è il pin dove il micro (ARDUINO) riverserà il dato serializzato. E' di tipo int.
• clockPin: E' il pin relativo al clock
• bitOrder: Indica la direzione dello shift: se dal bit più significativo posto a sinistra (MSBFIRST - Most Significant Bit) o da quello meno posto a destra (LSBFIRST: Least Significant Bit First). Si tratta di un tipo int
  
  
  
  
• Valore: è il dato da serializzare;

/* ----------------------------------------------------------------------------------- 
 Output serializzato a + di 8 bit
----------------------------------------------------------------------------------- */
// Caso con MSBFIRST
int data = 500;
shiftOut(dataPin, clock, MSBFIRST, (data >> 8)); // Scorrimento bit più significativi
shiftOut(dataPin, clock, MSBFIRST, data);        // Scorrimento bit meno significativi

// Caso LSBFIRST 
data = 500;
shiftOut(dataPin, clock, LSBFIRST, data);        // Scorrimento bit meno significativi
shiftOut(dataPin, clock, LSBFIRST, (data >> 8)); // Scorrimento bit più significativi
}

Che determina i seguenti risultati

/* -----------------------------------------------------------------------------------
Visualizza  il corrispondente numero in binario sfruttando una fila di 8 led
----------------------------------------------------------------------------------- */
int Pin_AbilitaScrittura = 2; // Pin 12 sullo SR - Cavo Bianco
int Pin_ClockRegister = 3;    // Pin 11 sullo SR - Cavo Blu
int Pin_SerialInput = 4;      // Pin 14 sullo SR - Cavo Marrone

void setup() 
{
   // Setto i pin come uscite
   pinMode(Pin_AbilitaScrittura, OUTPUT); 
   pinMode(Pin_ClockRegister, OUTPUT);
   pinMode(Pin_SerialInput, OUTPUT);
}

void loop() 
{
   for (int Valore=0; Valore <256 ; Valore++)
   {
      // Abilito la trasmissione del dato sull'ingresso seriale 
      digitalWrite(Pin_AbilitaScrittura, LOW);
      // Invio il dato sulla porta seriale
      shiftOut(Pin_SerialInput, Pin_ClockRegister , MSBFIRST, Valore); 
      // Disabilito la scrittura sull'ingresso seriale impostando il 
      // risultato del processo di shift sulle 8 uscite in parallelo
      digitalWrite(Pin_AbilitaScrittura, HIGH);
      delay(200);
  }
}

/* -----------------------------------------------------------------------------------
Visualizza  in binario, sfruttando 8 led, il numero digitato sul serial monitor
----------------------------------------------------------------------------------- */
int Pin_AbilitaScrittura = 2; // Pin 12 sullo SR - Cavo Bianco
int Pin_ClockRegister = 3;    // Pin 11 sullo SR - Cavo Blu
int Pin_SerialInput = 4;      // Pin 14 sullo SR - Cavo Marrone
#define MAX_DIGIT 4 // Accetto numeri con al massimo 3 cifre

void setup() 
{
   // Setto i pin come uscite
   pinMode(Pin_AbilitaScrittura, OUTPUT); 
   pinMode(Pin_ClockRegister, OUTPUT);
   pinMode(Pin_SerialInput, OUTPUT);
   InviaValoreAlloShiftRegister(0); // Spengo i LED
   Serial.begin(9600);
   Serial.println("Digita un numero  compreso tra 0 e 255:");
}
void InviaValoreAlloShiftRegister(int Valore)
{
   // Abilito la trasmissione del dato sull'ingresso seriale 
   digitalWrite(Pin_AbilitaScrittura, LOW);

   // Invio il dato sulla porta seriale
   shiftOut(Pin_SerialInput, Pin_ClockRegister , MSBFIRST, Valore); 

   // Disabilito la scrittura sull'ingresso seriale impostando il 
   // risultato del processo di shift sulle 8 uscite in parallelo
   digitalWrite(Pin_AbilitaScrittura, HIGH);
}
bool isInteger( char s[] )
{
  for (int i=0; i < strlen(s); i++ )
     if ( !isdigit( s[i] ) ) 
        return false; 
  return true;
}

void loop() 
{
  char  buffer[MAX_DIGIT];
  int i=0, Valore;
  if ( (Serial.available() > 0) )
  {
      // Questo Loop senza delay() permette di acquisire tutti i dati
      // nel buffer del Serial Monitor.
      while ( (Serial.available()>0) && (i<(MAX_DIGIT-1)) )
      {
          buffer[i++] = Serial.read();
          delay(10); // piccolo ritardo per evitare che i singoli digit del numero vengano spezzettati
      }
      buffer[i]='\0';
      while (Serial.available()>0)
          Serial.read(); // Lettura a vuoto per eliminare eventuali caratteri in +
      if (isInteger(buffer))
      {
         Valore=atoi(buffer);
         if (Valore < 256 && Valore >= 0)
         {
            InviaValoreAlloShiftRegister(Valore);
            Serial.println(Valore);
         }
         else
            Serial.println("Numero "+String(Valore)+" non accettato!");
      }
      else
         Serial.println(String(buffer)+" non e' un numero!");
      i=0;
  }
}

/* -----------------------------------------------------------------------------------
Visualizza  in binario, sfruttando 16 led, il numero digitato sul serial monitor
----------------------------------------------------------------------------------- */
int Pin_AbilitaScrittura = 4; // Pin 12 sullo SR - Cavo Bianco
int Pin_ClockRegister = 5;    // Pin 11 sullo SR - Cavo Blu
int Pin_SerialInput = 3;      // Pin 14 sullo SR - Cavo Marrone
#define MAX_DIGIT 6    // Accetto numeri con al massimo 5 cifre

void setup() 
{
   // Setto i pin come uscite
   pinMode(Pin_AbilitaScrittura, OUTPUT); 
   pinMode(Pin_ClockRegister, OUTPUT);
   pinMode(Pin_SerialInput, OUTPUT);
   InviaValoreAlloShiftRegister(0); // Spengo tutti i LED
   Serial.begin(9600);
   Serial.println("Digita un numero  compreso tra 0 e 65535:");
}

// Procedura alternativa a ShiftOut ma adatta a 16 bit
void My_shiftOut16Bit(unsigned int Val)
{
    for (int j=15; j>=0 ; j--)
    { 
       digitalWrite(Pin_ClockRegister,LOW); 
       digitalWrite(Pin_SerialInput,((Val>>j)&1)); 
       digitalWrite(Pin_ClockRegister,HIGH); 
    } 
}

void InviaValoreAlloShiftRegister(unsigned int Valore)
{
   // Abilito la trasmissione del dato sull'ingresso seriale 
   digitalWrite(Pin_AbilitaScrittura, LOW);
   // Effettuo lo shift di 16 bit MSBFIRST
   My_shiftOut16Bit(Valore);
   // Alternativa: doppio ShiftOut di 8 bit
   // shiftOut(Pin_SerialInput, Pin_ClockRegister , MSBFIRST, Valore >> 8);   // High Byte 
   // shiftOut(Pin_SerialInput, Pin_ClockRegister , MSBFIRST, Valore & 0xFF); // Low Byte 
   // Disabilito la scrittura sull'ingresso seriale impostando il 
   // risultato del processo di shift sulle 8 uscite in parallelo
   digitalWrite(Pin_AbilitaScrittura, HIGH);
}

// Determina se la stringa di caratteri è un numero intero
bool isInteger( char s[] )
{
   for (int i=0; i < strlen(s); i++ )
      if ( !isdigit( s[i] ) ) 
         return false; 
   return true;
}

void loop() 
{
  char  buffer[MAX_DIGIT];
  int i=0;
  unsigned int Valore;
  if ( (Serial.available() > 0) )
  {
      // Questo Loop senza delay() permette di acquisire tutti i dati
      // nel buffer del Serial Monitor.
      while ( (Serial.available()>0) && (i<(MAX_DIGIT-1)) )
      {
          buffer[i++] = Serial.read();
          delay(10); // piccolo ritardo per evitare che i singoli digit 
                     // del numero vengano spezzettati durante la digitazione 
                     // sul Serial Monitor
      }
      buffer[i]='\0';
      while (Serial.available()>0)
          Serial.read(); // Lettura a vuoto per eliminare eventuali caratteri in +
      if (isInteger(buffer))
      {
         Valore=atoi(buffer);
         if (Valore < 65536 && Valore >= 0)
         {
            InviaValoreAlloShiftRegister(Valore);
            Serial.println(Valore);
         }
         else
            Serial.println("Numero "+String(Valore)+" non accettato!");
      }
      else
         Serial.println(String(buffer)+" non e' un numero!");
      i=0;
  }
}

Codice Sorgente D

Obiettivo progetto: Costruire un circuito con 16 led che sia in grado di rappresentare in binario tutti i valori compresi tra 0 e 65.535 (2¹⁶-1)

soluzione:

Riutilizziamo lo stesso circuito dell'esempio C e inseriamo nell'ide il seguente codice:

/* -----------------------------------------------------------------------------------
Visualizza sfruttando una fila di 16 led tutti i numeri da 0 a 65.535
----------------------------------------------------------------------------------- */
int Pin_AbilitaScrittura = 4; // Pin 12 sullo SR - Cavo Bianco
int Pin_ClockRegister = 5;    // Pin 11 sullo SR - Cavo Blu
int Pin_SerialInput = 3;      // Pin 14 sullo SR - Cavo Marrone
void setup() 
{
   // Setto i pin come uscite
   pinMode(Pin_AbilitaScrittura, OUTPUT); 
   pinMode(Pin_ClockRegister, OUTPUT);
   pinMode(Pin_SerialInput, OUTPUT);
}

// Procedura alternativa a ShiftOut ma adatta a 16 bit
void My_shiftOut16Bit(unsigned int Val)
{
    for (int j=15; j>=0 ; j--)
    { 
       digitalWrite(Pin_ClockRegister,LOW); 
       digitalWrite(Pin_SerialInput,((Val>>j)&1)); 
       digitalWrite(Pin_ClockRegister,HIGH); 
    } 
}
void loop() 
{
   for (unsigned int Valore=0; Valore <65536 ; Valore++)
   {
      // Abilito la trasmissione del dato sull'ingresso seriale 
      digitalWrite(Pin_AbilitaScrittura, LOW);
      // Invio il dato sulla porta seriale
      My_shiftOut16Bit(Valore);
      // Disabilito la scrittura sull'ingresso seriale impostando il 
      // risultato del processo di shift sulle 16 uscite in parallelo
      digitalWrite(Pin_AbilitaScrittura, HIGH);
      delay(50);
  }
}