SUBSECRETARA DE EDUCACIN SUPERIOR DIRECCIN GENERAL DE EDUCACIN SUPERIOR TECNOLGICA

Instituto Tecnolgico de San Juan del Ro

Inteligencia Artificial I. Matriz led bicolor de 8X8. Profesora: Dorantes Hernndez Luz Mara. Alumnos: Paredes Nieto Erick Flores Miranda Jos Alfredo Nieto Segura Nalleli Herrera Vega Juan Carlos 08590024 11590142 09590525 08590276

Introduccin.
En este proyecto de inteligencia artificial con arduino, vamos a aprender a conectar una matriz de LED 88 bicolor a travs de unos registros de desplazamiento (Shift register) que nos van a permitir ahorrar muchos pines en nuestra placa, obteniendo un resultado tan espectacular haciendo referencia a un letrero que nosotros queramos poner haciendo ver las diferentes frases y palabras que podemos meter en esta matriz led conectada y manipulada con arduino.

Objetivo.
El objetivo de este proyecto es aprender a conectar el dispositivo arduino con la matriz led bicolor de 8X8 y aprender a programar dicho dispositivo de arduino en conjunto con una pequea programacin artificial para controlar los dispositivos de registro de corrimiento.

Contenido
Introduccin. ...................................................................................................................................... 2 Objetivo. ............................................................................................................................................. 2 Marco terico. ................................................................................................................................... 4 Materiales primarios. .................................................................................................................... 4 Diodo LED. ................................................................................................................................ 4 Resistencias. ............................................................................................................................. 4 Materiales secundarios................................................................................................................ 4 Matriz LED. ................................................................................................................................ 4 Registro de desplazamiento (74HC595)............................................................................... 6 Conexin de los dispositivos. ................................................................................................. 9 Programacin en Arduino. ........................................................................................................ 10 Explicacin del cdigo. .............................................................................................................. 13 Conclusin Conclusin Conclusin Conclusin Paredes Nieto Erick. ........................................................ 20 Paredes Nieto Erick. ........................................................ 20 Paredes Nieto Erick. ........................................................ 20 Paredes Nieto Erick. ............Error! Bookmark not defined.

Bibliografa. ....................................................................................................................................... 21

Marco terico.
En este circuito, no reside demasiada complejidad a la hora de disearlo, pues ya conocemos perfectamente que es un diodo LED, como se conecta y cul es la resistencia que debemos colocar en funcin de sus caractersticas tcnicas, y una matriz, como veremos, no es ms que un montn de led en un mismo encapsulado.

Materiales primarios.
El diodo LED. Los resistores.

Diodo LED.
Diodo LED: Se refiere a un componente opto electrnico pasivo, ms concretamente, un diodo que emite luz.

Resistencias.
Resistencias: Es la igualdad de oposicin que tienen los electrones para desplazarse a travs de un conductor. La unidad de resistencia en el Sistema Internacional es el ohmio, que se representa con la letra griega omega (), en honor al fsico alemn George Ohm, quien descubri el principio que ahora lleva su nombre.

Materiales secundarios.
Matriz LED.
Matriz Led: Una matriz de diodos LED, no es ms que un montn de diodos LED dentro de un mismo encapsulado en el que distribuimos los nodos en 8 columnas de 8 diodos unidos entre s y los ctodos en 8 filas de 8 diodos (o viceversa, hay muchos modelos) formando, como su nombre indica, una matriz de pixeles, siendo cada pixel la interseccin de una fila con una columna. Cuando nos hablan de una matriz 88 o 75, se refieren a la cantidad de filas x columnas que posee, por lo que una matriz de 88 es una matriz de 64 diodos LED, veamos el diagrama de conexin de una matriz de un solo color 88 con ctodos en filas y nodos en columnas.

En primer lugar, debemos diferenciar entre la numeracin de los PINES, con la numeracin de las filas y columnas, donde el nmero de pin ser aquella patilla fsica que conectaremos a nuestro Arduino, y la fila y columna, la referencia que tomaremos para encontrar un LED determinado, al ms estilo de hundir la flota, fila 2 columna 3 = Hundido. Se debe siempre mirar la hoja de caractersticas de la matriz, porque puede ser que difieran las conexiones internas de una marca a otra, o incluso en la misma marca, es decir, que en esta matriz, por ejemplo, la fila uno se corresponde con el pin 9, pero puede darse el caso que en otro modelo sea diferente, o que incluso las filas sean nodos. Una vez entendido esto, veamos cmo hacer que se encienda un diodo de la matriz. Como se menciona, es muy similar al cuadro cartesiano, una fila i con una columna j nos va a dar una coordenada nica, y para encender ese diodo, tan solo tendremos que tener la fila conectada al conjunto de leds y la fila a positivo. Si tenemos varias filas conectadas al conjunto de leds, por ejemplo la 1 la 3 y la 5, al introducir una tensin positiva por la columna 1, se encendern los diodos correspondientes a F1 C1, F3-C1 y F5 C1, siendo F = Fila y C = Columna.

Pero claro, a nosotros nos interesa crear ciertas formas o letras en la matriz, y si quisiramos dibujar dos filas diferentes entre s, no podramos, ya que si tenemos la fila 1 y 2 conectadas al conjunto de leds, y en la primera fila queremos encender el led de la primera columna, y en la segunda fila, el de la segunda columna, al tener constantemente alimentadas a positivo las dos columnas y a negativo las filas, se van a encender siempre los cuatro led de la esquina superior izquierda, intentar entenderlo, es importante. Para solucionar esto, lo que se hace es sincronizar utilizando el siguiente algoritmo: Conecto al conjunto de leds la fila uno y a positivo la columna 1 Quito el conjunto de leds de la fila uno y positivo de la columna 1. Conecto al conjunto de leds fila 2 y a positivo la columna 2. Quito el conjunto de leds de la fila 2 y positivo de la columna 2.

Y esto se repite tan rpidamente, que al ojo humano le parece que estn encendiendo los dos diodos constantemente.

Registro de desplazamiento (74HC595).

Registro de desplazamiento (74HC595): Es un chip con 8 salidas digitales las cuales vamos a poder controlar de una manera muy sencilla con solo tres pines de nuestro Arduino, adems, se pueden conectar en cascada ilimitadamente en detrimento, eso s, de la velocidad con la que queramos actuar en una salida determinada, siendo ms baja, cuantos ms integrados usemos.

Funcionamiento. Se manda un palabra o una serie de palabras de 8 bit (desde 00000000 hasta 11111111) por una salida digital y l las interpreta de tal manera que el primer 0 o 1 empezando por la derecha, establece el estado (0 o 1) de la primera salida del chip, el segundo 0 o 1, el de la segunda salida de chip, y as sucesivamente. Para seguir explicando de una manera ms tcnica, veamos el esquema de patinaje de este chip:

Donde: Q0 Q7: Salidas en paralelo a las que conectaremos los nodos de nuestra matriz. Gnd: Tierra de alimentacin del chip. Q7: Salida serie donde conectaremos otro chip si nos hicieran falta ms salidas digitales, de manera que la primera palabra de 8 bit pasara de largo del primer chip y se derivara por esta patilla al segundo. MR: Master reset, el cual tendremos conectado a +Vcc. SH_CP: Pin para el reloj que controlaremos desde Arduino y que marcar la frecuencia de desplazamiento del registro a modo de un pulso por bit. ST_CP: Pin para el latch, este pin deberemos ponerlo a 0 desde arduino cuando queramos enviar un dato para que el chip nos escuche y a 1 cuando hayamos terminado, hasta que se pone a 1, no se escriben las salidas de ningn chip. Para la inestabilidad se debe colocar un condensador de 100nf (Nano Faradios).

/OE: Ouput enable negado, o salida disponible negada, la cual llevaremos a tierra. DS: Datos en serie que enviaremos desde nuestro Arduino para que los reparta por las salidas. Vcc: Alimentacin +5v del chip

Para identificar las patillas en el chip, se debe colocar de manera que la muesca del extremo del chip, quede como en la imagen, as podris saber cul es cada patilla sin lugar a dudas. Con todo esto, ya debemos tener algo ms claro el funcionamiento de estos nuevos componentes, as que veamos el circuito a montar y empecemos a programar. Como al principio se menciona, el circuito en s es muy sencillo, simplemente se debe tener claro las caractersticas tcnicas de la matriz y como funciona un registro de desplazamiento. El esquema interno de una matriz bicolor, se corresponde al de la siguiente imagen:

De manera que lo nico que se debe hacer es conectar las salidas de un registro a las columnas de un color, y las salidas de otro a las del otro color.

Conexin de los dispositivos.

De manera que lo nico se debe hacer es conectar las salidas de un registro a las columnas de un color, y las salidas de otro a las del otro color. En cuanto a la conexin de los registros de desplazamiento, es muy sencilla, un pin para el latch, uno para el clock y otro para los datos. La manera de encadenarlos es conectando Q7 del primero a DS del segundo, vemos la distribucin en protoboard para que quede todo ms claro, es necesario buscar el datasheet (caractersticas tcnicas) de su matriz y de todos los dispositivos, para saber conectar en el caso de la matriz el pin correspondiente a cada fila y columna de cada color.

Aqu simplemente se tendrn que unir de Q0 a Q7 con cada nodo columna de la 1 a la 8 respectivamente en vuestros desplazamientos de registros.

Como se muestra en el siguiente esquema:

Programacin en Arduino.
La programacin se realizara en la plataforma que trae el componente de arduino que est programada en java, utilizando la programacin de C ahora desarrollaremos el programa para este proyecto.

1 2 3 4 5 6 7 8 9 10 11 12

Matriz bicolor 8x8 + Shift Register 74CH595 En este proyecto vamos a controlar los nodos de una matriz led bicolor con dos desplazamientos de registros, y las filas de la matriz con arduino directamente, Reproduciendo as una serie de caracteres previamente definidos.

int pinLatch = 10; int pinDatos = 11; int pinReloj = 12; int letra = 0;

//Pin para el latch de los 74CH495 //Pin para Datos serie del 74CH495 //Pin para reloj del 74CH495 //Variable para cada letra

10

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

int ciclo = 0; //Variable para los ciclos de cada letra en //cada posicion int desplaza = 0; //Variable para generar desplazamiento //en las filas //Definimos los numeros decimales que hacen falta //para dibujar cada caracter #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define SP {0, 0, 0, 0, 0} EX {0, 125, 0, 0, 0} A {31, 36, 68, 36, 31} B {127, 73, 73, 73, 54,} C {62, 65, 65, 65, 34} D {127, 65, 65, 34, 28} E {127, 73, 73, 65, 65} F {127, 72, 72, 72, 64} G {62, 65, 65, 69, 38} H {127, 8, 8, 8, 127} I {0, 65, 127, 65, 0} J {2, 1, 1, 1, 126} K {127, 8, 20, 34, 65} L {127, 1, 1, 1, 1} M {127, 32, 16, 32, 127} N {127, 32, 16, 8, 127} O {62, 65, 65, 65, 62} P {127, 72, 72, 72, 48} Q {62, 65, 69, 66, 61} R {127, 72, 76, 74, 49} S {50, 73, 73, 73, 38} T {64, 64, 127, 64, 64} U {126, 1, 1, 1, 126} V {124, 2, 1, 2, 124} W {126, 1, 6, 1, 126} X {99, 20, 8, 20, 99} Y {96, 16, 15, 16, 96} Z {67, 69, 73, 81, 97} //Espacio //Exclamacin !

//Escribimos la frase separando cada letra por comas //En el primer nmero lo adaptaremos la longitud //de la frase (caracteres) byte frase[32][6]={P,R,O,Y,E,C,T,O,SP,I,N,T,E,L,I,G,E,N,C,I,A,SP}; //Almacenamos los pines de las filas que van //conectadas a los ctodos int gnd[13]={0,0,0,0,0,2,3,4,5,6,7,8,9}; //Configuramos la placa void setup() { //Ponemos del pin 2 al 12 como salidas for (int i=2;i<=12; i++) { pinMode(i, OUTPUT);

11

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

} //Ponemos a nivel alto todas las lineas de //los catodos de la matriz for (int g=2; g<=9; g++) { digitalWrite(g, HIGH); } } void loop() { //Pequeo contador para que salga una letra de cada color for (int count = 0 ; count <= 1; count ++) { if (count < 1 ) { for (desplaza = 9; desplaza>=0; desplaza--) { for (ciclo=0; ciclo<=35; ciclo++) { imprimeRojo(); } } } else { for (desplaza = 9; desplaza>=0; desplaza--) { for (ciclo=0; ciclo<=35; ciclo++) { imprimeVerde(); } } } //Una vez ha mostrado una letra, sumamos uno para // que salga la siguiente letra++; } //Cuando ha llegado al final de la frase, lo pone a cero //para que vuelva a salir //Si cambiamos la longitud de la frase, este //valor hay que cambiarlo if(letra == 32) { letra = 0; } } //Funcion que imprime en color rojo void imprimeRojo()

12

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

{ //Un contador del tamao de las letras (5 lineas de ancho) for (int z=0; z<=5; z++) { int fila = z + desplaza; digitalWrite(gnd[fila], LOW); digitalWrite(pinLatch, LOW); shiftOut(pinDatos, pinReloj, MSBFIRST, 0); shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]); digitalWrite(pinLatch, HIGH); digitalWrite(gnd[fila], HIGH); } } //Funcion que imprime en color verde void imprimeVerde() { //Un contador del tamao de las letras (5 lineas de ancho) for (int z=0; z<=5; z++) { int fila = z + desplaza; digitalWrite(gnd[fila], LOW); digitalWrite(pinLatch, LOW); shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]); shiftOut(pinDatos, pinReloj, MSBFIRST, 0); digitalWrite(pinLatch, HIGH); digitalWrite(gnd[fila], HIGH); } }

Explicacin del cdigo.

En primer lugar hemos definido unas variables para los desplazamientos de registros, como se ve en el cdigo, aunque pongamos dos chip, seguimos usando tan solo dos patillas de Arduino. int pinLatch = 10; //Pin para el latch de los 74CH495 int pinDatos = 11; //Pin para Datos serie del 74CH495 int pinReloj = 12; //Pin para reloj del 74CH495 int letra = 0; //Variable para cada letra int ciclo = 0; //Variable para los ciclos de cada letra en cada posicin int desplaza = 0; //Variable para generar desplazamiento en las filas

13

Despus tenemos: #define nombredeConstante valor

Esta instruccin nos permite dar un nombre a un valor constante antes de que se compile el programa, de manera que luego la podremos llamar simplemente nombrndola.
#define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define SP {0, 0, 0, 0, 0} EX {0, 125, 0, 0, 0} A {31, 36, 68, 36, 31} B {127, 73, 73, 73, 54,} C {62, 65, 65, 65, 34} D {127, 65, 65, 34, 28} E {127, 73, 73, 65, 65} F {127, 72, 72, 72, 64} G {62, 65, 65, 69, 38} H {127, 8, 8, 8, 127} I {0, 65, 127, 65, 0} J {2, 1, 1, 1, 126} K {127, 8, 20, 34, 65} L {127, 1, 1, 1, 1} M {127, 32, 16, 32, 127} N {127, 32, 16, 8, 127} O {62, 65, 65, 65, 62} P {127, 72, 72, 72, 48} Q {62, 65, 69, 66, 61} R {127, 72, 76, 74, 49} S {50, 73, 73, 73, 38} T {64, 64, 127, 64, 64} U {126, 1, 1, 1, 126} V {124, 2, 1, 2, 124} W {126, 1, 6, 1, 126} X {99, 20, 8, 20, 99} Y {96, 16, 15, 16, 96} Z {67, 69, 73, 81, 97} //Espacio //Exclamacin !

Lo que hemos hecho es definir cada letra del abecedario (menos la ) por una serie de nmeros decimales. Estos nmeros decimales son los que mandaremos a nuestros registros de desplazamiento para decirle que columnas de diodos LED debe iluminar. Pasando de decimal a binario, observemos la siguiente imagen para entenderlo un poco mejor:

14

Vemos que el primer diodo LED vale 1 (2^0), el segundo 2(2^1), el tercero 4 (2^2) y as sucesivamente, de manera que los que necesitemos tener encendidos, deberemos sumarlos entre s. En el ejemplo de arriba nos encendera el cuarto y el octavo diodo empezando por la izquierda, ahora para dibujar una letra o smbolo, tan slo hace falta tiempo y paciencia. Por ejemplo, nuestras letras son de 7 columnas x 5 filas, de manera que la letra O por ejemplo sera: #define O {62, 65, 65, 65, 62}

Que al pasarlo a binario nos quedara as:

62 65 65 65 62 =>0 =>1 =>1 =>1 =>0 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0

Y donde tenemos un 1, tenemos un diodo LED encendido. Si seguimos con el programa, tenemos el lugar donde introduciremos un par de Arrays (listas) en las que almacenaremos las letras definidas que formarn nuestra frase y otra para los pines que tendremos conectados los ctodos de nuestra matriz.
byte frase[32][6]={P,R,O,Y,E,C,T,O,SP,I,N,T,E,L,I,G,E,N,C,I,A,SP}; int gnd[13]={0,0,0,0,0,2,3,4,5,6,7,8,9};

15

Se puede ver que hemos colocado unos cuantos ceros al principio de la matriz de los ctodos, ya que es un pin que para este proyecto est libre, o usamos para crear una separacin entre letras y que estas aparezcan por el lateral derecho. En cuanto a las matrices lo que debemos saber es que son una lista, matriz o array, como las queramos llamar, y simplemente es una coleccin de variables a las que se accede mediante un nmero de ndice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el nmero del ndice. Debemos tener en cuenta que el ndice siempre comienza en el 0, de manera que si tenemos un array de 10 elementos, accederemos a ellos del 0 al 9. La forma de declarar un array es la siguiente: int miArray[] = {valor0, valor1, valor2...}

Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamao, para posteriormente, asignar valores a una posicin especifica:
int lista[4]; // declara un array de enteros de 5 posiciones lista[4] = 12; // asigna el valor 12 a la posicin 5

Como decamos arriba, para leer de un array basta con escribir el nombre y la posicin a leer:
x = lista[4]; // x ahora es igual a 12 que est en la posicin 5

Ahora tenemos la configuracin de pines de nuestra placa:

//Configuramos la placa void setup() { //Ponemos del pin 2 al 12 como salidas for (int i=2;i<=12; i++) { pinMode(i, OUTPUT); } //Ponemos a nivel alto todas las lineas de los catodos de la matriz for (int g=2; g<=9; g++) { digitalWrite(g, HIGH); } }

16

El primer ciclo es para poner del pin 2 al 12 como salida, pues usaremos del 2 al 9 para los ctodos, y del 10 al 12 para los registros. El segundo lo que hace es ponernos los ctodos a 5v para tener todos los diodos LED apagados. Si seguimos el programa llegamos al loop, primero tenemos un contador de 0 a 1 para que alterne la llamada a la funcin imprimir en verde o imprimir en rojo, y como est dentro de cada opcin de la comparacin tenemos un ciclo for llamado desplaza, que no es ms que un contador de 8 a 0 que se le ir sumando a las funciones de imprimir para desplazar la fila de ctodos por la que empieza a dibujar la letra, es algo simpln, pero funciona De nuevo, dentro del contador desplaza tenemos un nuevo contador lla mado ciclo que lo utilizamos para repetir la llamada a la funcin imprimir (verde o rojo) tantas veces como queramos, de manera que controlamos la velocidad con la se desplazan las letras.
void loop() { //Pequeo contador para que salga una letra de cada color for (int count = 0 ; count <= 1; count ++) { if (count < 1 ) { for (desplaza = 8; desplaza>=0; desplaza--) { for (ciclo=0; ciclo<=35; ciclo++) { imprimeRojo(); } } } else { for (desplaza = 8; desplaza>=0; desplaza--) { for (ciclo=0; ciclo<=35; ciclo++) { imprimeVerde(); } } } //Una vez ha mostrado una letra, sumamos uno para que salga la siguiente letra++; } //Cuando ha llegado al final de la frase, lo pone a cero para que vuelva a salir //Si cambiamos la longitud de la frase, este valor hay que cambiarlo if(letra == 32)

17

{ letra = 0; } }

Despus de los contadores, sumamos 1 a la variable letra para que imprima la siguiente letra de la lista, despus hacemos un pequeo chequeo para saber si ha llegado a la ltima letra de la frase, y si es as, que lo vuelva a poner a 0.
void imprimeRojo() { //Un contador del tamao de las letras (5 lineas de ancho) for (int z=0; z<=5; z++) { int fila = z + desplaza; //Le decimos en que linea empieza a dibujar digitalWrite(gnd[fila], LOW); //La ponemos a cero digitalWrite(pinLatch, LOW); //Le decimos a los registros que empiecen a escuchar los datos shiftOut(pinDatos, pinReloj, MSBFIRST, 0); //Le decimos que en el ltimo registro no encienda nada shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]); //Le decimos que imprima la linea z de la letra en el primer registro (rojo) digitalWrite(pinLatch, HIGH); //Guarda y graba las salidas en los registros al poner a 1 el latch digitalWrite(gnd[fila], HIGH);//Apagamos esa fila poniendola en alto }}

Esta funcin es la que nos sincroniza los ctodos de las filas con la palabra que enviamos a los registros de desplazamiento. Como vemos, empezamos con un contador de 0 a 5, esto nos servir para decirle que lnea de la letra es la que queremos imprimir, si recordamos el ejemplo que ya se mencion de la letra 0, veremos que est compuesta por cinco lneas que deben ser impresas en las columnas de la matriz. Luego seguimos con la sincronizacin de los ctodos con estas instrucciones:
int fila = z + desplaza; //Le decimos en que linea empieza a dibujar digitalWrite(gnd[fila], LOW); //La ponemos a cero

La primera suma z + desplaza, esto nos va a devolver lo siguiente:

1. 2. 3. 4. 5. 6. 7. 8. 9. 1+8=9 2 + 8 = 10 3 + 8 = 11 4 + 8 = 12 5 + 8 = 13 1+7= 8 2+7=9 3 + 7 = 10 4 + 7 = 11

18

10. 11. 12. 13.

5 + 7 = 12 1+6=7 2+6=8 3+6=9

Con este valor variable aplicado al pin que queremos poner en nivel LOW le estamos diciendo que cada vez empiece a imprimirnos una lnea antes, de manera que primero har un barrido con los pines almacenados de la posicin 9 a la 13 de nuestro array, luego de la 8 a la 12, y as sucesivamente hasta que desaparece por la izquierda la letra, gracias al pin 0 como ayuda para esconder las letras. Despus ponemos el pin Latch de los registros de desplazamiento a 0 para que empiecen a escuchar los datos que vamos a mandar.
digitalWrite(pinLatch, LOW);//Le decimos a los registros que empiecen a escuchar los datos

Le enviamos los datos a los dos registros de desplazamiento, recordando siempre, que el primer dato que enviamos, va al ltimo registro de desplazamiento que tengamos conectado.
shiftOut(pinDatos, pinReloj, MSBFIRST, 0); shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]);

El componente Arduino puede escribir en los registros de desplazamiento sin la necesidad de una librera, pues ya viene integrada esa instruccin, y adems es muy fcil de usar, la sintaxis a utilizar es:
shiftOut(pinDatos, pinReloj, ordenBits, valor)

Donde: pinDatos: el pin en el cual extraer cada bit (int). pinReloj: el pin que hay que conmutar cada vez que a un pinDatos le ha sido enviado el valor correcto (int). ordenBits: en qu orden desplazar los bits; si hacia el MSBFIRST (bit ms significante primero) o hacia el LSBFIRST (bit menos significante primero). valor: los datos que rotar. (byte).

Por ltimo, le decimos a los registros que dejen de escuchar, e interpreten los datos enviados de una vez, y rpidamente colocamos el pin del ctodo de la lnea que hemos iluminado a 1 para apagarla, ya que hay que empezar de nuevo pero con la lnea siguiente. Y todo esto, es muy rpido lo que hace un scroll. Lo mismo es para la funcin imprimeVerde() solo que cambiamos el orden de los datos para que alterne los registros de desplazamiento.

19

Conclusin

Paredes Nieto Erick.

En este proyecto se demostr quien tiene conocimientos y quien no se pude decir que todos los tenemos en cuanto a programacin y a electrnica se refiere pero cada uno de nosotros demostr algo que no ha demostrado en otras materias y ese era el objetivo que tenamos como equipo aunque algunos no lo superaron supongo que quedara como una experiencia es para concluir con su carrera y ayudara ms que nada a terminarla en este proyecto tambin se realiz el trabajo en equipo y debo decir que estuvo bastante difcil pero al final todos nos llegamos a una misma meta que era realizar este letrero con una matriz led bicolor y con el componente de arduino utilizando el lenguaje de programacin de c++ que para todos creo yo ya sabemos ya que somos la mayora de 10 semestre debemos tener estos conocimientos, los tengamos o no creo que es muy buena idea repasar y con este proyecto no solo repasamos sino aprendimos cosas nuevas que era lo que importaba.

Conclusin

Flores Miranda Jos Alfredo.

Nuestro proyecto de la mini marquesina fue un reto ms para nosotros, principalmente como equipo y tambin individual ya que tenemos que saber todos los integrantes sobre todo lo que se realiz en el transcurso del mismo, su armado o estructura final y tambin la codificacin. En esta ocasin trabajamos sobre la plataforma de programacin de arduino, esta es muy parecida a la programacin en c++, tambin se trabaj con los registros de desplazamiento los cuales son los integrados 74HC595, estos integrados nos ayudaron a aumentar la cantidad de pines con los que podemos trabajar para as poder controlar la matriz de leds de 8x8, la cual cuenta con 24 pines, de tal modo si hubiramos trabajado con solo las salidas digitales del arduino, no nos hubieran sido suficientes para poder controlar la matriz, en conclusin este proyecto es muy interesante y tiene muchas oportunidades de optimizacin y/o mejoras a futuro.

Conclusin

Nieto Segura Nalleli.

El proyecto ha logrado cumplir todos los objetivos bsicos que se haban propuesto y respetando las especificaciones planteadas. Con este proyecto entendimos como es que un arduino toma informacin del entorno a travs de sus pines de entrada de toda una gama de sensores en este caso la matriz pudo

20

interactuar con l para la realizacin del encendido de los led. Tambin aprendimos a diferenciar entre la numeracin de los pines, entre sus filas y sus columnas etc. Puedo decir que cumplimos el objetivo del proyecto al hacer que al programar los led dibujaran letras y nmeros.

Bibliografa.
http://www.educontinua.fciencias.unam.mx/SiteNuevo/Cursos/Arduino/2012/MasInfo.php http://arduino.cc/es/Reference/Array} https://eva.fing.edu.uy/pluginfile.php/57765/mod_resource/content/1/TallerArduino2.pdf http://www.electronicaembajadores.com/Subfamilias/Productos/23/LCA1/modulos-arduino http://www.agelectronica.com/?p=arduino

21