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
// 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
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);
}
}
// 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);
}
}
Gracias por el aporte!!!
ResponderEliminarHola 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.
ResponderEliminarEl 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
Considera una matriz de 8x8 (64 leds) con dos 74hc595 en cascada.
ResponderEliminarCon uno controlas columnas y con otro filas.