Proyecto microcontrolador

INSTITUTO PÓLITECNICO NACIONAL

Escuela Superior de Ingeniería Mecánica y Eléctrica“Unidad Culhuacán”

Ing. en Comunicaciones y ElectrónicaMicrocontroladoresProfesor: Prieto Solano JoséGrupo: 7EV2

Bautista Pérez Jesús Magdiel

Miranda Chávez Alan Michel

Castañeda Durán Giovanna

PROYECTO FINAL: INVERNADERO

PROYECTO FINAL

ÍNDICE

OBJETIVOS.................................................................................................2

MARCO TEÓRICO.......................................................................................3LENGUAJE C ORIENTADO A MICROCONTROLADORES......................................3CARACTERÍSTICAS Y DESVENTAJAS DE LEGUAJE C..........................................3PIC16F877.......................................................................................................5MPLAB..............................................................................................................6ISIS DE PROTEUS.............................................................................................7DISPLAY LCD 2X16...........................................................................................8CRISTAL CUARZO.............................................................................................9AMPLIFICADOR OPERACIONAL LM358............................................................10TRIMPOT........................................................................................................11CAPACITOR CERAMICO..................................................................................11

MATERIAL................................................................................................12

ESPECIFICACIONES..................................................................................12

IMPLEMENTACIÓN...................................................................................13

DESARROLLO..........................................................................................14

CONCLUSIONES.......................................................................................39

ANEXOS..................................................................................................41DATASHEET PIC16F877.................................................................................41DATASHEET LM358........................................................................................42DATASHEET LM35..........................................................................................43

BIBLIOGRAFÍA.........................................................................................44

OBJETIVOS

Que el alumno:

Sea capaz de realizar desde cero un proyecto generado de su propio ingenio, poniendo a prueba sus expectativas y aptitudes.

Generar este proyecto en código, simulación y en físico para poder sustentarlo y realizar las pruebas pertinentes.

Aplicar todo lo aprendido en el semestre.

MARCO TEÓRICO

LENGUAJE C ORIENTADO A MICROCONTROLADORES

2

PROYECTO FINAL

El lenguaje C es de tipo profesional, muy completo y potente, pero su manejo exige una buena formación en Informática. También es muy conveniente conocer la arquitectura interna del procesador y en muchas ocasiones hay que combinarlo con el lenguaje Ensamblador.

Al lenguaje C, se lo puede considerar con un lenguaje intermedio entre alto nivel y bajo nivel, debido a sus características especiales tales como el manejo de punteros, operaciones a nivel de BIT que son propios de lenguajes de bajo nivel. Sin dejar de mencionar la capacidad de empotrar trozos de lenguaje Ensamblador dentro de su código.

Un programa codificado en lenguaje C resulta muy útil en la aplicación de microcontroladores, dado que su compilación es bastante eficiente y óptima acercándose a la codificación de lenguaje de máquina.

CARACTERÍSTICAS Y DESVENTAJAS DE LEGUAJE C

C es un lenguaje de programación de propósito general. Sus principales características son:

Programación estructurada Economía de las expresiones Abundancia en operadores y tipos de datos. Codificación en alto y bajo nivel simultáneamente. Reemplaza ventajosamente la programación en ensamblador

(assembler). Utilización natural de las funciones primitivas del sistema. No está orientado a ningún área en especial. Producción de código objeto altamente optimizado. Facilidad de aprendizaje (;))

Una de las peculiaridades de C es su riqueza de operadores, Puede decirse que prácticamente dispone de un operador para cada una de las posibles operaciones en código máquina. Finalmente, C, que ha sido pensado para ser altamente transportable y para programar lo inprogramable, igual que otros lenguajes tiene sus inconvenientes.

3

PROYECTO FINAL

Carece de instrucciones de entrada/salida, de instrucciones para manejo de cadenas de caracteres, con lo que este trabajo queda para la biblioteca de rutinas, con la consiguiente pérdida de transpirabilidad.

La excesiva libertad en la escritura de los programas puede llevar a errores en la programación que, por ser correctos sintácticamente no se detectan a simple vista.

Por otra parte las precedencias de los operadores convierten a veces las expresiones en pequeños rompecabezas. A pesar de todo, C ha demostrado ser un lenguaje extremadamente eficaz y expresivo.

La programación en lenguaje C, para PIC, es bastante similar en su estructura y sintaxis a la programación tradicional para ordenadores, una de las diferencias esta en las librerías creadas específicamente para los microcontroladores PIC como por ejemplo para el LCD, teclado, bus I2C, etc. La función main ()es imprescindible en todo programa escrito en lenguaje C, pues es la función principal, desde aquí se puede hacer el llamado a otras funciones.

Para crear un programa en lenguaje C, hay que seguir los pasos siguientes:

1. Especificaciones del programa (qué tiene que hacer)2. Hacer organigrama3. Escribir el código fuente (conocer el lenguaje)4. Compilar + Enlazar (Link) 5. Depurar errores, si los hay

PIC16F877

El PIC16F877 es un microcontrolador con memoria de programa tipo FLASH, lo que representa gran facilidad en el desarrollo de prototipos y en su aprendizaje ya que no se requiere borrarlo con luz ultravioleta como las versiones EPROM, sino que permite reprogramarlo nuevamente sin ser borrado con anterioridad.

4

PROYECTO FINAL

El PIC16F877 es un microcontrolador de Microchip Technology fabricado en tec- nología CMOS, su consumo de potencia es muy bajo y además es completamente estático, esto quiere decir que el reloj puede detenerse y los datos de la memoria no se pierden.

Fig. 1: PIC 16f877

El encapsulado más común para este microcontrolador es el DIP (Dual In-line Pin) de 40 pines, propio para usarlo en experimentación.

Los pines de entrada/salida de este microcontrolador están organizados en cinco puertos, el puerto A con 6 líneas, el puerto B con 8 líneas, el puerto C con 8 líneas, el puerto D con 8 líneas y el puerto E con 3 líneas. Cada pin de esos puertos se puede configurar como entrada o como salida independiente programando un par de registros diseñados para tal fin. En ese registro un bit en "0" configura el pin del puerto correspondiente como salida y un bit en "1" lo configura como entrada. Dichos pines del microcontrolador también pueden cumplir otras funciones especiales, siempre y cuando se configuren para ello, según se verá más adelante.

5

PROYECTO FINAL

Fig. 2: Puertos en el PIC 16f877

MPLAB

Es un programa que corre bajo Windows, Mac OS y Linux. Presenta las clásicas barras de programa, de menú, de herramientas de estado, etc.

El ambiente MPLAB® posee editor de texto, compilador y simulación (no en tiempo real). Para comenzar un programa desde cero para luego grabarlo al μC en MPLAB® v7.XX los pasos a seguir son:

1. Crear un nuevo archivo con extensión .ASM y nombre cualquiera2. Crear un Proyecto nuevo eligiendo un nombre y ubicación3. Agregar el archivo .ASM como un SOURCE FILE4. Elegir el microcontrolador a utilizar desde SELECT DEVICE del

menú CONFIGURE

Una vez realizado esto, se está en condiciones de empezar a escribir el programa respetando las directivas necesarias y la sintaxis para luego compilarlo y grabarlo en el PIC.

6

PROYECTO FINAL

Fig. 3: Entorno de desarrollo MPLab

ISIS DE PROTEUS

Es una compilación de programas de diseño y simulación electrónica, desarrollado por Labcenter Electronics que consta de algunos programas principales:

Ares Isis Módulos VSM módulos Electra

ISIS (Intelligent Schematic Input System) permite diseñar el plano eléctrico del circuito que se desea realizar con componentes muy variados, desde simples resistencias, hasta alguno que otro microprocesador o microcontrolador, incluyendo fuentes de alimentación, generadores de señales y muchos otros componentes con prestaciones diferentes.

Los diseños realizados en Isis pueden ser simulados en tiempo real, mediante el módulo VSM, asociado directamente con ISIS.

7

PROYECTO FINAL

Fig. 4: Entorno de desarrollo Isis de Proteus

DISPLAY LCD 2X16

Las pantallas de cristal líquido (LCD) se han popularizado mucho en los últimos años, debido a su gran versatilidad para presentar mensajes de texto (fijos y en movimiento), valores numéricos y símbolos especiales, su precio reducido, su bajo consumo de potencia, el requerimiento de solo 6 pines del PIC para su conexión y su facilidad de programación en lenguajes de alto nivel (por ejemplo, lenguaje C). Desde todo punto de vista el empleo del display LCD 16x2 (LCD 2x16) debería considerarse como la primera opción a la hora de decidir por un dispositivo de presentación alfanumérica, excepto cuando las condiciones de iluminación ambiental no sean las más favorables. En este último caso se debería pensar en el empleo de displays de 7 segmentos, que aunque no tienen la misma versatilidad tienen la ventaja innegable de sus mejores características de visibilidad aún en los ambientes más desfavorables. En la actualidad existen diversos modelos de display LCD, aunque los más comunes son los LCD 16x2 (16 caracteres x 2 filas) o LCD 2x16, gobernados por el controlador Hitachi HD44780, que se ha

8

PROYECTO FINAL

convertido en el estándar de facto para las aplicaciones con microcontroladores PIC.

Fig. 5: Pantalla LCD

CRISTAL CUARZO

Tipo de resonador Cuarzo

Frecuencia 20MHz

Tolerancia de resonadores ±30ppm

Alcance de capacidad 16…30 pF

Potencia 1mW

Montaje THT

Estabilidad en tiempo ±5ppm/año

Ráster de terminales 4.88mm

Fig. 6: Cristal Cuarzo

9

PROYECTO FINAL

AMPLIFICADOR OPERACIONAL LM358

Amplificador operacional de doble propósito general. No requiere fuente dual. Alta ganancia, bajo consumo de potencia. En electrónica el uso de amplificadores operacionales es muy común. Sobre todo porque son muy útiles en una amplia gama de circunstancias, gracias a sus distintas configuraciones. Lo que nos permite un control simple de la ganancia, incluso con valores muy altos. Teniendo en cuenta las limitaciones técnicas: la tensión de salida del amplificador estará por debajo de la tensión de alimentación positiva

Características:

Voltaje de alimentación: 3V a 32V fuente sencilla (±1.5V a ±16V fuente dual)

Bajo consumo de potencia Ancho de banda típico: 1 MHz

Aplicación: Radio frecuencia Audio frecuencia Generación de pulsos Sensores

Fig. 7: Integrado LM358

TRIMPOT

10

PROYECTO FINAL

Trim o Trimpot, son potenciómetros que se ajustan con la ayuda de un destornillador. Sirven para que el circuito al que pertenecen, actúe adecuadamente (en su punto) y compensar las tolerancias en otros componentes los Trimpot son resistencias variables que tienen 3 patitas o pines, cuyo valor cambia a medida que mueves una perilla, la cual se desliza en una cubierta de carbón, por lo que la resistencia entre la patita que se desliza y uno de los extremos varia lineal o logarítmicamente según la especificación del trimpot.

Fig. 8: Trimpot

CAPACITOR CERAMICO

Capacitores de disco de cerámica de baja tensión (de color naranja) y de poliéster metalizado (de color verde). Los capacitores de cerámica se fabrican con muy pequeñas capacidades y su tamaño también es pequeño. Se emplean, fundamentalmente, en circuitos de alta frecuencia y junto con los capacitores electrolíticos, son los más ampliamente utilizados en electrónica.

Fig. 9: Capacitor cerámicos

MATERIAL

Equipo de cómputo PIC16F877A Programador para PICs Diodos led

11

PROYECTO FINAL

Resistencias de distintos valores/Trimpots Protoboard Alambre calibre 22 Fuente de voltaje Capacitores LCD LM35/LM358 Pushbuttons

ESPECIFICACIONES

Se necesita crear un invernadero automatizado que cumpla con las siguientes funciones y características:

Al encender todo el sistema, primeramente se configurara la hora actual del dispositivo, luego se pedirá al usuario la hora en la cual el sistema tomara la temperatura del invernadero y después se pedirá la hora en la que se regara el agua. Para el regado de agua se deben de tener en cuenta las siguientes especificaciones:

1. Si la temperatura censada fue de 5 a10 grados se regara durante 10 minutos.

2. Si la temperatura censada fue de 11 a 15 grados se regara durante15 minutos.

3. Si la temperatura censada fue de 21 en adelante se regara 20 minutos.

Además se contara con el control de una ventana y de un ventilador, los cuales actuaran para mantener baja o alta la temperatura del invernadero, considerando lo siguiente:

1. Si la temperatura está entre 0 y 24 grados (temperatura ambiente), la ventana se mantendrá cerrada.

2. Arriba de 25º se abrirá la ventana 3. Si la temperatura es mayor de 30º se mantiene abierta la ventana

y se activa un ventilador.4. Si la temperatura comienza a bajar se desactivara el ventilador y

se cerrara la ventana [el ventilador se desactivara a menos de 31º y la ventana se cerrara a los 24 grados]

12

PROYECTO FINAL

Esto no contara con una hora específica, ya que se estará sensando a toda hora la temperatura.

Todo esto será visualizado en una pantalla LCD para que el sistema sea más amigable con el usuario.

IMPLEMENTACIÓN

Para poder implementar las especificaciones del proyecto expuestas anteriormente, decidimos utilizar lo siguiente: Pic16f877A, LM358, LM35, LCD, Pushbuttons, donde los últimos servirán como periféricos de entrada, donde el usuario lograra ingresar los datos requeridos.

En la LCD se mostraran menús amigables con el usuario, los cuales pedirán la hora, desplegando un aumento o disminución de minutos y horas, que iran haciendo saltos si el usuario ya haya terminado de ingresar los datos correctamente.

Utilizaremos el modo de 24 horas para que el usuario no pueda rebasar de las 24 horas establecidas normalmente.

Se mostrara la hora actual y la hora de riego, además de la temperatura del invernadero y la temperatura senasada.

Para los actuadores del aspersor, la ventana y el ventilador, se utilizaran LEDs para que sepamos cuando se activan o se desactivan los mismos, todo esto será explicado más adelante.

“Todo esto será presentado en protoboards, con su respectivo alambrado”

DESARROLLO

1. Genere un nuevo proyecto en MPLab para desarollar el proyecto explicado con anterioridad, posteriormente agregue un archivo .c para comenzar a programar siguiendo los pasos mostrados.

a. Ejecute MPLab X en el equipo de cómputo

13

PROYECTO FINAL

b. Seleccione el PIC que va a ser utilizadoc. Asígnele nombre a dicho proyecto y elija la ruta en donde

será guardo.d. Agregue un archivo .c y asígnele un nombree. Comience a programar sobre el archivo .asm antes creado

Utilizando el entorno de desarrollo MPLab X se generó un proyecto, seguido, se selecciono el PIC16F877A, se le asigno el nombre al proyecto llamado Invernadero, se creo un nuevo archivo .c con el mismo nombre en cada proyecto, siguiendo estos pasos el entorno de desarrollo quedó listo para comenzar a programar.

Cabe mencionar que para la programación de este proyecto fu necesario utilizar diversas librerías para ahorrar código en el programa principal, las librerías implementadas controlaron dispositivos tales como:

LCD Convertidor digital Librerías para el PIC Fuses implementados en el PIC Retardos

Figura 10: Proyecto y archivo .c generado en MPLab

14

PROYECTO FINAL

2. En el archivo .c generado realice programe las funciones del proyecto.

Para generar el proyecto propuesto se realizaron los siguientes pasos:

Se agregó la librería necesario para el PIC16F877A la cual aparece al inicio del programa.

Se definieron todas las librerías a utilizar. Se inicializó el programa. Se declararon los puertos necesarios tales como puertos de

entrada y salida. Se generó el código necesario para cubrir los

requerimientos. Se procedió a comentar cada línea del proyecto para llevar

una buena relación y entendimiento del mismo. El programa fue compilado, indicándonos que no se generó

ningún error. El archivo .hex fue identificado en la carpeta en dónde se

guardó el proyecto. Se extrajo el archivo .hex para posteriormente utilizarlo en

la simulación correspondiente montado en Isis de Proteus.

Figura 11: Compilación correcta del proyecto Invernadero

15

PROYECTO FINAL

Los pasos a seguir para hacer funcionar el proyecto generado, son mostrados a continuación.

Encender el dispositivo Definir la hora actual auxiliándose de un reloj Definir la hora en la que se tomará la temperatura para

comenzar a regar Observar cómo funciona el dispositivo Reiniciar el dispositivo

Código generado:

#define RS RD2 // Inicialización de puertos#define EN RD3#define D4 RD4#define D5 RD5#define D6 RD6#define D7 RD7

#include <xc.h> // Librerias #include <stdio.h>#include <stdlib.h>#include <math.h>#include "lcd.h"

// CONFIG#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator)#pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)#pragma config PWRTE = OFF // Power-up Timer Enable bit (PWRT disabled)#pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled)#pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)#pragma config CP = OFF

#define FOSC 20000000L /* target device system clock freqency */#define FCYC (FOSC/4L) /* target device instruction clock freqency */#define _XTAL_FREQ FOSC /* required for __delay_ms, __delay_us macros */

16

PROYECTO FINAL

int usegundos3=0; //Variable de unidades para los segundosint dsegundos3=0; //Variable de decenas para los segundosint uminutos3=0; //Variable de unidades para los minutosint dminutos3=0; //Variable de decenas para los minutosint uhoras3=0; //Variable de unidades para las horasint dhoras3=0; //Variable de decenas para las horas

int usegundos4=0; //Variable de unidades para los segundosint dsegundos4=0; //Variable de decenas para los segundosint uminutos4=0; //Variable de unidades para los minutosint dminutos4=0; //Variable de decenas para los minutosint uhoras4=0; //Variable de unidades para las horasint dhoras4=0; //Variable de decenas para las horas

void riego (int x) //Inicia función para el reloj del tiempo{ usegundos4=usegundos3; //Igualamos variables dsegundos4=dsegundos3; uminutos4=uminutos3; dminutos4=dminutos3; uhoras4=uhoras3; dhoras4=dhoras3; // Fin de la igualación int j=0; for(j=0; j<x;j++) { if(usegundos4<9) //Si unidades segundos menor a 9 { usegundos4++; //Aumentamos las unidades de los segundos } else { usegundos4=0; //Unidades segundos igual a 0 if(dsegundos4<5) //Si decenas segundos menor a 5 { dsegundos4++; //Aumento decenas de los segundos } else { dsegundos4=0; //decenas segundos igual a 0 if(uminutos4<9) //Si unidades minutos menor a 9 { uminutos4++; //Aumento unidades de los minutos } else { uminutos4=0; //Unidades minutos igual a 0

17

PROYECTO FINAL

if(dminutos4<5) //Si decenas minutos menor a 5 { dminutos4++; //Aumento decenas de minutos } else { dminutos4=0; //decenas minutos igual a 0 if(uhoras4<9 && dhoras4<2 || uhoras4<3 && dhoras4==2 ) ////Si unidades horas menor mayor a 9 y decenas horas menor a 2 { uhoras4++; //Aumento unidades de horas } else { uhoras4=0; //unidades horas igual a 0 if(dhoras4<2) { dhoras4++; //Aumento decenas horas } else { dhoras4=0; //Horas igual a 0 } } } } } } }}

int main(void) // Función principal { int usegundos=0; //Variable unidades segundos igual a 0 int dsegundos=0; //Variable decenas segundos igual a 0 int uminutos=0; //Variable unidades minutos igual a 0 int dminutos=0; //Variable decenas minutos igual a 0 int uhoras=0; // Variable unidades horas igual a 0 int dhoras=0; //Variable decenas horas igual a 0

int usegundos2=0; //Variable unidades segundos2 igual a 0 int dsegundos2=0; //Variable decenas segundos2 igual a 0 int uminutos2=0; //Variable unidades minutos2 igual a 0 int dminutos2=0; //Variable decenas minutos2 igual a 0 int uhoras2=0; // Variable unidades horas2 igual a 0 int dhoras2=0; //Variable decenas horas2 igual a 0

18

PROYECTO FINAL

int i=0; //Variables utilizadas con valor entero int time=0; //Variables utilizadas con valor entero char s[20]; //Variable cadena “s”

unsigned short ADCResult; int resultado=0; //Variable resultado igual a 0 int conversion=0; //Variable conversion igual a 0 int conversion2=0; //Variable conversion2 igual a 0

TRISB = 0x00; //Inicia Configuracion de puertos PORTB = 0x00; TRISD = 0x00; TRISC = 0xFF; //Finaliza Configuracion de puertos Lcd_Init(); //Inicializar LCD Lcd_Clear(); // Limpiar LCD

ADCON0bits.ADCS = 0; //Selecting the clk division factor = FOSC/2 ADCON0bits.ADCS1 = 1; ADCON1bits.ADCS2 = 0; //Selecting the clk division factor = FOSC/2

ADCON1bits.ADFM = 1; //Result right justified

ADCON1bits.PCFG = 0; //Setting all the analog ports as Analog inputs

ADCON0bits.ADON = 1; //Turns on ADC module

ADCON0bits.CHS = 0; //Selects channel 0 ( AN0 )

//========================================================================================================================

Lcd_Set_Cursor(1,1); //Linea 1,1 Lcd_Write_String("INGRESE LA HORA"); //Mostrar “INGRESE LA HORA” en la LCD Lcd_Set_Cursor(2,1); //Linea 2,1 Lcd_Write_String("ACTUAL..."); //Mostrar “ACTUAL…” en la LCD for(i=0;i<200;i++) { __delay_ms(10); //delay de 10 ms } Lcd_Clear(); // limpiar LCD Lcd_Set_Cursor(1,1); //Linea 1,1 Lcd_Write_String("00:00:00"); // Mostrar “00:00:00” en la LCD//===================================================================Parte del código para ingresar la hora while(PORTCbits.RC0==1) //Inicia While para el Puerto C = a 1

19

PROYECTO FINAL

{ if(PORTCbits.RC1==0) //if = 0 { __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); //Inicia While para el Puerto C = a 0 __delay_ms(50); // delay 50 ms if(dhoras<2) { dhoras++; // incremente decenas hora Lcd_Set_Cursor(1,1); sprintf(s, "%d", dhoras); Lcd_Write_String(s); } } if(PORTCbits.RC2==0) // if igual a cero { __delay_ms(50); // delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(dhoras>0) // if decenas horas mayor a 0 { dhoras--; // decrementa decenas de horas Lcd_Set_Cursor(1,1); // línea 1,1 del LCD sprintf(s, "%d", dhoras); // muestra decenas de horas Lcd_Write_String(s); } } }

__delay_ms(50); // delay 50 ms while(PORTCbits.RC0==0); __delay_ms(50); // delay 50 ms

while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); // delay 50 ms if(uhoras<9 && dhoras<2 || uhoras<3 && dhoras==2) //if para horas { uhoras++; // incrementa unidades de las horas Lcd_Set_Cursor(1,2); sprintf(s, "%d", uhoras); // muestra unidades de las horas Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); // delay 50 ms

20

PROYECTO FINAL

while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(uhoras>0) // si horas mayor a 0 { uhoras--; // decrementa unidades hora Lcd_Set_Cursor(1,2); línea 1,2 sprintf(s, "%d", uhoras); mostrar unidades hora Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); // delay 50 ms if(dminutos<5) { dminutos++; // incrementa decenas minutos Lcd_Set_Cursor(1,4); sprintf(s, "%d", dminutos); // muestra decenas minutes Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(dminutos>0) // si decenas minutos mayor a 0 { dminutos--; decrementa decenas minutos Lcd_Set_Cursor(1,4); sprintf(s, "%d", dminutos); // muestra minutes Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0)

21

PROYECTO FINAL

{ __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); // delay 50 ms if(uminutos<9) { uminutos++; // incrementa unidades minutos Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos); // muestra unidades minutos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(uminutos>0) { uminutos--; //decrement unidades minutos Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos); //muestra unidades de minutos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); // delay 50 ms if(dsegundos<5) // si decenas segunos menor a 5 { dsegundos++; // incremente decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos); // muestra decenas segundos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(dsegundos>0) // decenas segundos mayor a 0 {

22

PROYECTO FINAL

dsegundos--; // decrementa decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos); //muestra decenas segundos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); // delay 50 ms if(usegundos<9) { usegundos++; Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos); Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); // delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); // delay 50 ms if(usegundos>0) // si unidades segundos mayor a 0 { usegundos--; //decrementa unidades segundos Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos); //muestra unidades segundos Lcd_Write_String(s); } } }


//========================================================================================================================

Lcd_Set_Cursor(1,1); // Linea 1,1 Lcd_Write_String("INGRESE LA HORA"); //Mostrar “INGRESE LA HORA”

23

PROYECTO FINAL

Lcd_Set_Cursor(2,1); // Linea 2,1 Lcd_Write_String("DE TEMPERATURA..."); //Mostrar “DE TEMPERATURA. . .” for(i=0;i<200;i++) // for hasta i menor a 200 { __delay_ms(10); //delay 10 ms } Lcd_Clear(); //Limpiar LCD Lcd_Set_Cursor(1,1); //Linea 1,1 Lcd_Write_String("00:00:00"); //Mostrar "00:00:00"

//========================================================================================================= while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 10 ms if(dhoras2<2) //decenas horas mayor a 2 { dhoras2++; // aumenta decenas horas Lcd_Set_Cursor(1,1); sprintf(s, "%d", dhoras2); // muestra decenas horas Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dhoras2>0) // si decenas horas mayor a 0 { dhoras2--; //decrementa decenas horas Lcd_Set_Cursor(1,1); sprintf(s, "%d", dhoras2); //mostrar decenas horas Lcd_Write_String(s); } } }

__delay_ms(50); //delay 50 ms while(PORTCbits.RC0==0); __delay_ms(50); //delay 50 ms

while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0);

24

PROYECTO FINAL

__delay_ms(50); //delay 50 ms if(uhoras2<9 && dhoras<2 || uhoras2<3 && dhoras==2)//Condicion horas decenas, unidades { uhoras2++; //unidades horas aumenta Lcd_Set_Cursor(1,2); sprintf(s, "%d", uhoras2);// muestra unidades horas Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(uhoras2>0) //si unidades horas mayor a 0 { uhoras2--; //decrementa unidades hora Lcd_Set_Cursor(1,2); sprintf(s, "%d", uhoras2); // muestra unidades horas Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(dminutos2<5) // decenas minutos menor a 25 { dminutos2++; //incrementa decenas minutos Lcd_Set_Cursor(1,4); sprintf(s, "%d", dminutos2); // muestra decenas minutos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dminutos2>0) //si minutos mayor a 0 { dminutos2--; //decrementa decenas minutos Lcd_Set_Cursor(1,4);

25

PROYECTO FINAL

sprintf(s, "%d", dminutos2); //muestra decenas minutos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(uminutos2<9) //si unidades minutes menor a 9 { uminutos2++; //unidades minutes aumenta Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos2);// muestra unidades minutes Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(uminutos2>0) //si unidades minutes mayor a 0 { uminutos2--; //decrement unidades minutes Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos2); //Muestra unidades minutes Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(dsegundos2<5) //si decenas segundos menor a 5 {

26

PROYECTO FINAL

dsegundos2++;// incrementa decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos2); //muestra decenas segundos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dsegundos2>0) //si decenas segundos mayor a 0 { dsegundos2--; //decrementa decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos2);//muestra decenas segundos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(usegundos2<9) //si unidades segundos menor a 9 { usegundos2++; //incrementa unidades segundos Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos2); //muestra unidades segundos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(usegundos2>0) //si segundos mayor a 0 { usegundos2--; decrementa unidades Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos2); //muestra unidades segundos Lcd_Write_String(s); } }

27

PROYECTO FINAL

}


//============================================================================================================================

//========================================================================================================================

Lcd_Set_Cursor(1,1); //Linea 1,1 Lcd_Write_String("INGRESE LA HORA"); //Muestra “INGRESE LA HORA” Lcd_Set_Cursor(2,1); //Linea 2,1 Lcd_Write_String("DE RIEGO..."); //Muestra “DE RIEGO. . .” for(i=0;i<200;i++)//for para mostrar { __delay_ms(10); //delay 10 ms } Lcd_Clear(); Lcd_Set_Cursor(1,1); //linea 1,1 Lcd_Write_String("00:00:00"); //Muestra “00:00:00”

//========================================================================================================= while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(dhoras3<2) //Si decenas horas menor a 2 { dhoras3++; //Incrementa decenas horas Lcd_Set_Cursor(1,1); //Linea 1,1 sprintf(s, "%d", dhoras3); //Mostrar decenas horas Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dhoras3>0) //Si decenas horas mayor a 0 { dhoras3--; //Decrementa decenas horas Lcd_Set_Cursor(1,1); //Linea 1,1 sprintf(s, "%d", dhoras3); //Mostrar decenas horas

28

PROYECTO FINAL

Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(uhoras3<9 && dhoras<2 || uhoras3<3 && dhoras==2)//Condicion para decenas horas y unidades { uhoras3++;//Incrementa decenas horas Lcd_Set_Cursor(1,2); sprintf(s, "%d", uhoras3); //Muestra decenas horas Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(uhoras3>0) //Si horas mayor a 0 { uhoras3--; //Decrementa unidades hora Lcd_Set_Cursor(1,2); sprintf(s, "%d", uhoras3); //Muestra unidades hora Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(dminutos3<5) //Si decenas minutos menor a 5 {

29

PROYECTO FINAL

dminutos3++; //Incrementa decenas minutos Lcd_Set_Cursor(1,4); sprintf(s, "%d", dminutos3); //Muestra decenas minutos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dminutos3>0) //Si decenas minutos ayor a 0 { dminutos3--; Decrementa decenas minutos Lcd_Set_Cursor(1,4); sprintf(s, "%d", dminutos3); //Muestra decenas minutos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(uminutos3<9) //Si unidades minutos menor a 9 { uminutos3++; //Incrementa unidades minutos Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos3); //Muestra unidades minutos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(uminutos3>0) //Si unidades minutos mayor a 0 { uminutos3--; // Decrementa unidades minutos Lcd_Set_Cursor(1,5); sprintf(s, "%d", uminutos3); //Muestra unidades minutos Lcd_Write_String(s); } } }

30

PROYECTO FINAL


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(dsegundos3<5) //Si decenas segundos menor a 5 { dsegundos3++; // Incrementa decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos3); //Muestra decenas segundos Lcd_Write_String(s); } } if(PORTCbits.RC2==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC2==0); __delay_ms(50); //delay 50 ms if(dsegundos3>0) //Si decenas segundos mayor a 0 { dsegundos3--; // Decrementa decenas segundos Lcd_Set_Cursor(1,7); sprintf(s, "%d", dsegundos3); //Muestra decenas segundos Lcd_Write_String(s); } } }


while(PORTCbits.RC0==1) { if(PORTCbits.RC1==0) { __delay_ms(50); //delay 50 ms while(PORTCbits.RC1==0); __delay_ms(50); //delay 50 ms if(usegundos3<9) //Si unidades segundos menor a 9 { usegundos3++; //Incrementa unidades segundos Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos3); //Muestra unidades segundos Lcd_Write_String(s);

31

PROYECTO FINAL

} } if(PORTCbits.RC2==0) { __delay_ms(50); while(PORTCbits.RC2==0); __delay_ms(50); if(usegundos3>0) { usegundos3--; Lcd_Set_Cursor(1,8); sprintf(s, "%d", usegundos3); Lcd_Write_String(s); } } }


//============================================================================================================================

while(1) { //======================================================================================================================== ADCON0bits.GO = 1; //Starts ADC conversion while (ADCON0bits.nDONE) continue; //wait till ADC conversion is over ADCResult = (ADRESH<<8) + ADRESL ; //Merging the MSB and LSB resultado=ADCResult; conversion=(150.0/1024.0)*resultado; //Se realiza una conversion Lcd_Set_Cursor(2,1); Lcd_Write_String("Ta:"); //Muestra temperatura actual sprintf(s, "%d", conversion); Lcd_Write_String(s); Lcd_Set_Cursor(2,7); //Linea 2,7 Lcd_Write_String("C"); //========================================Codigo para las condiciones de riego if(conversion>=0 && conversion<=5) //Condicion para conversion mayor o igual a 0 y menor igual a 5 { PORTBbits.RB2=0; PORTBbits.RB3=1; //Se active este puerto PORTBbits.RB4=0; }

if(conversion>=6 && conversion<=24) // Condicion para conversion mayor o igual a 6 y menor igual a 24

32

PROYECTO FINAL

{ PORTBbits.RB2=0; PORTBbits.RB3=1; //Se active este puerto PORTBbits.RB4=0; }

if(conversion>=25 && conversion<=30) //Si conversion mayor o = a 25 y menor = a 30 { PORTBbits.RB2=1; //Se active este puerto PORTBbits.RB3=0; PORTBbits.RB4=0; } if(conversion>30) //So conversion mayor a 30 { PORTBbits.RB2=1; //Se active este puerto PORTBbits.RB3=0; PORTBbits.RB4=1; //Se active este puerto } else { PORTBbits.RB4=0; } //=============================================================================================================================

if(dhoras==dhoras2 && uhoras==uhoras2 && dminutos==dminutos2 && uminutos==uminutos2 && dsegundos==dsegundos2 && usegundos==usegundos2) { PORTBbits.RB0=1; ADCON0bits.GO = 1; //Starts ADC conversion while (ADCON0bits.nDONE) continue; //wait till ADC conversion is over ADCResult = (ADRESH<<8) + ADRESL ; //Merging the MSB and LSB resultado=ADCResult; //ADC conversion2=(150.0/1024.0)*resultado; //Conversion Lcd_Set_Cursor(2,9); Lcd_Write_String("Tr:"); //Muestra tiempo de riego sprintf(s, "%d", conversion2); Lcd_Write_String(s); Lcd_Set_Cursor(2,15); Lcd_Write_String("C"); } if(dhoras==dhoras3 && uhoras==uhoras3 && dminutos==dminutos3 && uminutos==uminutos3 && dsegundos==dsegundos3 && usegundos==usegundos3) { PORTBbits.RB1=1; //================================================================================================================================= if(conversion2>=5 && conversion2<=10) //Si conversión mayor = a 5 y menor igual a 10 {

33

PROYECTO FINAL

time=10; riego(600); }

if(conversion2>=11 && conversion2<=15) //Conversion mayor= a 11 y menor = a 15 { time=15; riego(900); }

if(conversion2>=16 && conversion2<=20)//Conversion mayor= a 16 y menor= a 20 { time=20; riego(1200); }

if(conversion2>=21)//Si conversion mayor= a 21 { time=25; riego(1200); } //========================================================================================================================================= }

if(dhoras==dhoras4 && uhoras==uhoras4 && dminutos==dminutos4 && uminutos==uminutos4 && dsegundos==dsegundos4 && usegundos==usegundos4) { PORTBbits.RB1=0; } Lcd_Set_Cursor(1,1); //Cursor 1,1 sprintf(s, "%d", dhoras); //Muestra decenas horas Lcd_Write_String(s); sprintf(s, "%d", uhoras); //Muestra unidades horas Lcd_Write_String(s); Lcd_Write_Char(':'); sprintf(s, "%d", dminutos); //Muestra decenas minutos Lcd_Write_String(s); sprintf(s, "%d", uminutos); //Muestra unidades minutos Lcd_Write_String(s); Lcd_Write_Char(':'); sprintf(s, "%d", dsegundos); //Muestra decenas segundos Lcd_Write_String(s); sprintf(s, "%d", usegundos); //Muestra unidades segundos Lcd_Write_String(s);

//==========================================================================================================================================

34

PROYECTO FINAL

Lcd_Set_Cursor(1,10); sprintf(s, "%d", time); Lcd_Write_String(s); Lcd_Write_String("min");

//==========================================================================================================================================

if(usegundos<9) //Si unidades segundos { for(i=0;i<100;i++) //for { __delay_ms(10); //delay 10 ms } usegundos++; //Incremento unidades segundos } else { for(i=0;i<100;i++) { __delay_ms(10); //Delay 10ms } usegundos=0; //Unidades segundos = a 0 Lcd_Set_Cursor(1,8); Lcd_Write_Char('0'); if(dsegundos<5) //Si decenas segundos menor a 5 { dsegundos++; //Incrementa decenas segundos } else { dsegundos=0; //decenas segundos = a 0 Lcd_Set_Cursor(1,7); Lcd_Write_Char('0'); if(uminutos<9) //Si minutos menor a 9 { uminutos++; //Incrementa unidades minutos } else { uminutos=0; //Unidades minutos = a 0 Lcd_Set_Cursor(1,5); Lcd_Write_Char('0'); if(dminutos<5) // Si decenas minutos menor a 5 { dminutos++; //Incrementa decenas minutos } else { dminutos=0; //Decenas minutos igual a 0 Lcd_Set_Cursor(1,4); Lcd_Write_Char('0');

35

PROYECTO FINAL

if(uhoras<9 && dhoras<2 || uhoras<3 && dhoras==2 )//Condicion unidades horas menos a 9 y decenas horas menor a 2 o unidades hora menor a 3 y decenas horas igual a 2 { uhoras++; //Incrementa unidades horas } else { uhoras=0; //Unidades horas = a 0 Lcd_Set_Cursor(1,2); Lcd_Write_Char('0'); if(dhoras<2) // Si decenas horas menor a 2 { dhoras++; //Incrementa decenas horas } else { dhoras=0; //decenas horas = a 0 Lcd_Set_Cursor(1,1); Lcd_Write_Char('0'); } } } } } } } return 0;} //Fin del código

Simulación:

Se genero la simulación es Isis de Proteus tal como se muestra en la figura siguiente.

DISEÑO FINAL DE PROYECTO

36

PROYECTO FINAL

Figura 12: Diseño de circuito en Isis de Proteus

INGRESAR HORA ACTUAL

Figura 13: Ingresar hora actual

INGRESAR HORA PARA TOMAR TEMPERATURA

37

PROYECTO FINAL

Figura 14: Ingresar hora para censar temperatura

INGRESAR HORA DE RIEGO

Figura 15: Ingresar hora para regar

38

PROYECTO FINAL

Cada uno de los LEDS ingresados en el proyecto actúan conforme a una característica específica , estas características se muestran en la tabla siguiente.

COLOR DE LEDCuadrado 1 Cuadrado 2 Amarillo Rojo VerdeINDICA RIEGO INDICA

TEMPERATURA TOMADA

INDICA VENTILADOR ENCENDIDO

INDICA VENTANA CERRADA

INDICA VENTANA ABIERTA

CONCLUSIONESBautista Pérez Magdiel

Para nuestro proyecto decidimos hacer un invernadero automático, ya que podríamos llevarlo a nivel industrial en algún futuro; basándonos en esto, aplicamos todo lo visto en clase durante el corto semestre, además de que se investigo y se encontró una extensa gama de documentación disponible y herramientas de ayuda que nos facilitaron la creación del proyecto.

Con todo lo anterior ya visto, ya nos es posible construir autómatas con componentes diversos que a la vez podrían ser reutilizables y de bajo costo, creándonos así nuevas formas de tecnologías, ya que el PIC, como lo mencione anteriormente, puede ser aplicable a muchas cosas.

La creación de Software para la programación de Microcontroladores ya no es una labor compleja debido a que se encuentran diversas alternativas, nosotros logramos pasar de una de bajo nivel a otro de alto nivel, facilitándonos la estructura de nuestro proyecto.

Por lo expresado anteriormente la elaboración de este proyecto nos sirve para comprender un poco más la teoría de los microcontroladores y su aplicación; de ahí la importancia del mismo, pues a través de él se puede apreciar lo interesante que es la programación en nuestra vida cotidiana, ya que los microcontroladores están presentes en muchos de

39

PROYECTO FINAL

los dispositivos con los que interactuamos en nuestra vida diaria, y que pasan inadvertido hasta que ponemos un especial interés en saber cómo logran que nuestra vida sea tan fácil.

Castañeda Durán GiovannaEn este proyecto se logró maximizar el uso del lenguaje C orientado a microcontroladores.

En la actualidad, tecnológicamente han cambiado muchas cosas, dentro de estos procesos tienen un rol importante los microcontroladores que son programables, la programación de los microcontroladores se ha realizado en varias plataformas una de las plataformas que utilizamos en el proyecto es basada en lenguaje C ya que la programación de este lenguajes es mucho más sencilla.

Para desarrollar el control del aspersor utilizamos amplificadores uno se utilizó para censar la temperatura LM35 el otro a utilizar fue el LM358 este a su vez hace la función de un sensor de temperatura que al variar la temperatura del sensor, también varía el voltaje, el PIC que usamos fue el 16f877A es un microcontrolador que por su memoria de programa tipo FLASH representa gran facilidad en el desarrollo de prototipos este no requiere borrarlo con luz ultravioleta tiene la facilidad que permite reprogramarlo nuevamente sin ser borrado con anterioridad; un LCD de 2X16 para mostrar el tiempo la temperatura el oscilador de cuarzo.

Miranda Chávez Alan Michel

Los microcontroladores son dispositivos cerrados que realizan tareas especificas programables, para la aplicación de este proyecto se utilizo un dispositivo de este tipo, PIC16F877A con el que se logró realizar todas las tareas señaladas, armar de forma sencilla y sobre todo la posibilidad de tener los recursos indispensables a la mano que son de gran utilidad.

Los lenguajes de programación han ido evolucionando año con año, en la implementación de este proyecto se uso el lenguaje C que junto con el microcontrolador antes señalado hacen una gran fusión para desarrollar prácticamente cualquier desafío que se presente, dadas las capacidades de programar de forma coherente y fluida, las conexiones y armado son mucho más sencillas.

Para la implementación d este proyecto se ocupar muchos puntos estratégicos en cuestión de teoría y que se aplicaron muchos temas muy bastos y robustos que fue necesario desglosar para obtener la información más puntual.

40

PROYECTO FINAL

Cabe destacar que este proyecto fue construido en varias partes, si bien la parte más grande fue la creación del termómetro, las otras se consideraron subcategorías que dependieron del termómetro.

Finalmente podemos concluir que para el diseño del invernadero se tomaron muchas cosas en cuenta, es importante señalar que con forme se va avanzando en la programación van surgiendo muchas más preguntas y consideraciones que se deben tomar en cuenta, la fue el caso de la implementación de la temperatura y de la hora en el reloj programado.

El proyecto se logró concluir satisfactoriamente, se tuvieron algunas fallas dadas algunas líneas de código, las cuales fueron superadas.

41

PROYECTO FINAL

ANEXOS

DATASHEET PIC16F877

42

PROYECTO FINAL

DATASHEET LM358

DATASHEET LM35

43

PROYECTO FINAL

44

PROYECTO FINAL

BIBLIOGRAFÍA

http://148.204.211.134/polilibros/portal/Polilibros/ www.oocities.org www.quegrande.org www.electronicafacil.net http://es.aliexpress.com/popular/digital-combinations.html http://es.scribd.com/doc/17273280/ADC PIC16F877http://www.lawebdelprogramador.com http://www.aurova.ua.es/microbot/index.php http://ww1.microchip.com/downloads/en/devicedoc/39632c.pdf http://blog.drk.com.ar/2012/amplificador-operacional-lm358

45

http://ww1.microchip.com/downloads/en/devicedoc/39632c.pdf

http://www.aurova.ua.es/microbot/index.php

http://www.electronicafacil.net/

Documents

Proyecto microcontrolador