EJERCICIO 2.

ENCENDIDO Y APAGADO DEL LED

CÓDIGO
#include <18F4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC =12MHz.
#byte tris_b = 0xF93 //Define el registro tris b en la localidad 0xF93.
#bit b0= 0xF81.0 //Define el bit b0 en la localidad 0xF81.0.
void main() //Función principal main.
{
disable_interrupts (GLOBAL); //Deshabilita las interrupciones globales.
tris_b = 0x00; //Configura el puerto B como salida.
do{ //Inicio del bucle infinito.
b0= 0; //El puerto RB0 = 0.
delay_ms( 500 ); //Retardo de 500 ms.
b0 =1; //El Puerto RB0 = 1.
delay_ms(500); //Retardo de 500 ms.
} while ( TRUE ); //Bucle infinito.
} //Fin del bucle main.

EJERCICIO 2.2
PRENDER Y APAGAR LOS LEDS DEL PUERTO B

CÓDIGO
#include <18F4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC = 12MHz.
#byte port_b = 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#byte tris_b = 0xF93 //Identificador para el registro tris b en la localidad 0xF93.
void main() //Función principal main.
{
disable_interrupts(GLOBAL); //Deshabilita todas las interrupciones globales.
tris_b = 0x00; //Configura todo el puerto B como salida.
port_b = 0x00; // Asigna a todo el Puerto B cero (0).
do{ // Hace o empieza el bucle infinito.
port_b = 0xFF; //Coloca todo el puerto B en 1.
delay_ms( 500 ); //Retardo de 500 ms.
port_b = 0x00; //Coloca todo el puerto B en 0.
delay_ms(500); //Retardo de 500 ms.
} while ( TRUE ); //Bucle infinito.
} //Fin del bucle main.

EJERCICIO 2.3

ON_OFF LEDS PUERTOS B INDEFINIDAMENTE

CÓDIGO
#include <18F4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC = 12MHz.
#byte port_b = 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#byte tris_b = 0xF93 //Identificador del registro tris b en la localidad 0xF93.
void main() //Función principal main.
{
disable_interrupts(GLOBAL); //Deshabilita todas las interrupciones globales.
tris_b = 0x00; // Configura el puerto B como salida.
port_b = 0x00; // Asigna a todo el Puerto B cero (0).
while (TRUE){ //Bucle infinito.
port_b = 0xFF; //Coloca todo el puerto B en 1.
delay_ms( 500 ); //Retardo de 500 ms.
port_b = 0x00; //Coloca todo el puerto B en 0.
delay_ms(500); //Retardo de 500 ms.
} //Fin del bucle infinito.
} //Fin del bucle main.

EJERCICIO 2.4

PRENDER Y APAGAR UN LED POR EL PUERTO RB0

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC=12MHz.
#use standard_io(b) //Directiva usado por el compilador por defecto.
//Es opcional llamarla en el programa.
void main(void) //Función principal main.
{
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
while(TRUE); //Bucle infinito.
{ //Inicio del bucle.
output_low(PIN_B0); //LED off.
delay_ms(500); //Retardo de 500 ms.
output_high(PIN_B0); //LED on.
delay_ms(500); //Retardo de 500 ms.
} //Fin del bucle infinito.
} //Fin del bucle main.

EJERCICIO 2.5

PRENDER Y APAGAR LED POR EL PUERTO RB0

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC=12MHz.
#use fast_io(b) //Define el puerto b como i/o digital.
void main(void) //Función principal main.
{
set_tris_b(0); //Define port_b como salida.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
while(TRUE); //Bucle infinito.
{ //Inicio del bucle.
output_low(PIN_B0); //LED off.
delay_ms(500); //Retardo de 500 ms.
output_high(PIN_B0); //LED on.
delay_ms(500); //Retardo de 500 ms.
} //Fin del bucle infinito.
} //Fin del main.

EJERCICIO 2.6

PRENDER Y APAGAR UN LED

CÓDIGO
/* MANEJO DEL PUERTO USANDO DIRECTIVA #USE FIXED */
#include <18F4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC=12MHz.
#use fixed_io(b_outputs=pin_b0) //Define el puerto b0 como salida.
void main() //Función principal main.
{
disable_interrupts(GLOBAL); //Desactiva todas las interrupciones.
while (TRUE) //Bucle infinito.
{ //Inicio del bucle.
output_high(pin_b0); //Puerto RB0 en alto.
delay_ms( 500 ); //Retardo de 500 ms.
output_low(pin_b0); //Puerto RB0 en bajo.
delay_ms(500); //Retardo de 500 ms.
} //Fin del bucle infinito.
} //Fin del bucle main.

EJERCICIO 2.7

SECUENCIA ENCENDIDO APAGADO DE LEDS

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC=12MHz
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.
int i; //Variable i tipo int para el bucle FOR.
void main(void) { //Función principal main
set_tris_b(0x00); //Puerto B como salida
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas
while(TRUE) //Bucle infinito
{ //Inicio del bucle.
port_b=0x01; //Puerto RB0 = 1
for (i=1;i<=8;++i) //Realiza el bucle para i = 0 hasta que sea menor o igual 8 en
//incrementos de 1.
{
delay_ms(100); //Retardo de 100 ms
port_b= port_b<<1; //Desplaza el valor del puerto a la izquierda en 1
}
port_b= 128; //port_b = 128.
for (i=1;i<=8;++i) //Realiza el bucle para i = 0 hasta que sea menor o igual
//8 en incrementos de 1.
{
delay_ms(100); //Retardo de 100 ms
port_b= port_b>>1; //Desplaza el valor del puerto a la derecha en 1
}
} //Fin del bucle infinito.
} //Fin del bucle main.
EJERCICIO 2.8

MANEJO DE LEDS CON EL PUERTO A

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550
#fuses HS,NOWDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC =12MHz
#BYTE port_a= 0xF80 //Identificador para el puerto a en la localidad 0xF80.
void main() //Función main.
{
set_tris_a(0x00); //Puerto A como salida.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
port_a=0x00; //Puerto A = 0.
while(TRUE); //Bucle infinito
{
output_low(PIN_A0); //LED conectado en el Puerto RA0 off.
output_low(PIN_A4); //LED conectado en el Puerto RA4 on.
delay_ms(500); //Retardo 500 ms.
output_high(PIN_A0); //LED conectado en el Puerto RA0 on.
output_high(PIN_A4); //LED conectado en el Puerto RA4 off.
delay_ms(500); //Retardo 500 ms.
} //Fin del bucle infinito.
} //Fin del main

EJERCICIO 2.9

MANEJO DE PULSADORES
CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC =12MHz.
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81
#BYTE port_d= 0xF83 //Identificador para el puerto d en la localidad 0xF83.
#define prender bit_test(port_d,0) //Define el pin RD0 para prender.
#define apagar bit_test(port_d,1) //Define el pin RD1 para apagar.
void main(void) //Función principal main.
{
set_tris_b(0x00); //Define puerto b como salida.
set_tris_d(0xff); //Define puerto d como entrada.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
while(TRUE){ //Inicio del bucle.
if (prender == 0) //Censa si P1= 0 .
{
bit_set(port_b,0); //LED on.
}
if (apagar==0) //Censa si P2 = 0.
{
bit_clear(port_b,0); //LED off.
}
} //Fin de bucle infinito.
} //Fin del main.
EJERCICIO 2.10

MANEJO DE PULSADORES MEDIANTE LA FUNCIÓN INPUT

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz
#use standard_io(B) //Usa librería estándar para el puerto B.
#use standard_io(D) //Usa librería estándar para el puerto D.
void main(void) //Función principal main.
{
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
output_low(PIN_B0); //LED off.
while(TRUE){ //Inicio del bucle.
if (input(PIN_D0) == 0) //Detecta si se accionado el pulsador P1.
output_high(PIN_B0); //LED on.
if (input(PIN_D1) == 0) //Detecta si se accionado el pulsador P2.
output_low(PIN_B0); //LED off.
} // Fin de bucle infinito.
} //Fin del main.

EJERCICIO 2.11

EFECTO DEL REBOTE MECÁNICO DE UN PULSADOR

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC =12MHz.
#use fast_io(b) //Directivas de i/o para puerto b.
#use fast_io(d) //Directivas de i/o para puerto d.
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#BYTE port_d= 0xF83 //Identificador para el puerto d en la localidad 0xF83.
#define pulsador bit_test(port_d,0); //Define el pin RD0 para prender.
int k; //Variable k para determinar el estado del LED.
void main() //Función principal main.
{
set_tris_b(0x00); //Fija el puerto B como salida.
set_tris_d(0xff); //Fija el puerto D como entrada.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
port_b=0; //Port =0.
k=0; //k=0.
while(TRUE){ //Inicio del bucle.
if(bit_test(port_d,0)==0 && k==0)//Si pulsador = 0 y k = 0, realiza.
{
k=1; //k=1.
bit_set(port_b,0); //LED on.
}
if(bit_test(port_d,0)==0 && k==1) //Si pulsador = 0 y k = 1, realiza…..
{
k=0; //k=0.
bit_clear(port_b,0); //LED off.
}
} //Bucle infinito.
} //Fin del main.

EJERCICIO 2.12

ELIMINACIÓN DEL REBOTE MECÁNICO DE UN PULSADOR

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) // FOSC =12MHz.
#use fast_io(b) //Directivas de i/o para puerto b.
#use fast_io(d) //Directivas de i/o para puerto d.
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#BYTE port_d= 0xF83 //Identificador para el puerto b en la localidad 0xF83.
#define pulsador bit_test(port_d,0); //Define el pin RD0 para prender.
int k; //Variable k para determinar el estado del LED.
void antirebote(); //Función anti rebote.
void main() //Función principal main.
{
set_tris_b(0x00); //Fija el puerto B como salida.
//set_tris_d(0xff); //Fija el puerto D como entrada.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
port_b=0; //Port =0.
k=0; //k=0.
while(TRUE){ //Inicio del bucle.
if(bit_test(port_d,0)==0 && k==0); //Si pulsador = 0 y k = 0, realiza.
{
antirebote(); //Si el pulsador = 0 llama a subrutina anti rebote.
k=1; //k=1.
bit_set(port_b,0); //LED on.
}
if(bit_test(port_d,0)==0 && k==1); //Si pulsador = 0 y k = 1, realiza…..
{
antirebote(); //Si el pulsador = 0 llama a subrutina anti rebote.
k=0; //k=0.
bit_clear(port_b,0); //LED off.
}
} //Bucle infinito.
} //Fin del main.
void antirebote(void) //Función anti rebote.
{
while(bit_test(port_d,0)==0)
{ } //No realiza nada hasta que el pulsador esté inactivo.
delay_ms(30); //Retardo de 30 ms.
return; //Retorna al programa principal.
} //Bucle infinito.
EJERCICIO 2.13

GENERACIÓN DE SONIDO

CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.

#use delay (clock=12000000) //FOSC =12MHz.

#include <TONES.c> //Librería para gestión de sonido.

void main(void) { //Función principal main.

int fusa=62; //Tiempo de duración fusa.

int semicorchea=125; //Tiempo de duración semicorchea.

int corchea=250; //Tiempo de duración corchea.

while(TRUE) { //Bucle infinito.

generate_tone(C_NOTE[0],fusa);

generate_tone(C_NOTE[1],fusa);

generate_tone(Eb_NOTE[2],corchea);

generate_tone(C_NOTE[3],fusa);

generate_tone(C_NOTE[0],fusa);

generate_tone(Eb_NOTE[1],corchea);

generate_tone(C_NOTE[3],fusa);

generate_tone(Eb_NOTE[3],fusa);

generate_tone(Ab_NOTE[3],semicorchea);

generate_tone(G_NOTE[3],semicorchea);

generate_tone(F_NOTE[3],semicorchea);

generate_tone(F_NOTE[3],semicorchea);

generate_tone(Eb_NOTE[3],semicorchea);

delay_ms(100);

} //Fin del bucle infinito.

} //Fin del main.

EJERCICIO 2.14

ENCENDER Y APAGAR LED CON UN INTERRUPTOR

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz
#byte tris_b = 0xF93 //Identificador para el registro TRIS B en la localidad 0xF93.
void main() { //Función principal main.
set_tris_b(0xFF); //Fija el Puerto B como salida.
port_b_pullups(TRUE); //Habilitación del Pull-up.
while(TRUE){ //Bucle Infinito.
if (input(PIN_B3) == 0) //Detecta si se accionado el pulsador P1….
output_high(PIN_D0); //….y activa al LED.
else //caso contrario…..
output_low(PIN_D0); //….el LED permanece apagado.
} //Fin del bucle infinito.
} //Fin del main.

EJERCICIO 2.15

ENCENDER Y APAGAR LED CON UN INTERRUPTOR

CÓDIGO
#include <18f4550.h> //Cargar libreria del micro
#fuses XT,NOWDT //Configurar fusibles xt cristal 8MHz, hs 10MHz, watchdoc
temporizador(NO WDT)
#use delay (clock=4M)
void main(){
set_tris_b(0); //0 salida, 1 entrada (puertos)
output_b(0);
while (1,1){
output_b(0);
delay_ms(150);
output_b(1);
delay_ms(150);
output_b(3);
delay_ms(150);
output_b(7);
delay_ms(150);
output_b(15);
delay_ms(150);
output_b(31);
delay_ms(150);
output_b(63);
delay_ms(150);
output_b(127);
delay_ms(150);
output_b(255);
delay_ms(150);
output_b(127);
delay_ms(150);
output_b(63);
delay_ms(150);
output_b(31);
delay_ms(150);
output_b(15);
delay_ms(150);
output_b(7);
delay_ms(150);
output_b(3);
delay_ms(150);
output_b(1);
delay_ms(150);
}
}
EJERCICIO 2.16

USO DE RESISTENCIAS PULL UP

CÓDIGO

#include <16f88.h> //Librería para usar el PIC16F88.

#fuses INTRC,NOWDT,NOMCLR,NOPROTECT,NOPUT //Configuración de
fusibles.
#use delay (clock=4000000) //Fosc=4MHz
void main(void){ //Función principal main.
port_b_pullups (TRUE); //Activa las resistencias Pull Up del puerto B.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
output_low(PIN_A0); //Pin A0= 0.
while(TRUE){ //Bucle infinito.
if (input(PIN_B0) == 0) //Si pin RB0= 0….
output_high (PIN_A0); //Pin RA0= 1.
else //Caso contrario…
output_low(PIN_A0); //Pin RA0=0.
} //Fin del bucle infinito
} //Fin del main.

EJERCICIO 3.1

CONTADOR DE 0 A 9 UTILIZANDO UN DECODIFICADOR Y

DISPLAY.
CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.

#use delay (clock=12000000) // FOSC = 12MHz.

#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.

int i; //Variable i para el bucle FOR.

void main(void) //Función principal main.

set_tris_b(0x00); //Define port_b como salida

disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.

port_b = 0; //Puerto b = 0.

while(TRUE) //Bucle infinito.

{ //Inicio del bucle.

for (i=0; i<=9;++i){ //Repite mientras i sea menor o igual a 9.

delay_ms(500); //Retardo de 500 ms.

port_b= i; //El valor de i se saca al Puerto B. i varia de 0 a 9.

}
 } //Fin del bucle de inicio.

} //Fin del bucle main.

EJERCICIO 3.2

CONTADOR MOD 10, MANEJANDO DIRECTAMENTE EL DISPLAY DE 7

SEGMENTOS CON EL MICROCONTROLADOR.

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles
#use delay (clock=12000000) //FOSC =12MHz
#BYTE port_d= 0xF83 //Identificador para el puerto d en la localidad 0xF83.
int i; //Variable i, contador para el bucle FOR.
const int x[]= {64,121,36,48,25,18,2,120,0,16}; //Tabla de datos decodificados a 7
segmentos.
void main(void) //Función principal main.
{
set_tris_d(0x00); //Identificador para el puerto d como salida.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
port_d = 64; //Asigna el valor de 64 al Puerto para ver el número 0.
while(TRUE) //Bucle infinito.
{ //Inicio del bucle.
for (i=0; i<=9;++i) //Repite mientras i sea menor o igual a 9.
{
delay_ms(100); //Retardo de 500 ms. Necesario para mantener el dato en el
// puerto.
port_d= x[i]; //Asigna al puerto el valor apuntado por la variable i en el
//array x.
}
} //Fin del bucle infinito.
}
EJERCICIO 3.3

MANEJO DE DOS DISPLAY POR PRINCIPIO DE MULTIPLEXACIÓN

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,WDT,NOPROTECT,PUT, NOPBADEN //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz.
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#BYTE port_d= 0xF83 //Identificador para el puerto d en la localidad 0xF83.
int unidad, decena, x; //Variables.
//Función display. Muestra los datos en los display y genera un retardo de 1segundo.
void display()
{
for (x= 1; x<= 25; ++x){ //Repite 25 veces.
port_d = 1; //Habilita display unidad y apaga display decena.
port_b= unidad; //Asigna al Puerto b el dato de unidad.
delay_ms(500); //El dato de unidad permanece el Puerto b 20 ms.
port_d = 2; //Habilita el display decena y apaga display unidad.
port_b= decena; //Asigna al Puerto b el dato de decena.
delay_ms(500); //El dato de decena permanece el Puerto b 20 ms.
}
return; //Retorna al programa principal.
}
void main(void) //Función principal main.
{
set_tris_b(0x00); //Define port_b como salida.
set_tris_d(0x00); //Identificador para el puerto d como salida.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas.
port_b = 0; //Puerto b =0.
while(TRUE){
for (decena=0; decena<=9;++decena){ //Datos para el display decena 0 a 9.
for (unidad=0; unidad<=9;++unidad){ //Datos para el display unidad 0 a 9.
display(); //Función display.
}
}
} //Fin del bucle infinito.
}

EJERCICIO 3.4

MANEJO DEL MÓDULO LCD POR EL PUERTO D.

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS, NOPROTECT, NOWRT, NOPUT, NOWDT //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz.
#include <lcd.c> //Librería lcd.c
//Identificador para el puerto d como salida
void main(void) //Función principal main.
{
set_tris_d(0x00);
lcd_init(); // Inicializa el LCD.
lcd_gotoxy(4,1); //Sitúa el cursor en columna 4, fila 1.
lcd_putc("HOLA MUNDO!!\n LCD en CCS"); //Escribe en el LCD.
}
EJERCICIO 3.5

MANEJO DEL MÓDULO LCD POR EL PUERTO D.

CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS, NOPROTECT, NOWRT, NOWDT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz.
#include <lcd.c> //Librería lcd.c.
int i; //Variable i.
void main(void) //Función principal main
{
lcd_init(); // Inicializa el LCD.
while (TRUE){ //Inicio del bucle.
lcd_gotoxy(5,1); //Sitúa el cursor en 5 columna, 1 fila.
lcd_putc("CONTADOR"); //Escribe CONTADOR.
 for (i=0; i<=9;++i) //La variable empieza desde 0 hasta 9.
{
lcd_gotoxy(8,2); //Sitúa el cursor en 8 columna, 2 fila.
printf(lcd_putc," %d ",i); //Escribe en el LCD el valor actual de i.
delay_ms(500); //Retardo de 500 ms.
}
} //Fin del bucle infinito.
}
EJERCICIO 3.6

MÓDULO LCD USANDO EL PUERTO B.

CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS, NOPROTECT, NOPUT, NOWDT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC =12MHz.
#define LCD_ENABLE_PIN PIN_B0 //Definición de pines para la conexión del
LCD al puerto B.
#define LCD_RS_PIN PIN_B1
#define LCD_RW_PIN PIN_B2
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#include <lcd.c> //Librería para el manejo del LCD.
void main(void) //Función principal main.
{
lcd_init(); //Inicializa el LCD.
lcd_putc("HOLA MUNDO\n LCD en CCS"); //Escribe en el LCD.
}
EJERCICIO 3.7

MÓDULO LCD USANDO EL PUERTO B.

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS, NOPROTECT, NOWRT, NOPUT, NOWDT //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <lcd.c> //Librería para el manejo del LCD.
const char mensaje[]= {"electromicrodigital"}; //Mensaje a desplegarse en el LCD.
void main(void) //Función principal main.
{
char y=1; //Índice fila.
signed char x=16; //Índice columnas (posiciones).
lcd_init(); //Inicializa LCD.
while(TRUE){ //Bucle inicio.
lcd_gotoxy(x,y) ; //Ubica cursor para escribir mensaje.
lcd_putc(mensaje ) ; //Muestra por pantalla el mensaje.
delay_ms(50); //Retardo 150 ms.
x--; //Decremento índice de columnas.
if(x>-16){ //¿Se ha mostrado mensaje entero en la primera fila?.
x=16; //SI, índice columna x=-16, inicia el cursor en la primera posición.
y++; //Incremento índice fila (mostrar texto en segunda columna).
if(y>2) //Se ha mostrado mensaje por segunda fila?.
y=1; //SI, restaurar índice de fila.
}
lcd_putc("\f" ) ; ///Borra pantalla.
} //Bucle infinito.
}

EJERCICIO 3.8

DESPLAZAMIENTO DEL TEXTO HACIA LA DERECHA.

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) // FOSC = 12 MHz.
#include <lcd.c> //Librería para el manejo del LCD.
const char mensaje[]= {"electromicrodigital"}; //Mensaje a desplegarse en el LCD.
void main(void) //Función principal main.
 {
char y=1; //Índice fila.
signed char x=-16; //Índice columnas (posiciones).
lcd_init(); //Inicializa LCD.
while(TRUE){ //Inicio del bucle.
lcd_gotoxy(x,y) ; //Ubica cursor para escribir mensaje.
lcd_putc(mensaje); //Muestra por pantalla el mensaje.
delay_ms(150); //Retardo de 150 ms.
x++; //Incremento índice de columnas.
if(x>16){ //¿se ha mostrado mensaje entero en la primera fila?
x=-16; //SI, índice columna x=-16, inicia el cursor en la primera posición.
y++; //incremento índice fila (mostrar texto en segunda columna).
if(y>2) //¿se ha mostrado mensaje por segunda fila?.
y=1; //SI, restaurar índice de fila.
}
lcd_putc("\f" ) ; //Borra pantalla.
} //Bucle infinito.
}

EJERCICIO 3.9

EN EL SIGUIENTE PROGRAMA SE UTILIZA LAS FUNCIONES DE

INICIALIZACIÓN DEL LCD Y DE CAMBIO DEL COLOR DE LA PANTALLA.
 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) // FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main(){
glcd_init(1); //Inicializa el GLCD
while(TRUE){
glcd_fillScreen(off); //Pinta la pantalla completamente de blanco.
delay_ms(2000); //Espera dos segundos.
glcd_fillScreen(on); //Pinta la pantalla completamente de negro.
delay_ms(2000); //Espera dos segundos.
}
}

EJERCICIO 3.10

GRAFICAR CUATRO PUNTOS EN LOS LÍMITES DE LAS ESQUINAS DE

LA PANTALLA DEL GLCD.
 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
GLCD_pixel(0,0,1); //Punto esquina superior izquierda
GLCD_pixel(0,63,1); //Punto esquina inferior izquierda
GLCD_pixel(127,0,1); //Punto esquina superior derecha
GLCD_pixel(127,63,1); //Punto esquina inferior derecha
}

EJERCICIO 3.11

GRAFICAR UNA MATRIZ DE PUNTOS EN TODA LA PANTALLA DEL

GLCD.
CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
int x,y,i; //Variables para las coordenadas de los pixel.
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
for(x=0; x<=127; x=x+5){ //Los puntos se pintan cada 5 pixel en el eje x.
for(i=0; y<=63; y=y+5) { //Los puntos se pintan cada 5 pixel en el eje y.
GLCD_pixel(x,y,1); //Pinta el punto.
}
}
}
EJERCICIO 3.12

GRAFICAR DOS LÍNEAS DIAGONALES EN EL LCD.

 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla. Trazo varias líneas diagonales, empieza en
la esquina superior.
GLCD_line(0,0,127,63,1); // Trazo varias líneas diagonales, empieza en la esquina
inferior.
GLCD_line(0,63,127,0,1);
}

EJERCICIO 3.13

DIBUJAR UN RECTÁNGULO RELLENO EN TODA LA PANTALLA DEL

GLCD.
CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
GLCD_rect(0,0,127,63,yes,1); //Dibuja el rectángulo.
}

EJERCICIO 3.14

GRAFICAR UNA BARRA EN EL CENTRO DE LA PANTALLA.

 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
GLCD_bar(63,0,63,31,20,1); //Dibuja el rectángulo.
}

EJERCICIO 3.15

GRAFICAR UN CIRCULO EN EL CENTRO DE LA PANTALLA DEL

GLCD.
 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
GLCD_circle(63,31,20,1,1); //Dibuja el círculo.
}

EJERCICIO 3.16

ESCRIBIR EN EL CENTRO DE LA PANTALLA DEL GLCD LA PALABRA

PIC MICRO.
 CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
void main() //Función principal.
{
char TEXTO[] = "PIC MICRO";
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
GLCD_text57(31,31,TEXTO, 1,1); //Escribe el texto desde la posición 31,31 con
ancho de 1.
}

EJERCICIO 3.17

ENVIAR UN DATO NUMÉRICO A LA PANTALLA DEL GLCD,

SIMULANDO QUE ES UNA VARIABLE ELÉCTRICA.
CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
#include <stdlib.h> //Librería para búsqueda y ordenamiento de datos
#include <math.h> //Librería para cálculos matemáticos.
char Voltaje[9]; //Array de 10 elementos tipo char
float x= 50.123457; //Variable x definida con valor.
char Magnitud[] = "Voltaje=";

void main(){

GLCD_init(1); //Inicializa el GLCD, encendido.

GLCD_fillscreen(0); //Limpia la pantalla.
sprintf(Voltaje, "%f", (float)x); //Convierte el valor numérico a texto.
Voltaje[5] = '\0'; //Limita a 4 dígitos para mostrar el valor de Voltaje.
glcd_text57(35, 8, Magnitud, 1, ON); //Escribe Voltaje en las coordenadas 35, 8.
glcd_text57(45, 20, Voltaje, 1, ON); //Escribe el valor de la variable Voltaje.
}
 EJERCICIO 3.18

ENVIAR UN DATO NUMÉRICO A LA PANTALLA DEL GLCD,

SIMULANDO QUE ES UNA VARIABLE ELÉCTRICA.

CÓDIGO

#include <18f4550.h> //Librería para usar el PIC18F4550.

#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=12000000) //FOSC = 12 MHz.
#include <HDM64GS12.c> //Librería para el manejo del GLCD.
#include <graphics.c> //Librería gráfica para funciones del GLCD.
#include <stdlib.h> //Librería para búsqueda y ordenamiento de datos
#include <math.h> //Librería para cálculos matemáticos.
char Voltaje[9]; //Array de 10 elementos tipo char
float x= 50.123457; //Variable x definida con valor.
char Magnitud[] = "Voltaje=";

const int8 imagen[55][14] = {

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

};
//Función para dibujar la imagen.
void glcd_imagen()
{
 char i,j;
signed char k;
for( i = 0 ; i < 55 ; i ++ )
{
for( j = 0 ; j < 14 ; j ++)
{
for(k=7;k>-1;k--)
{
if( bit_test(imagen[i][j] ,7-k ))
glcd_pixel( j*8+k,i, ON );
}
}
}
}
void main() //Función principal.
{
GLCD_init(1); //Inicializa el GLCD, encendido.
GLCD_fillscreen(0); //Limpia la pantalla.
while(TRUE){
glcd_imagen(); //Llamamos a la función imagen para dibujar.
delay_ms(4000); // en el Display gráfico.
glcd_fillScreen(0); //Limpia la pantalla.
} //Ciclo infinito.
}

EJERCICIO 3.19

MANEJO DE TECLADO MATRICIAL Y VISUALIZACIÓN EN DISPLAY

DE 7 SEGMENTOS.
 CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS, WDT, NOPROTECT, NOPUT, NOPBADEN //Configuración de
fusibles.
#use delay (clock=12000000) //FOSC=12MHz
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81
#BYTE port_d= 0xF83 //Identificador para el puerto d en la localidad 0xF83.
#BIT F0 = 0xF83.0 //Asigna en la localidad 0xF83 bit 0 a la variable FA.
#BIT F1 = 0xF83.1 //Asigna en la localidad 0xF83 bit 1 a la variable FB.
#BIT F2= 0xF83.2 //Asigna en la localidad 0xF83 bit 2 a la variable FC.
#BIT F3 = 0xF83.3 //Asigna en la localidad 0xF83 bit 3 a la variable FD.
#define C0 bit_test(port_d,4) //Define la variable C0 para el port d4.
#define C1 bit_test(port_d,5) //Define la variable C1 para el port d5.
#define C2 bit_test(port_d,6) //Define la variable C2 para el port d6.
#define C3 bit_test(port_d,7) //Define la variable C3 para el port d7.
void antirebote(); //Función antirebote.
int x; //Variable x para almacenar el número del pulsador.
void main() //Función principal main.
{
set_tris_b(0x00); //Puerto b como salida.
set_tris_d(0xf0); //Puerto D4 primeros bits como salida y 4 bits como entrada.
disable_interrupts(GLOBAL); //Todas las interrupciones desactivadas
port_b = 0; //Todo el Puerto B = 0.
//Asigna a todas las variables F0, F1, F2 y F3 el valor de 1.
//Estas son las filas del teclado.
F0=1;
F1=1;
F2=1;
F3=1;
while(TRUE){ //Bucle de barrido.
F1=0; //La fila F1 = 0.
if (C0 == 0){ //Censa si la tecla de la columna 0 ha sido accionada.
x=1; //Asigna x = 1. Valor de la primera tecla.
antirebote(); //Llamado a la función antirebote.
}
if (C1 == 0){ //Censa si la tecla de la columna 1 ha sido accionada.
x=2; //Asigna x = 2. Valor de la segunda tecla.
antirebote(); //Llamado a la subrutina antirebote.
}
if (C2 == 0){ //Censa si la tecla de la columna 2 ha sido accionada.
x=3; //Asigna x = 3. Valor de la tercera tecla.
antirebote(); //Llamado a la subrutina antirebote.
}
if (C3 == 0){ //Censa si la tecla de la columna 3 ha sido accionada.
x=10; //Asigna x = 10, considerando el caso un teclado hexadecimal.
// Valor de la cuarta tecla.
antirebote(); //Función antirebote.
}
F0=1; //La fila F0 = 1.
//Comienza el censado de las teclas conectadas en la fila 1, para los números, 4, 5, 6,
//11 (letra B).
F1=0; //La fila F1= 0.
if (C0 == 0){
x=4;
antirebote();
}
if (C1 == 0){
x=5;
antirebote();
}
if (C2 == 0){
x=6;
antirebote();
}
if (C3 == 0){
x=11;
antirebote();
}
F1=1;
//Comienza el censado de las teclas conectadas en la fila 2, para los números 7, 8, 9,
//12 (letra C).
F2=0; //La fila F2= 0.
if (C0 == 0){
x=7;1;
antirebote();
}
if (C1 == 0){
x=8;
antirebote();
}
if (C2 == 0){
x=9;
antirebote();
}
if (C3 == 0){
x=12;
antirebote();
}
F2=1; //La fila F2 = 1.
//Comienza el censado de las teclas conectadas en la fila 3, para los números 13, 0,
//14, 15.
F3=0; //La fila F3= 0.
 if (C0 == 0){
x=13;
antirebote();
}
if (C1 == 0){
x=0;
antirebote();
}
if (C2 == 0){
x=14;
antirebote();
}
if (C3 == 0){
x=15;
antirebote();
}
F3=1;
} //Fin del bucle infinito.
} //Fin del main.
void antirebote(void) //Función anti rebote.
{ //No realiza nada hasta que el pulsador esté INACTIVO.
while(C0 == 0) { }
while(C1 == 0) { }
while(C2 == 0) { }
while(C3 == 0) { }
delay_ms(30); //Retardo de 30 ms.
//Puerto b = x. Se envía al puerto b el dato de x, para visualizar en display.
port_b = x;
return;
}
EJERCICIO 3.20

MANEJO DE TECLADO MATRICIAL Y VISUALIZACIÓN EN LCD.

CON BASE EN EL FUNCIONAMIENTO DEL CIRCUITO ANTERIOR SE
VA A OPTIMIZAR EL PROGRAMA REALIZANDO UN ALGORITMO MÁS
FUNCIONAL PARA EL MANEJO DEL TECLADO.
 CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550.
#fuses HS, WDT, NOPROTECT, NOPUT, NOPBADEN //Configuración de
fusibles.
#use delay (clock=12000000) //FOSC=12MHz
#include <lcd.c> //Incluye librería para manejar el LCD.
#use standard_io(B) //Usa la librería estándar (io) del puerto B.
#BYTE port_b= 0xF81 //Identificador para el puerto b en la localidad 0xF81.
#byte tris_b = 0xF93 //Identificador para el registro TRISB en la localidad 0xF93.
//Definición de los pines a utilizar:
#define F0 PIN_B0 //Filas: F0,F1, F2,F3.
#define F1 PIN_B1
#define F2 PIN_B2
#define F3 PIN_B3
#define C0 PIN_B4 //Columnas: C0,C1,C2,C3.
#define C1 PIN_B5
#define C2 PIN_B6
#define C3 PIN_B7
//Declaración de variables.
int count=0; //count, cuenta el número de filas.
int8 n =1; //Desplaza los ceros (0) en las filas.
char K; //Acepta el valor de la tecla pulsada.
int C; //Número de Columnas.
int F; //Número de Filas.
void antirebote(); //Función antirebote.
char const TECLAS[4][4] = { {'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'} };
//Función columnas: censa el cambio de estado.
short int columnas (void) {
if(input (C0) & input (C1) & input (C2) & input (C3))
return (0);
else
return (1);
}
void main(){ //Función principal main.
lcd_init(); //Inicializa el LCD.
printf(lcd_putc, "Pulse una tecla"); //Mensaje en el LCD: "Pulse una tecla".
set_tris_b(0xF0); //Fija el puerto B como entrada(B7:B4) y salida (B3:B0).
port_b= 0xFF; //El puerto B en forma inicial en 1.
while(true){ //Bucle infinito.
if (count<4){ //Si contador (count) es menor que 4….
F= count; //F recibe 0, 1,2,3 según count se incrementa.
port_b= ~n; //Invierte el valor de n y asigna al puerto B.
n= n<<1; //n desplaza su valor en 1.
++count; //incrementa count en 1.
columnas(); //Detecta si hay cambio en una de las columnas.
}
else { //Reinicia variables a su valores iniciales.
count=0;
port_b= 0xFF;
n=1;
}
if(columnas()) { //Si hay un cambio en la columna (columnas= 0)...
if(input(C0) == 0){ //… y asigna el valor a la columna respectiva.
C=0;
 }
else if(input(C1) == 0){
C=1;
}
else if(input(C2) == 0){
C=2;
}
else if(input(C3) == 0){
C=3;
}
antirebote(); //Llama a la subrutina antirebote.
}
}
} //Fin del main.
void antirebote(void) //Subrutina antirebote.
{
while(input(C0) == 0) { } //No realiza nada hasta que el pulsador esté inactivo
while(input(C1) == 0) { }
while(input(C2) == 0) { }
while(input(C3) == 0) { }
delay_ms(30);
K =TECLAS[F][C]; //Asigna a K el valor de la tecla ubicada en la fila F, columna C.
printf(lcd_putc, "\fTecla pulsada: %c", k); //Visualiza el número de la tecla en el
LCD.
return; //Retorna al programa principal.
}

EJERCICIO 3.21
 MANEJO DE TECLADO 4X3, MODIFICANDO EL DRIVER KBD.C
UTILIZANDO PIC16F877A.

CÓDIGO
#include <16f877A.h> //Incluye librería para usar PIC16F877A.
#fuses XT,WDT,NOPROTECT,NOPUT //Configuración de fusibles.
#use delay (clock=4000000) //FOSC=4 MHz
#include <kbd.c> //Driver creado para manejo de teclado por puerto B.
#include <lcd.c> //Driver para el LCD por el puerto D.
char k; //Variable donde se almacena tecla pulsada.
void main() //Función principal main.
{
lcd_init(); //Inicializa el LCD.
kbd_init(); //Inicializa el teclado.
port_b_pullups(TRUE); //Activa las resistencias PULL UP del puerto B.
printf(lcd_putc,"\fTECLA PULSADA ES:\n"); //Mensaje para la tecla pulsada.
lcd_gotoxy(8,2); //Ubica el cursor en la columna 1, fila 2.
while(TRUE) { //Inicio del bucle...
k = kbd_getc(); //Detecta la tecla pulsada.
switch (k)
{ //Muestra en el LCD el valor de la tecla pulsada.
case '0': lcd_putc("0"); break;
case '1': lcd_putc("1"); break;
 case '2': lcd_putc("2"); break;
case '3': lcd_putc("3"); break;
case '4': lcd_putc("4"); break;
case '5': lcd_putc("5"); break;
case '6': lcd_putc("6"); break;
case '7': lcd_putc("7"); break;
case '8': lcd_putc("8"); break;
case '9': lcd_putc("9"); break;
case '#': lcd_putc("#"); break;
case '*': lcd_putc("*"); break;
default: break;
}
lcd_gotoxy(8,2); //Ubica el cursor en la 1 columna. fila2
} //Fin del bucle infinito.
}
EJERCICIO 3.22

MANEJO DE TECLADO 4X3, DEFINIENDO EL PUERTO DESDE EL

PROGRAMA UTILIZANDO EL DRIVER KBD.C Y CON PIC16F877A.

CÓDIGO

#include <16f877A.h> //Incluye librería para usar PIC16F877A.

 #fuses XT,WDT,NOPROTECT,NOPUT //Configuración de fusibles.
#use delay (clock=4000000) //FOSC=4 MHz
#define use_portb_kbd TRUE //Activa el puerto B para manejar el teclado.
#include <kbd.c> //Driver para manejo de teclado.
#include <lcd.c> //Driver para el LCD por el puerto D.
char k; //Variable donde se almacena tecla pulsada.
void main() { //Función principal main.
lcd_init(); //Inicializa el LCD.
kbd_init(); //Inicializa el teclado.
port_b_pullups(TRUE); //Activa las resistencias PULL UP del puerto B.
printf(lcd_putc, "Pulse una tecla"); //Solicita que pulse una tecla.
while(TRUE) { //Inicio del bucle...
k = kbd_getc(); //Detecta la tecla pulsada.
if(k != 0) { //Si el carácter es diferente de 0.
printf(lcd_putc, "\fTecla pulsada: %c", k); //Imprime el valor de k.
}
} //Fin del bucle infinito.
} //Fin del main.
EJERCICIO 3.23

MANEJO DE LA MEMORIA EEPROM.

EN ESTE EJERCICIO SE ALMACENA EN LA MEMORIA EEPROM A
PARTIR DE LA DIRECCIÓN 00 LOS NÚMEROS 3, 5, 1, 7, 2, UTILIZANDO LA
DIRECTIVA #ROM.

CÓDIGO
#include <18f4550.h> //Librería para usar el PIC18F4550
#fuses HS,NOWDT,NOPROTECT,NOPUT, NOLVP //Configuración de fusibles.
#use delay (clock=4000000) //FOSC =4MHz
#rom int8 0xF00000= {'5','3','1','7','2'} //Datos para la EEPROM.
void main()
{
//……. Programa
}
EJERCICIO 3.24

ABRIR UNA PUERTA UTILIZANDO UNA CLAVE DE SEGURIDAD.

CONDICIONES DEL PROGRAMA
CÓDIGO

#include <16f877A.h> //Incluye librería del PIC16F877A

#fuses XT,NOWDT,NOPROTECT,NOLVP //Configuración de fusibles.
#use delay(clock= 4000000) //FOSC= 4MHz.
#define use_portb_kbd TRUE //Define el uso del puerto B para el teclado.
#include <TONES.c> //Incluye la librería TONESA para generar sonido.
#include <lcd.c> //Incluye librería LCD.
#include <kbd.c> //Incluye librería para manejar teclado.
#rom 0x2100={'3','7','5'} //Graba en la ROM la clave 3 7 5.
void alarma(); //Define la función alarma.
void main() { //Función principal main.
char k; //Variable K para almacenar dato del teclado.
int i; //Variable para contar el número de datos que ingresa.
char data[3], clave[3]; //Vectores para almacenar datos del teclado y de la clave.
lcd_init(); //Inicializa el LCD.
kbd_init(); //Inicializa el teclado.
port_b_pullups(TRUE); //Activa las resistencias PULL UP del puerto B.
while (TRUE) { //Bucle infinito.
i=0; //Variable i, almacena cuantas teclas se ha pulsado.
printf(lcd_putc,"\fingrese digito 1\n"); //Pide ingresar el primer digito.
while(i<=2){ //Mientras i menor o igual a 2.
k=kbd_getc(); //Asigna a la variable k la tecla pulsada.
if (k!=0) //Si k no es igual a 0.
{data[i]=k; //almacena en el vector data[i] el dato de la tecla ingresada.
i++; //incrementa i en 1
printf(lcd_putc,"\fingrese digito %u\n",i+1); //ingresa la tecla según indica i.
}
}
for (i=0;i<=2;i++) { //Bucle para leer datos de la eeprom
clave[i]=read_eeprom(i);} //Lee y asigna en el vector clave[i] según indica i.
//Si clave igual a dato ingresado... abre la
if ((data[0]==clave[0])&&(data[1]==clave[1])&&(data[2]==clave[2])){
printf(lcd_putc,"\fPuerta Abierta"); //Puerta abierta
output_high(PIN_A0); //Señal para manejar un relé para abrir la puerta.
delay_ms(5000); //Retardo 5 s.
output_low(PIN_A0);} //Apaga puerta
else
{ //Si no son igual dato = clave. La puerta permanece cerrada.
printf(lcd_putc,"\fPuerta Cerrada");
for (i=1;i<=5;i++){ //Acciona alarma
alarma(); //Función alarma.
}
}
} //Fin del bucle.
} //Fin del main.
void alarma (void) //Función alarma. Genera sonido que simula una alarma.
{
int fusa=62;
int semicorchea=125;
int corchea=250;
generate_tone(C_NOTE[0],fusa);
generate_tone(C_NOTE[1],fusa);
generate_tone(Eb_NOTE[2],corchea);
generate_tone(C_NOTE[3],fusa);
generate_tone(C_NOTE[0],fusa);
generate_tone(Eb_NOTE[1],corchea);
generate_tone(C_NOTE[2],fusa);
generate_tone(Eb_NOTE[3],fusa);
generate_tone(Ab_NOTE[0],semicorchea);
generate_tone(G_NOTE[1],semicorchea);
generate_tone(F_NOTE[2],semicorchea);
generate_tone(F_NOTE[3],semicorchea);
generate_tone(Eb_NOTE[0],semicorchea);
delay_ms(100);
return;
}