Proyecto2 150103163545 Conversion Gate02

Las matrices hoy en da han tomado un gran

auge en la publicidad de las grandes tiendas de

nuestra ciudad, donde se puede apreciar la

publicidad de sus productos, tomando en

cuenta que algunas veces es tedioso estar

usando papel para la realizacin de informar a

los clientes las ofertas existentes en ese da.

Hay matrices donde se puede cambiar el texto

fcilmente por medio de la computadora

optimizando el tiempo de publicar su producto.

Cuando vemos las matrices hablando de las ms

sencillas que son las que solo muestra un texto

y despus lo cambia, nos preguntamos Cmo

lo hacen?, Estar difcil realizar una matriz? Las

respuestas pueden ser ms que fciles, ya que

si usted es electrnico entender la lgica que

conlleva la construccin de una matriz de led

esttica (Solo mostrar texto).

Primero que nada hay que definir Que es una

matriz?

Es unn cartel formado por varias filas y

columnas de LEDs, convenientemente

programado, puede servir para pasar mensajes

publicitarios, decorar nuestra habitacin,

ordenador o lo que se nos ocurra. No solo se

trata de un proyecto ms que interesante para

llevarlo a cabo como hobbysta, sino que puede

resultar interesante como un producto

comercializable. Es que estas matrices, que en

algunos pases se las conoce como cartel de

LEDs o Publik, son un recurso muy

frecuentemente utilizado con fines publicitarios

o informativos.

Para gastar lo menos posible vallamos a

construir una simple matriz de led 8x8

utilizando la tcnica de multiplicacin como

vimos en el proyecto anterior, pero en este casi

el multiplexor no ser el microcontrolador que

lo haga sino otro circuito el 74HC164 que es un

registro de corrimiento de 8 bit, el Micro solo

har la tarea de enviar pulsos para que el IC

74HC164 haga la tarea de multiplexar la matriz.

El material a usar es el siguiente:

Cantidad Material

1 PIC18F2550

1 74HC164

8 2N2222A

1 Matriz de Led 8x8 (nodo comn)

8 Resis. 330 ohm

8 Resis. 1kohm

1 7805

2 Cap. 100uF

Crearemos una simple

matrix de led de 8x8

[PRACTICA # 2] 15 de diciembre de 2010

PROYECTO #2 Pgina 108

Vallamos primero por pasos, tenemos primero que nada el diagrama de nuestra matriz donde muestra

como son las conexiones de nuestra matriz.

Como vemos en la imagen de la Izquierda tenemos que hay 8

led conectado por el nodo, entonces sabemos que cada

columna es de nodo comn, esto da entender que debemos de

proporcionarle corriente positiva (+5) mientras que cada fila

estn conectado los ctodos, entonces debemos de poner a

cero (a tierra) para que fluya una corriente de positivo a tierra,

para encender cualquier led de la matriz.

Por ejemplo se enva un dato en la fila:

11111110

Y tenemos en la columna un dato:

10000000

En hace que solo un pixel encienda:

Si hacemos un corrimiento en la columna, har que el pixel empiece a moverse hacia la ltima columna

para hacer esto tenemos el IC 74HC164 que es un registro de corrimiento de 8 bits.

Donde su configuracin bsica es poner el pin de RST a positivo para habilitar el corrimiento, mientras

que los pines DSA,DSB deben ser unidos y solo tener uno en comn para suministrar el dato a correr,

puede ser 0 o 1, el pin de Clock ser los pulsos que harn el efecto de corrimiento, este pin ser

manipulado por el Microcontrolador.

1 0 0 0 0 0 0 0

0

1

1

1

1

1

1

1



Entonces en el Microcontrolador ser el

responsable de administrar el dato en los pines

DSA,DSB cuando sea necesario, y tambin ser el

que generara los pulsos de corrimiento, si

deseamos tambin usar otro pin del Micro para

poder resetear el 74HC164 en el pin RST, lo

podemos hacer.

Cada vez que una columna sea puesta a 1

debemos de colocar el dato en la fila, despus

que la columna haga un corrimiento, se debe de

colocar el siguiente dato en la columna

correspondiente, al hacer eso, pero a una

velocidad moderada, podemos decir a 1Khz, se

podr apreciar la figura en la matriz, ya que el ojo

humano solo puede captar parpadeo antes de los

60 Hz despus de esta frecuencia el ojo humano

no puede percibir tal parpadeo.

Como vemos en la imagen de alado, se puede apreciar una letra A, los

datos de la fila, se estn multiplexando cada vez que es generado el

corrimiento, cada columna contiene un dato en la fila, los datos estarn

guardados en un arreglo de 8 byte, cada vez que sea necesario este

arrojara el dato que corresponda a cada columna. Como sabemos para

mostrar tal letra se est realizando las acciones a una frecuencia de 1Khz

o menos. Lo ms importante es que no genere parpadeos ya que puede

afectar a largo plazo la vista humana, y generar en nosotros dolor de

cabeza, es recomendable que las letras que se muestren estn a una

frecuencia suficientemente estable y veloz para que no produzca tales dolores en nosotros.

Se ha creado una funcin en C para realizar la funcin de enviar los pulsos de corrimiento para el circuito

74HC164.

//--------------------------------------------------------- //FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO / //--------------------------------------------------------- void SEND_DATA(unsigned char DATA){ DATO=DATA; CLOCK=0; __delay_us(2); CLOCK=1; }



Cuando queramos enviar una transicin de 0 a 1 para hacer el corrimiento, solo debemos de llamar a la

funcin SEND_DATA(con el valor a enviar) .

Ej.

Antes de la funcion

0 0 0 0 0 0 0 0

SEND_DATA(1) ; realiza el corrimiento del dato 1.

Despues de la funcion

1 0 0 0 0 0 0 0

Despus de enviar el dato 1, podemos enviar 8 ceros, para hacer el corrimiento del dato 1 hacia toda la

fila. Esto se puede hacer usando simplemente un ciclo for que cuente de 0 a 7.

0 1 0 0 0 0 0 0

0 0 1 0 0 0 0 0

0 0 0 1 0 0 0 0

0 0 0 0 0 0 0 0

Cada vez que surja un corrimiento se debe de cargar el valor que corresponda a dicha columna en este

caso se tomara un puerto completo del microcontrolador.

Los datos estarn guardados en un arreglo de 8 byte, cada byte corresponde al valor que debe de tener

la columna. Para sacar los valores y guardarlos en el arreglo es muy simple, tenemos un software

llamado control de matriz de led 8x8

0

for(Letra=0;Letra



Software para matriz de Leds

Este software nos permitir dibujar en una matriz 8x8, al tener nuestra letra o lo que vallamos hacer

solo presionaremos el botn Valores

Los datos que aparecen a un lado son los

valores que necesitamos para mostrar la letra

A en la matriz, entonces copiamos estos

valores y pegamos en nuestra variable.

Ahora bien te preguntaras como o cuando

llamamos a las variables cada vez que sea

necesario en nuestro programa, es muy

simple como ya hemos visto el corrimiento

de datos anteriormente solo basta de agregar

las lneas de:

unsigned char arreglo[8]={ 0, 252, 254, 51, 51, 51, 254, 252};//A

while(1){ for(Letra=0;Letra



La conexin de la Matriz se puede ver a continuacin:

Como vemos la conexin se una matriz de Leds de nodo comn en las filas y ctodo comn en las

columnas. He usado 8 transistores en cada fila para que entregue toda la corriente y as pueda iluminar

ms.

RB0~RB7 corresponden a los 8 pines del PUERTO B del microcontrolador, mientras de C0~C7

corresponden a los 8 pines del circuito de corrimiento (74HC164).



El esquema completo podemos apreciarlo a continuacin;

El programa que contiene el Microcontrolador es el siguiente:

//////////////////////////////////////////////////////// // Simple Matriz //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// //////////////////////////////////////////////////////// #include ///////////////////////////////////////////////////////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLLPOSTDIV2 & CPUDIV1 & USBOSC); ///////////////////////////////////////////////////////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS); __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT);



////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Definiciones ////////////////////////////// #define CLOCK RC1 #define DATO RC0 #define RESET1 RC2 ////////////////////////////// //Variable Globales // ////////////////////////////// unsigned char MAX; unsigned char Letra; unsigned char ALFA[]={0, 252, 254, 51, 51, 51, 254, 252};//A //--------------------------------------------------------- //FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO / //--------------------------------------------------------- void SEND_DATA(unsigned char DATA){ DATO=DATA; CLOCK=0; __delay_us(2); CLOCK=1; } //---------------------------------------------------------- //FUNCION DE BORRADO / //---------------------------------------------------------- void CLEAR(void){ for(MAX=1;MAX SEND_DATA(1); //->COLUMNAS } } ///////////////////////////////////////////////// //Funcion de interrupcion //Si no se usa simplemente no hacemos nada... //Esto sirve para direccionar lo los datos //en un lugar muy cercano al Inicio de la memoria //de datos //////////////////////////////////////////////// static void interrupt isr(void){} ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ OSCCON=0x70; NOP();NOP();NOP();NOP(); ////////////////////////////////////////////////////////////////////// // Configuracion de Puertos /// ////////////////////////////////////////////////////////////////////// TRISB=0x00;//SALIDA PARA FILA DE LA MATRIX TRISC=0x00;//RX=ENTRADA,TX=SALIDA /*---------------------Fin de Conf. Puertos-------------------------*/



GIE=0; //INTERRUPCIONES GLOBALES DesACTIVADAS PEIE=0; //DesACTIVA INTERURPCIONES POR PERIFERICOS /////////////////////////////////////////////////////////////////////// // FUNCION PRINCIPAL /// /////////////////////////////////////////////////////////////////////// RESET1=1; CLEAR(); //Limpia columnas SEND_DATA(1);//Inicializa columnas while(1){ for(Letra=0;Letra



Ahora en da es muy importante manipular cualquier cosa electrnica como son los motores,

servomotores, puertas electrnicas, cmaras, por medio de la computadora, por supuesto no era de

esperarse el uso de esta tecnologa para los carteles de LED, es muy frecuente tener la necesidad de

cambiar algn texto en un tablero de LED o una animacin.

Este Proyecto consta de hacer precisamente la funcin de manipular nuestra matriz de led va serial, en

este caso tenemos el software Control de Matrix 8x8, el funcionamiento es sencillo, en el programa

haremos la figura que deseamos, al tenerla sacaremos los valores, presionaremos el botn Valores

para adquirir los respectivos datos, al tener esto solo debemos de conectar el Serial, dirigiremos nuestro

mouse a Serial y despus config.Serial.

Configuraremos el COM disponible en nuestra PC, y elegiremos a los baudios a 19200, despus haremos

click en Aplicar y Conectar.

Solo bastara de conectar el nuestro circuito hecho junto con el

MAX232 en los pines RC6 y RC7.

Pero antes explicare cmo funciona el programa que debe de

tener el Microcontrolador. Por lgica debemos de usar una

interrupcin por USART, cuando surja dicha interrupcin se

debe de tomar 8 byte que corresponden a los 8 byte del

programa y depositarlos en la variable que se usa en la funcin

principal.

La configuracin del Serial debe de ser a 19200 baudios ya que con una buena velocidad disminuye el

cambio o parpadeo de la matriz.

Siguiendo con nuestro

circuito armado



Como debemos de conectarlo a la computadora se debe de tener convertidor de RS232 a TTL, para

hacer esto tener el Circuito MAX232, su conexin se presenta a Continuacin.

NOTA

El conector DB9 debe ser de tipo Hembra.

Tambin se recomienda soldar solo el Max232 en una tablilla para diseos futuros ya que se le facilitara

al usuario la posibilidad de hacer menos trabajos de armar y armar nuevamente en el Protoboard.

/////////////////////////////////////////////////////////////////////// // Configuracion del USART /// /////////////////////////////////////////////////////////////////////// OpenUSART(USART_TX_INT_OFF &//Interrupcion por Transmision apagado USART_RX_INT_ON &//Interrupcion por Recepcion Apagado USART_ASYNCH_MODE &//Modo Asincronico USART_EIGHT_BIT &//8-bit de transmision USART_CONT_RX &//Recepcion Continua USART_BRGH_HIGH, //Alta velocidad de baudios 25); //para alta Velocidad: // FOSC / (16 * (spbrg + 1)) // spbrg=(FOS/baud*16)-1 //Para baja Velocidad: // FOSC / (64 * (spbrg + 1)) /*---------------------Fin de Conf. USART----------------------------*/



Esquema Completo se da a continuacin:

El programa que contiene el Microcontrolador es el siguiente:

//////////////////////////////////////////////////////// // Control de Matrix 8x8 //// //Autor: george.manson.69 //// //Lugar: Mxico //// //Compilador: HI TECH PIC18 (LITE MODE) //// //////////////////////////////////////////////////////// #include ///////////////////////////////////////////////////////////// //Configuracin para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLLPOSTDIV2 & CPUDIV1 & USBOSC); ///////////////////////////////////////////////////////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS); __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz



////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Definiciones ////////////////////////////// #define CLOCK RC1 #define DATO RC0 #define RESET1 RC2 ////////////////////////////// //Variable Globales // ////////////////////////////// unsigned char MAX; unsigned char CONT; unsigned char Letra; unsigned char ALFA[]={255, 255, 255, 227, 227, 255, 255, 255};//A //--------------------------------------------------------- //FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO / //--------------------------------------------------------- void SEND_DATA(unsigned char DATA){ DATO=DATA; CLOCK=0; __delay_us(2); CLOCK=1; } //---------------------------------------------------------- //FUNCION DE BORRADO / //---------------------------------------------------------- void CLEAR(void){ for(MAX=1;MAX SEND_DATA(1); //->COLUMNAS } } //----------------------------------------------------------- // HABILITADOR / //----------------------------------------------------------- void HABILITO(void){ if(CONT==0) SEND_DATA(1); //ENVIO DATA 0 O 1 else SEND_DATA(0); } ///////////////////////////////////////////////// //Funcion de interrupcin //Si no se usa simplemente no hacemos nada... //Esto sirve para direccionar lo los datos //en un lugar muy cercano al Inicio de la memoria //de datos //////////////////////////////////////////////// static void interrupt isr(void){ /////////////////////////////////////////////// //Al recibir 8 bytes los toma para guardarlos //en la variable que hace que mantenga el //la imagen en la matriz 8x8 /////////////////////////////////////////////// if(RCIF){ getsUSART(ALFA,8);//Toma 8 bytes



RCIF=0;//Reset a interrupcion por recepcion } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ OSCCON=0x70; NOP();NOP();NOP();NOP(); ////////////////////////////////////////////////////////////////////// // Configuracion de Puertos /// ////////////////////////////////////////////////////////////////////// TRISB=0x00;//SALIDA PARA FILA DE LA MATRIX TRISC=0x80;//RX=ENTRADA,TX=SALIDA /*---------------------Fin de Conf. Puertos-------------------------*/ /////////////////////////////////////////////////////////////////////// // Configuracion del USART /// /////////////////////////////////////////////////////////////////////// OpenUSART(USART_TX_INT_OFF &//Interrupcion por Transmision apagado USART_RX_INT_ON &//Interrupcion por Recepcion Apagado USART_ASYNCH_MODE &//Modo Asincronico USART_EIGHT_BIT &//8-bit de transmision USART_CONT_RX &//Recepcion Continua USART_BRGH_HIGH, //Alta velocidad de baudios 25); //para alta Velocidad: // FOSC / (16 * (spbrg + 1)) // spbrg=(FOS/baud*16)-1 //Para baja Velocidad: // FOSC / (64 * (spbrg + 1)) /*---------------------Fin de Conf. USART----------------------------*/ GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS /////////////////////////////////////////////////////////////////////// // FUNCION PRINCIPAL /// /////////////////////////////////////////////////////////////////////// RESET1=1; CLEAR(); SEND_DATA(1); while(1){ for(Letra=0;Letra



Ejemplo de uso de Controlar una Matriz de LED via Serial

MAX232



El corrimiento o desplazamiento de letras es muy comn en los panales de Leds ya que con pocas

matrices se puede hacer que aparezca un texto completo simplemente usando el desplazamiento en

estos. Para hacer el algoritmo de programacin del microcontrolador se debe de entender el

procedimiento para la realizacin de nuestro proyecto.

Como vimos en el proyecto anterior, tenamos un arreglo donde se depositaba los 8 datos necesarios

para mostrar la letra A, ahora si deseamos que la letra empiece desplazarse en la matriz de Leds,

consta de usar una interrupcin por TIMER0 para que cada 200mS podamos actualizar la matriz, cuando

la interrupcin desborde a los 200mS, lo primero que hay que realizar es copiar los datos del arreglo a

un arreglo temporal que podemos nombrarlo carrgelo , donde al ser copiado, nuevamente pasaremos

carreglo al arreglo, pero la nica diferencia es que se va realizar un corrimiento de datos del arreglo

original, con un ciclo for .

Siguiendo con nuestra Matriz de Led armada, haremos lo que todos desean de las matrices de led,

hacer el corrimiento de letras.

////////////////////////////////////////// //Ciclo for para copiar el arreglo actual ////////////////////////////////////////// for(x=0;x



La lgica de este ltimo es muy sencillo, cuando se halla copiado el arreglo original al segundo (carreglo)

debemos de sacar del arreglo el primer valor y recorrer todos los valores y el ultimo ser donde

debemos de colocar el valor deseado.

Cuando pasa por el ciclo:

Como vemos se ha recorrido todos los datos y dejando un espacio libre donde debe de ir el dato, este

dato ultimo ser aquel que este guardado en un arreglo de datos.

Se presenta el diagrama de flujo:

Esto har el efecto de corrimiento, lo bueno de esta tcnica es que si usamos una matriz 8x8 podemos

poner un texto completo sin afectar la velocidad, si lo contrario se desea usar mas matrices esto

reducir la velocidad y causara parpadeos o letras errneas, para solucionar esto cuando mas matrices

se use la interrupcin por timer0 se debe de acortar.

Esta prctica se desea que se desplace un texto HOLA MUNDO en una matriz 8x8, como ya tenemos

listo nuestro circuito armado solo basta de programar nuevamente el microcontrolador para probar el

circuito:

0x02 0xff 0x3d 0x4f 0xdd 0xff 0x00 0xaa

0xff 0x3d 0x4f 0xdd 0xff 0x00 0xaa dato

Arreglo=

Arreglo=

0x02



El programa del Microcontrolador es el siguiente:

//////////////////////////////////////////////////////// // Corrimiento de Matrix //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// //////////////////////////////////////////////////////// #include ///////////////////////////////////////////////////////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLLPOSTDIV2 & CPUDIV1 & USBOSC); ///////////////////////////////////////////////////////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS); __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Definiciones ////////////////////////////// #define CLOCK RC1 #define DATO RC0 #define RESET1 RC2 ////////////////////////////// //Variable Globales // ////////////////////////////// unsigned char MAX; unsigned char CONT; unsigned char Letra,c,f,x; unsigned char arreglo[8]={255, 255, 255, 227, 227, 255, 255, 255};//A unsigned char carreglo[8]; unsigned char datos[88] ={0, 255, 255, 24, 24, 24, 255, 255, //H 0, 126, 255, 195, 195, 195, 255, 126, //O 0, 255, 255, 192, 192, 192, 192, 192, //L 0, 252, 254, 51, 51, 51, 254, 252, //A 0, 0, 0, 0, 0, 0, 0, 0, //" " 0, 255, 254, 12, 28, 12, 255, 255, //M 0, 127, 255, 192, 192, 192, 255, 127, //U 0, 255, 254, 24, 48, 96, 255, 254, //N 0, 255, 255, 195, 195, 195, 126, 60, //D 0, 126, 255, 195, 195, 195, 255, 126, //O 0, 0, 0, 0, 0, 0, 0, 0}; //" " //--------------------------------------------------------- //FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO / //--------------------------------------------------------- void SEND_DATA(unsigned char DATA){ DATO=DATA; CLOCK=0;



__delay_us(2); CLOCK=1; } //---------------------------------------------------------- //FUNCION DE BORRADO / //---------------------------------------------------------- void CLEAR(void){ for(MAX=1;MAX SEND_DATA(1); //->COLUMNAS } } //----------------------------------------------------------- // HABILITADOR / //----------------------------------------------------------- void HABILITO(void){ if(CONT==0) SEND_DATA(1); //ENVIO DATA 0 O 1 else SEND_DATA(0); } ///////////////////////////////////////////////// //Funcion de interrupcion //Si no se usa simplemente no hacemos nada... //Esto sirve para direccionar lo los datos //en un lugar muy cercano al Inicio de la memoria //de datos //////////////////////////////////////////////// static void interrupt isr(void){ ////////////////////////////////////// //Interrupcion por TIMER0 ////////////////////////////////////// if(TMR0IF){ ////////////////////////////////////////// //Ciclo for para copiar el arreglo actual ////////////////////////////////////////// for(x=0;x



if(c>86) c=0; else c++; TMR0IF=0; WriteTimer0(62410);//Valor para tener una interrupcion cada 200mS } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ OSCCON=0x70; NOP();NOP();NOP();NOP(); ////////////////////////////////////////////////////////////////////// // Configuracion de Puertos /// ////////////////////////////////////////////////////////////////////// TRISB=0x00;//SALIDA PARA FILA DE LA MATRIX TRISC=0x00; /*---------------------Fin de Conf. Puertos-------------------------*/ ////////////////////////////////////////////////////////////////////// // Configuracion de Timer1 /// ////////////////////////////////////////////////////////////////////// OpenTimer0(TIMER_INT_ON &//Interrupcion activada T0_16BIT &//valor de 16 bit T0_SOURCE_INT &//Corriente desde el oscilador principal T0_PS_1_128); //Preescalar de 16 /*---------------------Fin de Conf. TIMER1--------------------------*/ INTCON|=0b00100000;//Para activar interrupcion por timer0 WriteTimer0(62410);//Valor para tener una interrupcion cada 200 mS GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS /////////////////////////////////////////////////////////////////////// // FUNCION PRINCIPAL /// /////////////////////////////////////////////////////////////////////// RESET1=1; CLEAR(); SEND_DATA(1); while(1){ for(Letra=0;Letra



Este proyecto a comparacin del anterior

consta de cambiar el texto de la Matrix, cuando este en corrimiento o desplazndose, y as hemos de

finalizar todo lo relacionado con Matrices.

Tenemos un programa llamado Matrix que fue realizado con el Software Microsoft visual C# 2010

express que realiza una funcin primordial en el proyecto. Su funcionamiento es sencillo, primero

conectaremos el software al serial al COM existente en nuestra computadora.

Como la velocidad de transmisin ser de 19200

baudios por default, debemos de procurar que sea la

misma en el microcontrolador.

Y simplemente escribiremos el texto en el textbox

siempre y cuando cumpla con los 27 caracteres, esto

quiere decir que debemos de escribir como mximo

27 letras.

Despus de haber armado el circuito fsicamente

solo basta de conectarlo y enviar el dato.

Ahora como ya tenemos la idea de cmo

funciona, pasaremos a explicar el

funcionamiento del programa del

microcontrolador que no es ms que la unin de

los 2 ltimos proyectos anteriores.

Como ya hemos visto como funciona al recibir los datos por el serial y como hace el corrimiento de

letras, no es ms que unir las dos ideas para desarrollar este proyecto.

27 caracteres escritos

debe de aparecer un

cero para OK



En el programa que a continuacin se dara se dice que tiene un arreglo de 216 bytes que debe de tener

los datos. Como el programa Matrix enva 216 bytes que corresponden a que cada 8 byte es para la

letra escrita.

EJ.

Si enviamos 216 bytes entonces dividos.

=

8

=216

8= 27

El resultado si vemos es el mismo valor que corresponde al programa, que solo debemos de escribir 27

letras como mximo.

La nica diferencia que vamos a tener al unir las dos ideas de los 2 ltimos proyectos, es que el arreglo

de datos debe de ser de 216 ya que ser el mximo de bytes necesarios para mostrar 27 letras.

El circuito es exactamente igual que el proyecto anterior, solo debemos de programar el micro con el

programa que a continuacin se da.

Programa que contiene el Microcontrolador.

//////////////////////////////////////////////////////// // Corrimiento de Matrix //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// //////////////////////////////////////////////////////// #include ///////////////////////////////////////////////////////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLLPOSTDIV2 & CPUDIV1 & USBOSC); ///////////////////////////////////////////////////////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS); __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Definiciones ////////////////////////////// #define CLOCK RC1 #define DATO RC0 #define RESET1 RC2



////////////////////////////// //Variable Globales // ////////////////////////////// unsigned char MAX; unsigned char CONT; unsigned char Letra,c,f,x; unsigned char arreglo[8]={255, 255, 255, 227, 227, 255, 255, 255};//A unsigned char carreglo[8]; unsigned char datos[216]; //--------------------------------------------------------- //FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO / //--------------------------------------------------------- void SEND_DATA(unsigned char DATA){ DATO=DATA; CLOCK=0; __delay_us(2); CLOCK=1; } //---------------------------------------------------------- //FUNCION DE BORRADO / //---------------------------------------------------------- void CLEAR(void){ for(MAX=1;MAX SEND_DATA(1); //->COLUMNAS } } //----------------------------------------------------------- // HABILITADOR / //----------------------------------------------------------- void HABILITO(void){ if(CONT==0) SEND_DATA(1); //ENVIO DATA 0 O 1 else SEND_DATA(0); } ///////////////////////////////////////////////// //Funcion de interrupcin //Si no se usa simplemente no hacemos nada... //Esto sirve para direccionar lo los datos //en un lugar muy cercano al Inicio de la memoria //de datos //////////////////////////////////////////////// static void interrupt isr(void){ ////////////////////////////////////// //Interrupcin por TIMER0 ////////////////////////////////////// if(TMR0IF && TMR0IE){ ////////////////////////////////////////// //Ciclo for para copiar el arreglo actual ////////////////////////////////////////// for(x=0;x



//Creando el efecto de corrimiento ////////////////////////////////////////// for(x=0;x214) c=0; else c++; TMR0IF=0; WriteTimer0(62410);//Valor para tener una interrupcion cada 200 mS } //////////////////////////////////////// //Surge la interrupcin por Recepcion //de datos, recibiremos 216 BYTES //Desactiva la interrupcin por Timer0 //////////////////////////////////////// else if(RCIF){ TMR0IE=0; getsUSART(datos,216); TMR0IE=1; } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ OSCCON=0x70; NOP();NOP();NOP();NOP(); ////////////////////////////////////////////////////////////////////// // Configuracion de Puertos /// ////////////////////////////////////////////////////////////////////// TRISB=0x00;//SALIDA PARA FILA DE LA MATRIX TRISC=0x80; /*---------------------Fin de Conf. Puertos-------------------------*/ ////////////////////////////////////////////////////////////////////// // Configuracion de Timer1 /// ////////////////////////////////////////////////////////////////////// OpenTimer0(TIMER_INT_ON &//Interrupcion activada T0_16BIT &//valor de 16 bit T0_SOURCE_INT &//Corriente desde el oscilador principal T0_PS_1_128); //Preescalar de 16 /*---------------------Fin de Conf. TIMER1--------------------------*/ /////////////////////////////////////////////////////////////////////// // Configuracion del USART /// /////////////////////////////////////////////////////////////////////// OpenUSART(USART_TX_INT_OFF &//Interrupcion por Transmision apagado



USART_RX_INT_ON &//Interrupcion por Recepcion Apagado USART_ASYNCH_MODE &//Modo Asincronico USART_EIGHT_BIT &//8-bit de transmision USART_CONT_RX &//Recepcion Continua USART_BRGH_HIGH, //Alta velocidad de baudios 25); //para alta Velocidad: // FOSC / (16 * (spbrg + 1)) // spbrg=(FOS/baud*16)-1 //Para baja Velocidad: // FOSC / (64 * (spbrg + 1)) /*---------------------Fin de Conf. USART----------------------------*/ INTCON|=0b00100000;//Para activar interrupcion por timer0 WriteTimer0(62410);//Valor para tener una interrupcion cada 200 mS GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS /////////////////////////////////////////////////////////////////////// // FUNCION PRINCIPAL /// /////////////////////////////////////////////////////////////////////// RESET1=1; CLEAR(); //Limpia la Matriz SEND_DATA(1);//Envia el dato para Inicializar corrimiento //en el IC 74HC164 while(1){ for(Letra=0;Letra

Proyecto2 150103163545 Conversion Gate02

Documents

Transcript of Proyecto2 150103163545 Conversion Gate02