Przesuwane diody

Ostatnim z elementów Arduino Starter Kitu, który jeszcze nie doczekał się opisu na tym blogu jest niepozorny układ scalony – rejestr przesuwny. Jest układ 74HC595, rejestr przesuwny typu SIPO (Serial-In, Parallel-Out) o 8 wyjściach równoległych.

Rejestr przesuwny (ang. shift register) jest układem posiadającym wejście szeregowe i kilka (zazwyczaj 8) wyjść równoległych. Co to znaczy? Z każdą zmianą zegara na wejściu, stany wyjść są przesuwane o jeden. Czyli stan wyjścia 1 jest przepisywany do wyjścia 2, 2 do 3, itd. Stan wejścia 1 jest ustalany na podstawie stanu wejścia szeregowego.

Do czego można to zastosować w praktyce?

Każde miejsce które potrzebuje wielu wyjść cyfrowych, może być miejscem w którym można rozważyć zastosowanie rejestru przesuwnego. Można powiedzieć, że trzy piny mogą sterować znacznie większa ilością wyjść. Zobaczmy to na najprostszym przykładzie – diody LED.

Dzisiejszy artykuł jest oparty na przewodniku opublikowanym na stronach Arduino.cc, stanowi on źródło ilustracji i tekstu. Ilustracje wykorzystują więcej niż jedną płytkę stykową, ale zdecydowałem się je wykorzystać, aby przyspieszyć powstawanie tego wpisu – zrobienie dobrej ilustracji do tego wpisu we Fritzingu chyba nie jest możliwe (hint – czytelnej ilustracji :) )

Zacznijmy od podłączenia:

Schemat układu z rejestrem przesuwnym - zamontowany na płytce stykowej
Schemat układu z rejestrem przesuwnym – zamontowany na płytce stykowej

Zasilanie jest rozprowadzone przez szyny na płytce stykowej. Na lewej płytce są podłączone diody LED wraz rezystorami. Na prawej jest podłączony sam układ scalony 74HC595. Jego wyprowadzenia:

Wyprowadzenia pinów 74HC595
Wyprowadzenia pinów 74HC595

Na powyższym diagramie przedstawione są wyprowadzenia pinów opisane zgodnie z danymi producenta (ST Microelectronics), którego to układy są w ofercie Nettigo i stanowią część Starter Kitu. Na stronie Arduino jest opis przystosowany dla układów z oznaczeniami zgodnymi z nomenklaturą Philipsa. Co to znaczy? Na szczęście w tym wypadku różnica polega tylko w nazwach sygnałów (np wyjścia w STM – QA do QH, w wersji Philipsa Q0-Q7), położenie i znaczenie pinów jest identyczne. W tym przewodniku będę używał nazewnictwa zgodnego z STM.

Najprostsze podłączenie rejestru przesuwnego do Arduino wygląda następująco:

  • Zasilanie +5V do pinu 16 rejestru
  • Masa do pinu 8 rejestru

Jeżeli nie przeszkadza nam to, że po włączeniu diody mogą się nam zapalić w losowym układzie a chcemy użyć mniej wyjść cyfrowych na Arduino podłączamy:

  • G – pin 13 na rejestrze do masy
  • SCLR – pin 10 na rejestrze do +5V

Minimalny zestaw podłączeń do sterowania rejestrem z Arduino przedstawia się następująco (wszystkie piny na Arduino to wejścia cyfrowe):

  • SI – pin 14 rejestru do pinu 11 na Arduino
  • SCK – pin 11 rejestru do pinu 12 na Arduino
  • RCK – pin 12 rejestru do pinu 8 na Arduino

Między pinem RCK a masą może być potrzebny mały kondensator (1 μF – nie jest częścią Starter Kitu). Z serii eksperymentów które przeprowadziłem wynika, że nie powinien być potrzebny :)

Oto schemat logiczny  całego połączenia:

Schemat logiczny układu
Schemat logiczny układu

Co nam pozostaje? Program:

//**************************************************************//
//  Name    : shiftOutCode, One By One                          //
//  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                            //
//****************************************************************

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

//holder for infromation you're going to pass to shifting function
byte data = 0; 

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

}

void loop() {

  //function that blinks all the LEDs
  //gets passed the number of blinks and the pause time
  blinkAll(1,500); 

 // light each pin one by one using a function A
  for (int j = 0; j < 8; j++) {
    lightShiftPinA(j);
    delay(1000);
  }

  blinkAll(2,500);  

 // light each pin one by one using a function A
  for (int j = 0; j < 8; j++) {
    lightShiftPinB(j);
    delay(1000);
  } 

}

//This function uses bitwise math to move the pins up
void lightShiftPinA(int p) {
  //defines a local variable
  int pin;

  //this is line uses a bitwise operator
  //shifting a bit left using << is the same
  //as multiplying the decimal number by two.
  pin = 1<< p;

  //ground latchPin and hold low for as long as you are transmitting
  digitalWrite(latchPin, LOW);
  //move 'em out
  shiftOut(dataPin, clockPin, MSBFIRST, pin);
  //return the latch pin high to signal chip that it
  //no longer needs to listen for information
  digitalWrite(latchPin, HIGH);

}

//This function uses that fact that each bit in a byte
//is 2 times greater than the one before it to
//shift the bits higher
void lightShiftPinB(int p) {
  //defines a local variable
  int pin;

  //start with the pin = 1 so that if 0 is passed to this
  //function pin 0 will light.
  pin = 1;

  for (int x = 0; x < p; x++) {
    pin = pin * 2;
  }

  //ground latchPin and hold low for as long as you are transmitting
  digitalWrite(latchPin, LOW);
  //move 'em out
  shiftOut(dataPin, clockPin, MSBFIRST, pin);
  //return the latch pin high to signal chip that it
  //no longer needs to listen for information
  digitalWrite(latchPin, HIGH);

}

//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll(int n, int d) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, 0);
  digitalWrite(latchPin, HIGH);
  delay(200);
  for (int x = 0; x < n; x++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 255);
    digitalWrite(latchPin, HIGH);
    delay(d);
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);
    delay(d);
  }
}

Kod mignie wszystkimi diodami, potem zapali każdą po kolei diodę, mignie dwa razy wszystkimi i jeszcze raz zapali, korzystając z innej metody.

Najważniejsze wiadomości:

  • shiftOut to funkcja biblioteki Arduino, wysyłająca szeregowo wybrany bajt na wybrane wyjścia
  • ustawiając RCK (na Arduino podłaczony do 8) w stan niski możemy wysyłać dane do rejestru