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:

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:

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:

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