SHIFT REGISTER que son y cmo se usan?

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 #define #define #use #use Clk Load DI Pin_A0 Pin_A1 Pin_A2

fast_io(a) 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); las output_high(Load); for(t=0;t<=7;++t){ Lectura<<=1; Lectura+=input(Di); output_low(Clk); output_high(Clk); } return Lectura; }

// Pongo a low Load para "cargar" el estado de // entradas y paso a high para poder leerlas. // Hago un ciclo de 8 pasos (0 - 7) // Roto los bits de la variable temporal // y le sumo el valor del ultimo bit leido // La transicion low-to-high hace que la // memoria interna del integrado rote.

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.

Controlar display de 7 segmentos con 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.

Matriz de 8x8 LED controlada con 2 shift register y PIC

Muchas personas experimentan a diario con arrays de 8x8 LED y un porcentaje de esas personas reflejan sus dudas en distintos sitios desperdigados por la red destinados a este mundillo de la electrnica y los microcontroladores. Precisamente de una duda que se me plante hace poco por correo electrnico surgi un pequeo proyecto a modo de ejemplo de un array de 8x8 LED; El cual funciona de maravillas tanto simulado como fsicamente y es por eso que lo publico en esta ocacin. Dicho proyecto est basado en una serie de artculos anteriores dedicados a los shift register, en otras palabras es una implementacin de los registros para usarlos con una matriz de LED. Aqu presento el diagrama de conexin:

El PIC utilizado en esta ocacin es el PIC16F88 por ser muy fcil de implementar y contar con oscilador interno. La lnea Load se conecta al pin B0 del PIC, Clk al B1, dClm a B2 y dLin a B3. La lista de componentes es mas cuantiosa que variada pues esta compuesta por:
R1-R8 R9-R16 Q1-Q8 8 x Resistencias de 220 8 x Resistencias de 3,9K 8 x Transistores BC547 o similar

2 x 74HC595 64 x LED rojo de 5mm brillo standard

El cdigo, escrito en CCS C, para probar el hardware es el que sigue a continuacin, solo he dejado las letras pertinentes a PICROBOT, ya que sino se hace muy largo y repetitivo para mostrarlo como ejemplo, pero desde este link te puedes descargar el cdigo completo con las letras en maysculas A-Z, el .HEX, el .COF para simularlo en el ISIS de Proteus y el .DSN con el diseo. Hay dos versiones del cdigo en este paquete, matriz8x8Q y matriz8x8. La primera es para cuando se usen los transistores a los ctodos de los LED y la segunda si los ctodos van directamente a las salidas del registro de desplazamiento encargado de controlar las columnas. La nica diferencia entre las dos versiones es que la primer versin (Q) no invierte y la segunda si lo hace, las salidas del registro encargado de controlar las filas. Se podra haber solucionado el problema declarando o no una macro instruccin dirn algunos, despus de todo lo nico que vara es un caracter de una versin a otra, pero para no confundir, y como este es un ejemplo sencillo, decid hacerlo as. En un futuro ejemplo de la implementacin tal vez incluya una macro instruccin. /************************************************************************ * ** ** ** Ejemplo bsico para controlar una matriz de 8x8 LEDs con PIC. ** ** ** ** (c) 2010 Gerardo Ariel Ramrez ** ** picblog@hotmail.com ** ** http://picrobot.blogspot.com/ ** ** ** ************************************************************************* * ** ** ** Microcontrolador: PIC16F88 Oscilador: Interno - 8 MHz ** ** Lenguaje: CCS C ** ** ** ************************************************************************* / #include <16f88.h> // Tipo de microcontrolador

#fuses INTRC_IO,MCLR #fuses NOPUT,NOBROWNOUT #use fast_io(all) al principio. #use delay(clock=8M) #define #define #define #define char char int1 int1 int int int int int Load Clk dClm dLin PIN_B0 PIN_B1 PIN_B2 PIN_B3

// Oscilador interno, MCLR activo // Sin Brownout reset ni Power up timer // La configuracin de los puertos solo se hace // Velocidad del oscilador interno 8 MHz // // // // Load (STCP ambos integrados) B0 Clock (SHCP ambos integrados) B1 Data para las columnas (DS integrado 1) BC2 Data para las lineas (DS integrado 2) B3

Memoria[96]; Visor[8]; flag; flag2; indx; line; time; ptime; t;

// 96 Bytes para la memoria (0 - 95) // 8 para el visor (8 columnas) // Flags de control // // // // // Indice donde almacenar las nuevas columnas. Linea que a mostrar. Variables para el control de la velocidad de desplazamiento. Variable auxiliar.

void CargaMem(char Ascii); void GuardaClm(char c); #int_rtcc void isr(){ int Mul=128; if(++line>7)Line=0; vuelve a 0. if(++ptime>5){ ptime=0; if(++time>200){ time=0; Flag=true; } } for(t=0;t<8;t++){ valor // del bit de la fila actual. if (Line==t)output_high(dClm); correspondiente else output_low(dClm); desactiva. // Si Line es igual a t // activa el bit // a la columna, sino lo

// Cada vez que ocurre la interrupcion // selecciona la siguiente linea, si se pasa de 7 // Suma 1 a ptime. Si se pasa de 20 // lo pone en 0 y suma 1 a time. // Si se pasa de 200 // lo pone en 0 // y activa el flag.

// Bucle 0 - 7 (Lineas) // dLin es seteado con el

output_bit(dLin,!!(Visor[Line]&Mul));

output_low(Clk); // output_high(Clk); // Rota el contenido interno del 74HC595. Mul>>=1; (128,64,32...) // Divide la mascara que compara con Visor[]

} output_low(Load); output_high(Load);// El contenido interno del integrado pasa a las salidas. } void main(){ int k; set_tris_a(0x00); set_tris_b(0x00); for (k=0;k<8;k++){ Visor[k]=0; } for (k=0;k<96;k++){ Memoria[k]=0; } flag=true;

// Limpia la memoria y el visor // Activo el flag para que cargue la memoria // Configuracin del Timer0 // Interrupcion por Timer0 // Interrupciones globales

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); enable_interrupts(int_rtcc); enable_interrupts(global); do{ if (Flag){ flag2=true;

// Si el flag est activado // Activa el flag2

for (k=0;k<8;k++){ // Pasa el contenido de las primeras 8 visor[k]=Memoria[k]; // columnas en memoria al visor } for (k=0;k<95;k++){ memoria Memoria[k]=Memoria[k+1];// a la izquierda 1=1+1, 2=2+1, n=n+1... if (Memoria[k]!=0){Flag2=false;} // Si hay alguna columna que no // est vaca desactiva el flag2 } Memoria[95]=0; memoria if (Flag2){ indx=7; CargaMem("PICROBOT"); } Flag=false; } }while (true); } void GuardaClm(char c){ // Si flag2 est activo // a partir de la columna 7 // escribe PICROBOT // Desactiva el flag // Limpia la ultima columna de la // Rota el contenido de toda la

// Bucle infinito

if (indx<94){ Memoria[indx]=c; memoria indx++; } } void CargaMem(char ascii){ switch (ascii){

// Guarda la columna en la ubicacin actual de // y aumenta el indice

// Carga la memoria con el caracter deseado

case('B'): GuardaClm(0b01111111); GuardaClm(0b01111111); GuardaClm(0b01001001); GuardaClm(0b01001001); GuardaClm(0b01111111); GuardaClm(0b00110110); break; case('C'): GuardaClm(0b00111110); GuardaClm(0b01111111); GuardaClm(0b01000001); GuardaClm(0b01000001); GuardaClm(0b01100011); GuardaClm(0b00100010); break; case('I'): GuardaClm(0b01000001); GuardaClm(0b01000001); GuardaClm(0b01111111); GuardaClm(0b01111111); GuardaClm(0b01000001); GuardaClm(0b01000001); break; case('O'): GuardaClm(0b00111110); GuardaClm(0b01111111); GuardaClm(0b01000001); GuardaClm(0b01000001); GuardaClm(0b01111111); GuardaClm(0b00111110); break; case('P'): GuardaClm(0b01111111); GuardaClm(0b01111111); GuardaClm(0b00001001); GuardaClm(0b00001001); GuardaClm(0b00001111); GuardaClm(0b00000110); break; case('R'):

GuardaClm(0b01111111); GuardaClm(0b01111111); GuardaClm(0b00001001); GuardaClm(0b00011001); GuardaClm(0b01111111); GuardaClm(0b01100110); break; case('T'): GuardaClm(0b00000011); GuardaClm(0b00000001); GuardaClm(0b01111111); GuardaClm(0b01111111); GuardaClm(0b00000001); GuardaClm(0b00000011); break; } GuardaClm(0b00000000); }

Conexin y funciones de un mdulo LCD

Una pantalla de cristal lquido o LCD (Liquid Cristal Display) es un dispositivo para la presentacin de imagenes o caracteres. En este caso usaremos uno basado en el Controlador Hitachi 44780 o compatible, que muestra 16 o 20 caracteres en 1, 2 o 4 lneas. Las funciones de control son iguales para todos los modelos.

Conexionado:
PIN 01 02 Nombre Vss Vdd Direccin P P Funcin GND Alimentacin a 5V

03 04 05 06 07 - 14 15 - 16

Vee RS RW E D0 - D7 A-K

P I I I I/O P

Control de contraste Seleccin de Registro / Dato Seleccin de Escritura / Lestura Enable / Disable Bus de datos Corresponden al nodo y ctodo del backlight (si el modelo lo tiene)

Bueno, la operacion del display es bastante sencilla ya que el Controlador interno, hace casi todo el trabajo, para comandarlo debemos saber como funcionan sus pines. Para enviar un comando o un dato deberemos primero indicar que es lo que estamos enviando para eso se usa el pin RS, cuando este pin esta en 0 el LCD interpretar la informacin que esta prensente en sus pines D0 a D7 como un comando, si est en 1 significa que estamos enviandole un caracter, en cuyo caso se imprimira donde est actualmente el cursor. Asimismo en lugar de enviar informacin puede llegar el momento en que queramos leer algo de su memoria, para eso se utiliza el pin R/W, en 0 el LCD estar en modo escritura y en 1 en modo lectura. El pin E es el que le indica al display que ejecute la operacin que estamos enviandole, cuando este pin esta en 0 cualquier modificacin que hagamos en sus otros pines ser ignorada. Entonces la forma de proceder ser asi:

- Se colocan los pines RS en 1 o 0 dependiendo si vamos a enviar un caracter o una direccin. - R/W a 0 si queremos enviar un caracter o un comando y en 1 si queremos leer algun dato del display. - Ponemos D0 a D7 Con el valor del caracter que queremos imprimir, o con el comando que deseamos ejecutar en el display ( si R/W es 1 estos pines se convertiran en salidas y solo podremos leer el estado) - Por ultimo se pone en alto el pin E y el display ejecutar la funcin. Ahora bien, como ya coment por ahi, el R/W no lo usaremos, ya que como nosotros escribiremos en el display no necesitaremos obtener ninguna informacin de el, para hacer esto basta con conectar el pin 5 (R/W) directamente a GND y el LCD estar siempre en modo escritura. El funcionamiente se resumira asi: RS nos servir para indicarle al LCD si lo que le estamos mandando es un comando o un caracter; D0 a D7 para enviarle el dato o el comando y E para que lo ejecute.

Para enviar un caracter simplemente ponemos RS en 1 y el valor binario del caracter en los pines D0 a D7E y aparecer nuestro caracter en pantalla. luego pasamos a 1 el pin.

Impresin de caracteres. Pero esto solo nos permite escribir un caracter al lado de otro, para seleccionar donde escribir, borrar pantalla etc debemos hacer el mismo procedimiento pero con el pin RS en 0 y los pines D0 a D7 con el valor del comando correspondiente a la operacin que queramos hacer:

CLEAR DISPLAY la pantalla.

Borra el contenido de

HOME

Coloca el cursor en el primer espacio de la primera lnea sin modificar el contenido de la pantalla.

ENTRY MODE SET que se imprimiran los caracteres. I/D = 0 Incrementa el cursor I/D=1 Decrementa el cursor S=0 Desplaza el cursor S=1 Desplaza el display

Especifica el modo en

DISPLAY ON/OFF CONTROL encendido y apagado de la pantalla. D=0 Pantalla apagado D=1 Pantalla encendida C=0 Oculta el cursor C=1 Muestra el cursor B=0 Cursor esttico B=1 Cursor parpadeante

Control de

CURSOR OR DISPLAY SHIFT display o el cursor. S/C=0 Mueve el cursor S/C=1 Mueve el display

Mueve el

R/L=0 Mueve a la derecha R/L=1 Mueve a la izquierda

FUNCTION SET datos, cantidad de lneas y modo de caracteres. DL=0 Bus de datos de 4 bits (D4 a D7) DL=1 Bus de datos de 8 bits (D0 a D7) N=0 LCD de 1 lnea N=1 LCD de 2 lneas F=0 Caracteres de 5 x 7 pixeles F=1 caracteres de 5 x 10 pixeles SET CG RAM ADDRESS

Establece el bus de

Ingresando de este modo la direccin de la CG RAM, indica que cuando usemos el comando para escribir en el display, lo que enviaremos sern caracteres personalizados, se necesitan 7 instrucciones por caracter.

SET DD RAM ADDRESS Cuando escribimos en el display lo que en realidad estamos diciendole al mdulo que haga es almacenar X caracter en Y posicin de memoria, con este comando indicamos en que lugar de la DD RAM se guardar el prximo caracter que enviemos. 80-8F corresponde a la memoria para la primera linea y C0-CF a la segunda. Lo siguiente que nos queda es mostrar las rutinas para hacer todo esto, y eso lo pueden ver en este apartado: Control de un mdulo LCD con PIC y CCS C

Controlar 8 displais de 7 segmentos con shift register

Continuando con el tema de los shift register, ofrecer algunas utilidades a dichos integrados utilizando un microcontrolador a modo de ejemplo y totalmente funcionales. El ejemplo que aqu propongo es la utilizacin de los registros para controlar 8 displais de 7 segmentos, como ya vimos anteriormente en este artculo, pero con el agregado de la implementacin de un teclado; Pero aqu les proporciono el ejemplo completo con el cdigo fuente en CCS C y su respectivo .HEX para que puedan grabarlo en el PIC y probarlo. He aqu el diagrama de conexin:

El diagrama es bastante sencillo, solo hace falta conectar cada segmento de cada display a las salidas (Q0-Q7) del shift register encargado de "dibujar" los nmeros y el nodo comn de cada display a cada una de las salidas del segundo integrado. Tambin este diseo es vlido si los displais son de ctodo comn la nica diferencia est en que habra que hacer una pequea modificacin en el cdigo. Para probar el cdigo que les propongo, al diagrama anterior hay que agregarle algunas cosas como por ejemplo 10 pulsadores, 10 diodos 1N4001-7 y 2 resistencias de unos 10K, como se ve en el siguiente diagrama.

Cada nodo de los diodos se conecta a una salida diferente del shift register encargado de seleccionar el display que se iluminar, de esta forma multiplexmos el teclado de modo que a cada iteracin del bucle encargado de encender un display comprobamos una tecla, como esto nos da la posibilidad de conectar solo 8 pulsadores, se agrega otra entrada para comprobar una segunda lnea. A continuacin les dejo el cdigo: /************************************************************************ * ** ** ** Ejemplo para controlar 8 display de 7 segmentos ** ** y un teclado con dos shift register y un PIC. ** ** ** ** (c) 2010 Gerardo Ariel Ramrez ** ** picblog@hotmail.com **

** http://picrobot.blogspot.com/ ** ** ** ************************************************************************* * ** ** ** Microcontrolador: PIC16F88 Oscilador: Interno - 8 MHz ** ** Lenguaje: CCS C ** ** ** ************************************************************************* / #include <16f88.h> // Tipo de microcontrolador #fuses INTRC_IO,MCLR,NOPUT,NOBROWNOUT // Fuses #use fast_io(all) #use delay(clock=8M) #define #define #define 1) B2 #define 2) B3 #define #define #define #define #define #define #define #define de cada #define Mask. Load Clk dDsp dSeg Teclado1 Teclado2 PIN_B0 PIN_B1 PIN_B2 PIN_B3 PIN_B4 PIN_B5 // Load (STCP ambos integrados) B0 // Clock (SHCP ambos integrados) B1 // Data para seleccionar display (DS integrado // Data para activar segmentos (DS integrado // Entrada de teclas 0-7 // Entrada de teclas 8 y 9

Seg_A 0x01 Seg_B 0x02 Seg_C 0x04 Seg_D 0x08 Seg_E 0x10 Seg_F 0x20 display. Seg_G 0x40

// Los bits correspondientes a cada segmento // Estos bits se comparan mediante la mscara

int Digit[8]; int Numero[10]={ Seg_A + Seg_B + Seg_C + Seg_D + Seg_B + Seg_C, Seg_A + Seg_B + Seg_D + Seg_E + Seg_A + Seg_B + Seg_C + Seg_D + Seg_B + Seg_C + Seg_F + Seg_G, Seg_A + Seg_C + Seg_D + Seg_F + Seg_A + Seg_C + Seg_D + Seg_E + Seg_A + Seg_B + Seg_C Seg_A + Seg_B + Seg_C + Seg_D + Seg_A + Seg_B + Seg_C + Seg_D + }; // Establece Numero[0-9] con segmento que deber encender. void CargaMem(char Ascii);

Seg_E + Seg_F, Seg_G, Seg_G, Seg_G, Seg_F + Seg_G, Seg_E + Seg_F + Seg_G, Seg_F + Seg_G los datos correspondientes a cada

void GuardaClm(char c); void main(){ int d; int b; int Mask; int Tecla; int anTecla; setup_ccp1(CCP_OFF); set_tris_a(0); set_tris_b(0b00110000); B4:B5 como entradas setup_oscillator(OSC_8MHZ); d=0; anTecla=10; do{ Mask=0x80; en high for (b=0;b<8;b++){ // Carga la mascara, solo el MSB // Un bucle de 8 pasos (0-7) // Le enva // register encargado de encender // segmentos. if (b==d) output_high(dDsp); else output_low(dDsp);// alto el bit corres// al display que se va a // en esta iteracin. Mask>>=1; 64, 32... output_low(Clk); output_high(Clk); register rote } output_low(Load); memoria output_high(Load); represente en sus salidas if (input(Teclado2)) Tecla=d+9; la pulsacin en las if (input(Teclado1)) Tecla=d+1; en la variable Tecla. if (++d>7){ // Low-to-High en el Clk // hace que la memoria del shift los Pone en pondiente encender // Puerto A como salida // Puerto B como salida excepto

output_bit(dSeg,!(Mask&Numero[Digit[d]])); los bits al shift

// Divide la mascara por 2 : 128,

// Low-to-High en Load hace que la // del shift register se // Comprueba que se haya detectado // entradas de teclado y lo guarda // Incrementa el display a mostrar // si se pasa de 7 vuelve a 0-

if (Tecla!=0 && AnTecla==0){ ha pulsado una tecla) for (b=7;b>0;b--){ Digit[b]=Digit[b-1]; } Digit[0]=Tecla-1; ultimo display. } AnTecla=Tecla; Tecla=0; la proxima vez. d=0; display y comenzar } }while (true); }

// Si Tecla es diferente a 0 (se // Hace un scroll en los display // y guarda la tecla pulsada en el // Guarda la tecla pulsada y // pone Tecla a 0 para comprobar // d a 0 para encender el primer // otra vez. // Bucle infinito

Espero que les haya gustado y lo prximo que les entregar ser un artculo sobre el control de un array de 8x8 LED con el mismo sistema.