http://www.romanblack.com/shift1.

htm
http://microcontrolandos.blogspot.mx/2014/04/one-wire-com-
74hc595.html#more
http://dqsoft.blogspot.mx/

Controlar display de 7 segmentos con shift register
Etiquetas: 74hc595, 74xx595, Circuito, Conexin, Diagrama, Display, Display 7
segmentos, Electrnica, Microcontrolador, PIC, Registro de desplazamiento, Robtica,
Shift register
Ya vimos lo que es y como se controla un shift register, ahora veremos una de las tantas
utilidades que tiene. Aqu se explicar como utilizar un shift register para controlar un
display de 7 segmentos.

Para el que todava no lo conozca, un display de 7 segmentos es un panel conformado por 7
LED que comparten entre si sus nodos o ctodos segn si sean de nodo o ctodo comn
respectivamente.

A un display de nodo comn deberemos aplicar tensin positiva al pin compartido y GND
a cada uno de los pines correspondientes a los segmentos que se quieran iluminar, para un
display de ctodo comn deberemos invertir la polaridad. La mayora de displais poseen
tambin un octavo segmento que normalmente es un punto o dos.

Hasta aqu una pequea introduccin para conocer un poco su funcionamiento, ahora bien,
vimos que un shift register serial-paralelo memoriza el estado (0 o 1) de un pin (entrada)
y va rotando esos valores por cada pulso de reloj para representar la secuencia completa,
cuando se activa el pin Load, en unos pines asignados que tiene el integrado a tal fin.

Si a cada pin de salida (Q0-Q7) del integrado le conectamos un segmento del display, como
en la figura 1, logramos encender y apagar dichos segmentos independientes unos de los
otros. La principal utilidad es representar un nmero del 0 al 9 o una letra de la A a la F.

La ventaja de usar el shift register es que slo necesitaremos 3 pines del microcontrolador:
Clock (Amarillo), Data out (Verde) y Load (Rojo).

Figura 1. Conexin de un display de 7 segmentos a un shift register.

Si en lugar de emplear un solo integrado usamos dos (Figura 2), podremos multiplexar los
datos. Utilizando el segundo integrado para seleccionar el display que deseamos encender
en determinado momento, aumentaremos el numero de displais de 1 a 8 con un integrado
mas.

Figura 2. Conexin de 8 display de 7 segmentos a 2 shift register.

Si encendemos un display, lo apagamos y luego encendemos otro, y hacemos todo esto de
manera muy rpida el cerebro humano lo interpreta como si en realidad todos los display
permanecieran encendidos al mismo tiempo. Jugando con esto podemos ahorrarnos
muchsimos pines de nuestro PIC, por ejemplo si quisiramos hacer un reloj que indique la
hora, los minutos y los segundos, y conectramos cada segmento a cada pin de un
microcontrolador necesitaramos uno con 42 pines solo para los displais.

Sin shift register tambin se puede multiplexar, pero aun as utilizaramos demasiados
pines, 7 para los segmentos y 1 para cada display, para disear el mismo reloj del ejemplo
anterior necesitaramos un total de 13 pines contra los 4 que se necesitan implementando
los registros de desplazamiento.

Para usar los dos integrados, se conectan siguiendo el diagrama de la figura 2, el segmento
A de todos los displais con la Q0 del primer integrado, los segmentos B con el Q1, los C
con Q2 y as sucesivamente. La salida Q0 del segundo integrado se conecta al comn del
primer display, el pin Q1 al segundo, el Q2 al tercero as hasta un mximo de 8 displais.

Para controlarlo enviaremos los bits que conforman el caracter del primer display al primer
integrado y el bit correspondiente a dicho display en 0, a cada pulso de reloj, cuando
hayamos enviado todos los bits se manda el pulso Load y es cuando aparece el caracter en
el primer display, luego se repite la operacin pero con el bit del segundo display en 0, de
esa forma, y si los displais son de ctodo comn, encendern de a uno. A una alta
frecuencia esto crea la ilusin de estar todos encendidos.

Utilizando dos shift registers y 4 pines del microcontrolador tendremos capacidad para
controlar 8 displais, y si utilizramos un integrado y un pin del microcontrolador ms,
aumentaramos la cantidad de displais a 16.


SHIFT REGISTER que son y cmo se usan?
Etiquetas: 74hc165, 74hc595, 74xx165, 74xx595, Diagrama, Electrnica, PIC, Registro de
desplazamiento, Robtica, Shift register, SiLMuP
Un registro de desplazamiento (shift register en ingls), es un integrado capaz de almacenar
bits y presentarlos en sus pines.

Hay varios tipos pero los que aqu nos interesan son los del tipo Serial-Paralelo y Paralelo-
Serial, esto significa que en el primer caso los bits "entran" en forma serial (uno a uno) y
"salen" de forma paralela, en el segundo caso entrar en paralelo (todos juntos) y salen en
serie.

Unos de los integrados que hacen esto, entre muchos otros, son el 74HC595 y el 74HC165,
que son Serial/Paralelo y Paralelo/Serial respectivamente.

El pinout del 74HC595 es el siguiente:

Los pines marcados como Q0-Q7 son salidas y reflejan el estado interno de cada bit cuando
es activado poniendo a nivel alto el pin 12 (STCP), los datos ingresan de forma serial por el
pin 14(DS) cada vez que el pin SHCP pasa de estado bajo a alto ( de 0v a 5v).

Tambin se pueden enlazar varios integrados iguales de modo que ampliamos la cantidad
de bits. para ello agregamos un segundo integrado y conectamos la patilla DS a la patilla
Q7' del primero.

La secuencia seria la siguiente:
1.Se pone el pin DS en el estado del bit que se quiera ingresar
2.Pin SHCP en bajo
3.Pin SHCP en alto
4.Se repite el proceso hasta enviar los 8 bits
5.Se coloca el pin STCP en bajo
6.Se coloca el pin STCP en alto

y de esa forma aparece el byte en las salidas.

Pinout del 74HC165:

De manera similar funciona el 74HC165 solo que a los bit los "lee" todos juntos.

Aqu las entradas son D0 a D7 y la salida es Q7, PL es el Load y cuando pasa a estado bajo
carga los valores de las patas D0-D7 en "memoria" y dandole pulsos altos y bajos a CP los
datos van saliendo bit a bit.

Para encadenar varios basta con conectar Q7 de un integrado con DS del siguiente y leer la
pata Q7 del ltimo.

Este es el diagrama de conexin para leer 16 bits (2bytes) con dos integrados enlazados:

La forma de proceder sera asi:
Se pone en bajo el Load para tomar el estado de todas las entradas (b0 a b15) luego se envia
la seal de reloj poniendo en bajo y luego en alto Clk y se lee el estado de DI (Data-In).
Recordar que en DI aparecer primero el bit mas significativo (MSB).

Esta tcnica es vlida para controlar un display LCD, o multiplexar cualquier dato.

Aqu esta el cdigo en CSS C:
#include <16f84a.h>

#define Clk Pin_A0
#define Load Pin_A1
#define DI Pin_A2

#use fast_io(a)
#use fast_io(b)

int Leer_Shift (void);

void main(void){

set_tris_A(0b10100);
set_tris_B(0b00000000);

do{
if (input(pin_a4)==true) output_b(leer_shift());
}while(true);

}
int Leer_Shift (void){
int t;
int Lectura=0;
output_low (Load); // Pongo a low Load para "cargar" el estado de
las
output_high(Load); // entradas y paso a high para poder leerlas.

for(t=0;t<=7;++t){ // Hago un ciclo de 8 pasos (0 - 7)

Lectura<<=1; // Roto los bits de la variable temporal
Lectura+=input(Di); // y le sumo el valor del ultimo bit leido

output_low(Clk); // La transicion low-to-high hace que la
output_high(Clk); // memoria interna del integrado rote.
}
return Lectura;
}

En el ejemplo, Clock se conectara al pin 0, Load al pin 1 y DI al pin 2 del Puerto A. Pero
este programa solo leer de b8 a b15, para leer b0 a b15 se deber usar Int de 16 bits para
guardar los datos o dos de 8 bits y guardarlos en variables diferentes. Aparte de todo esto se
deber hacer un bucle de 16 ciclos en lugar de los 8 para leer 1 byte.

Con este circuito el nico pin exclusivo para el funcionamiento del registro es el pin A2
(Data in) ya que los otros se pueden conectar a otros circuitos sin que afecten a este.

SiLMuP (todava en construccin) utiliza un 74HC595 para controlar el display LCD y por
el mismo bus controlar las teclas de funcin y un 74HC165 para leer el estado de los
sensores de lneas.

De esta forma controla un display LCD, 4 teclas de funcin, 8 sensores siguelineas, y
proximamente mas sensores y bumpers para obstaculos con 6 pines del pic y solo 3 son
exclusivos.


Noveno Ejercicio:
Controlar desde el Arduino, un Display LED de 7-Segmentos, a travs de un IC 74HC595,
para mostrar un nmero de 0 a 9, dependiente de la posicin del Potencimetro.
Descripcin:
En este laboratorio se realizara el control de un Display 7 segmentos por medio de un
integrado IC 74HC595, el cual recibe los datos en forma serial y su salida es en forma
paralela (8 bits).
Para esta prctica, el procedimiento es crear una tabla de secuencias que contenga cada uno
de los nmeros del 0 al 9 y por medio de un potencimetro ir graduando el nmero a
mostrar.
Materiales:
Los materiales que usaremos para este noveno laboratorio son los siguientes:
2 resistencias
1 Display LED de 7-Segmentos Ctodo comn
1 plataforma Arduino Uno o MEGA
1 Integrado IC 74HC595
1 Protoboard
1 Potencimetro.
Diagrama:
ProtoBoard:

Esquematico:

Imgenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este noveno laboratorio.

Paso 2: Ubicar las resistencias y el Integrado IC 74HC595 en la ProtoBoard con sus pines
de alimentacin.
Paso 3: Ubicar el Potencimetro en el lugar que corresponde con sus pines de alimentacin
ya ubicados en la ProtoBoard.

Paso 4:
Conectar el Arduino al integrado, por medio de sus salidas digitales. Las salidas
digitales del Arduino a utilizar, son los pines del 7 al 9.
const int Latch = 8;
const int Clock = 9;
const int Data = 7;
Conectar el Potenciometro de 10k a la placa Arduino, el pin del medio del
Potenciometro se conectan al pin analogo A0.
Conectar los pines del integrado (Q0,Q1,Q2,Q3,Q4..) A los pines del display
respectivamente (A,B,C,D,E..)



Paso 5: Cdigos de nmeros y letras.

CODIGO ARDUINO:
// Se definen la cantidad de pines que vamos a usar como PIN
// y la entrada analoga A0 como la que se va a usar por el
// potencimetro
#define PIN 3
#define Pot A0

// Se le dan nombres a los pines (7-9) del arduino
// que van a ser usados por el integrado respectivamente
// adems el pin SH_CP osea Clock debe ser PWM(~)
const int Latch = 8;
const int Clock = 9;
const int Data = 7;

int led[PIN] = {
7,8,9};

// El valor de cada uno de los numeros que voy
// a mostrar en mi Display
int Numeros[10]={63,6,91,79,102,109,125,7,127,111};

// Ciclo para activar los ocho pines como salida
// y el pin A0 como entrada
void setup() {
for (int i=0; i<PIN; i++){
pinMode(led[i], OUTPUT);
}
pinMode(Pot, INPUT);
}

// Recibe la info de la posicin del potencimetro
void loop()
{
int Pos = analogRead(Pot);
Pos = map(Pos, 0, 1023, 0,10);
Casos(Pos);
}

// Segn la posicin del potencimetro escoge un caso
// osea un numero
void Casos(int Valor)
{
switch(Valor)
{
case 0:
On(Numeros[0]);
break;
case 1:
On(Numeros[1]);
break;
case 2:
On(Numeros[2]);
break;
case 3:
On(Numeros[3]);
break;
case 4:
On(Numeros[4]);
break;
case 5:
On(Numeros[5]);
break;
case 6:
On(Numeros[6]);
break;
case 7:
On(Numeros[7]);
break;
case 8:
On(Numeros[8]);
break;
case 9:
On(Numeros[9]);
break;
}
}

// Funcin para enviar los datos al Integrado IC 74HC595
void On(int Valor)
{
digitalWrite(Latch, LOW);
shiftOut(Data, Clock, MSBFIRST, Valor);
digitalWrite(Latch, HIGH);
delay(8);
}
CODIGO ARDUINO USANDO LETRAS:
// Se definen la cantidad de pines que vamos a usar como PIN
// y la entrada analoga A0 como la que se va a usar por el
// potencimetro
#define PIN 3
#define Pot A0

// Se le dan nombres a los pines (7-9) del arduino
// que van a ser usados por el integrado respectivamente
// adems el pin SH_CP osea Clock debe ser PWM(~)
const int Latch = 8;
const int Clock = 9;
const int Data = 7;

int led[PIN] = {
7,8,9};

// El valor de cada uno de los numeros que voy
// a mostrar en mi Display
int Numeros[10]={30,118,63,119,84,128,62,109,57,128};

// Ciclo para activar los ocho pines como salida
// y el pin A0 como entrada
void setup() {
for (int i=0; i<PIN; i++){
pinMode(led[i], OUTPUT);
}
pinMode(Pot, INPUT);
}

// Recibe la info de la posicin del potencimetro
void loop()
{
int Pos = analogRead(Pot);
Pos = map(Pos, 0, 1023, 0,10);
Casos(Pos);
}

// Segn la posicin del potencimetro escoge un caso
// osea un numero
void Casos(int Valor)
{
switch(Valor)
{
case 0:
On(Numeros[0]);
break;
case 1:
On(Numeros[1]);
break;
case 2:
On(Numeros[2]);
break;
case 3:
On(Numeros[3]);
break;
case 4:
On(Numeros[4]);
break;
case 5:
On(Numeros[5]);
break;
case 6:
On(Numeros[6]);
break;
case 7:
On(Numeros[7]);
break;
case 8:
On(Numeros[8]);
break;
case 9:
On(Numeros[9]);
break;
}
}

// Funcin para enviar los datos al Integrado IC 74HC595
void On(int Valor)
{
digitalWrite(Latch, LOW);
shiftOut(Data, Clock, MSBFIRST, Valor);
digitalWrite(Latch, HIGH);
delay(8);
}

74HC595 shift register para controlar display de 7 elementos

En un post anterior hablaba de como usar 8 puertos del Arduino para controlar un display
de 7 elementos, es una manera rpida pero poco practica de controlar estos elementos.
Y es ocupar 8 salidas en el Arduino nos reduce la posibilidad de hacer otras cosas, nos deja
6 salidas libres.
Podemos usar un chip 74HC595 que nos sirve para controlar 8 salidas digitales mediante 3
salidas del Arduino, ademas se puede encadenar, por lo que podemos controlar bastantes
salidas y tener libres 11 salidas del Arduino para agregarle cosas.
Antes de seguir, he de aclarar que este post y los dems relacionados son los menos
tcnicos, los menos formales y son solamente mis descubrimientos (no estudie nada
relacionado a la electrnica o programacin), pero hay que compartr lo que uno aprende,
quiz haya personas como yo que no queremos ser ingenieros en algo para hacer algn
aparato til.
Hay una gua muy interesante aqu sobre como usar un 74HC595 con un Arduino para
controlar LEDs, de hecho hay muchos otros tipos de shift register, pero usemos este (y
aprovechando que me hice de 25 de estos a un sper precio).
El chip 74HC595 tiene 16 pins, 8 de ellos para controlar mismo numero de salidas, 3 para
control 1 salida de datos (para conectar otros 74HC595)
Para conectarlo seguimos la recomendacin de la pagina de Arduino
Mostrar registros
Buscar:
Pin Conectar a
15, 1-7 salidas digitales, leds, display
8, 13 GND
9 al pin 14 del segundo 74HC595
10, 16 5V
11 Arduino D12
12 Arduino D8
14 Arduino D11
Mostrando desde 1 hasta 7 de 7 registros
Y aqu esta la imagen de dos 74HC595 conectados a 2 displays de 7 segmentos, el orden de
los pins es sencillo, el pin-disp quedaria: 15-A, 1-B, 2-C, 3-D, 4-Dp, 5-E, 6-F, 7-G

Hasta aqu todo bien, pero empezamos con los problemas
Mis display son de Anodo comn, lo que significa que un segmento se enciende al apagarse
un pin del 74HC595, cual es el problema? pues tenemos que cambiar el modo en que
enviamos los datos
para desplegar un 0 usando un display de ctodo comn enviaramos un byte 01101111
desde arduino, este encendera esos segmentos y tenemos un lindo 0; pero en uno de nodo
comn tendramos que enviar un byte 10010000 para que deje apagados (y por ende
enciendan en el AC)
Ademas, claro, el byte depende de como hayamos hecho la conexin entre display y el
74HC595; as que si elegimos otro orden en los pins pues habr que cambiar el byte de
control. Lo que hace esto en poco standard y no podemos robarnos usar cdigo de otras
personas que hayan publicado.
Ya estando en el IDE de Arduino controlar el shift register es de lo mas fcil, muy pocas
lineas de programacin, ya que hay una instruccin que hace todo el trabajo por nosotros:
shiftOut
/* Ejemplo de uso de un display de 7 segmentos nodo comn
usando un shift register 74HC595

Ivan Capdeville - ivan@darkapple.org

*/



const int latchPin = 8;
const int clockPin = 12;
const int dataPin = 11;


void setup() {

pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);


}

void loop() {


digitalWrite(latchPin,LOW);
shiftOut(dataPin, clockPin, LSBFIRST, *); // * caracter del segundo
display
shiftOut(dataPin, clockPin, LSBFIRST, *); // * caracter del primer
display
digitalWrite(latchPin, HIGH);

el cdigo es simple, declaramos las salidas del arduino que conectamos al 74HC595, las
configuramos como salidas digitales y vamos a usar esta secuencia para activar los
caracteres
digitalWrite(latchPin,LOW);
cuando el latchPin se apaga el shift register se prepara para recibir nuevos datos
shiftOut(dataPin, clockPin, LSBFIRST, *);
Esta parte es quiz la mas interesante y complicada de dominar al inicio, hay que elegir
como va leer el byte de entrada, si de derecha a izquierda (LSBFIRST) o de izquierda a
derecha (MSBFIRST) y en que nos afecta esto? pues determina como vamos a
confeccionar los caracteres, si usamos MSBFIRST usaremos el byte 10010000 para mostrar
un 0, si usamos LSBFIRST usaremos el byte 00001001
ya que elegimos que segmentos vamos a querer, ponemos una linea por cada display (en
orden inverso) ponemos esta linea para prender el latchPin y que se genere la instruccin
digitalWrite(latchPin,HIGH);
Afortunadamente para los que no queremos meternos tanto en rollos tcnicos, resulta que
podemos usar caracteres decimales para mostrar segmentos (aqu viene la rechifla despus
de leer tanto sobre nmeros binarios)
Podemos usar nmeros del 0 al 255 para controlar los segmentos a desplegar, pero no es tan
sencillo como poner un 5 para desplegar un 5, pues no, tienen su representacin, as que
usamos, por ejemplo, el 14 para desplegar el numero 3 y el 156 para el numero 4. Aqu es
donde usar binarios se vuelve mas simple (8 caracteres fijos y un 1 o un 0 para elegir si se
muestra o no el segmento, as que todos los segmentos prendidos en un display de nodo
comn seria un byte 00000000 (0) todos apagados 11111111 (256))
Esto hace mucho mas fcil el elegir que segmentos se prendern (o en una matriz de leds lo
mismo) se vuelve mas grfico el elegir, usando nmeros decimales aun no veo una relacin
o secuencia (quiz la haya pero ya despus buscare)
Al final de tanto rollo, mi recomendacin es usar LSBFIRST si usamos un display de
anodo comun y byte binario, si usamos numeros decimales y el anodo comun hay que usar
MSBFIRST y la conversion a decimal del byte
Mostrar registros
Buscar:
Digito en display Byte binario Decimal
0 10010000 9
1 11111001 159
2 01010100 42
3 01110000 14
4 00111001 156
5 00110010 76
6 00010010 72
7 01111000 31
8 00010000 8
9 00110000 12
Mostrando desde 1 hasta 10 de 11 registros
- See more at: http://blog.ivancapdeville.com/2011/09/26/74hc595-shift-register-para-controlar-
display-de-7-elementos/#sthash.tWiNwu4o.dpuf

Shift Registeresa pequea maravilla
09/06/2010 Deja un comentario






1 Votes

Hoy vamos a aprender a utilizar nuestro primer circuito integrado con Arduino (Luego le
vais a pillar el gusanillo a esto de utilizar IC con arduino pa t).
El 74HC595 Shift Register (Unos 0.65eur por unidad..barato,barato oiiiiigaaaa, lo tengo
baraaaaaato).

Que es ese chisme?
Como ya hemos visto anteriormente, Arduino nos permite controlar 14
Entradas/Salidas digitales (DE LA 0 A LA 13) ..o lo que es lo mismo, puedo conectar
14 dispositivos a esos pines y recibir o enviar ceros y unos.
Y si me hacen falta ms?ejemplo, la luz del coche fantstico (Knight Rider).
Si quiero hacer la famosa luz de KIT, necesitara para que quedara lo que se dice bonito,
bonito, unos 30 Leds.
30 leds.13 pineslas cuentas no dan.
SHIFT REGISTERS es la solucin, y en nuestro caso, vamos a utilizar uno llamado
74HC595(El ms baratito).
(POR CIERTO, ME ENTER HACE POCO QUE LOS 6 PINES ANALGICOS,
TB SE PUEDEN COMPORTAR COMO PINES DIGITALES.el pin analgico 0
se comportara como el 14 , el 1 como el 15, etc,etc.)
El 74HC595 permite que le conectemos 8 dispositivos y los va a controlar con solamente 3
pines en Arduino..la reduccin no parece mucha, pero lo que tb permite es enlazar
vrios ics entre ellos..lo que nos dara un resultado de:
1IC=8 dispositivos conectados, 3 pines en Arduino para conectarlos
2IC=16 dispositivos conectados, 3 pines en Arduino para conectarlos
3IC=24 dispositivos conectados, 3 pines en Arduino para conectarlos
4IC=32 dispositivos conectados, 3 pines en Arduino para conectarlos
xIC= 8*X dispositivos conectados, 3 pines en Arduino para conectarlos
Os habeis fijado?.nicamente hacen falta 3 pines conectados a Arduino para
controlar XXXX salidasdejando libres los otros 11 pines de Arduino.
Funcionamiento de un Shift
No voya liaros, que para eso est la documentacin tcnica (datasheet) del IC.

Los pines a los que vamos a conectar los LEDS (O lo que sea, van numerados desde del Q0
(patilla 15) hasta el Q7 (patilla 7) =8 salidas
Vcc (Patilla 16) recibe la corriente de +5v de la placa Arduino o de una fuente
externa.RECUERDA qeu si conectamos muchos LEDS, Arduino no va a ser capaz de
alimentarlos, por loq ye debemos recurrir a limentacin externa (de +5v igualmente)
Luego hay unas patillas 12 (latch) , 11(clock) y 14(data) que son las que vamos a
conectar a Arduinocon ellas vamos a controlar las 8 salidas .
Mecnica del asunto:
Los tres patillas tienen una funcin muy concreta que hay que entender para sacarle jugo al
IC.
LATCH (patilla 12) =CERROOJO . Esta patilla, es la primer ay la tima en activar. su funcin
es permitir la recepcin de datos y una vez recibidos, enviarle la orden a las 8 salidas para
que respondan a la informacin enviada.
CLOCK(Patilla 11) =RELOJ. Esta patilla, se encarga de guardar el dato enviado y pasar de
posicin a la nueva salida.
DATA (Pin 14) = DATOS. Esta patilla le indica al shift si la salida marcada por el clock actual
debe o no encenderse).
Ein?.mandeeee?
Vamos a explicarlo con un simil:
Imaginemos que somos un multimillonario (En mi caso, mucho imaginar).llegamos a
una tienda de deportivos osea superfashion osea y nos hacen una demostracin privada de
cada carro.
no sentamos en un super sof y damos la orden de que comienze el show . pasa el primer
carro ..nos mola y levantamos el pulgar para decir que lo compramos y que pase el
siguiente carro.
Pasa el siguiente carro, no nos mola, por lo que pulgar abajo y pasamos al
siguente..tercer,cuarto,quintoy as hasta el octavo.
Cmo lo hara el shift?
Sentarse en el sof a la espera que pase el carro = enviarle al pin LATCH un 0 y a CLOCK
un 0 . (Clock es un contador de la posicin en la que nos encontramos)
Pasa el primer carro y lo compramos = enviarle al pin DATA un 1 y a CLOCK un 1 y un 0
.lo que hemos hecho es decirle al shift, que en la posicin 0 (Que es en la que estaba el
clock), guarde un ON (data=1)
Clock 1 y cero es lo mismo que decirle.CLOCK, pasa a la siguiente posicin (o lo que es
lo mismo, a la posicin 1)
Pasa el segundo carro y no lo compramos = enviarle al pin DATA un 0 y a CLOCK un 1 y
un 0 (Posicion 1 guarda un OFF)
pasa el tercer carro y lo compramos = enviarle al pin DATA un 1 y a CLOCK un 1 y un 0
(posicion 3 guarda un ON)
El resto de los carros no los compramos
Al terminar de pasar los 8 carros le menadmos a LATCH un 1y lo que hace es enender
A LA VEZ los pines qeu tengan guardados un ON . En nuestro ejemplo (ON,OFF,ON,
OFF,OFF,OFF,OFF,OFF)
HAY QUE PASAR SIEMPRE POR LAS 8 POSICIONES DA IGUAL QUE SLO QUERAMOS
ENCENDER EL PIN 1HAY QUE PASAR POR LAS 8 SIEEEEEMPRE.
Vamos a simplificar un poco el coche fantsticolo haremos con dos
ejemplos.
El ms bsico = 1IC con 8 salidas controlado por 3 pines en Arduino (luz de KIT con 8
leds)

int latchPin = 8;
int clockPin = 12;
int dataPin = 11;
int cont=0;
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
digitalWrite(latchPin, 0);
digitalWrite(clockPin, 0);
digitalWrite(dataPin, 0);
//Iniciamos los 3 pines a 0
}
void loop() {
for (int i=1;i<=8;i++){ //recorremos desde el pin 1 al 8
if(i==cont){
digitalWrite(dataPin, 1);
}else{
digitalWrite(dataPin, 0);
}
digitalWrite(clockPin, 1);//Guarda el registro
digitalWrite(clockPin, 0);
}
if (cont=8){cont=0;}else{cont++;};
digitalWrite(latchPin, 1); //enviamos la orden de que se activen
digitalWrite(latchPin, 0);
delay(150);
}
En el sigiente captulo, el complicado:

El complicado = 2IC con 16 salidas controlado por 3 pines en Arduino (luz de KIT con 16 leds) (Este ejemplo
valdra para conectar de 2 hasta 50 ICsla lgica es la misma).
Arduino + 7 Segmentos (74HC595, 74HC4511)
By Ricardo Sequeira Ricardo Sequeira On 12 December 2012 In Arduino
Este circuito permite controlar vrios displays 7-Segmentos com apenas 3 pinos de um
Arduino. Para isso utiliza-se um registo de deslocamento (74HC595) e um controlador do
7-Segmentos para fazer a descodificao dos algarismos (binrio > 7-Segmentos).
Materiais
1 ATMega328p (*)
1 Cristal 16MHz (*)
2 Condesadores Cermicos 22pF (*)
14 Resistncias 220 Ohm
2 74HC4511 BCD to 7-segment latch/decoder/driver
1 74HC595 8 Bit Shift Registers with 3-State Output Register
Caso seja utilizado um Arduino os componentes assinalados com (*) no so necessrios.
Para representar o maior algarismo em binrio (9 > 1001) necessitamos de 4-bits, assim
podemos utilizar o 74HC595 para controlar 2 display de 7-Segmentos, uma vez que este
um registo de deslocamento de 8 bits. Para que o nmero em binrio possa ser representado
no display necessrio utilizar o 74HC4511 para efectuar o controlo dos 7 LEDs do
display.
necessrio um registo de deslocamento por cada 2 displays e por cada display
necessrio um driver (74HC4511).
Caso sejam utilizados 4 displays de 7-Segmentos sero necessrios 2 shift registers ligados
em cascata e 4 driver dos 7-Segmentos. Sero tambm necessrias algumas alteraes no
cdigo de modo a poder controlar os 4 displays.
Esquema do Circuito

Cdigo Arduino
/*
LCD circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
*/

#include <LiquidCrystal.h>

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 9;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8, 7, 6, 4, 3, 2);

int seven_seg_digits[10][4] = { { 0,0,0,0 }, // = 0
{ 0,0,0,1 }, // = 1
{ 0,0,1,0 }, // = 2
{ 0,0,1,1 }, // = 3
{ 0,1,0,0 }, // = 4
{ 0,1,0,1 }, // = 5
{ 0,1,1,0 }, // = 6
{ 0,1,1,1 }, // = 7
{ 1,0,0,0 }, // = 8
{ 1,0,0,1 } // = 9
};

void disp7Segm(int digit)
{
digitalWrite(5, seven_seg_digits[digit][0]);
digitalWrite(9, seven_seg_digits[digit][1]);
digitalWrite(10, seven_seg_digits[digit][2]);
digitalWrite(11, seven_seg_digits[digit][3]);
}

void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}

void loop() {
// Print a message to the LCD.
lcd.print("hello, world!");
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis()/1000);

for(int j=0; j<200; j++){
disp7SegmWrite(j);
delay(100);
}
}

// This method sends bits to the shift register:
void registerWrite(int whichPin, int whichState) {
// the bits you want to send
byte bitsToSend = 0;
// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);
// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}

void disp7SegmWrite(int number) {
int num1=0, num2=0;
if((number < 0) || (number > 99)){
number = 0;
}
num1=number/10;
num2=number%10;
// the bits you want to send
byte bitsToSend = 0;
// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);

//Escreve num1 (digito mais significativo)
bitWrite(bitsToSend, 0, seven_seg_digits[num1][3]);
bitWrite(bitsToSend, 1, seven_seg_digits[num1][2]);
bitWrite(bitsToSend, 2, seven_seg_digits[num1][1]);
bitWrite(bitsToSend, 3, seven_seg_digits[num1][0]);

//Escreve num2 (digito menos significativo)
bitWrite(bitsToSend, 4, seven_seg_digits[num2][3]);
bitWrite(bitsToSend, 5, seven_seg_digits[num2][2]);
bitWrite(bitsToSend, 6, seven_seg_digits[num2][1]);
bitWrite(bitsToSend, 7, seven_seg_digits[num2][0]);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}
Downloads