Oito LEDs

Descrición:

Nesta práctica imos controlar 8 LEDs facendo distintas secuencias con eles. Realmente iso é o mesmo que o que fixemos nos xogos de luces, pero ímolo usar como escusa para traballar cun rexistro de desprazamento.

Se non tes problemas de pins dispoñibles na túa placa non necesitarás isto, pero se queres engadir moitos LEDs ao teu proxecto consumirás enseguida os pins dixitais do Arduíno e non quedarán para poder conectar outras cousas. Utilizar un rexistro de desprazamento vainos permitir aforrar pins de Arduíno.

Se non tes problemas de pins non te compliques, pasa desta sección e traballa como fixeches ata agora.

Rexistro de desprazamento:

Un rexistro de desprazamento é un circuíto secuencial que cumpre as seguintes funcións:

• É capaz de almacenar un conxunto de n bits.
• Permite realizar a conversión de datos de serie a paralelo e viceversa.

Nós imos utilizar o 74HC595 (Shift Register de 8 bits serial-in, parallel-out) para cargar datos en serie e que o rexistro os vaia cargando nas saídas en paralelo. Con isto aforramos pins do Arduíno pois con só tres pins podemos controlar 8 saídas dixitais.

Montaxe:

A forma de conectalo é a que se mostra na figura.

Hai tres pins importantes que conectaremos á placa Arduíno, no noso caso conectámolos aos pins 8, 11 e 12:

• DATA IN ou DS: pin para enviar los bits en serie
• Clock ou SH_CP: indica cando hai que ler o bit.
• LATCH ou ST_CP: Cando os 8 bits de entrada se leron no rexistro, o LATCH escribe estes bits nos pins de saída do chip e mantenos ata que se reciban novos datos.

Os LEDs coas súas resistencias de protección irán nos pins 15, 1, 2, 3, … 7 (os marcados na figura como a, b, c,  etc.). Utilizamos 8 LEDs

Programa:

Para enviar os datos ao rexistro imos utilizar a función

shiftOut(dataPin, clockPin, LSBFIRST, n);

• n é o número que imos enviar. Se n=1 envía 00000001, se n=7 envía 00000111, se n=255 envía 11111111 etc. É dicir, hai que indicar o equivalente ao binario que se quere mostrar.
• LSBFIRST indica que enviamos o número binario empezando polo menos significativo. Se n=7 (00000111) mostra 00000111
• MSBFIRST indica que enviamos o número binario empezando polo máis significativo. Se n=7 (00000111) mostra 11100000

Tamén usaremos os operadores de desprazamento lóxico:

• a<<n Despraza o número “a” n bits cara á esquerda. Por exemplo, 1<<2 despraza o número 00000001 dous lugares cara á esquerda, quedando 00000100
• a>>n Despraza o número “a” n bits cara á dereita. Por exemplo, 128>>1 despraza o número 10000000 un lugar cara á dereita, quedando 01000000

Neste programa podes ver varios modos de funcionamento:

// Declaración de variables: 

int latchPin = 8 ;       //Pin ST_CP do 74HC595 - Escritura na saída
int clockPin = 12;        //Pin SH_CP do 74HC595 - Reloxo
int dataPin = 11;         //Pin DS do 74HC595 - Datos

// Configuración:

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

// Programa: 

void loop() {

// Programa que envía bytes determinados

  digitalWrite(latchPin, LOW) ;                 // Latch a LOW mentres introducimos os datos
  shiftOut(dataPin, clockPin, LSBFIRST, 7);     // Enviamos 7 (00000111) LSBFIRST -> queda 00000111
  digitalWrite(latchPin, HIGH) ;                // Latch a HIGH fixa os valores na saída
  delay(1000);

  digitalWrite(latchPin, LOW) ;                 
  shiftOut(dataPin, clockPin, MSBFIRST, 7);     // Enviamos 7 (00000111) MSBFIRST -> queda 11100000
  digitalWrite(latchPin, HIGH) ;                
  delay(1000);

// Programa que representa nos LEDs os números binarios de 0 a 256
  
  for (int n = 0; n <= 256; n++)  {
    digitalWrite(latchPin, LOW) ;                 
    shiftOut(dataPin, clockPin, LSBFIRST, n);     // Aquí introducimos o número
    digitalWrite(latchPin, HIGH) ;                
    delay(100);
  }

// Programa que despraza un byte cara á esquerda

  for (int i = 0; i < 9; i++)  {                    
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, LSBFIRST, 1<<i);    // Despraza 00000001 cara á esquerda
    digitalWrite(latchPin, HIGH) ;                  
    delay(300);
  }

// Programa que despraza un byte cara á dereita
 
  for (int i = 0; i < 9; i++)  {
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, MSBFIRST, 1<<i);    // Despraza 10000000 cara á dereita
    digitalWrite(latchPin, HIGH) ;                  
    delay(300);
  }

// Programa que despraza un byte (7=00000111) cara á esquerda 
 
  for (int i = 0; i < 6; i++)  {
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, LSBFIRST, 7<<i);    // Despraza 00000111 (7) cara á esquerda
    digitalWrite(latchPin, HIGH) ;                  
    delay(500);
  }
  
// Programa que despraza un byte (224=11100000) cara á dereita 
 
  for (int i = 0; i < 6; i++)  {
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, LSBFIRST, 224>>i);    // Despraza 11100000 (224) cara á dereita
    digitalWrite(latchPin, HIGH) ;                  
    delay(500);
  }

// Programa que vai apagando leds cara á esquerda

  for (int i = 0; i < 9; i++)  {
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, LSBFIRST, 255<<i);  // Despraza 11111111 (255) cara  á esquerda
    digitalWrite(latchPin, HIGH) ;                  
    delay(300);
  }

// Programa que vai apagando leds cara á dereita

  for (int i = 0; i < 9; i++)  {
    digitalWrite(latchPin, LOW) ;                   
    shiftOut(dataPin, clockPin, LSBFIRST, 255>>i);  // Despraza 11111111 (255) cara á dereita
    digitalWrite(latchPin, HIGH) ;                  
    delay(300);
  }
    
}

Propostas:

• Fai os teus xogos de luces co rexistro de desprazamento.

Recurso:

Se necesitas axuda para converter de binario a decimal e viceversa pode resultarche útil esta aplicación feita con Scratch:

[Scratch: Convertedor de sistemas de numeración]