MICROPROCESADORES Y MICROCONTROLADORES

Pasó 3
Solucionar los circuitos y avances del proyecto

PRESENTADO POR:
CARLOS RABIN CUBIDES LOPEZ COD: 79792670
JAVIER ANDRES DONCEL ZAMBRANO COD: 80030874
DIEGO JAVIER COHECHA LEON COD: 80228006

GRUPO: 309696_29

PRESENTADO A:
Ing. NESTOR JAVIER RODRIGUEZ

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BASICAS, TECNOLOGIA E INGENIERIA
BOGOTA D. C, - COLOMBIA
ABRIL 2018
 INTRODUCCION

En este trabajo se presentará la solución a ejercicios planteados mediante el

Microcontrolador Pic16f877 realizando su diseño y programación dando solución a
una determinada aplicación o aplicaciones que muy posiblemente de ven en el
campo industrial empleándose sensores y control de variables como lo es la
temperatura.

Para este trabajo se utilizó el lenguaje de programación Pic C y la simulación del

software mediante Proteus

Diseño e implementación de tres soluciones con micro controladores Pic 16f877.

Utilizando el programa de lenguaje asembler para la elaboración de los programas
respectivos. Simulado en programa Proteus 7.9 o Versiones 8.0 en adelante.

Las aplicaciones de control, medición, instrumentación, entretenimiento y consumo,

son las promotoras y fuente del creciente mercado tanto de microprocesadores
como de microcontroladores.

Con el desarrollo de este trabajo se busca que los estudiantes de la materia de

microprocesadores y controladores desarrollen una serie de prácticas empleando
los circuitos integrados (PIC) y otros componentes electrónicos para la solución de
algún problema o requerimiento. Para esto es necesario que el estudiante ponga en
práctica los conocimientos adquiridos durante el desarrollo de la presente fase, y
además que se despejen algunas dudas que surjan durante la construcción y/o
desarrollo del mismo.

Utilización de software para la programación y compilación de los códigos que se

utilizan en la programación de los diferentes microcontroladores, el cual conectado
a un sistema eléctrico y mecánico tendremos algunas respuestas.
 OBJETIVOS

 Los estudiantes conocerán analizarán y comprenderán las bases de

programación en lenguajes de alto nivel así como los sistemas
microcontrolados de última generación y sus aplicaciones.

 Efectuar los respectivos montajes con los componentes eléctricos necesarios

de acuerdo a lo establecido en cada práctica, colocando a prueba los
conocimientos adquiridos durante el desarrollo de la fase.

 Desarrollar y establecer los códigos en assembler para los PIC empleados·

 Debe tener un sistema de actuadores (salidas) controlados por el

Microcontrolador (bobinas, motores dc, servomotores, etc.) que cumplan la
función de control.

 Diseñar circuitos estudiando las diferentes aplicaciones que se puede tener

con el Micro controlador Pic16f877a, acoplados a Dth 11(sensores de
temperatura y humedad).

 Diseñar circuitos empleando el acoplamiento y uso de pulsadores

Actividades a desarrollar

Diseño e implementación de 2 circuitos en microcontroladores: Utilizando el

pic16f877a
Los programas gratuitos a utilizar son lenguaje C: Pic C. Micro C. Con las
siguientes características:

Micro controlador Pic16f877a

1 Display 16 X 2 1
Dth11 (sensor de temperatura y humedad)
3 leds (rojo, amarillo, verde)
2 Motores 12 vdc (ventilador)
3 resistencias de 220 ohmios
3 resistencias de 1 k ohmios
5 pulsadores

Programa 1:

Debe sensar la humedad y temperatura del ambiente con el sensor dth11 de

proteus, monitorizando las dos variables y visualizándolas en un display 16
x2 y si la temperatura está menor o igual de 15 grados el led verde se
encenderá, si la temperatura está entre los 20 y 28 grados se encenderá un led
amarillo, y si supera los 30 grados el led rojo se prendera y debe dar una
alarma constante y prenderse el ventilador hasta que baje la temperatura
menor o igual a 20 grados. En el display se debe visualizar el valor de la
temperatura y la activación de motor como MOTOR ON o MOTOR OFF. Debe
sensar a todo momento la humedad del ambiente al pasar por el 60% se debe
activar un motor ventilador y se debe apagar cuando esta baje a menos de
50%.
Carlos Cubides:
 Si la temperatura está menor o igual de 15 grados el led verde se
encenderá.
 Si la temperatura está entre los 20 y 28 grados se encenderá un led
amarillo.
 Si supera los 30 grados el led rojo se prendera y debe dar una alarma
constante y prenderse el ventilador hasta que baje la temperatura
menor o igual a 20 grados.
Código Compiler:
Programa 2:

Se diseñará un sistema de cerradura electrónica el cual deberá en un display

16X2 desplegar en la primera línea el nombre del curso y numero de grupo,
habrá un teclado matricial de 4 x4, y al digitar el número de cedula de cada
estudiante debe aparecer en el display y al ser el correcto se debe encender
un led para cada uno de los estudiantes, serán 5 leds (verde, amarillo, rojo,
azul y blanco)

-Con la propuesta escogida de trabajo final debe realizar:

- Metodología
- Inicio de fase del Algoritmo
- Esquema General
- Análisis de resultados
- Recursos a utilizar

EJERCICIO SELECIONADO Sistema de seguridad:

Alarma con 6 puntos de sensibilidad con sensores de movimiento, infrarrojos,
temperatura, presión etc. con indicación de zona de ingreso y por medio de
un lcd 16x2, y 3 salidas que activen los leds de color rojo, amarillo y verde
como zona segura (verde), alerta (amarilla) y alarma (rojo), zona segura no se
activa ningún sensor, alerta máximo 2 sensores activados y alarma 3 sensores
activados, más una salida a relevos para sirena.

 Metodología

Conocimiento previo para el desarrollo de la práctica:

Los integrantes del curso debe realizar lectura de los contenidos del curso y material
bibliográfico suministrado en el curso “e-BIBLIOTECA, utilizar la documentación y
los ejemplos suministrados en el aula de curso, en el recurso “Herramientas y
sistemas de desarrollo” y módulo de curso, material de soporte como videos en
YouTube, google, www,arduino.com.co, Etc, de manera que tenga los fundamentos
teóricos y los conocimientos necesarios para diseñar y desarrollar algoritmos,
diagramas de flujo y programas en lenguaje ensamblador, simulación del sistema
microcontrolado “proteus”, programación de la memoria del microcontrolador
“Arduino” e implementación del circuito electrónico.
 Inicio de fase del Algoritmo

Para la realización de los ejercicios, los estudiantes deben diseñar

individualmente sus algoritmos hacer la compilación, depuración y ejecución del
programa.
 Establecer las variables, constantes y entradas y/o salidas necesarias,
 Establecer los elementos componentes principalmente el
microcontrolador “ARDUINO” y los componentes o periféricos que
estarán conectados al microcontrolador “ARDUINO”.
 Diseñar el esquema general de conexiones y su correspondiente circuito
electrónico.
 Diseñar el algoritmo y diagrama de flujo solución del problema planteado.
 Generar el código fuente, producto del algoritmo diseñado.
 Compilar, depurar y ejecutar el programa, hacer uso del simulador IDE u
otro software de uso libre, evaluación o gratuito para realizar una
simulación previa y garantizar el funcionamiento de la fase de diseño de
software.
 Grabar el programa “Compilar” en la memoria del microcontrolador físico
“ ARDUINO”
 Realizar la implementación del montaje electrónico, siguiendo los
esquemas generales y de conexión de circuito electrónico, tomar las
precauciones de establecer la correcta continuidad entre componentes,
su distribución y montaje correcto en protoboard o tabla de prototipos
 Incorporar el microcontrolador en el montaje, probar su conexión antes de
energizar.
 Energizar y probar el funcionamiento del programa, si hay fallas o
correcciones para reevaluar el algoritmo proseguir con los pasos
siguientes hasta obtener la solución al problema planteado.
  Esquema General

Sistema de alarma basado en Arduino. Con sensores movimiento, infrarrojos,

temperatura, presión los cuales activaran la alarma. Después de detectar alarma,
se entra en un estado de pre-alarma que si no se introduce la clave correcta en 10
segundos, paso a un estado de alarma.
Para entrar en estado de alarma hay dos condiciones:
 Detectar un movimiento (activar el sensor tilt)
 Detectar más de 5 segundos una iluminación superior a 900.

Para salir del estado de pre-alarma se debe introducir la clave correcta por teclado
en los 10 segundos siguientes a la detección de alarma.
Para salir del estado de alarma no debe haber ninguna de las dos condiciones de
alarma y se debe pulsar el botón.
En estado normal led apagado y zumbador apagado
 Análisis de resultados

 Recursos a utilizar

 Computador PC compatible con el sistema operativo Windows o que pueda

instalarse los paquetes de software necesarios para realizar la práctica.
 Fuente de poder regulada, fuente poder “Batería litio.”
 Tarjeta de desarrollo Microcontrolador “Arduino” UNO, MEGA, NANO.
 Protoboard, Multímetro, punta lógica
 Teclado matricial (3x4 o 4x4),
 display 16*2 LCD, según esquemas de circuito.
 Pinzas, pelacables, cable AWG22 (similar al de UTP) en varios colores.
 Se utiliza principalmente herramientas de Software libre o gratuito limitado o
versiones DEMO estas pueden ser “ARDUINO”:
 Compilador (Arduino”)
 Simulador Proteus, prueba funcionamiento código.
 Dth11 (sensor de temperatura y humedad)
 sensores de movimiento, infrarrojos, temperatura, presión
 Zumbador
Javier Doncel:

Esta menor o igual a 15 grados: 11 grados

Supera los 30 grados:

Esta entre 20 y 28 grados:

Código:

// LCD module connections

sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB2_bit;
sbit LCD_D5 at RB3_bit;
sbit LCD_D6 at RB4_bit;
sbit LCD_D7 at RB5_bit;

sbit LCD_RS_Direction at TRISB0_bit;

sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;
// End LCD module connections
#define LEDV PORTD.RD0
#define LEDA PORTD.RD1
#define LEDR PORTD.RD2
#define VENTILADOR PORTD.RD4

unsigned long valor;

char texto;
char texto2;

void sonido1() {
Sound_play(1000, 500);
}
void sonido2() {
Sound_play(1059, 500);
}

void main () {
TRISD=0;
PORTD=0;

Sound_Init (&PORTD, 3);

ADC_Init ();
Lcd_init();
Lcd_Cmd(_LCD_CLEAR);
Lcd_Cmd(_LCD_CURSOR_OFF);
Lcd_out(1,1,"TEMPERATURA");
LCD_Out(2,4,"'C");

while (1) {
valor=ADC_Read(2);
valor=valor * 5000 / 1023;
texto=valor / 100;
Lcd_chr(2,1,48+texto);
texto2=(valor / 10) % 10;
Lcd_chr_cp(48+texto2);

if ( texto < 2 ){
LEDV=1;
LEDA=0;
LEDR=0;
VENTILADOR=0;
Lcd_out(2,8,"MOTOR OFF");
sonido1();
delay_ms(2000);

else {
if ( texto < 3 ) {
LEDV=0;
LEDA=1;
LEDR=0;
VENTILADOR=0;
Lcd_out(2,8,"MOTOR OFF");

}
else {
if ( texto >= 3 ) {
LEDV=0;
LEDA=0;
LEDR=1;
VENTILADOR=1;
Lcd_out(2,8,"MOTOR ON ");
Sonido3();
Programa 2:

Se diseñará un sistema de cerradura electrónica el cual deberá en un display

16X2 desplegar en la primera línea el nombre del curso y numero de grupo,
habrá un teclado matricial de 4 x4, y al digitar el número de cedula de cada
estudiante debe aparecer en el display y al ser el correcto se debe encender
un led para cada uno de los estudiantes, serán 5 leds (verde, amarillo, rojo,
azul y blanco)
Código del Micro
//LCD conexiones al PIC
#define LCD_RS_PIN PIN_C0
#define LCD_RW_PIN PIN_C1
#define LCD_ENABLE_PIN PIN_C2
#define LCD_DATA4 PIN_C3
#define LCD_DATA5 PIN_C4
#define LCD_DATA6 PIN_C5
#define LCD_DATA7 PIN_C6
//Aqui terminan las conexiones al PIC
#define Boton_1 pin_D0
#define Boton_2 pin_D1

#include <16F877A.h>
#use delay(crystal=4000000)
#include <lcd.c>

void main(){

while(TRUE)
{
lcd_init();
lcd_gotoxy(1,1);
printf(lcd_putc,"Micropr-Microcon");
lcd_gotoxy(1,0);
printf(lcd_putc,"Grupo_25");
delay_ms(2000);

if(input(pin_D0))
{
 lcd_init();
lcd_gotoxy(1,1);
printf(lcd_putc," FABIAN CELIS ");
lcd_gotoxy(1,0);
printf(lcd_putc,"C.C. 1.098.619.117");
delay_ms(2000);
}
if(input(pin_D1))
{
lcd_init();
lcd_gotoxy(1,1);
printf(lcd_putc," MAURICIO CARDONA ");
lcd_gotoxy(1,0);
printf(lcd_putc,"CC 18.533.116");
delay_ms(2000);
}
}
}
-Con la propuesta escogida de trabajo final debe realizar:

- Metodología
- Inicio de fase del Algoritmo
- Esquema General
- Análisis de resultados
- Recursos a utilizar

EJERCICIO SELECIONADO Sistema de seguridad:

Alarma con 6 puntos de sensibilidad con sensores de movimiento, infrarrojos,
temperatura, presión etc. con indicación de zona de ingreso y por medio de
un lcd 16x2, y 3 salidas que activen los leds de color rojo, amarillo y verde
como zona segura (verde), alerta (amarilla) y alarma (rojo), zona segura no se
activa ningún sensor, alerta máximo 2 sensores activados y alarma 3 sensores
activados, más una salida a relevos para sirena.

Metodología:

Conocimiento previo:
Contenidos del curso y material bibliográfico suministrado en el curso “e-BIBLIOTECA.
Emplear los conocimientos necesarios para diseñar y desarrollar algoritmos, diagramas de
flujo y programas en lenguaje ensamblador, simulación del sistema microcontrolado
“proteus”, programación de la memoria del microcontrolador “Arduino” e implementación
del circuito electrónico

Inicio de fase del Algoritmo

Análisis de resultados
Por medio de las simulaciones en programa.

Recursos a utilizar

 Computador PC con softwares necesarios para realizar la práctica y

simulaciones.
 sensores
 Resistencias con valores según calculado en el diseño
 Speaker
 Lcd
 Led de diferentes colores.
 Zumbador
Diego Cohecha:

Actividades a desarrollar
Programa 1:
Microcontrolador Pic16f877a
1 Display 16 X 2
1 Dth11 (sensor de temperatura y humedad)
3 leds (rojo , amarillo, verde)
2 Motores 12 vdc (ventilador)
3 resistencias de 220 ohmios
3 resistencias de 1 k ohmios
5 pulsadores

Debe sensar la humedad y temperatura del ambiente con el sensor

dth11 de proteus, monitorizando las dos variables y visualizándolas en
un display 16 x2 y si la temperatura está menor o igual de 15 grados
el led verde se encenderá , si la temperatura está entre los 20 y 28
grados se encenderá un led amarillo , y si supera los 30 grados el led
rojo se prendera y debe dar una alarma constante y prenderse el
ventilador hasta que baje la temperatura menor o igual a 20 grados.
En el display se debe visualizar el valor de la temperatura y la
activación de motor como MOTOR ON o MOTOR OFF. Debe sensar a
todo momento la humedad del ambiente al pasar por el 60% se debe
activar un motor ventilador y se debe apagar cuando esta baje a
menos de 50%.

Para este primer ejercicio realice la aplicación mediante PIC C, a continuación

describo el código:
#include <16F877A.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock = 20M)
#define PCF_SDA PIN_C2
#define PCF_SCL PIN_C1
// LCD con i2C
#use i2c(master, sda=PCF_SDA, scl=PCF_SCL)
#define PCF_ID 7
#define PCF 64 // Puede ser 112 ó 64 (PCF8574T=64, PCF8574A=112, PCF8574=64)
#define blacking P3
#define LCD_RS P0
#define LCD_RW P1
#define LCD_E P2
#define LCD_DB4 P4
#define LCD_DB5 P5
#define LCD_DB6 P6
#define LCD_DB7 P7
#include <LCD_PCF.c>// Librerio para manejar el I2C
#use fast_io(D)

// Asignacion de pin para conectar el DTH11 al puerto D0

#BIT Data_Pin = 0x08.0 // Pin mapped to PORTD.0
#BIT Data_Pin_Direction = 0x88.0 // Pin direction mapped to TRISD.0

short Time_out;//Variable para el tiempo de respuesta del sensor

unsigned int8 T_byte1, T_byte2, RH_byte1, RH_byte2,Temp,RH,CheckSum ;

void start_signal(){
Data_Pin_Direction = 0; // Configure connection pin as output
Data_Pin = 0; // Connection pin output low
delay_ms(25);
Data_Pin = 1; // Connection pin output high
delay_us(30);
Data_Pin_Direction = 1; // Configure connection pin as input
}

short check_response(){
delay_us(40);
if(!Data_Pin){ // Read and test if connection pin is low
delay_us(80);
if(Data_Pin){ // Read and test if connection pin is high
delay_us(50);
return 1;}
}
}
unsigned int8 Read_Data(){
unsigned int8 i, k, _data = 0; // k is used to count 1 bit reading duration
if(Time_out)
break;
for(i = 0; i < 8; i++){
k = 0;
while(!Data_Pin){ // Wait until pin goes high
k++;
if (k > 100) {Time_out = 1; break;}
delay_us(1);}
delay_us(30);
if(!Data_Pin)
bit_clear(_data, (7 - i)); // Clear bit (7 - i)
else{
bit_set(_data, (7 - i)); // Set bit (7 - i)
while(Data_Pin){ // Wait until pin goes low
k++;
if (k > 100) {Time_out = 1; break;}
delay_us(1);}
}
}
return _data;
}

//Cadena para el manejo del char donde se enviara los datos para el i2c

Const char Letra1[8]= {0b00000,0b11011,

0b11011,
0b00000,
0b11111,
0b11111,
0b01110,
0b00000
};
char i; //Variable para el i2c

void main(){
lcd_init(); // Initialize LCD module
CGRAM_x(5);
lcd_putc('\f'); // LCD clear
for(i=0;i<=7 ;i++) lcd_send_byte(1,Letra1[i]);
output_high(pin_b3); //Sentido motor
output_low(pin_b4); //Sentido motor
output_low(pin_b7); //Apaga Motor RH
output_low(pin_b5); //Apaga Motor
while(TRUE){
delay_ms(1000);
Time_out = 0;
Start_signal();
if(check_response()){ // Si hay respuesta del sensor
RH_byte1 = Read_Data(); // lee Humedad Relativa del byte1
RH_byte2 = Read_Data(); // lee Humedad Relativa del byte2
T_byte1 = Read_Data(); // lee Temperatura del byte1
T_byte2 = Read_Data(); // lee Temperatura del byte2
CheckSum = Read_Data();
Temp=((T_byte2*10)+T_byte1);
RH=((RH_byte2*10)+RH_byte1);
lcd_putc('\f');
lcd_gotoxy(1, 1);
printf(LCD_PUTC,"Temp: ");
printf(LCD_PUTC,"%d", Temp);
lcd_gotoxy(1, 2);
printf(LCD_PUTC,"RH: ");
printf(LCD_PUTC,"%d", RH);
delay_us(1000);
delay_us(1000);

}
if(Temp<=15){
output_high(pin_b2);
output_low(pin_b1);
output_low(pin_b0);
}else if(Temp >=20 && Temp <=28){
output_low(pin_b2);
output_high(pin_b1);
output_low(pin_b0);
}
if(Temp >=30){
output_low(pin_b2);
output_low(pin_b1);
output_high(pin_b0);
output_high(pin_b5); //Encender motor
output_high(pin_b6); //Encender Alarma
lcd_putc('\f');
lcd_gotoxy(1, 1);
printf(LCD_PUTC,"Temp: ");
printf(LCD_PUTC,"%d", Temp);
lcd_gotoxy(1,2);
printf(LCD_PUTC,"MOTOR ON ");
delay_us(1000);
delay_ms(1000);
}else if(Temp <=20){
output_low(pin_b5); //Apaga Motor
output_low(pin_b6); //Apaga Alarma - buzzer
lcd_putc('\f');
lcd_gotoxy(1, 1);
printf(LCD_PUTC,"Temp: ");
printf(LCD_PUTC,"%d", Temp);
lcd_gotoxy(1,2);
printf(LCD_PUTC,"MOTOR OFF ");
delay_us(1000);
delay_us(1000);
}
if(RH>=60){
output_high(pin_b7); // Apaga Motor RH
lcd_putc('\f');
lcd_gotoxy(1, 1);
printf(LCD_PUTC,"RH: ");
 printf(LCD_PUTC,"%d", RH);
lcd_gotoxy(1,2);
printf(LCD_PUTC,"MOTOR ON ");
delay_us(1000);
delay_ms(1000);
}
if(RH<=50){
output_low(pin_b7); // Apaga Motor RH
lcd_putc('\f');
lcd_gotoxy(1, 1);
printf(LCD_PUTC,"RH: ");
printf(LCD_PUTC,"%d", RH);
lcd_gotoxy(1,2);
printf(LCD_PUTC,"MOTOR OFF ");
delay_us(1000);
delay_us(1000);
}
}
}

Como para esta práctica utilice un I2C, se requiere incluir la librería I2C en la misma
carpeta de realización del ejercicio para que funcione correctamente, es decir en la
carpeta del proyecto.
Montaje de la Práctica en Proteus
Programa 2:
Se diseñara un sistema de cerradura electrónica el cual deberá en un
display 16X2 desplegar en la primera línea el nombre del curso y numero
de grupo, habrá un teclado matricial de 4 x4, y al digitar el número de
cedula de cada estudiante debe aparecer en el display y al ser el correcto
se debe encender un led para cada uno de los estudiantes, serán 5 leds
(verde, amarillo, rojo, azul y blanco)

En primer lugar para este ejercicio los integrantes del grupo somos:
Diego
Carlos
Nestor
Roosber
Javier
Y con respecto al número de documento designe los siguientes números
de documento de identidad respectivamente:
1033685765
1033685766
1033685767
1033685768
1033685769

Para este segundo ejercicio también utilice el lenguaje PIC C

El cual es el siguiente:
#include <16F877A.h>
#fuses XT,HS
#use delay (clock=4M)
#define PCF_SDA PIN_D1
#define PCF_SCL PIN_D0
#use i2c(master, sda=PCF_SDA, scl=PCF_SCL)
#define PCF_ID 7
#define PCF 64 // Puede ser 112 ó 64 (PCF8574T=64, PCF8574A=112, PCF8574=64)
#define blacking P3
#define LCD_RS P0
#define LCD_RW P1
#define LCD_E P2
#define LCD_DB4 P4
#define LCD_DB5 P5
#define LCD_DB6 P6
#define LCD_DB7 P7
#include <LCD_PCF.c>
#include <KBD1.c>
Const char Letra1[8]= {0b00000,0b11011,
0b11011,
0b00000,
0b11111,
0b11111,
0b01110,
0b00000
};
char c;
int clave1[10]={'1','0','3','3','6','8','5','7','6','5'};
int clave2[10]={'1','0','3','3','6','8','5','7','6','6'};
int clave3[10]={'1','0','3','3','6','8','5','7','6','7'};
int clave4[10]={'1','0','3','3','6','8','5','7','6','8'};
int clave5[10]={'1','0','3','3','6','8','5','7','6','9'};
int i,u=0; // contador
char k; // lectura del teclado
char dato[10]; //dato: almacena los dígitos

void main(){
lcd_init();
CGRAM_x(5);
for(c=0;c<=7 ;c++) lcd_send_byte(1,Letra1[c]);
kbd_init();
port_b_pullups(TRUE); // resistencias o internas del pic
for(;;){
lcd_putc("\f");
lcd_putc("MICROCONTROLADOR "); // Nombre del programa
lcd_putc("\n GRUPO 29 "); // numero del grupo
delay_ms(1000);
delay_ms(1000);
lcd_putc("\fINGRESE SU CLAVE ");
output_low(PIN_D0);
output_low(PIN_D1);

i=0;
while(i<10){
k=kbd_getc(); // leer la tecla presionada
if(k!=0){
dato[i]=k;
i++;
lcd_gotoxy(i,2); // posición i de la segunda línea
lcd_putc(k);
}
}

if( u==0 && dato[0]==clave1[0] && dato[1]==clave1[1] && dato[2]==clave1[2] && dato[3]==clave1[3]
&& dato[4]==clave1[4] && dato[5]==clave1[5] && dato[6]==clave1[6] && dato[7]==clave1[7] &&
dato[8]==clave1[8] && dato[9]==clave1[9])
{
lcd_putc("\fClave Correcta! ");
lcd_putc("\nUsuario Diego ");
delay_ms(2000);
output_high(pin_c0);
u=1;
}
if( u==0 &&dato[0]==clave2[0] && dato[1]==clave2[1] && dato[2]==clave2[2] && dato[3]==clave2[3]
&& dato[4]==clave2[4] && dato[5]==clave2[5] && dato[6]==clave2[6] && dato[7]==clave2[7] &&
dato[8]==clave2[8] && dato[9]==clave2[9])
{
lcd_putc("\fClave Correcta! ");
lcd_putc("\nUsuario Carlos ");
delay_ms(2000);
output_high(pin_c1);
u=1;
}
if( u==0 && dato[0]==clave3[0] && dato[1]==clave3[1] && dato[2]==clave3[2] && dato[3]==clave3[3]
&& dato[4]==clave3[4] && dato[5]==clave3[5] && dato[6]==clave3[6] && dato[7]==clave3[7] &&
dato[8]==clave3[8] && dato[9]==clave3[9])
{
lcd_putc("\fClave Correcta! ");
lcd_putc("\nUsuario Nestor ");
delay_ms(2000);
output_high(pin_c2);
u=1;
}
if(u==0 && dato[0]==clave4[0] && dato[1]==clave4[1] && dato[2]==clave4[2] && dato[3]==clave4[3]
&& dato[4]==clave4[4] && dato[5]==clave4[5] && dato[6]==clave4[6] && dato[7]==clave4[7] &&
dato[8]==clave4[8] && dato[9]==clave4[9])
{
lcd_putc("\fClave Correcta! ");
lcd_putc("\nUsuario Roosber ");
delay_ms(2000);
output_high(pin_c3);
u=1;
}
if( u==0 &&dato[0]==clave5[0] && dato[1]==clave5[1] && dato[2]==clave5[2] && dato[3]==clave5[3]
&& dato[4]==clave5[4] && dato[5]==clave5[5] && dato[6]==clave5[6] && dato[7]==clave5[7] &&
dato[8]==clave5[8] && dato[9]==clave5[9])
{
lcd_putc("\fClave Correcta! ");
lcd_putc("\nUsuario Javier ");
delay_ms(2000);
output_high(pin_c4);
u=1;
}
 if(u==0){
lcd_putc("\fClave incorecta ");
lcd_putc("\n -_- ");
delay_ms(2000);

}else u=0;
}
}

Para este ejercicio también se requiere incluir la librería de I2C para su

correcto funcionamiento.

A continuación anexo pantallazo de montaje realizado en proteus

PROPUESTA GRUPAL

SISTEMA DE SEGURIDAD:
Alarma con 6 puntos de sensibilidad con sensores de movimiento,
infrarrojos, temperatura, presión etc. con indicación de zona de ingreso
y por medio de un lcd 16x2, y 3 salidas que activen los leds de color
rojo, amarillo y verde como zona segura(verde), alerta(amarilla) y
alarma(rojo), zona segura no se activa ningún sensor, alerta máximo 2
sensores activados y alarma 3 sensores activados, más una salida a
relevos para sirena.

Metodología:
Para este proyecto se utilizara Proteus para su simulación donde implementaremos
los componentes necesarios para dar solución a la problemática planteada.
Insertaremos como nos lo pide la guía; 6 sensores los cuales los simularemos por
medio de Switches - pulsadores, la visualización será por medio de un LCD de 16x2,
como salidas tendremos 3 leds lo cuales nos mostraran su visualización mediante
su encendido, teniendo en cuenta que el led rojo nos indica alarma; es decir que
hay presencia de peligro y se activaran 3 sensores, el led amarillo nos indica alerta:
es decir que muy posiblemente hay presencia de algún peligro y se activaran 2
sensores y el led verde nos indica zona segura y por lo tanto no se activara ningún
sensor.
Como alarma utilizaremos un buzzer.
Y posteriormente procederemos a utilizar Arduino para la realización del código
Para este utilizaremos del pin 1 al 6 como entradas (serian los sensores) y del pin
7 al 9 como salidas (serian los leds de visualización)
En el código es importante identificar los pines asignados tanto para los sensores
como para las salidas y la configuración del display y la declaración de las variables.
Y teniendo en cuenta lo anterior se utilizaría un If (si condicional) para el
reconocimiento de los 6 sensores según su estado, es decir; nos validara si están
en 0 (low) o en 1 (hight) para la detección del sistema de seguridad y así
dependiendo del estado se nos activaría los leds. Así mismo teniendo en cuenta
esta condición también se visualizara en el LCD el análisis de resultados
Inicio de fase del Algoritmo:
Esquema General:

Análisis de Resultados:
El análisis de resultados lo tendremos básicamente de 3 maneras según el estado
de activación de los 6 sensores.
Tendremos la visualización en LCD del estado de los 6 sensores, es decir de las
entradas y nos dirá si están activados o encendidos o están desactivados o
apagados y simultáneamente podemos visualizar el estado de las salidas, que para
la práctica son los led’s, y también tenemos un tercer dispositivo como salida que
es un buzzer el cual únicamente se activara cuando se activen 3 o más sensores lo
que indicara que la alarma de activo, a este buzzer le podremos controlar el tono
mediante un potenciómetro de 1KΏ

Recursos a utilizar:
Tarjeta Arduino MEGA (1)
LCD 16x2 (1)
Pulsadores N/A (6)
Resistencias (varios valores)
Potenciómetro 1 kΏ(1)
Led Verde (1)
Led Amarillo (1)
Led Rojo (1)
Buzzer (1)
 CONCLUSIONES
 Una gran ventaja de los PIC es que permite controlar, programar y sincronizar
tareas electrónicas a través del tiempo simplemente realizando una correcta
programación.

 Se llevaron a cabo la programación a través de software de los PIC para

poder realizar los montajes de acuerdo a los ejercicios establecidos.

 Durante el desarrollo de los ejercicios propuestos mediante la simulación se

presentaron algunas dificultades al momento de compilar el código, errores
y problemas que fueron resueltos con la ayuda de manuales, guías y videos
tutoriales.

 Gran diversidad de micros controladores PIC, se pueden elegir para

desarrollar propuestas, como: cantidad de puertos, cantidad de entradas y
salidas, conversor Analógico al Digital, cantidad de memoria, espacio físico,
y permiten tener una mejor elección de un PIC.

 Desventajas Microcontrolador PIC necesitan muchas instrucciones para una

tarea cuando el proyecto es complejo.

 Se identificó las características funcionales, arquitectura, aplicación del

Microcontrolador Pic 16f877
 Se realizó la simulación mediante Proteus y utilización del programa PIC C,
determinando de esta forma que las aplicaciones se pueden realizar primero
de forma computacional para dar respuesta a la problemática planteada.
 Se aplicó un determinado diseño de algoritmo dependiendo la problemática
 REFERENCIAS
Angulo U, (2001). Microcontroladores PIC. Diseño practico de aplicaciones (2ª
Ed).Recuperado de
http://bibliotecavirtual.unad.edu.co:2460/lib/unadsp/detail.action?docID=3194849
Ibrahim, Dogan (2006) PIC BASIC Projects, 30 Projects Using PIC BASIC and PIC
BASIC PRO. Recuperado de
http://bibliotecavirtual.unad.edu.co:2139/eds/detail/detail?vid=7&sid=bb49356b-
11e7-4189-
97ffc78729359ced%40sessionmgr198&hid=127&bdata=Jmxhbmc9ZXMmc2l0ZT1l
ZHMtbGl2ZQ%3d%3d#AN=173572&db=nlebk

Di Jasio, Lucio (2007) Programming 16-bit PIC Microcontrollers in C, Learning to Fly

the PIC 24.nRecuperado de
http://bibliotecavirtual.unad.edu.co:2139/eds/detail/detail?vid=3&sid=bb49356b11e
7-4189-
97ffc78729359ced%40sessionmgr198&hid=127&bdata=Jmxhbmc9ZXMmc2l0ZT1l
ZHMtbGl2ZQ%3d%3d#AN=193636&db=nlebk

Boxall, John (2013). Arduino Workshop, A Hands-on Introduction with 65 Projects.

Recuperado de
http://bibliotecavirtual.unad.edu.co:2139/eds/detail/detail?vid=5&sid=bb49356b-
11e7-4189-
97ffc78729359ced%40sessionmgr198&hid=127&bdata=Jmxhbmc9ZXMmc2l0ZT1l
ZHMtbGl2ZQ%3d%3d#AN=578482&db=nlebk

G Vivero, E. (13 de junio de 2014). Arduino desde cero - Repositorio Unad.

Recuperado de
https://www.youtube.com/watch?v=3BnS59Kg9DE