shiftOut()

Descripción

Desplaza hacia la salida un byte de datos un bit a cada vez. Comienza a partir del bit más significativo (más a la izquierda) o menos significativo (más a la derecha). Cada bit se escribe a su vez en un pin de datos, después de lo cual un pulso de reloj se activa (pasa a nivel alto,  y a continuación, a nivel bajo) para indicar que el bit está disponible.
Nota: si estamos conectados con un dispositivo que está sincronizado por flancos de subida, necesitamos asegurarnos de que el pin de reloj está a nivel bajo antes de llamar a shiftOut (), por ejemplo, con una llamada a digitalWrite (pinReloj, LOW).
Esta es una implementación de software; véase también la biblioteca SPI, que proporciona una implementación de hardware que es más rápida, pero sólo funciona en pines específicos.

Sintaxis

shiftOut(dataPin, clockPin, bitOrder, value)

Parámetros

dataPin: el pin por el que sale cada bit (int)
clockPin: el pin que cambia cada vez que dataPin ha sido establecido a su valor correcto (int)
bitOrder: dirección de desplazamiento de los bits; MSBFIRST o LSBFIRST.
(Primero el Bit Más Significativo, o, Primero el Bit Menos Significativo)

value: los datos que se desplazan a la salida. (byte)

Retornos

Ninguno

Note

Los dataPin y clockPin deben estar ya configurados como salida conto pinMode().
shiftOut actualmente escribe en la salida 1 byte (8 bits) por lo que requiere una operación de dos pasos para valores de salida mayores que 255.
// Hacer esto para MSBFIRST serie
int data = 500;
// desplaza a la salida el byte alto
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));  
// desplaza a la salida el byte bajo
shiftOut(dataPin, clock, MSBFIRST, data);

// O hacer esto para LSBFIRST serie
data = 500;
// 
desplaza a la salida el byte bajo
shiftOut(dataPin, clock, LSBFIRST, data);  
// 
desplaza a la salida el byte alto
shiftOut(dataPin, clock, LSBFIRST, (data >> 8)); 


Ejemplo

Para acompañamiento del circuito, ver el tutorial para control de un Registro de Desplazamiento 74HC595.
//**************************************************************//
//  Name    : shiftOutCode, Hello World                         //
//  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 conectado ato ST_CP del 74HC595
int latchPin = 8;
//Pin conectado a SH_CP del 74HC595
int clockPin = 12;
////Pin conectado a DS del 74HC595
int dataPin = 11;

void setup() {
  // configurar pines de salida que ya están direccionados en el bucle principal
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
  //count up routine
  for (int j = 0; j < 256; j++) {
    // pone a masa latchPin y lo mantiene a nivel bajo durante la transmisión
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);   
    // devuelve el latch pin a nivel alto indicando al chipque 
    // ya no necesita escuchar la información
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
} 

3 comentarios:

  1. Hola Manolo. Tengo en proyecto hacer un circuito para hacer un juego similiar al de La Oca con ARDUINO. Es decir, lanzas un dado electronico, lees el valor y vas encendiendo los leds hasta llegar al valor del dado. Con la serie 4XXX CMOS o la 74HCXX no tengo problema. Usaria los 4514 y 4515 y utilizaria 7 pines del ARDUINO como direccionamiento.
    El problema está en que de esta forma, sólo enciendo un led que se mueve de forma progresiva, tanto hacia adelante como hacia atrás y me gustaría hacerlo como si fuera un "gusano". Me explico: Imaginemos que sale un 8 en el dado. La visualizacion seria ver como se van encendiendo del 1 al 8 y como se van apagando de 1 al 7, dando la sensación de un gusano en movimiento.He leido sobre los shift register (74hc595) y mas o menos es eso lo que busco. El problema es que no encuentro cómo "restar" o ir hacia atrás si por ejemplo caes en una casilla que te "invita" a la casilla 0 y que haga la misma visualización. Por ej. si estas en la casilla 40, iluminar los 40 leds y de forma progresiva ir apagándose del 40 al 1 hasta llegar al 0 que quedaría iluminado.Espero haberme explicado. Gracias y un saludo

    ResponderEliminar
  2. Considera una matriz de 8x8 (64 leds) con dos 74hc595 en cascada.
    Con uno controlas columnas y con otro filas.

    ResponderEliminar