Proyecto3

Proyectos

Teclado

Los teclados son una Buena manera de introducir información hacia el Microcontrolador. Los teclados

están normalmente enumeradas, típicamente se realiza el etiquetado de las teclas para conocer la

acción que se debe de ejecutar, o simplemente para ser mas interactivo. Los teclados son encontrados

en controles remotos, alarmas, Microondas, etc. Pero hay una gran variedad de proyectos que se

pueden usar teclados.

La mayor parte de los teclados están en un formato Matricial, para reducir el números de conexiones

E/S. Un teclado de 12 teclas utiliza 7 conexiones, mientras un teclado de 16 teclas necesita solo 8

conexiones.

Considere un Teclado de 16 teclas, este arreglo consta de 4 columnas y 4 filas (4x4), como se muestra en

la siguiente tabla:

Columna 1 Columna 2 Columna 3 Columna 4

Fila 1 1 2 3 A

Fila 2 4 5 6 B

Fila 3 7 8 9 C

Fila 4 * 0 # D

Esta conexión funciona de la siguiente manera, si presionamos el número o carácter <5> la columna 2 y

fila 2 se deben de interceptar para que se pueda acceder al número <5>.

Simples Proyectos con LCD y Teclado 4x4

PROYECTOS: LCD Y TECLADO 4X4

PROYECTO #3 Página 133

Usando Librería para Teclado

Las funciones que tiene la librería del teclado, es la función de Inicialización:

void key_init(void);

Que se debe de llamar antes de cualquier función, mientras la siguiente función es la que regresa la

letra presionada, en este caso se debe de realizar un ciclo hasta que sea presionada una tecla.

unsigned char getkey(unsigned char kbd);

Esta función regresa el valor presionado en el teclado, se debe de introducir siempre un valor 0 en la

variable kbd. Una función creada por nosotros puede lucir de la siguiente manera:

///////////////////////////////////////////////// //Funcion para Obtener la letra presionada //en el teclado 4x4 ///////////////////////////////////////////////// unsigned char key(){

unsigned char _var; do{

_var=getkey(0); } while (_var==0); return _var;

}

Y de esta manera podemos simplemente llamar a la función <key>para que solo regrese la tecla

presionada.

LETRA=key();

Conexión del Teclado

a) Esta conexión es muy típica para teclados 4x4:

PUERTO B Pines del Teclado

RB0 4

RB1 3

RB2 2

RB3 1

RB4 A

RB5 B

RB6 C

RB7 D



b) conexión de un teclado de Membrana es el siguiente:

Conexión Típica de un Teclado hacia el Microcontrolador:

LCD

Los LCD pueden adherir interfaces de visualización entre el usuario, o debbuggear aplicaciones, o

simplemente dar una buena apariencia a nuestra aplicación. El controlador de LCD más común es el

Hitachi 44780, cual promueve una simple interfaz entre el Procesador y LCD. Usando este interfaz no es

apto para nuevos diseñadores porque es difícil encontrar buena documentación sobre el interfaz, la

Inicialización puede ser un problema muy común para trabajar con LCD, los Display son caros.

PUERTO B Pines del Teclado

RB4 4

RB5 3

RB6 2

RB7 1

RB0 A

RB1 B

RB2 C

RB3 D



Como probablemente supondrás de esta descripción, el interfaz es un Bus paralelo que permite ser

simple y rápido para escribir/leer fatos hacia el LCD. Esta forma para escribir un valor ASCII al LCD es de

la siguiente manera:

El código ASCII para ser mostrado es 8-bit y es enviado al LCD también en 4 u 8 bits. Si el modo de 4-bit

es usado, dos nibbles de datos (envía el nibble alto 4-bits y después el nibble bajo 4 bits con un pulso E

en cada nibble enviado) son enviado para establecer una transferencia de 8 bit. El pulso E es usado para

inicializar la transferencia de datos dentro del LCD.

Descripción de pines del LCD

PIN Descripción 1 Tierra 2 Vcc 3 Voltaje de Contraste 4 R/S Instrucción/Selección de registro 5 R/W Leer/Escribir Registros del LCD 6 E pulso o CLOCK

7-14 D0-D7 datos 15 LED + 16 LED -

Tabla de Comandos para el LCD:



Enable display/cursor: D—Turn display on(1)/off(0)

C—Turn cursor on(1)/off(0) B—Cursor blink on(1)/off(0) Move cursor/shift display:

SC—Display shift on(1)/off(0) RL—Direction of shift right(1)/left(0) Set interface length:

DL—Set data interface length 8(1)/4(0) N—Number of display lines 1(0)/2(1)

F—Character font 5 _ 10(1)/5 _ 7(0)

Poll the busy flag: BF—This bit is set while the LCD is processing Move cursor to CGRAM/display:

A—Address Read/write ASCII to the display: H—Data

Info: datasheet HITACHI LCD

Pasos para una simple Inicialización de LCD en modo de 8 bits

1.-Esperar mas de 15mS después que se halla conectado a la fuente

2.-Ecribir 0x03 al LCD y esperar 5mS para se complete la Instrucción

3.-Ecribir 0x03 al LCD y esperar 160uS o esperar la bandera busy

4.-Escribir 0x03 otra vez y esperar 160uS o esperar la bandera busy

5.-Establecer las características de operación del LCD:

Escribir SetInterface lengh

Escribir 0x01 para apagar el Display

Escribir 0x01 para limpiar Display

Escribir set cursor move direction para establecer el cursor

Escribir enable display/cursor para establecer display y opciones del cursor

Conexión Tipia hacia el Microcontrolador:



Librería del LCD

Como cualquier otro dispositivo siempre es necesaria la Inicialización, del cual siempre se debe de

llamar antes de otra función:

void lcd_init(unsigned char config);

Config puede tomar uno de los dos comandos que es prender o que aparezca el cursor, o si no lo

deseamos.

config:

#define CURSOR_ON 0X07

#define CURSOR_OFF 0X04

Como a veces se presenta la ocasión de manipular los comandos, se ha creado una función para este

propósito:

void send_byte(unsigned char data);

Ejemplo:

send_byte(CLEAR); //Limpia LCD

Para poder escribir en el LCD datos guardados en la ROM del Microcontrolador se usa la siguiente

función:

void writeRSLCD(const char *string);

Ejemplo:

writeRSLCD(“HOLA MUNDO”);

Si los datos son volátiles o están temporalmente guardado en la RAM se usa esta función:



void writeSLCD(unsigned char *dir);

Ejemplo:

unsigned char dato[15]={“HOLA MUNDO”};

writeSLCD(dato);

Para escribir un simple carácter de 8-bit se usa esta función:

void writeCLCD(char c);

Ejemplo:

writeCLCD(‘A’);

Algunas veces es necesario posicionar el cursor para que este empiece a escribir en una posición dada,

para ellos se usa esta función:

void gotoXYLCD(unsigned char x, unsigned char y);

Proyecto #1 : Manipulacion de 8 LED

Consta de manipular un arreglo de 8 led con el teclado & LCD 16x2, donde al presionar un numero del

teclado del 0 al 7 podemos encender correspondientemente el led, como hemos limitado los pines de

salida, ya que hemos usado 2 puertos completos donde están conectados el Teclado y el LCD, esto hace

que disminuya el numero de E/S, para eso hemos usado un CI 74LS138 que tiene 3 líneas de entrada a 8

salidas Demultiplexadas, a continuación se muestra el esquema de conexión del CI.

Como vemos solo necesitaremos 3 salidas en lugar de 8 salidas, esto permite reducir el número de

salidas de un Microcontrolador.



Vemos el esquema de conexión de nuestro proyecto:

La conexión del teclado 4x4 es una conexión típica, pero en la realidad se ha usado un teclado de

membrana, de acuerdo a la explicación de conexión de teclados, en mi caso hice una conexión de un

teclado 4x4 de membrana.

La conexión del CI 74LS138 es tener los dos pines que se muestran en la letra “A” esa tierra pero como

he realizado físicamente el circuito con un 74LS138N, a veces la conexión del E1 va a +5v y el E1 a tierra.

Lógica de Programación

Para la realización del programa del Micro, consta de Inicializar correctamente el Teclado, llamando a la

función de Inicialización <key_init> después Inicializar el LCD, llamando a la función de Inicialización

<lcd_init> con el cursor apagado o encendido, como nosotros queramos.

Después podemos Escribir algo en el LCD, y entrar a un ciclo while para que sea perpetuo, después

podemos esperar a que letra del teclado se ha presionado y convertirlo a un numero decimal, después

pasar el numero al puerto donde va conectado el CI 74LS138N, para encender el led correspondiente, y

visualizar en el LCD lo que se ha presionado.

A



Para entender mejor se ha puesto un código de flujo con los pasos necesarios, para desarrollar el

programa:

INICIO

Inicializa LCD

Inicializa Teclado

Escribe texto

al LCD

While 1

Var=key()

PORTC=var-48

Posicion cursor

12,2

writeCLCD(var)

FIN



El programa del Microcontrolador es el siguiente:

/////////////////////////////////////////////////// ///// // USO LCD Y TECLADO 4X4 //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & 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 #include"libkey/keydr.h" #include"liblcd/lcddr.h" //..........................// //Variables Globales //..........................// unsigned char var; ///////////////////////////////////////////////// //Funcion para Obtener la letra presionada //en el teclado 4x4 ///////////////////////////////////////////////// unsigned char key(){ unsigned char _var; do{ _var=getkey(0); }while(_var==0); return _var; } ///////////////////////////////////////////////// //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();



///////////////////////////////// //Inicializa TECLADO ///////////////////////////////// key_init(); ///////////////////////////////// //Desactivamos ADC ///////////////////////////////// ADCON0=0x00; ADCON1=0x0F; ///////////////////////////////// //Inicializa Puertos ///////////////////////////////// TRISC=0; PORTC=0; ///////////////////////////////// //Inicializa LCD ///////////////////////////////// TRISE=0; lcd_init(CURSOR_OFF); GIE=0; //INTERRUPCIONES GLOBALES DesACTIVADAS PEIE=0; //DesACTIVA INTERURPCIONES POR PERIFERI COS ////////////////////////////////// //Programa Principal ////////////////////////////////// writeRSLCD("LCD&Teclado 4x4"); gotoXYLCD(1,2); writeRSLCD("Secuencia:"); while(1){ var=key(); //OTIENE LA LETRA PRESIONADA DEL TECLADO PORTC=var-48; //CONVIERTE A NUMERO gotoXYLCD(12,2);//POSICIONA EL CURSOR writeCLCD(var); //ESCRIBE EN EL LCD EL VALOR } while(1); }



Material a usar:

Material Cantidad

PIC18F4550 1

TECLADO 4X4 1

LCD 16X2 1

Barra de Led (10 leds) 1

CI 74LS138N 1

Regulador de Voltaje 7805 1

Cap 100uF 2

Resis 330ohm 9

Resis 10K 1

Material Extra

Cable

Pinzas

ProtoBoard

Fuente de 9 Volts

Fotografía del Proyecto:

Teclado

7805

Arreglo de Leds

74LS138N

PIC18F4550

LCD



Proyecto #2: Contraseña

Es normal encontrar en dispositivos de seguridad, sistemas que se necesita acceder por medio de

contraseñas, estos sistemas tienen la capacidad de guardar la contraseña de cualquier tamaño en una

memoria tipo EEPROM, para que siempre este guardado aunque existe apagones repentinos. Esta

práctica trata de ensenar la lógica de programación usando un LCD y un Teclado 4x4, donde el actuador

será un simple Led, el sistema a desarrollar es simple, tenemos la capacidad de cambiar contraseña no

importa el tamaño de la contraseña solo recordar que el máximo de caracteres a mostrar en un LCD es

de 16.

La idea es guardar la contraseña en 16 posiciones de la memoria EEPROM que contiene el

Microcontrolador PIC18F4550, buscando en la hoja de datos del PIC18, podemos notar el espacio de

memoria de EEPROM.

Lo bueno de estas memorias es que se pueden cada así hasta mayor de 40 años, según lo que dice la

hoja de datos de este PIC18.

Inicializando memoria EEPROM

Teniendo como consideración cuando se vende un producto o un sistema que se requiera una

contraseña, el fabricante pone una contraseña por defecto en la memoria EEPROM, para lograr esto en

un microcontrolador el compilador HI TECH COMPILER FOR PIC18 ofrece la capacidad de guardar los

datos inicialices en la memoria EEPROM cuando se programa el Microcontrolador.

Después de incluir la librería estándar htc.h se llama a un Macro que el compilador tiene internamente,

este Macro se usa de la siguiente manera:

#include <htc.h> __EEPROM_DATA(0, 1, 2, 3, 4, 5, 6, 7);

El Macro acepta 8 parametros, cada valor debe ser 8-bits, valores sin uso se deben de colocar como ‘0’,

El macro deberá de llamarse las veces que queramos para inicializar la memoria EEPROM.



Por ejemplo:

En el Macro anterior solo hemos escrito 8 bytes en la posición de 0x00 a 0x07 de la memoria EEPROM,

pero si se desea poner más información o simplemente, colocar un dato a otra dirección solo se debe de

hacer lo siguiente:

#include<htc.h> __EEPROM_DATA(0, 1, 2, 3, 4, 5, 6, 7);//Password po r defecto en la EEPROM __EEPROM_DATA(0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X FF); __EEPROM_DATA(8,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF) ;

Como vemos para guardar un dato en la dirección <0x10> se tuvo que escribir un macro completo (8

bytes) y después otro macro con el dato en la dirección deseada, y resto lo que queramos (0Xff).

Esta técnica para Inicializar nuestra memoria con una clave, para que el usuario tenga la oportunidad de

cambiar la clave a su gusto, siempre y cuando se conozca la contraseña de fábrica. Como Vemos el

parámetro o el dato que se encuentra en la dirección de la memoria EEPROM <0x10> es el valor que

necesitamos para decirle cuantos datos se ha escrito. Como vemos en el ejemplo anterior, solo

teníamos 8 datos escritos en la EEPROM, entonces el dato contiene un valor de ocho en la posición

<0x10> donde nos indica que se ha grabado 8 datos como contraseña.

Para checar la contraseña se ha creado un buffer de 16 datos, para guardar la contraseña escrita, para

después compararla con la que hay en la memoria EEPROM que es la que debe ser escrita por el usuario.

Como los datos del teclado 4x4 están en forma de caracteres se hace una operación de resta con 48

para obtener el número no el carácter.

Key()-48; //Al obtener el carácter del teclado pasa por una resta para adquirir el numero.



Como vemos se ha creado un ciclo

for para que pueda contar solo a

16 que el máximo para visualizar

en el LCD 16x2, cada vez que

presionamos una tecla se guarda

el numero en un arreglo y, ese

número en el arreglo pasa por una

comparación con una posición de

la memoria EEPROM, si es

correcta aumenta una variable

indicándole cuantos caracteres se

han escrito correctamente,

cuando se escriban todos los

caracteres de la contraseña

correctamente se sale del ciclo he

retorna un valor verdadero, que es

el que vamos a usar para indicar que la contraseña que se ha escrito es correcta.

Como vemos las funciones de leer/Escribir en la EEPROM son los siguientes:

EEPROM_READ(dirección);

EEPROM_WRITE(dirección, dato);

Ahora bien como se necesita cambiar la contraseña, y que esta permanezca en la memoria EEPROM por

posibles apagones del sistema y que pueda recordar la contraseña escrita por el usuario, se utiliza la

siguiente lógica de programación:

Se ha utilizado un ciclo for para esperar los 16 caracteres o simplemente para hacer un conteo, donde al

escribir la contraseña de cualquier tamaño sin superar los 16 caracteres, si al escribir 4 caracteres solo

basta de presionar el botón <D> del teclado, para guardar el dato.

Cada vez que se guarda un dato, se suma uno a una variable que guarda el número máximo de

caracteres escritos por el usuario, este número se guardara en la posición <0x10> de la memoria

EEPROM.

////////////////////////////// //FUNCION DE PEDIR CLABE ////////////////////////////// unsigned char password(){ unsigned char flag2; for(char x=0;x<16;x++){ gotoXYLCD(x+1,2); pass[x]=key()-48; //Convertir a numero writeCLCD('*'); if(pass[x]==EEPROM_READ(x)){ cont++; if(cont==EEPROM_READ(MAX)){ flag2=VERDAD; return flag2; } }else{ cont--; flag2=FALSO; } } return flag2; }



Al saber cómo comparar la contraseña con la verdadera, y como poder cambiarla, solo basta usar estas

funciones en nuestro programita:

Lo que se va a realizar es cuando Inicie el sistema o cuando sea conectado nuestro circuito, rápidamente

parecerá la opción de elección, donde la primera opción es si deseamos cambiar la contraseña, y la

segunda opción es si deseamos acceder para prender el led.

Si queremos acceder al primera opción de cambiar contraseña, se debe de presionar la tecla <A>

entonces al presionarla, este rápidamente mandara un mensaje que indique que se debe de escribir la

contraseña actual, que es la cual hemos inicializado en la memoria EEPROM. Al introducir correctamente

la contraseña, podemos acceder a poder cambiarla, al escribir la nueva contraseña, solo basta de

presionar la tecla <D> del teclado, para salir y guarde la contraseña.

Si deseamos acceder a la segunda opción, solo necesitaremos introducir la contraseña actual, al entrar

solo para togglear el LED de estado. (0 ->1 , 1->0)

El esquema del circuito es igual que de la practica #1

///////////////////////////////// //FUNCION DE CAMBIAR CLABE ///////////////////////////////// void cambiar_password(void){ cont=0; send_byte(CLEAR); writeRSLCD("Correcto"); DELAY1S(); send_byte(CLEAR); writeRSLCD("Escriba ahora"); for(char x=0;x<16;x++){ gotoXYLCD(x+1,2); pass[x]=key(); if(pass[x]=='D'){ break; } cont++; writeCLCD(pass[x]); EEPROM_WRITE(x,pass[x]-48); //GRABA EN MODO BCD } EEPROM_WRITE(MAX,cont); send_byte(CLEAR); writeRSLCD("GUARDADO"); DELAY1S(); }



La lógica de Programación es la siguiente:

/////////////////////////////////////////////////// ///// // USO LCD Y TECLADO 4X4 //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> __EEPROM_DATA(0, 1, 2, 3, 4, 5, 6, 7);//Password po r defecto en la EEPROM __EEPROM_DATA(0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X FF); __EEPROM_DATA(8,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF) ; /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & 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 #include"libkey/keydr.h" #include"liblcd/lcddr.h" ////////////////////////////// //Definiciones Globales ////////////////////////////// #define FALSO 0 #define VERDAD 1 #define MAX 0x10 ////////////////////////////// //Variables Globales ////////////////////////////// unsigned char pass[16]; unsigned char tpass[16]; unsigned char dir; char cont; unsigned char flag; ///////////////////////////////////////////////// //Funcion para Obtener la letra presionada //en el teclado 4x4 ///////////////////////////////////////////////// unsigned char key(){ unsigned char _var; do{ _var=getkey(0); }while(_var==0); return _var; } ////////////////////////////// //FUNCION DE 1 SEG // ////////////////////////////// void DELAY1S(void){ unsigned char time; for(time=0;time<100;time++){ __delay_ms(10);

}



} ////////////////////////////// //FUNCION DE PEDIR CLABE ////////////////////////////// unsigned char password(){ unsigned char flag2; for(char x=0;x<16;x++){ gotoXYLCD(x+1,2); pass[x]=key()-48; //Convierte a BCD writeCLCD('*'); if(pass[x]==EEPROM_READ(x)){ cont++; if(cont==EEPROM_READ(MAX)){ flag2=VERDAD; return flag2; } }else{ cont--; flag2=FALSO; } } return flag2; } ///////////////////////////////// //FUNCION DE CAMBIAR CLABE ///////////////////////////////// void cambiar_password(void){ cont=0; send_byte(CLEAR); writeRSLCD("Correcto"); DELAY1S(); send_byte(CLEAR); writeRSLCD("Escriba ahora"); for(char x=0;x<16;x++){ gotoXYLCD(x+1,2); pass[x]=key(); if(pass[x]=='D'){ break; } cont++; writeCLCD(pass[x]); EEPROM_WRITE(x,pass[x]-48); //GRABA EN MODO BCD } EEPROM_WRITE(MAX,cont); send_byte(CLEAR); writeRSLCD("GUARDADO"); DELAY1S(); }



///////////////////////////////////////////////// //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(); ///////////////////////////////// //Inicializa TECLADO ///////////////////////////////// key_init(); ///////////////////////////////// //Desactivamos ADC ///////////////////////////////// ADCON0=0x00; ADCON1=0x0F; ///////////////////////////////// //Inicializa Puertos ///////////////////////////////// TRISC=0; PORTC=0; ///////////////////////////////// //Inicializa LCD ///////////////////////////////// TRISE=0; lcd_init(CURSOR_OFF); GIE=0; //INTERRUPCIONES GLOBALES DesACTIVADAS PEIE=0; //DesACTIVA INTERURPCIONES POR PERIFER ICOS ////////////////////////////////// //Programa Principal ////////////////////////////////// while(1){ send_byte(CLEAR); //Limpia LCD writeRSLCD("Cambiar PIN <A>"); //1,1 gotoXYLCD(1,2); writeRSLCD("Acceder <B>"); //1,2 dir=key(); //Espera ha presionar desicion switch(dir){ case 'A': cont=0; send_byte(CLEAR); writeRSLCD("Password actual"); flag=password(); __delay_ms(50); if(flag==VERDAD){ cambiar_password(); break; }else{ send_byte(CLEAR); writeRSLCD("Incorrecto"); gotoXYLCD(1,2);



writeRSLCD("Intente Otra vez"); DELAY1S(); } break; case 'B': cont=0; send_byte(CLEAR); writeRSLCD("Password actual"); flag=password(); __delay_ms(50); send_byte(CLEAR); writeRSLCD("Togglear RC0"); gotoXYLCD(1,2); writeRSLCD("Salir <D>"); if(flag==VERDAD){ while(pass[0]!='D'){ pass[0]=key(); if(pass[0]=='1') RC0=1; else if(pass[0]=='2')RC0=0; } }else{ send_byte(CLEAR); writeRSLCD("Incorrecto"); gotoXYLCD(1,2); writeRSLCD("Intente Otra vez"); DELAY1S(); } break; default: send_byte(CLEAR); //Limpia LCD writeRSLCD("Intente otra vez"); //1,1 DELAY1S(); break; } }

}



Imágenes Físicas de la práctica

Menu

Proyecto3

Documents

Transcript of Proyecto3