UNIVERSIDAD NACIONAL DE INGENIERÍA

Facultad de Ingeniería Eléctrica y Electrónica

CURSO: INTRODUCCIÓN A MICROCONTROLADORES-EE604

LABORATORIO 3 - GRUPO 7

PROFESOR: BARRIGA HOYLE JAVIER

INTEGRANTES:

- Soria Pinedo, Franck David 20190235I

- Cruz Chavarria, Miguel Angel 20192060A

- Agapito Quiñones, Daniel Eduardo 20194016J

- Lopez Diestra, Javier Rodrigo 20192100C

SECCIÓN: P

2021-2

1
 UNIVERSIDAD NACIONAL DE INGENIERÍA Ciclo Académico: 2021-II
FACULTAD DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA Fecha: 20/11/21
DEPARTAMENTOS ACADÉMICOS Duración: 5 días

CURSO: INTRODUCCIÓN A LOS MICROCONTROLADORES COD. CURSO: EE604P

DOCENTE: BARRIGA HOYLE, JAVIER
TIPO DE PRUEBA: Laboratorio No. 3

1. (10.0 puntos) Diseñe y simule un circuito basado en el Microcontrolador PIC18F4550, usando

programación en C, que permita lo siguiente:
a) En el LCD de 4 filas x 20 columnas, se mostrará inicialmente un LOGO a definir por ustedes y se
debe mostrar durante 5 segundos, luego se borra y debe aparecer en la primera fila el nombre de
MALL que ustedes elijan, en la segunda fila la cantidad de personas que ingresaron, en la tercera fila
la cantidad de personas que salieron y en la cuarta fila la cantidad de personas presentes dentro del
MALL.
b) El programa principal deberá estar siempre mostrando en el LCD, la cantidad de personas presentes
dentro de un MALL con capacidad para 1000. Este MALL cuenta con 1 puerta de entrada y 2 puertas
de salida, donde en cada puerta habrá conectado un sensor conectado a una de las 3 líneas de
interrupción que ustedes definirán (INT0, INT1, INT2).
c) Para detectar el ingreso y salida deberán usar en cada puerta: sensor infrarrojo, LDR y un pulsador.
Es decir, usar un sensor diferente conectado a cada línea de interrupción.
d) En los 7 leds conectados al PC, se debe mostrar un programa similar al auto fantástico donde se
desplazará un bit en estado lógico 0 (los demás en uno) de derecha a izquierda y viceversa a
intervalos de 300 ms de manera indefinida que será programado mediante interrupciones del TIMER
1.
e) En la puerta de ingreso se debe tener a la vista dos leds, uno de color verde indicando que hay
capacidad y otro de color rojo, indicando que no hay capacidad.

Nota: hay datos por omisión y/o exceso que deben ser evaluados con criterio ingenieril para
dar solución a la pregunta.

2
DIAGRAMA DE FLUJO

3
4
Codigo en C

/* Autores: Agapito Quiñones Daniel Eduardo 20194016J

* Cruz Chavarría Miguel Angel 20192060A
* López Diestra Javier Rodrigo 20192100C
* Soria Pinedo Franck David 20190235I
*/
#include <xc.h>
#define _XTAL_FREQ 20000000

//Zona de los bits de configuración

#pragma config PLLDIV = 5 // PLL Prescaler Divide by 5 (20 MHz/5 = 4 MHZ)
#pragma config CPUDIV = OSC4_PLL6 // System Clock Postscaler (96 MHz/6 = 16 MHz)
#pragma config USBDIV = 1 // USB Clock Full-Speed (96 MHz/2 = 48 MHz)
#pragma config FOSC = HSPLL_HS // Oscillator Selection bits
#pragma config PWRT = ON // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOR = OFF // Brown-out Reset disabled
#pragma config BORV = 3 // Brown-out Reset Voltage (Minimum 2.05V)
#pragma config WDT = OFF // Watchdog Timer disabled
#pragma config CCP2MX = OFF // CCP2 MUX bit (CCP2 is multiplexed with RB3)
#pragma config PBADEN = OFF // PORTB A/D (PORTB<4:0> configured as digital I/O)
#pragma config MCLRE = ON // MCLR Pin Enable bit (MCLR pin enabled)
#pragma config STVREN = ON // Stack Full/Underflow will cause Reset
#pragma config LVP = OFF // Single-Supply ICSP disabled

#define RS LATCbits.LATC0 /*PORTD 0 pin is used for Register Select*/

#define E LATCbits.LATC1 /*PORTD 1 pin is used for Enable*/
#define ldata LATD /*PORTB is used for transmitting data to LCD*/

void LCD_Inicio(void);
void LCD_Comando(char );
void LCD_Enable(void);
void LCD_Data(unsigned char x);
void LCD_Cadena(const char *);
void LCD_Gotoxy(char ,char);
void Mall_Logo(void);
void LCD_Borra(void);
void LCD_Custom_Char(unsigned char,unsigned char*);
void LCD_NumberInt(int number);
void __interrupt(high_priority) Int0ISR(void);
void __interrupt(low_priority) Int1ISR(void);
void __interrupt(low_priority) Int2ISR(void);
void __interrupt(low_priority) Tmr0ISR(void);
unsigned char smile[8] = {0x00,0x0A,0x0A,0x00,0x1F,0x11,0x0E,0x0F};
unsigned char sad[8] = {0x00,0x0A,0x0A,0x00,0x0E,0x11,0x1F,0x0F};
unsigned char blanco[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

// para LOGO
unsigned char linea_v[8] = {0x00,0x00,0x1F,0x1F,0x1F,0x00,0x00,0x00};
unsigned char linea_h[8] = {0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x00};

// defino mensajes

char Logo1[18] = {"MALL"}; // fila 2

char Logo2[18] = {"AVENTURA"}; // fila 3
char Mensaje1[18] = {"MALL AVENTURA"}; // fila 1
char Mensaje2[18] = {"Ingresaron:"}; // fila 2
5
char Mensaje3[18] = {"Salieron:"}; // fila 3
char Mensaje4[18] = {"Aforo(1000):"}; // fila 4
char Mensaje5[18] = {"/1000"};
/*****************************Main Program*******************************/
int k=10,l=0,s=0,e=20,o=10;
unsigned int cuenta;

void main(void)
{
// Configuro puertos como entradas o salidas
TRISBbits.TRISB0 = 1; // Configura el pin RB0 como entrada (INT0).
TRISBbits.TRISB1 = 1; // Configura el pin RB1 como entrada (INT1).
TRISBbits.TRISB2 = 1; // Configura el pin RB2 como entrada (INT2).
TRISCbits.TRISC2 = 0;
TRISBbits.TRISB3 = 0; //LED verde: aforo disponible
TRISBbits.TRISB4 = 0; //LED rojo: aforo lleno
TRISA=0x00;
LATA=0x00;
// Configuro las interrupciones INT0, INT1, INT2
INTCONbits.GIE = 0; // Deshabilita Interrupcion GLOBAL.
INTCONbits.INT0IE = 1; // Habilita interrupcion Externa INT0.
INTCON2bits.INTEDG0 = 0; // Interrupcion por flanco de bajada.
INTCON3bits.INT1IE = 1; // Habilita interrupcion Externa INT1.
INTCON2bits.INTEDG1 = 0; // Interrupcion por flanco de bajada.
INTCON3bits.INT2IE = 1; // Habilita interrupcion Externa INT2.
INTCON2bits.INTEDG2 = 0; // Interrupcion por flanco de bajada.
INTCON3bits.INT1IP = 1; // Alta prioridad.
INTCON3bits.INT2IP = 1; // Alta prioridad.
RCONbits.IPEN = 1; // Habilita las Interrupciones de Prioridad.
INTCONbits.TMR0IE = 1; // Habilita interrupcion TMR0.
INTCON2bits.TMR0IP = 0; // TMR0 en baja prioridad.
INTCONbits.GIEL = 1; // Habilita Interrupcion de baja prioridad.
INTCONbits.GIE = 1; // Habilita Interrupcion GLOBAL.

//configuro Timer0
T0CON = 0xC3; // Ftmr0= 4MHz/16= 250KHz
// Ttmr0= 4uS, Arranca el timer
TMR0L = 5; // Se inicia con ese valor, para 1 ms

char j;
LCD_Inicio();

// LOGO dura 5s
Mall_Logo();

LCD_Gotoxy(1,1); /*Display string for respective symbol*/

LCD_Cadena(Mensaje1);

// TOMAR EL DISPLAY COMO UNA MATRIZ DE 4x20, YA ESTA CONFIGURADO

LCD_Gotoxy(2,1); /*Display string for respective symbol*/

LCD_Cadena(Mensaje2);
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,1); /*Display string for respective symbol*/
LCD_Cadena(Mensaje3);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
6
 LCD_Gotoxy(4,1);
LCD_Cadena(Mensaje4);
LCD_Gotoxy(4,13);
LCD_NumberInt(k);

while(1){
k=e-o;
if(k<1000){
LATBbits.LATB3=1; //Led verde encendido
LATBbits.LATB4=0; //Led rojo apagado
}
else{
LATBbits.LATB4=1; //Led rojo encendido
LATBbits.LATB3=0; //Led verde apagado
}
// for(j=1;j<3;j++)
// {
// LCD_Gotoxy(4,20);
// __delay_ms(100);
// LCD_Data(j); /*To display custom character send address as data to point stored character */
// }
};
}

/** Mis funciones o interrupciones **/

void __interrupt(high_priority) Int0ISR(void)

{
LCD_Custom_Char(5,blanco);
if(k<1000){
if(INTCONbits.INT0IF == 1){
k++;
e++;
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
if(k<=9){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
}
if(10<=k){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
}
INTCONbits.INT0IF = 0; // Borra el flag de interrupcion
}

if(INTCON3bits.INT1IF == 1){
k--;
o++;
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
if(k<=9){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
7
 }
if(10<=k){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
}
INTCON3bits.INT1IF = 0; // Borra el flag de interrupcion
}

if(INTCON3bits.INT2IF == 1){
k--;
o++;
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
if(k<=9){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
}
if(10<=k){
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
}
INTCON3bits.INT2IF = 0; // Borra el flag de interrupcion
}
}
else{
if(INTCON3bits.INT1IF == 1){
k--;
o++;
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
INTCON3bits.INT1IF = 0; // Borra el flag de interrupcion
}

if(INTCON3bits.INT2IF == 1){
k--;
o++;
LCD_Gotoxy(2,13);
LCD_NumberInt(e);
LCD_Gotoxy(3,13);
LCD_NumberInt(o);
LCD_Gotoxy(4,13);
LCD_NumberInt(k);
INTCON3bits.INT2IF = 0; // Borra el flag de interrupcion
}
if(k==999){
LCD_Gotoxy(4,16);
LCD_Data(5);
}
INTCONbits.INT0IF = 0;
}
}

8
void __interrupt(low_priority) Tmr0ISR(void)
{
TMR0L = 5; // Se inicia con ese valor, para 1 ms
cuenta++;
if(cuenta==300){ //Cada 300ms entra al condicional
if(s==0){
l++;
}
if(s==1){
l--;
}
if(l==1){
LATCbits.LATC2=1;
LATA=0x3E;
s=0;
}
if(l==2){
LATCbits.LATC2=1;
LATA=0x3D;
}
if(l==3){
LATCbits.LATC2=1;
LATA=0x3B;
}
if(l==4){
LATCbits.LATC2=1;
LATA=0x37;
}
if(l==5){
LATCbits.LATC2=1;
LATA=0x2F;
}
if(l==6){
LATCbits.LATC2=1;
LATA=0x1F;
}
if(l==7){
LATCbits.LATC2=0;
LATA=0x3F;
s=1;
}
cuenta = 0;
}
INTCONbits.TMR0IF = 0;
}

void LCD_NumberInt(int number)

{
int dec=0;
int cen=0;
int uni=0;
int mil=0;
if(number>0){
uni = number%10;
number = number-uni;
number = number/10;
if(number>0){
dec = number%10;
9
 number=number-dec;
number = number/10;
if(number>0){
cen = number%10;
number = number-cen;
number = number/10;
if(number>0){
mil = number%10;
}
}
}
}
if(uni>=0){
if(dec>=0){
if(cen>=0){
if(mil>0){
mil=mil+48;
LCD_Data(mil);
}
cen=cen+48;
LCD_Data(cen);
}
dec=dec+48;
LCD_Data(dec);
}
uni=uni+48;
LCD_Data(uni);
}
}

/****************************Functions********************************/
void LCD_Inicio(void)/*Configuracion*/
{
TRISD = 0x00; /* Puerto D como salida*/
TRISCbits.TRISC0 = 0x00; /* Pin 0D como salida*/
TRISCbits.TRISC1 = 0x00; /* Pin 1D como salida*/

__delay_ms(15); /*15ms,16x2 LCD Power on delay*/

RS=0; /* Modo comando*/
LATD = 0x30;
LCD_Enable();
__delay_ms(1); // Demora superior a 4,1 msg
LATD = 0x30;
LCD_Enable();
__delay_ms(1); // Demora superior a 100 useg
LATD = 0x30;
LCD_Enable();
__delay_ms(1); // Demora superior a 100 useg

/* LCD 8 BITS */
LCD_Comando(0x38); /*uses 2 line and initialize 5*7 matrix of LCD*/
LCD_Comando(0x0C); /*display on cursor off*/
LCD_Comando(0x01); /*clear display screen*/
LCD_Comando(0x06); /*increment cursor (shift cursor to right)*/
}

void LCD_Borra(void)
{
10
 LCD_Comando(0x01); /*clear display screen*/
__delay_ms(3);
}

void LCD_Comando(char cmd )

{
ldata= cmd; /*Send data to PORT as a command for LCD*/
RS = 0; /*Command Register is selected*/
LCD_Enable();
}

void LCD_Enable(void)
{
/************ ENABLE ************/
__delay_ms(1); // Demora superior a 100 useg
E=1; //Enable
__delay_ms(1); // Demora superior a 100 useg
E=0; //Disable
/********************************/
}

void LCD_Data(unsigned char dat)

{
ldata= dat; /*Send data to LCD*/
RS = 1; /*Data Register is selected*/
LCD_Enable();
}

void LCD_Cadena(const char *msg)

{
while((*msg)!=0)
{
LCD_Data(*msg);
msg++;
}
}

void LCD_Gotoxy(char row,char pos)

{
char location=0;
switch(row){
case 1:
location=(0x80) + pos - 1; /*Print message on 1st row and desired location*/
LCD_Comando(location);
break;
case 2:
location=(0xC0) + pos - 1; /*Print message on 1st row and desired location*/
LCD_Comando(location);
break;
case 3:
location=(0x94) + pos - 1; /*Print message on 1st row and desired location*/
LCD_Comando(location);
break;
case 4:
location=(0xD4) + pos - 1; /*Print message on 1st row and desired location*/
LCD_Comando(location);
break;
}
11
 LCD_Enable();
}

void LCD_Custom_Char(unsigned char loc,unsigned char *msg)

{
unsigned char i;
if(loc<8)
{
LCD_Comando(0x40+(loc*8)); /* Command 0x40 and onwards forces the device to point CGRAM
address */
for(i=0;i<8;i++) /* Write 8 byte for generation of 1 character */
LCD_Data(msg[i]);
}
}

void Mall_Logo(void)
{
char i;
//LCD_Borra();

LCD_Custom_Char(1,smile);
LCD_Custom_Char(2,sad);
LCD_Custom_Char(3,linea_v);
LCD_Custom_Char(4,linea_h);
for(i=7;i<16;i++)
{
LCD_Gotoxy(1,i);
__delay_ms(10);
LCD_Data(3); /*To display custom character send address as data to point stored character */
__delay_ms(10);
}
for(i=2;i<4;i++)
{
LCD_Gotoxy(i,16);
__delay_ms(10);
LCD_Data(4);
}
for(i=15;i>6;i--)
{
LCD_Gotoxy(4,i);
__delay_ms(10);
LCD_Data(3); /*To display custom character send address as data to point stored character */
__delay_ms(10);
}
for(i=3;i>1;i--)
{
LCD_Gotoxy(i,5);
__delay_ms(10);
LCD_Data(4);
}

LCD_Gotoxy(2,9);
LCD_Cadena(Logo1);
LCD_Gotoxy(3,7);
LCD_Cadena(Logo2);

__delay_ms(1000);
12
 LCD_Borra();
}
2. (10.0 puntos) Diseñe y simule un circuito basado en el Microcontrolador PIC18F4550, usando
programación en C, que permita lo siguiente mostrar la temperatura en un LCD de 2x40:
a) En el LCD de 4 filas x 20 columnas, se mostrará inicialmente el LOGO de la pregunta 1 que se
mostrará durante 5 segundos, luego se borra y debe aparecer en la primera fila el nombre del
proyecto que ustedes elijan, referente a usar un sensor de temperatura LM35 (usar en todo su rango
desde -55° hasta 150°), en la tercera fila se debe mostrar la temperatura leída del proceso con
intervalos de 10mV, ósea con tres decimales.
b) La lectura del ADC se realizará a intervalos de dos segundos programado por interrupciones del
timer 0 (modo 16 bits) y para leer la temperatura del ADC también se usará su interrupción.
c) En las filas 2 y 4 del LCD llenar con ***** o con ==== u otro que usted crea conveniente.

Nota: hay datos por omisión y/o exceso que deben ser evaluados con criterio ingenieril para
dar solución a la pregunta.

SE PIDE:

a) Diagrama de flujo.
b) Códigos del programa en lenguaje C, debidamente comentados.
c) Circuitos de simulación en proteus.
d) Archivos con el código fuente y el circuito en Proteus (aquí deben comprimir toda la carpeta creada
en el MPLAB más su simulación).
e) En sus nombres de archivos USAR LA NOMENCLATURA USADA EN EL LABORATORIO 2.

13
14
Código en C:
/*
* File: Sensor_Temperatura_LCD.c
* Autores: Agapito Quiñones Daniel Eduardo 20194016J
* Cruz Chavarría Miguel Angel 20192060A
* López Diestra Javier Rodrigo 20192100C
* Soria Pinedo Franck David 20190235I
*
* El proyecto elegido consiste en medir Temperatura en un determinado espacio del centro comercial Mall
Aventura
* para luego enviar este dato al sistema de aire acondicionado con el fin de controlar la Temperatura del
Mall.
*
* Este programa solo se limita a extraer la información de la temperatura del sensor LM35 con un tiempo de
muestreo
* de 2seg controlado por la interrupción del timer0 en 16bits y por la interrupción del convertidor ADC.
*/
#include <xc.h>
#include <stdio.h>
#define _XTAL_FREQ 20000000

//Zona de los bits de configuración

#pragma config PLLDIV = 5 // PLL Prescaler Divide by 5 (20 MHz/5 = 4 MHZ).
#pragma config CPUDIV = OSC4_PLL6 // System Clock Postscaler (96 MHz/6 = 16 MHz).
#pragma config USBDIV = 2 // USB Clock Full-Speed (96 MHz/2 = 48 MHz).
#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator).
#pragma config PWRT = ON // Power-up Timer Enable bit (PWRT enabled).
#pragma config BOR = OFF // Brown-out Reset disabled.
#pragma config BORV = 3 // Brown-out Reset Voltage (Minimum 2.05V).
#pragma config WDT = OFF // Watchdog Timer disabled.
#pragma config CCP2MX = OFF // CCP2 MUX bit (CCP2 is multiplexed with RB3).
#pragma config PBADEN = OFF // PORTB A/D (PORTB<4:0> configured as digital I/O).
#pragma config MCLRE = ON // MCLR Pin Enable bit (MCLR pin enabled).
#pragma config STVREN = ON // Stack Full/Underflow will cause Reset.
#pragma config LVP = OFF // Single-Supply ICSP disabled.

// Defino algunos valores importantes para el LCD

#define RS LATD0 // LATD.0 asignado a RS del LCD
#define WR LATD1 // LATD.1 asignado a R/W del LCD
#define EN LATD2 // LATD.2 asignado a EN del LCD
#define ldata LATD /*PORTD is used for transmitting data to LCD*/

//Definimos los prototipos de las funciones de LCD

void LCD_Inicio(void);
void LCD_Comando(char );
void LCD_Data(unsigned char x);
void LCD_Cadena(const char *);
void LCD_Gotoxy(unsigned char fila,unsigned char columna);
void Mall_Logo(void);
void LCD_Borra(void);
void LCD_Custom_Char(unsigned char,unsigned char*);

// Defino variables para el LOGO

unsigned char smile[8] = {0x00,0x0A,0x0A,0x00,0x1F,0x11,0x0E,0x0F};
unsigned char sad[8] = {0x00,0x0A,0x0A,0x00,0x0E,0x11,0x1F,0x0F};
unsigned char linea_v[8] = {0x00,0x00,0x1F,0x1F,0x1F,0x00,0x00,0x00};
unsigned char linea_h[8] = {0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x00};
char Logo1[18] = {"MALL"}; // fila 2
15
char Logo2[18] = {"AVENTURA"}; // fila 3

// Defino variables globales

unsigned char flag_fin_conversion;
double temp = 0;

// Programa Principal
void main(void) {
//Definimos variable
char temperatura[5];

//Definimos puertos de entrada y salida

TRISA = 0xFF; // Definimos Puerto A como entrada
TRISD = 0x00; // Definimos Puerto D como salida
ADCON1 = 0x0E; // Colocamos bit 0 de PA como entrada Analógica
ADCON0 = 0x00; // Seleccionamos el canal 0 y desabilitamos la conversió
ADCON2 = 0x96; // Elegimos Right Justified, 4Tad, Fosc/64
flag_fin_conversion = 0;
ADCON0bits.ADON = 1; // Habilitamos el conversor ADC

//Configuramos las interrupciones

INTCONbits.GIE = 0; // Deshabilita Interrupcion GLOBAL.
INTCON2bits.INTEDG0 = 0; // Interrupcion por flanco de bajada.
RCONbits.IPEN = 1; // Habilita las Interrupciones de Prioridad.
INTCONbits.TMR0IE = 1; // Habilita la interrupción TMR0
INTCON2bits.TMR0IP = 1; // TMR0 en alta prioridad.
PIR1bits.ADIF = 0; // Borro el flag de fin de conversion
PIE1bits.ADIE = 1; // Habilito la interrupción del ADC
IPR1bits.ADIP = 0; // ADC en baja prioridad
INTCONbits.GIEH = 1; // Habilita Interrupcion de alta prioridad.
INTCONbits.GIEL = 1; // Habilita Interrupcion de baja prioridad.
INTCONbits.GIE = 1; // Habilita Interrupcion GLOBAL.

//MOSTRAMOS EL LOGO
LCD_Inicio(); //Inicializo el LCD
Mall_Logo(); // Se muestra el Logo por 5 seg

// Mostramos la pantalla principal del LCD

LCD_Gotoxy(1,1);
LCD_Cadena("SENSOR TEMPERATURA");
LCD_Gotoxy(2,0);
LCD_Cadena("====================");
LCD_Gotoxy(3,0);
LCD_Cadena("TEMPERATURA: C");
LCD_Gotoxy(4,0);
LCD_Cadena("====================");

//Configuramos el Timer0
T0CON = 0x86; // 0x86 = 10000110 Iniciamos timer,16bits,Fosc/4,flanco de bajada,Usamos
Pre-scaler,1:128
// Fosc = 16MHz -> Fosc/4 = 4MHz
// 4MHz/128 = 31.25 kHz -> T = 32us
// N*T = 2 -> N = 62500 Max = 65535
TMR0 = 3035; // Iniciamos en 3035 para llegar a 62500 pulsos y obtener 2seg
ADCON0bits.GO = 1; // Iniciamos por primera vez la conversion ADC
//Bucle Infinito
while(1){
if(flag_fin_conversion==1){ // Esperamos a que termine de realizar la conversión
16
 flag_fin_conversion = 0;
sprintf(temperatura,"%.3f",temp); // Convertimos temp (float) a cadena para mostrar en LCD.

// Mostramos el valor de la temperatura en LCD

LCD_Gotoxy(3,12);
LCD_Cadena(" C");
LCD_Gotoxy(3,12);
LCD_Cadena(temperatura);
}
}
}
// Fin de Programa Principal

/****************************Interrupciones****************************/
void __interrupt(high_priority) Tmr0ISR(void){
TMR0 = 3035; // Iniciamos el contador en 3035 para generar 2seg
ADCON0bits.GO = 1; // Cuando llegue a 2seg empieza la conversion ADC
INTCONbits.TMR0IF = 0;
}

void __interrupt(low_priority) ADCISR(void){

if(PIR1bits.ADIF==1){
temp = (ADRESH*256+ADRESL)*150/307; // Convertimos el valor de los registros H y L a
temperatura
flag_fin_conversion = 1;
PIR1bits.ADIF = 0;
}
}

/****************************Functions********************************/
void LCD_Inicio(void)/*Configuracion*/
{
__delay_ms(15); // Espera de 15 ms
LATD= 0x30; // DB[7..4] X EN R/W RS
// 0011 0 0 0 0
EN = 1; // Genero pulso en EN (1-to-0)
NOP(); // Retarda un ciclo
EN = 0;
__delay_ms(5); // Demora superior a 4,1 msg

LATD= 0x30; // DB[7..4] X EN R/W RS

// 0011 0 0 0 0
EN = 1; // Genero pulso en EN (1-to-0)
NOP(); // Retarda un ciclo
EN = 0;
__delay_ms(1); // Demora superior a 100 useg

LATD= 0x30; // DB[7..4] X EN R/W RS

// 0011 0 0 0 0
EN = 1; // Genero pulso en EN (1-to-0)
NOP(); // Retarda un ciclo
EN = 0;
__delay_ms(1); // Demora superior a 100 useg

/* Tras esta inicialización el display configuramos LCD en modo 4 bits */

LCD_Comando(0x02); // Configuro en modo 4 bits
LCD_Comando(0x28); // Usa 2 lineas y matriz de 5x8
LCD_Comando(0x01); // Borra display
17
 LCD_Comando(0x0c); // Display ON, cursor OFF
LCD_Comando(0x06); // Incrementa cursor y desplaza a la derecha
}

void LCD_Borra(void)
{
LCD_Comando(0x01); /*clear display screen*/
__delay_ms(3);
}

void LCD_Comando(const char cmd)

{
ldata = (ldata & 0x0f) |(0xF0 & cmd); // Envía nibble alto al PORT
RS = 0; // RS=0 selecciona registro comandos
EN = 1; // Genero pulso en EN (1-to-0)
NOP();
EN = 0;
__delay_ms(1);
ldata = (ldata & 0x0f) | (cmd<<4); // Envía nibble bajo al PORT
EN = 1; // Genero pulso en EN (1-to-0)
NOP();
EN = 0;
__delay_ms(3);
}

void LCD_Data(unsigned char dat)

{
ldata = (ldata & 0x0f) | (0xF0 & dat); // Envía nibble alto al PORT
RS = 1; // RS=1 selecciona registro datos
EN = 1; // Genero pulso en EN (1-to-0)
NOP();
EN = 0;
__delay_ms(1);
ldata = (ldata & 0x0f) | (dat<<4); // Envía nibble bajo al PORT
EN = 1; // Genero pulso en EN (1-to-0)
NOP();
EN = 0;
__delay_ms(3);
}

void LCD_Cadena(const char *msg)

{
while((*msg)!=0)
{
LCD_Data(*msg);
msg++;
}
}

void LCD_Gotoxy(unsigned char fila,unsigned char columna)

{
char posicion=0;

if(fila==1)
{
posicion=(0x80) | (columna); // Posiciona cursor en la fila 1
LCD_Comando(posicion);
}
18
 if(fila==2)
{
posicion=(0xC0) | (columna); // Posiciona cursor en la fila 2
LCD_Comando(posicion);
}
if(fila==3)
{
posicion=(0x80) | (0x14+columna); // Posiciona cursor en la fila 3
LCD_Comando(posicion);
}
if(fila==4)
{
posicion=(0xC0) | (0x14+columna); // Posiciona cursor en la fila 4
LCD_Comando(posicion);
}
}

void LCD_Custom_Char(unsigned char loc,unsigned char *msg)

{
unsigned char i;
if(loc<8)
{
LCD_Comando(0x40+(loc*8)); /* Command 0x40 and onwards forces the device to point CGRAM
address */
for(i=0;i<8;i++) /* Write 8 byte for generation of 1 character */
LCD_Data(msg[i]);
}
}

void Mall_Logo(void)
{
char i;

LCD_Custom_Char(1,smile);
LCD_Custom_Char(2,sad);
LCD_Custom_Char(3,linea_v);
LCD_Custom_Char(4,linea_h);
for(i=7;i<16;i++)
{
LCD_Gotoxy(1,i);
__delay_ms(10);
LCD_Data(3); /*To display custom character send address as data to point stored character */
__delay_ms(10);
}
for(i=2;i<4;i++)
{
LCD_Gotoxy(i,16);
__delay_ms(10);
LCD_Data(4);
}
for(i=15;i>6;i--)
{
LCD_Gotoxy(4,i);
__delay_ms(10);
LCD_Data(3); /*To display custom character send address as data to point stored character */
__delay_ms(10);
}
19
 for(i=3;i>1;i--)
{
LCD_Gotoxy(i,5);
__delay_ms(10);
LCD_Data(4);
}

LCD_Gotoxy(2,9);
LCD_Cadena(Logo1);
LCD_Gotoxy(3,7);
LCD_Cadena(Logo2);

__delay_ms(1000);
LCD_Borra();
}

20