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 & 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);
//////////////////////////////
//Frecuencia FOSC 8Mhz
//////////////////////////////
#define _XTAL_FREQ 8000000
#include"libkey/keydr.h"
#include"liblcd/lcddr.h"
//..........................//
//Variables Globales
//..........................//
unsigned char var;
/////////////////////////////////////////////////
//en el teclado 4x4
/////////////////////////////////////////////////
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 PERIFERICOS
//////////////////////////////////
//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 por defecto en la EEPROM
__EEPROM_DATA(0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF);
__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");
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 por defecto en la EEPROM
__EEPROM_DATA(0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF);
__EEPROM_DATA(8,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF);
/////////////////////////////////////////////////////////////
//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);
//////////////////////////////
//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;
/////////////////////////////////////////////////
//en el teclado 4x4
/////////////////////////////////////////////////
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;
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");
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 PERIFERICOS
//////////////////////////////////
//Programa Principal
//////////////////////////////////
while(1){
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:
writeRSLCD("Intente otra vez"); //1,1
DELAY1S();
break;
}
}
}

Imágenes Físicas de la práctica
Menu

Proyecto3

Más contenido relacionado

La actualidad más candente (20)

Similar a Proyecto3 (20)

Más de georgemanson69 (10)

Proyecto3