TRABAJO COLABORATIVO UNO

INSTRUMENTACIÓN MÉDICA

FRACICA HEYLER ANTONIO Cód.: 74375216

HERRERA, JAVIER ALFREDO Cód.: 11441279

BURGOS, JAVIER MAURICIO Cód.:11444359

MOSQUERA, GEVER YESID Cód.:

DIRECTOR

SAULO ANDRES GÓMEZ

Ingeniero Electrónico

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

UNAD

INGENIERIA ELECTRONICA

2013

INTRODUCCIÓN

En el presente trabajo se explica el diseño y desarrollo para implementar un "termómetro

digital" basado en el microcontrolador PIC16F84, fabricado por Microchip, el cual se

programará en el lenguaje ensamblador del microcontrolador para el funcionamiento del

proyecto.

La importancia de realizar un termómetro digital es debido a que es muy fácil realizar

medidas de la temperatura con un sistema de adquisición de datos, pero la realización de

medidas de temperatura exactas y repetibles no es tan fácil.

La temperatura es un factor de medida engañoso debido a su simplicidad. A menudo

pensamos en ella como un simple número, pero en realidad es una estructura estadística

cuya exactitud y repetitividad pueden verse afectadas por la masa térmica, el tiempo de

medida, el ruido eléctrico y los algoritmos de medida.

La temperatura es difícil de medir con exactitud aún en circunstancias óptimas, y en las

condiciones de prueba en entornos reales es aún más difícil. Entendiendo las ventajas y

los inconvenientes de los diversos enfoques que existen para medir la temperatura,

resultará más fácil evitar los problemas y obtener mejores resultados.

OBJETIVOS

Generar una simulacion del un termometro a construir en el programa proteus

teniendo en cuenta un pic, un display, tres leds indicadores y un buzer.

Elaborar un programa que permita el control del pic para que deacuerdo a las

especificaciones dadas nos evidencie tanto en el display como en los leds los

cambios de temperaturas.

Desarrollar las habilidades necesarias para el manejo de software de simulacion de

circuitos electronicos como Proteus.

Aplicar los conocimientos adquiridos en el curso de microcontroladores para el

desarrollo de un sistema electrónico que permita medir la temperatura del cuerpo

humano.

Verificar el funcionamiento de los diferentes módulos de trabajo del PIC 16F877, en

especial su puerto conversor análogo digital.

Utilizar el microcontrolador como una herramienta fundamental en la

instrumentación diagnostica.

DESCRIPCIÓN:

El sensor que se utilizará será el transistor LM35DZ modelo TO-92, el cual es un sensor

de temperatura con buena precisión en escala Celsius. Éste dispositivo transforma la

temperatura del ambiente en voltaje, del orden de mV.

El LM35DZ entrega a la salida una resolución de 10mV por cada grado centígrado.

Empleándolo solo sin ninguna configuración en especial, el dispositivo presenta un rango

de medición de 2 a 150°C.

Esta configuración es la idónea para el proyecto pues solamente la utilizaremos para

medir temperaturas puede ser hasta 99°C.

Este sensor es fabricado por Fairchild y National Semiconductor.

El sensor LM35DZ nos entrega la temperatura como voltaje y como el voltaje es una

cantidad analógica, necesitamos convertirla a su equivalente en valor digital para poderla

manejar, pues los valores digitales son cantidades discretas y por lo tanto es más fácil

trabajar con ellas que con cantidades analógicas.

El PIC16F84 convertirá los valores del ADC0804 en valores equivalentes para la

visualización.

Como éste dispositivo es el que desarrollará el trabajo más importante de nuestro

proyecto, pues de nada sirve tener el mejor sensor de temperatura ni el convertidor

analógico digital más exacto sino contamos con un dispositivo que interprete los valores

correctamente, se describirá brevemente a continuación al PIC16F84:

Para las aplicaciones más habituales (casi un 90%) la elección de una versión adecuada

de PIC es la mejor solución; sin embargo, dado su carácter general, otras familias de

microcontroladores son más eficaces en aplicaciones específicas, especialmente si en

ellas predomina una característica concreta, que puede estar muy desarrollada en otra

familia.

Los detalles más importantes de la excelente acogida que tienen los PIC son los

siguientes:

Sencillez de manejo: Tienen un juego de instrucciones reducido; 35 en la gama

media.

Buena información, fácil de conseguir y económica.

Precio: Su coste es comparativamente inferior al de sus competidores.

Poseen una elevada velocidad de funcionamiento. Buen promedio de parámetros:

velocidad, consumo, tamaño, alimentación, código compacto, etc.

Herramientas de desarrollo fáciles y baratas.

Existe una gran variedad de herramientas hardware que permiten grabar, depurar,

borrar y comprobar el comportamiento de los PIC.

Diseño rápido.

La gran variedad de modelos de PIC permite elegir el que mejor responde a los

requerimientos de la aplicación.

Una de las razones del éxito de los PIC se basa en su utilización. Cuando se aprende a

manejar uno de ellos, conociendo su arquitectura y su repertorio de instrucciones, es muy

fácil emplear otro modelo.

Características del PIC16F84:

Memoria RAM de programa de 1K con palabra de 14 bits tipo Flash.

Memoria EEPROM de datos con 68 registros de propósito general.

ALU de 8 bits.

2 puertos de comunicación puerto A de 5 bits y puerto B de 8 bits.

Temporizador con preescaler.

Stack de 8 niveles.

Contador de programa de 13 bits.

Para la visualización de la temperatura se empleará un display de cristal líquido (LCD) de

2 líneas por 16 caracteres (ks0066u), el cual será conectado a la salida del puerto B del

PIC16F84A para enviarle a éste los datos a visualizar, siendo éstos los equivalentes a

números decimales de la palabra digital obtenida del ADC y por el puerto A se enviarán

las señales para controlar el dispositivo.

DESARROLLO DEL TERMÓMETRO DIGITAL

Inicialmente se tiene que considerar la manera como funciona el sensor LM35, que como

anteriormente se mencionó, nos entrega a la salida 10mV por cada grado centígrado.

Como la salida del sensor es en mV dicha salida se convertirá en una cantidad digital para

facilitar su manejo. Para esto se empleará el ADC0804.

Para la conversión analógico – digital el ADC0804 se manipulará de la siguiente manera:

1.- Se habilita el CAD mediante un pulso bajo aplicado a la terminal de CS, para que se

inicie la conversión.

2.- Se habilita la terminal (pulso bajo) denominada WR para que inicie el proceso de

conversión, para esto se debe esperar 100m s aproximadamente para que se lleve a cabo

la conversión.

3.- Se habilita la terminal (pulso bajo) denominada RD para que a la salida se tenga el

resultado de la conversión.

4.- Finalmente se deshabilita el convertidor.

Lo anterior se observa en el siguiente diagrama:

El voltaje de referencia que se manejará en el convertidor se calcula de la siguiente

manera:

Como el LM35 nos entrega a la salida 10mV/°C y la máxima temperatura que puede

detectar es de 150 °C, se tiene que 10mV x 150 = 1.5V, el cual es el máximo voltaje que

nos puede entregar, entonces, en base a este voltaje como es el máximo será el voltaje

de referencia.

Pero como el ADC maneja en su entrada VREF/2 el voltaje de referencia será de 0.75 V.

La corriente que se manejará en dicho voltaje de referencia será de 1mA y el voltaje se

obtendrá de VCC= 5V mediante un divisor de tensión:

La resistencia total del divisor se calcula:

Rt = VCC / Ideseada

Rt = 5V / 1mA = 2.5 kW

El factor que se manejará para poder calcular R1 y R2 del divisor de tensión se calcula:

Vdeseado/ Vtotal = 0.75V / 5V = 0.15

Una vez obtenido el factor se procede a calcular el valor de los resistores:

R1 = 0.15 * 2.5kW = 375W

R2 = 2.5kW - 375W = 2125W

Ahora se comprobará si los valores son correctos:

Vref = (375W /375W +2125W ) * 5V = 0.75 V

Que es el voltaje que se necesita para ajustar los pasos del convertidor a escala

completa.

En lo que respecta al PIC16F84A el programa, para leer el CAD; interpretar el valor de la

conversión y la visualización de la misma, se desarrolló el programa de conforme al

siguiente diagrama de bloques:

Etapa de Amplificación

Simulación amplificador de señal , en el cual podemos observar que ante una señal de

entrada de 100mV (canal B), la señal de salida del amplificador es de 1V (canal A), la

ganancia del amplificador inversor es de 1.10.

Etapa de filtrado

El amplificador operacional esta configurado como filtro pasa bajos, permitiendo el paso

de señales sin atenuación del orden de los 10 Hz, a medida que la frecuencia de la señal

de entrada aumenta, la señal de salida se ve drásticamente atenuada, esto con el fin de

no permitir ruido eléctrico que afecte la medición proveniente de fuentes de

radiofrecuencia como equipos electrónicos o fuentes de iluminación.

Frecuencia de trabajo 10Hz

Señal de entrada canal B, amplitud 800mv

Señal de salida canal A, amplitud 600mv

Frecuencia de trabajo 50Hz

Señal de entrada canal B, amplitud 800mv

Señal de salida canal A, amplitud 200mv

Frecuencia de trabajo 150Hz

Señal de entrada canal B, amplitud 800mv

Señal de salida canal A, amplitud 200mv

DIAGRAMA DE FLUJO DEL TERMÓMETRO MICROCONTROLADO

CÓDIGO DEL PROGRAMA EN LEGUAJE ASSEMBLER

PARA EL MICROCONTROLADOR

Filename: C:\Documents and Settings\Fracica Heyler\Escritorio\pic_c++\Conversor_ADC\Conversor_ADC.lst

ROM used: 721 words (9%)

Largest free fragment is 2048

RAM used: 13 (4%) at main() level

29 (8%) worst case

Stack: 4 locations

0000: MOVLW 00

0001: MOVWF 0A

0002: GOTO 179

0003: NOP

.................... #include "C:\Documents and Settings\Fracica Heyler\Escritorio\pic_c++\Conversor_ADC\Conversor_ADC.h"

.................... #include <16F877A.h>

.................... //////// Standard Header file for the PIC16F877A device ////////////////

.................... #device PIC16F877A

.................... #list

....................

.................... #device *=16

.................... #device adc=8

....................

.................... #FUSES NOWDT //No Watch Dog Timer

.................... #FUSES XT //Crystal osc <= 4mhz

.................... #FUSES PUT //Power Up Timer

.................... #FUSES NOPROTECT //Code not protected from reading

.................... #FUSES NODEBUG //No Debug mode for ICD

.................... #FUSES NOBROWNOUT //No brownout reset

.................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

.................... #FUSES NOCPD //No EE protection

.................... #FUSES WRT_50% //Lower half of Program Memory is Write Protected

....................

.................... #use delay(clock=4000000,RESTART_WDT)

*

0054: MOVLW 2E

0055: MOVWF 04

0056: BCF 03.7

0057: MOVF 00,W

0058: BTFSC 03.2

0059: GOTO 06B

005A: MOVLW 01

005B: MOVWF 78

005C: MOVLW BF

005D: MOVWF 77

005E: CLRWDT

005F: DECFSZ 77,F

0060: GOTO 05E

0061: DECFSZ 78,F

0062: GOTO 05C

0063: MOVLW 4A

0064: MOVWF 77

0065: DECFSZ 77,F

0066: GOTO 065

0067: NOP

0068: CLRWDT

0069: DECFSZ 00,F

006A: GOTO 05A

006B: RETLW 00

....................

....................

.................... #include <LCD.C>

.................... ///////////////////////////////////////////////////////////////////////////

.................... //// LCDD.C ////

.................... //// Driver for common LCD modules ////

.................... //// ////

.................... //// lcd_init() Must be called before any other function. ////

.................... //// ////

.................... //// lcd_putc(c) Will display c on the next position of the LCD. ////

.................... //// The following have special meaning: ////

.................... //// \f Clear display ////

.................... //// \n Go to start of second line ////

.................... //// \b Move back one position ////

.................... //// ////

.................... //// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) ////

.................... //// ////

.................... //// lcd_getc(x,y) Returns character at position x,y on LCD ////

.................... //// ////

.................... ///////////////////////////////////////////////////////////////////////////

.................... //// (C) Copyright 1996,2003 Custom Computer Services ////

.................... //// This source code may only be used by licensed users of the CCS C ////

.................... //// compiler. This source code may only be distributed to other ////

.................... //// licensed users of the CCS C compiler. No other use, reproduction ////

.................... //// or distribution is permitted without written permission. ////

.................... //// Derivative programs created using this software in object code ////

.................... //// form are not restricted in any way. ////

.................... ///////////////////////////////////////////////////////////////////////////

....................

.................... // As defined in the following structure the pin connection is as follows:

.................... // D0 enable

.................... // D1 rs

.................... // D2 rw

.................... // D4 D4

.................... // D5 D5

.................... // D6 D6

.................... // D7 D7

.................... //

.................... // LCD pins D0-D3 are not used and PIC D3 is not used.

....................

.................... // Un-comment the following define to use port B

.................... // #define use_portb_lcd TRUE

....................

....................

.................... struct lcd_pin_map { // This structure is overlayed

.................... BOOLEAN enable; // on to an I/O port to gain

.................... BOOLEAN rs; // access to the LCD pins.

.................... BOOLEAN rw; // The bits are allocated from

.................... BOOLEAN unused; // low order up. ENABLE will

.................... int data : 4; // be pin B0.

.................... } lcd;

....................

....................

.................... #if defined use_portb_lcd

.................... #locate lcd = getenv("sfr:PORTB") // This puts the entire structure over the port

.................... #define set_tris_lcd(x) set_tris_b(x)

.................... #else

.................... #locate lcd = getenv("sfr:PORTD") // This puts the entire structure over the port

.................... #define set_tris_lcd(x) set_tris_d(x)

.................... #endif

....................

....................

.................... #define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines

.................... #define lcd_line_two 0x40 // LCD RAM address for the second line

....................

....................

.................... BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};

.................... // These bytes need to be sent to the LCD

.................... // to start it up.

....................

....................

.................... // The following are used for setting

.................... // the I/O port direction register.

....................

.................... struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out

.................... struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in

....................

....................

....................

.................... BYTE lcd_read_byte() {

.................... BYTE low,high;

.................... set_tris_lcd(LCD_READ);

*

007A: MOVLW F0

007B: BSF 03.5

007C: MOVWF 08

.................... lcd.rw = 1;

007D: BCF 03.5

007E: BSF 08.2

.................... delay_cycles(1);

007F: NOP

.................... lcd.enable = 1;

0080: BSF 08.0

.................... delay_cycles(1);

0081: NOP

.................... high = lcd.data;

0082: MOVF 08,W

0083: SWAPF 08,W

0084: ANDLW 0F

0085: MOVWF 35

.................... lcd.enable = 0;

0086: BCF 08.0

.................... delay_cycles(1);

0087: NOP

.................... lcd.enable = 1;

0088: BSF 08.0

.................... delay_us(1);

0089: CLRWDT

.................... low = lcd.data;

008A: MOVF 08,W

008B: SWAPF 08,W

008C: ANDLW 0F

008D: MOVWF 34

.................... lcd.enable = 0;

008E: BCF 08.0

.................... set_tris_lcd(LCD_WRITE);

008F: MOVLW 00

0090: BSF 03.5

0091: MOVWF 08

.................... return( (high<<4) | low);

0092: BCF 03.5

0093: SWAPF 35,W

0094: MOVWF 77

0095: MOVLW F0

0096: ANDWF 77,F

0097: MOVF 77,W

0098: IORWF 34,W

0099: MOVWF 78

.................... }

....................

....................

.................... void lcd_send_nibble( BYTE n ) {

.................... lcd.data = n;

*

006C: SWAPF 35,W

006D: ANDLW F0

006E: MOVWF 77

006F: MOVLW 0F

0070: ANDWF 08,W

0071: IORWF 77,W

0072: MOVWF 08

.................... delay_cycles(1);

0073: NOP

.................... lcd.enable = 1;

0074: BSF 08.0

.................... delay_us(2);

0075: CLRWDT

0076: NOP

.................... lcd.enable = 0;

0077: BCF 08.0

.................... }

0078: RETLW 00

....................

....................

.................... void lcd_send_byte( BYTE address, BYTE n ) {

....................

.................... lcd.rs = 0;

0079: BCF 08.1

.................... while ( bit_test(lcd_read_byte(),7) ) ;

*

009A: MOVF 78,W

009B: MOVWF 34

009C: BTFSC 34.7

009D: GOTO 07A

.................... lcd.rs = address;

009E: BTFSS 32.0

009F: BCF 08.1

00A0: BTFSC 32.0

00A1: BSF 08.1

.................... delay_cycles(1);

00A2: NOP

.................... lcd.rw = 0;

00A3: BCF 08.2

.................... delay_cycles(1);

00A4: NOP

.................... lcd.enable = 0;

00A5: BCF 08.0

.................... lcd_send_nibble(n >> 4);

00A6: SWAPF 33,W

00A7: MOVWF 34

00A8: MOVLW 0F

00A9: ANDWF 34,F

00AA: MOVF 34,W

00AB: MOVWF 35

00AC: CALL 06C

.................... lcd_send_nibble(n & 0xf);

00AD: MOVF 33,W

00AE: ANDLW 0F

00AF: MOVWF 34

00B0: MOVWF 35

00B1: CALL 06C

.................... }

00B2: RETLW 00

....................

....................

.................... void lcd_init() {

.................... BYTE i;

.................... set_tris_lcd(LCD_WRITE);

00B3: MOVLW 00

00B4: BSF 03.5

00B5: MOVWF 08

.................... lcd.rs = 0;

00B6: BCF 03.5

00B7: BCF 08.1

.................... lcd.rw = 0;

00B8: BCF 08.2

.................... lcd.enable = 0;

00B9: BCF 08.0

.................... delay_ms(15);

00BA: MOVLW 0F

00BB: MOVWF 2E

00BC: CALL 054

.................... for(i=1;i<=3;++i) {

00BD: MOVLW 01

00BE: MOVWF 24

00BF: MOVF 24,W

00C0: SUBLW 03

00C1: BTFSS 03.0

00C2: GOTO 0CB

.................... lcd_send_nibble(3);

00C3: MOVLW 03

00C4: MOVWF 35

00C5: CALL 06C

.................... delay_ms(5);

00C6: MOVLW 05

00C7: MOVWF 2E

00C8: CALL 054

.................... }

00C9: INCF 24,F

00CA: GOTO 0BF

.................... lcd_send_nibble(2);

00CB: MOVLW 02

00CC: MOVWF 35

00CD: CALL 06C

.................... for(i=0;i<=3;++i)

00CE: CLRF 24

00CF: MOVF 24,W

00D0: SUBLW 03

00D1: BTFSS 03.0

00D2: GOTO 0DC

.................... lcd_send_byte(0,LCD_INIT_STRING[i]);

00D3: MOVF 24,W

00D4: CALL 004

00D5: MOVWF 25

00D6: CLRF 32

00D7: MOVF 25,W

00D8: MOVWF 33

00D9: CALL 079

00DA: INCF 24,F

00DB: GOTO 0CF

.................... }

00DC: BCF 0A.3

00DD: BCF 0A.4

00DE: GOTO 1C2 (RETURN)

....................

....................

.................... void lcd_gotoxy( BYTE x, BYTE y) {

.................... BYTE address;

....................

.................... if(y!=1)

*

00F6: DECFSZ 2F,W

00F7: GOTO 0F9

00F8: GOTO 0FC

.................... address=lcd_line_two;

00F9: MOVLW 40

00FA: MOVWF 30

.................... else

00FB: GOTO 0FD

.................... address=0;

00FC: CLRF 30

.................... address+=x-1;

00FD: MOVLW 01

00FE: SUBWF 2E,W

00FF: ADDWF 30,F

.................... lcd_send_byte(0,0x80|address);

0100: MOVF 30,W

0101: IORLW 80

0102: MOVWF 31

0103: CLRF 32

0104: MOVF 31,W

0105: MOVWF 33

0106: CALL 079

.................... }

....................

.................... void lcd_putc( char c) {

.................... switch (c) {

*

00DF: MOVF 2D,W

00E0: XORLW 0C

00E1: BTFSC 03.2

00E2: GOTO 0EA

00E3: XORLW 06

00E4: BTFSC 03.2

00E5: GOTO 0F2

00E6: XORLW 02

00E7: BTFSC 03.2

00E8: GOTO 108

00E9: GOTO 10D

.................... case '\f' : lcd_send_byte(0,1);

00EA: CLRF 32

00EB: MOVLW 01

00EC: MOVWF 33

00ED: CALL 079

.................... delay_ms(2);

00EE: MOVLW 02

00EF: MOVWF 2E

00F0: CALL 054

.................... break;

00F1: GOTO 113

.................... case '\n' : lcd_gotoxy(1,2); break;

00F2: MOVLW 01

00F3: MOVWF 2E

00F4: MOVLW 02

00F5: MOVWF 2F

*

0107: GOTO 113

.................... case '\b' : lcd_send_byte(0,0x10); break;

0108: CLRF 32

0109: MOVLW 10

010A: MOVWF 33

010B: CALL 079

010C: GOTO 113

.................... default : lcd_send_byte(1,c); break;

010D: MOVLW 01

010E: MOVWF 32

010F: MOVF 2D,W

0110: MOVWF 33

0111: CALL 079

0112: GOTO 113

.................... }

.................... }

0113: RETLW 00

....................

.................... char lcd_getc( BYTE x, BYTE y) {

.................... char value;

....................

.................... lcd_gotoxy(x,y);

.................... while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low

.................... lcd.rs=1;

.................... value = lcd_read_byte();

.................... lcd.rs=0;

.................... return(value);

.................... }

....................

....................

.................... void main()

.................... {

*

0179: CLRF 04

017A: BCF 03.7

017B: MOVLW 1F

017C: ANDWF 03,F

017D: BSF 03.5

017E: BSF 1F.0

017F: BSF 1F.1

0180: BSF 1F.2

0181: BCF 1F.3

0182: MOVLW 07

0183: MOVWF 1C

.................... char tecla;

.................... long lectura;

.................... setup_adc_ports(NO_ANALOGS);

*

0187: BSF 03.5

0188: BSF 1F.0

0189: BSF 1F.1

018A: BSF 1F.2

018B: BCF 1F.3

.................... setup_adc(ADC_OFF);

018C: BCF 03.5

018D: BCF 1F.0

.................... setup_psp(PSP_DISABLED);

018E: BSF 03.5

018F: BCF 09.4

.................... setup_spi(SPI_SS_DISABLED);

*

0184: MOVLW FF

0185: BCF 03.5

0186: MOVWF 20

*

0190: BCF 03.5

0191: BCF 14.5

0192: BCF 20.5

0193: MOVF 20,W

0194: BSF 03.5

0195: MOVWF 07

0196: BCF 03.5

0197: BSF 20.4

0198: MOVF 20,W

0199: BSF 03.5

019A: MOVWF 07

019B: BCF 03.5

019C: BCF 20.3

019D: MOVF 20,W

019E: BSF 03.5

019F: MOVWF 07

01A0: MOVLW 01

01A1: BCF 03.5

01A2: MOVWF 14

01A3: MOVLW 00

01A4: BSF 03.5

01A5: MOVWF 14

.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

01A6: MOVF 01,W

01A7: ANDLW C7

01A8: IORLW 08

01A9: MOVWF 01

.................... setup_timer_1(T1_DISABLED);

01AA: BCF 03.5

01AB: CLRF 10

.................... setup_timer_2(T2_DISABLED,0,1);

01AC: MOVLW 00

01AD: MOVWF 78

01AE: MOVWF 12

01AF: MOVLW 00

01B0: BSF 03.5

01B1: MOVWF 12

.................... setup_comparator(NC_NC_NC_NC);

01B2: MOVLW 07

01B3: MOVWF 1C

01B4: MOVF 05,W

01B5: CLRWDT

01B6: MOVLW 02

01B7: MOVWF 77

01B8: DECFSZ 77,F

01B9: GOTO 1B8

01BA: GOTO 1BB

01BB: MOVF 1C,W

01BC: BCF 03.5

01BD: BCF 0D.6

.................... setup_vref(FALSE);

01BE: BSF 03.5

01BF: CLRF 1D

.................... lcd_init();

01C0: BCF 03.5

01C1: GOTO 0B3

.................... SETUP_ADC(AN0_VREF_VREF);

01C2: BSF 03.5

01C3: BCF 1F.6

01C4: BCF 03.5

01C5: BCF 1F.6

01C6: BCF 1F.7

01C7: BSF 03.5

01C8: BCF 1F.7

01C9: BCF 03.5

01CA: BSF 1F.0

.................... SETUP_adc(ADC_CLOCK_DIV_32);

01CB: BSF 03.5

01CC: BCF 1F.6

01CD: BCF 03.5

01CE: BCF 1F.6

01CF: BSF 1F.7

01D0: BSF 03.5

01D1: BCF 1F.7

01D2: BCF 03.5

01D3: BSF 1F.0

.................... set_adc_channel(0);

01D4: MOVLW 00

01D5: MOVWF 78

01D6: MOVF 1F,W

01D7: ANDLW C7

01D8: IORWF 78,W

01D9: MOVWF 1F

.................... delay_ms(100);

01DA: MOVLW 64

01DB: MOVWF 2E

01DC: CALL 054

.................... port_b_pullups(TRUE);

01DD: BSF 03.5

01DE: BCF 01.7

.................... while(1){

.................... lectura=read_adc();

01DF: BCF 03.5

01E0: BSF 1F.2

01E1: BTFSC 1F.2

01E2: GOTO 1E1

01E3: MOVF 1E,W

01E4: CLRF 23

01E5: MOVWF 22

.................... printf(lcd_putc,"\nT=%lu Grados . ",lectura);

01E6: MOVLW 0A

01E7: MOVWF 2D

01E8: CALL 0DF

01E9: MOVLW 54

01EA: MOVWF 2D

01EB: CALL 0DF

01EC: MOVLW 3D

01ED: MOVWF 2D

01EE: CALL 0DF

01EF: MOVLW 10

01F0: MOVWF 04

01F1: MOVF 23,W

01F2: MOVWF 25

01F3: MOVF 22,W

01F4: MOVWF 24

01F5: GOTO 114

01F6: MOVLW 06

01F7: MOVWF 24

01F8: MOVF 24,W

01F9: CALL 00C

01FA: INCF 24,F

01FB: MOVWF 77

01FC: MOVWF 2D

01FD: CALL 0DF

01FE: MOVLW 10

01FF: SUBWF 24,W

0200: BTFSS 03.2

0201: GOTO 1F8

.................... delay_ms(50);

0202: MOVLW 32

0203: MOVWF 2E

0204: CALL 054

.................... if(read_adc()>=38|read_adc()<=36)

0205: BSF 1F.2

0206: BTFSC 1F.2

0207: GOTO 206

0208: MOVF 1E,W

0209: SUBLW 25

020A: BTFSS 03.0

020B: GOTO 20E

020C: MOVLW 00

020D: GOTO 20F

020E: MOVLW 01

020F: MOVWF 25

0210: BSF 1F.2

0211: BTFSC 1F.2

0212: GOTO 211

0213: MOVF 1E,W

0214: SUBLW 24

0215: BTFSC 03.0

0216: GOTO 219

0217: MOVLW 00

0218: GOTO 21A

0219: MOVLW 01

021A: IORWF 25,W

021B: BTFSC 03.2

021C: GOTO 224

.................... output_high(PIN_C0);//Zumbador

021D: BCF 20.0

021E: MOVF 20,W

021F: BSF 03.5

0220: MOVWF 07

0221: BCF 03.5

0222: BSF 07.0

.................... else

0223: GOTO 22A

.................... output_low(PIN_C0);//Zumbador

0224: BCF 20.0

0225: MOVF 20,W

0226: BSF 03.5

0227: MOVWF 07

0228: BCF 03.5

0229: BCF 07.0

.................... delay_ms(50);

022A: MOVLW 32

022B: MOVWF 2E

022C: CALL 054

.................... if(read_adc()<=38)

022D: BSF 1F.2

022E: BTFSC 1F.2

022F: GOTO 22E

0230: MOVF 1E,W

0231: SUBLW 26

0232: BTFSS 03.0

0233: GOTO 23B

.................... output_low(PIN_C2);//Led Amarillo

0234: BCF 20.2

0235: MOVF 20,W

0236: BSF 03.5

0237: MOVWF 07

0238: BCF 03.5

0239: BCF 07.2

.................... else

023A: GOTO 241

.................... output_high(PIN_C2);//Led Amarillo

023B: BCF 20.2

023C: MOVF 20,W

023D: BSF 03.5

023E: MOVWF 07

023F: BCF 03.5

0240: BSF 07.2

.................... delay_ms(500);

0241: MOVLW 02

0242: MOVWF 24

0243: MOVLW FA

0244: MOVWF 2E

0245: CALL 054

0246: DECFSZ 24,F

0247: GOTO 243

.................... if(read_adc()>=36)

0248: BSF 1F.2

0249: BTFSC 1F.2

024A: GOTO 249

024B: MOVF 1E,W

024C: SUBLW 23

024D: BTFSC 03.0

024E: GOTO 256

.................... output_low(PIN_C3);//Led Rojo

024F: BCF 20.3

0250: MOVF 20,W

0251: BSF 03.5

0252: MOVWF 07

0253: BCF 03.5

0254: BCF 07.3

.................... else

0255: GOTO 25C

.................... output_high(PIN_C3);//Led Rojo

0256: BCF 20.3

0257: MOVF 20,W

0258: BSF 03.5

0259: MOVWF 07

025A: BCF 03.5

025B: BSF 07.3

.................... delay_ms(500);

025C: MOVLW 02

025D: MOVWF 24

025E: MOVLW FA

025F: MOVWF 2E

0260: CALL 054

0261: DECFSZ 24,F

0262: GOTO 25E

.................... if(read_adc()>=39)

0263: BSF 1F.2

0264: BTFSC 1F.2

0265: GOTO 264

0266: MOVF 1E,W

0267: SUBLW 26

0268: BTFSC 03.0

0269: GOTO 276

.................... printf(lcd_putc,"\f hipertermia");

026A: CLRF 24

026B: MOVF 24,W

026C: CALL 021

026D: INCF 24,F

026E: MOVWF 77

026F: MOVWF 2D

0270: CALL 0DF

0271: MOVLW 0E

0272: SUBWF 24,W

0273: BTFSS 03.2

0274: GOTO 26B

.................... else

0275: GOTO 2A7

.................... if(read_adc()>=39)

0276: BSF 1F.2

0277: BTFSC 1F.2

0278: GOTO 277

0279: MOVF 1E,W

027A: SUBLW 26

027B: BTFSC 03.0

027C: GOTO 289

.................... printf(lcd_putc,"\f hipertermia");

027D: CLRF 24

027E: MOVF 24,W

027F: CALL 021

0280: INCF 24,F

0281: MOVWF 77

0282: MOVWF 2D

0283: CALL 0DF

0284: MOVLW 0E

0285: SUBWF 24,W

0286: BTFSS 03.2

0287: GOTO 27E

.................... else

0288: GOTO 2A7

.................... if(read_adc()<=36)

0289: BSF 1F.2

028A: BTFSC 1F.2

028B: GOTO 28A

028C: MOVF 1E,W

028D: SUBLW 24

028E: BTFSS 03.0

028F: GOTO 29C

.................... printf(lcd_putc,"\f hipotermia");

0290: CLRF 24

0291: MOVF 24,W

0292: CALL 034

0293: INCF 24,F

0294: MOVWF 77

0295: MOVWF 2D

0296: CALL 0DF

0297: MOVLW 0D

0298: SUBWF 24,W

0299: BTFSS 03.2

029A: GOTO 291

.................... else

029B: GOTO 2A7

.................... printf(lcd_putc,"\f Normal");

029C: CLRF 24

029D: MOVF 24,W

029E: CALL 046

029F: INCF 24,F

02A0: MOVWF 77

02A1: MOVWF 2D

02A2: CALL 0DF

02A3: MOVLW 09

02A4: SUBWF 24,W

02A5: BTFSS 03.2

02A6: GOTO 29D

.................... delay_ms(50);

02A7: MOVLW 32

02A8: MOVWF 2E

02A9: CALL 054

.................... if(read_adc()>=38|read_adc()<=36)

02AA: BSF 1F.2

02AB: BTFSC 1F.2

02AC: GOTO 2AB

02AD: MOVF 1E,W

02AE: SUBLW 25

02AF: BTFSS 03.0

02B0: GOTO 2B3

02B1: MOVLW 00

02B2: GOTO 2B4

02B3: MOVLW 01

02B4: MOVWF 25

02B5: BSF 1F.2

02B6: BTFSC 1F.2

02B7: GOTO 2B6

02B8: MOVF 1E,W

02B9: SUBLW 24

02BA: BTFSC 03.0

02BB: GOTO 2BE

02BC: MOVLW 00

02BD: GOTO 2BF

02BE: MOVLW 01

02BF: IORWF 25,W

02C0: BTFSC 03.2

02C1: GOTO 2C9

.................... output_low(PIN_C1);//Led verde

02C2: BCF 20.1

02C3: MOVF 20,W

02C4: BSF 03.5

02C5: MOVWF 07

02C6: BCF 03.5

02C7: BCF 07.1

.................... else

02C8: GOTO 2CF

.................... output_high(PIN_C1);//Led verde

02C9: BCF 20.1

02CA: MOVF 20,W

02CB: BSF 03.5

02CC: MOVWF 07

02CD: BCF 03.5

02CE: BSF 07.1

....................

.................... }

02CF: GOTO 1E0

.................... }

....................

02D0: SLEEP

CIRCUITO TERM OMETRO DIGITAL

CONCLUSIONES

Los software de simulación de circuitos electrónicos son herramientas muy versátiles y de gran ayuda para el desarrollo y análisis de respuesta para el desarrollo de sistemas electrónicos.

Mediante el uso de software de simulación como Proteus es posible simular señales tanto análogas como digitales como son las señales del cuerpo humano y la respuesta de un microcontrolador respectivamente.

Los costos de desarrollo de un sistema electrónico son altamente reducidos en su tiempo de ejecución y costos de montaje gracias a que estos programas cuenta con un ambiente virtual que permite la simulación de dispositivos de control sin la necesidad de la implementación o montaje real de estos.

El pic 16f877A es una potente herramienta en el manejo de señales análogas y de señales digitales.

Se identificó el contenido temático del curso el cual se desarrolla en este semestre.

Se identificar las intencionalidades formativas así como los objetivos a lograr en pro de la culminación del curso.

BIBLIOGRAFIA.

MODULO DEL CURSO INSTRUMENTACION MEDICA, Universidad Nacional

Abierta y a Distancia UNAD

MICROCHIP, www.microchip.com

Revista de ingeniería electrónica microcontroladores al día

CEKIT, curso de electrónica Industrial

Microcontroladores PIC, Diseño práctico de aplicaciones

José Ma. Ángulo Usategui, Ignacio Ángulo Martínez

2da. edición

Editorial Mc Graw Hill

Págs. 29,30

Quintero,Jorge(2010).Instrumentación Médica. Protocolo y material en línea Extraído el 20de febrero 2013 del sitio web de la Universidad Nacional Abierta y a Distancia: http://campus07.unadvirtual.org/moodle/file.php/95/MODULO_INST/2/protocolo.html