INSTRUMENTACION MÉDICA
TRABAJO COLABORATIVO Nº 2
TERMOMETRO MEDICO
Actividad 6
Presentado por
Andrés Ricardo
González Idarraga
Luis Alberto
Sánchez Correa - CC 16.786.134 de Cali
Henry Andrés
Ramírez Claro – Código 17.593.993
Julián Andrés Ramírez
Presentado a:
ANDRES SAULO
GOMEZ
GRUPO: 299016_5
UNIVERSIDAD
NACIONAL ABIERTA Y A DISTANCIA –
UNAD- PALMIRA
OCTUBRE
2013
INTRODUCCION
El ejercicio
desarrollado en esta práctica colaborativa que
plantearemos a continuación permitirá
la verificación de la
temperatura; el cual
se puede desarrollar
en varios escenarios a
ya sea a
nivel industrial, comercial,
hospitalario, etc. Esto nos puede permitir menores consumos, también control de
temperaturas criticas. El micro controlador es
un componente electrónico en
donde tenemos miles
de transistores, el cual permite realizar un Trabajo según nuestras
necesidades.
El microprocesador es
uno de los logros más sobresalientes del siglo XX. Esas son palabras
atrevidas, y hace
un cuarto de
siglo tal afirmación habría
parecido absurda. Pero cada año, el microprocesador se
acerca más al centro de nuestras vidas, forjándose un
sitio en el núcleo de
una máquina tras
otra. Su presencia ha
comenzado a cambiar
la forma en que
percibimos el mundo
e incluso a nosotros mismos. Cada vez se hace más
difícil pasar por alto
el microprocesador como
otro simple producto en una larga
línea de innovaciones tecnológicas.
La realización del
siguiente trabajo permite obtener una rápida visualización de los contenidos
del módulo instrumentación medica favoreciendo
el repaso y el aprendizaje de manera organizada y jerarquizada rápida
detección de los conceptos clave Como Ingeniería Biomédica, Bioinstrumentación,
Instrumentación Diagnostica, Bioseñal,
etc. así como de las relaciones entre los mismos y como La medición de
los distintos parámetros eléctricos que
intervienen en un proceso de diagnóstico y terapia para diversas enfermedades
comunes. Así el conocimiento de los principios de funcionamiento básico de los
diferentes equipos de electro medicina nos permitirá mejorar las competencias
como profesionales.
II. PLANTEAMIENTO
DEL PROBLEMA
Medidor de temperatura. Primero debemos
especificar qué tipo de
micro controlador debemos o queremos utilizar; debemos proponer con que vamos a
realizar la lectura análoga del
sistema, también si queremos
que sea visualizada
o solamente indicadores de alta o
baja. Especificaremos el rango
de trabajo y para
que será
utilizado; continuaremos con la
estructura básica o
programación para ingresar estos
datos al micro controlador dando los datos de entrada y salidas que se
utilizaran por ultimo compilaremos
el programa y haremos
la verificación por
medio de un software
que nos permita
trabajar con micro controladores.
III. JUSTIFICACIÓN
Actualmente las
mediciones de la temperatura para
procesos industriales,
comerciales, hospitalarios, residenciales es un proceso que
se vive a
diario, debido a esto
nos proponemos hacer
un proyecto de un
medidor de temperatura; pretendiendo a través de esta
propuesta verificar niveles
de temperatura para cualquier ámbito o necesidad planteada Controlador
de temperatura
OBJETIVOS
Objetivo General
·
Utilizar un
sistema de verificación
de temperatura para ser
leído por medio
de un micro controlador por
medio de su
(ADC) y verificado bien sea por
un LCD, display, o leds.
B. Objetivos específicos
·
Se verificaran
diferentes tipos de micro controladores para llegar a utilizar
el más adecuado, también esquemas
de programación para concluir en el mas practico.
·
Se determinaran
los componentes electrónicos a
utilizar.
.
V. MARCO
REFERENCIAL
El modelo
del controlador debe
contar con indicadores o
visualizadores; la temperatura es un
componente importante en
cualquier proceso, por tal
motivo este no
puede ser excluido o estar
ausente.
VI. METODOLOGÍA
·
Investigación acerca
de instrucciones de programación
·
Investigación acerca
de sensores de temperatura eficientes
·
Determinación
de componentes a utilizar
·
Verificar
funcionamiento de programas
·
Organizar
diagramas de flujo
·
Verificación de software a
utilizar
.
CONTENIDO
1. Programa
#
include<16f877.h>
#
device adc=10
#
device *=16
#
use delay (clock=4M)
#include
<lcd.c>
Float
temperatura;
void main()
{
//**************Convertidor de temperatura
//*****************************
setup_adc_ports (RA0_ANALOG);//entrada lm35
setup_adc (ADC_CLOCK_INTERNAL); //***convertidor
analógico digital o reloj interno
setup_COUNTERS (RTCC_internal.rtcc_div_1) ; //marca
división para convertidor
set_adc_channel
(0);
//*********************************
//****************Inicio
del LCD **************
Lcd_init
();//******inicio lcd
Lcd_gotoxy
(2,1);
Printf
(lcd_putc,"Termometro UNAD");
delay_ms(400);
//******************************************
while(true)
{
temperatura= (float)read_adc()/2 ;// lectura convertidor
análogo digital temperatura
lcd_gotoxy (25,1);
printf (lcd_putc,"%f",temperatura); //*****%f
variable flotante***
lcd_gotoxy(33,1);
printf(lcd_putc,"Grados");
delay_ms (300);
//***********************Logica para temperatura Normal
if(temperatura<=39&&temperatura>=36)
{
output_high(pin_c1);
//Led normal ON
output_low(pin_c2);
//Led hipotermia OFF
output_low(pin_c3);
//Led Hipertermia ON
lcd_gotoxy
(6,3); //
printf(lcd_putc,"Normal");
delay_ms(400);
}
//*******************Logica para temperatura alta
if(temperatura<=200&&temperatura>39)
{
output_low(pin_c1);
//Led normal OFF
output_low(pin_c2);
//Led hipotermia OFF
output_high(pin_c3);
//Led Hipertermia ON
lcd_gotoxy
(6,3); //
printf(lcd_putc,"Hipertermia");
delay_ms(400);
lcd_gotoxy
(6,3);
printf(lcd_putc," ");
output_low(pin_c3);
//Led Hipertermia OFF - BLINK
delay_ms(400);
}
//***************************Logica para temperatura es
baja
if(temperatura<36&&temperatura>=2)
{
output_low(pin_c1);
//Led normal OFF
output_high(pin_c2);
//Led hipotermia ON
output_low(pin_c3);
//Led Hipertermia OFF
lcd_gotoxy
(6,3); //
printf(lcd_putc,"Hipotermia");
delay_ms(400);
lcd_gotoxy
(6,3); //
printf(lcd_putc," ");
output_low(pin_c2);
//Led hipotermia OFF - BLINK
delay_ms(400);
}
}
}
PROYECTO EN LENGUAJE ASEMBLER
; CLock : 4 Mhz
; WDT: deshabilitado
; codeprotect: off
;************************************************************************************************************
LIST p=16F877
0000:
MOVLW 04
0001:
MOVWF 0A
0002: GOTO 40B
0003: NOP
# include<16f876.h>
Standard Header file for the PIC16F877 device
////////////////
#device PIC16F877
#list
# device adc=10
# device *=16
# use delay (clock=4M)
*
0034:
MOVLW 33
0035:
MOVWF 04
0036: BCF 03.7
0037: MOVF 00,W
0038: BTFSC 03.2
0039: GOTO 048
003A:
MOVLW 01
003B:
MOVWF 78
003C: CLRF
77
003D: DECFSZ 77,F
003E: GOTO
03D
003F: DECFSZ
78,F
0040: GOTO 03C
0041:
MOVLW 4A
0042:
MOVWF 77
0043: DECFSZ
77,F
0044: GOTO 043
0045: GOTO 046
0046: DECFSZ 00,F
0047: GOTO 03A
0048: RETURN
.................... # include <lcd.c>
....................
///////////////////////////////////////////////////////////////////////////////
.................... //// LCD.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 ////
.................... ////
////
.................... //// CONFIGURATION ////
.................... //// The LCD can be configured in one of two ways:
a.) port access or ////
.................... //// b.) pin access. Port access requires the entire 7 bit
interface ////
.................... //// connected to one GPIO port, and the data bits
(D4:D7 of the LCD) ////
.................... //// connected to sequential pins on the
GPIO. Pin access ////
.................... //// has no requirements, all 7 bits of the
control interface can ////
.................... //// can be connected to any GPIO using several
ports. ////
.................... ////
////
.................... //// To use port access, #define LCD_DATA_PORT to
the SFR location of ////
.................... //// of the GPIO port that holds the interface,
-AND- edit LCD_PIN_MAP ////
.................... //// of this file to configure the pin order. If you are using a ////
.................... //// baseline PIC (PCB), then LCD_OUTPUT_MAP and
LCD_INPUT_MAP also must ////
.................... //// be defined.
////
.................... //// ////
.................... //// Example of port access:
////
.................... //// #define LCD_DATA_PORT
getenv("SFR:PORTD") ////
.................... ////
////
.................... //// To use pin access, the following pins must be
defined: ////
.................... //// LCD_ENABLE_PIN
////
.................... //// LCD_RS_PIN
////
.................... //// LCD_RW_PIN ////
.................... //// LCD_DATA4
////
.................... //// LCD_DATA5
////
.................... //// LCD_DATA6
////
.................... //// LCD_DATA7
////
.................... ////
////
.................... //// Example of pin access:
////
.................... //// #define LCD_ENABLE_PIN PIN_E0 ////
....................
//// #define LCD_RS_PIN PIN_E1 ////
....................
//// #define LCD_RW_PIN PIN_E2 ////
.................... //// #define LCD_DATA4 PIN_D4 ////
.................... //// #define LCD_DATA5 PIN_D5 ////
.................... //// #define LCD_DATA6 PIN_D6 ////
.................... //// #define LCD_DATA7 PIN_D7 ////
.................... ////
////
....................
///////////////////////////////////////////////////////////////////////////////
.................... //// (C) Copyright 1996,2009 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. ////
....................
///////////////////////////////////////////////////////////////////////////
....................
.................... // define the pinout.
.................... // only required if port access
is being used.
.................... typedef struct
.................... { // 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 LSB pin of that port.
....................
#if defined(__PCD__) // The
port used will be LCD_DATA_PORT.
....................
int reserved: 8;
....................
#endif
.................... } LCD_PIN_MAP;
....................
.................... // this is to improve
compatability with previous LCD drivers that accepted
.................... // a define labeled
'use_portb_lcd' that configured the LCD onto port B.
.................... #if ((defined(use_portb_lcd))
&& (use_portb_lcd==TRUE))
....................
#define LCD_DATA_PORT getenv("SFR:PORTB")
.................... #endif
....................
.................... #if defined(__PCB__)
....................
// these definitions only need to be modified for baseline PICs.
....................
// all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions.
.................... /* EN,
RS, RW, UNUSED,
DATA */
....................
const LCD_PIN_MAP LCD_OUTPUT_MAP =
{0, 0, 0,
0, 0};
....................
const LCD_PIN_MAP LCD_INPUT_MAP =
{0, 0, 0,
0, 0xF};
.................... #endif
....................
.................... ////////////////////// END
CONFIGURATION ///////////////////////////////////
....................
.................... #ifndef LCD_ENABLE_PIN
....................
#define lcd_output_enable(x) lcdlat.enable=x
....................
#define lcd_enable_tris()
lcdtris.enable=0
.................... #else
....................
#define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)
....................
#define lcd_enable_tris()
output_drive(LCD_ENABLE_PIN)
.................... #endif
....................
.................... #ifndef LCD_RS_PIN
....................
#define lcd_output_rs(x) lcdlat.rs=x
....................
#define lcd_rs_tris()
lcdtris.rs=0
.................... #else
....................
#define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
....................
#define lcd_rs_tris()
output_drive(LCD_RS_PIN)
.................... #endif
....................
.................... #ifndef LCD_RW_PIN
....................
#define lcd_output_rw(x) lcdlat.rw=x
....................
#define lcd_rw_tris()
lcdtris.rw=0
.................... #else
....................
#define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
....................
#define lcd_rw_tris()
output_drive(LCD_RW_PIN)
.................... #endif
....................
.................... // original version of this
library incorrectly labeled LCD_DATA0 as LCD_DATA4,
.................... // LCD_DATA1 as LCD_DATA5, and so
on. this block of code makes the driver
.................... // compatible with any code written
for the original library
.................... #if (defined(LCD_DATA0)
&& defined(LCD_DATA1) && defined(LCD_DATA2) &&
defined(LCD_DATA3) && !defined(LCD_DATA4) &&
!defined(LCD_DATA5) && !defined(LCD_DATA6) && !defined(LCD_DATA7))
....................
#define LCD_DATA4 LCD_DATA0
....................
#define LCD_DATA5 LCD_DATA1
....................
#define LCD_DATA6 LCD_DATA2
....................
#define LCD_DATA7 LCD_DATA3
.................... #endif
....................
.................... #ifndef LCD_DATA4
.................... #ifndef LCD_DATA_PORT
....................
#if defined(__PCB__)
.................... #define LCD_DATA_PORT 0x06
//portb
.................... #define set_tris_lcd(x) set_tris_b(x)
....................
#else
.................... #if defined(PIN_D0)
.................... #define LCD_DATA_PORT getenv("SFR:PORTD") //portd
.................... #else
.................... #define LCD_DATA_PORT getenv("SFR:PORTB") //portb
.................... #endif
....................
#endif
.................... #endif
....................
.................... #if defined(__PCB__)
....................
LCD_PIN_MAP lcd, lcdlat;
....................
#byte lcd = LCD_DATA_PORT
....................
#byte lcdlat = LCD_DATA_PORT
.................... #elif defined(__PCM__)
....................
LCD_PIN_MAP lcd, lcdlat, lcdtris;
....................
#byte lcd = LCD_DATA_PORT
....................
#byte lcdlat = LCD_DATA_PORT
....................
#byte lcdtris = LCD_DATA_PORT+0x80
.................... #elif defined(__PCH__)
....................
LCD_PIN_MAP lcd, lcdlat, lcdtris;
....................
#byte lcd = LCD_DATA_PORT
....................
#byte lcdlat = LCD_DATA_PORT+9
....................
#byte lcdtris = LCD_DATA_PORT+0x12
.................... #elif defined(__PCD__)
....................
LCD_PIN_MAP lcd, lcdlat, lcdtris;
....................
#word lcd = LCD_DATA_PORT
....................
#word lcdlat = LCD_DATA_PORT+2
....................
#word lcdtris = LCD_DATA_PORT-0x02
.................... #endif
.................... #endif //LCD_DATA4 not defined
....................
.................... #ifndef LCD_TYPE
....................
#define LCD_TYPE 2 //
0=5x7, 1=5x10, 2=2 lines
.................... #endif
....................
.................... #ifndef LCD_LINE_TWO
....................
#define LCD_LINE_TWO 0x40 //
LCD RAM address for the second line
.................... #endif
....................
.................... 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.
....................
.................... BYTE lcd_read_nibble(void);
....................
.................... BYTE lcd_read_byte(void)
.................... {
....................
BYTE low,high;
....................
....................
#if defined(__PCB__)
....................
set_tris_lcd(LCD_INPUT_MAP);
....................
#else
....................
#if (defined(LCD_DATA4) && defined(LCD_DATA5) &&
defined(LCD_DATA6) && defined(LCD_DATA7))
....................
output_float(LCD_DATA4);
....................
output_float(LCD_DATA5);
....................
output_float(LCD_DATA6);
....................
output_float(LCD_DATA7);
....................
#else
....................
lcdtris.data = 0xF;
*
005C:
MOVLW 0F
005D: BSF 03.5
005E:
ANDWF 06,W
005F:
IORLW F0
0060:
MOVWF 06
....................
#endif
....................
#endif
....................
....................
lcd_output_rw(1);
0061: BCF 03.5
0062: BSF 06.2
....................
delay_cycles(1);
0063: NOP
....................
lcd_output_enable(1);
0064: BSF 06.0
....................
delay_cycles(1);
0065: NOP
....................
high = lcd_read_nibble();
0066: CALL 055
0067: MOVF 78,W
0068:
MOVWF 3A
....................
....................
lcd_output_enable(0);
0069: BCF 06.0
....................
delay_cycles(1);
006A: NOP
....................
lcd_output_enable(1);
006B: BSF 06.0
....................
delay_us(1);
006C: NOP
....................
low = lcd_read_nibble();
006D: CALL 055
006E: MOVF 78,W
006F:
MOVWF 39
....................
....................
lcd_output_enable(0);
0070: BCF 06.0
....................
....................
#if defined(__PCB__)
....................
set_tris_lcd(LCD_INPUT_MAP);
....................
#else
....................
#if (defined(LCD_DATA4) && defined(LCD_DATA5) &&
defined(LCD_DATA6) && defined(LCD_DATA7))
....................
output_drive(LCD_DATA4);
....................
output_drive(LCD_DATA5);
....................
output_drive(LCD_DATA6);
....................
output_drive(LCD_DATA7);
....................
#else
....................
lcdtris.data = 0x0;
0071:
MOVLW 0F
0072: BSF 03.5
0073:
ANDWF 06,W
0074:
MOVWF 06
....................
#endif
....................
#endif
....................
....................
return( (high<<4) | low);
0075: BCF 03.5
0076:
SWAPF 3A,W
0077:
MOVWF 77
0078:
MOVLW F0
0079:
ANDWF 77,F
007A: MOVF 77,W
007B:
IORWF 39,W
007C:
MOVWF 78
.................... }
....................
.................... BYTE lcd_read_nibble(void)
.................... {
....................
#if (defined(LCD_DATA4) && defined(LCD_DATA5) &&
defined(LCD_DATA6) && defined(LCD_DATA7))
....................
BYTE n = 0x00;
....................
....................
/* Read the data port */
....................
n |= input(LCD_DATA4);
....................
n |= input(LCD_DATA5) << 1;
....................
n |= input(LCD_DATA6) << 2;
....................
n |= input(LCD_DATA7) << 3;
....................
....................
return(n);
....................
#else
....................
return(lcd.data);
*
0055: MOVF 06,W
0056:
MOVWF 77
0057:
SWAPF 06,W
0058:
ANDLW 0F
0059: MOVWF 78
....................
#endif
.................... }
005A: RETURN
....................
.................... void lcd_send_nibble(BYTE n)
.................... {
....................
#if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6)
&& defined(LCD_DATA7))
....................
/* Write to the data port */
....................
output_bit(LCD_DATA4, bit_test(n, 0));
....................
output_bit(LCD_DATA5, bit_test(n, 1));
....................
output_bit(LCD_DATA6, bit_test(n, 2));
....................
output_bit(LCD_DATA7, bit_test(n, 3));
....................
#else
....................
lcdlat.data = n;
*
0049:
SWAPF 3A,W
004A:
ANDLW F0
004B:
MOVWF 77
004C:
MOVLW 0F
004D:
ANDWF 06,W
004E:
IORWF 77,W
004F:
MOVWF 06
....................
#endif
....................
....................
delay_cycles(1);
0050: NOP
....................
lcd_output_enable(1);
0051: BSF 06.0
....................
delay_us(2);
0052: GOTO 053
....................
lcd_output_enable(0);
0053: BCF 06.0
.................... }
0054: RETURN
....................
.................... void lcd_send_byte(BYTE address,
BYTE n)
.................... {
....................
lcd_output_rs(0);
*
005B: BCF 06.1
....................
while ( bit_test(lcd_read_byte(),7) ) ;
*
007D: MOVF
78,W
007E: MOVWF
39
007F:
BTFSC 39.7
0080: GOTO 05C
....................
lcd_output_rs(address);
0081:
BTFSS 37.0
0082: BCF 06.1
0083:
BTFSC 37.0
0084: BSF 06.1
....................
delay_cycles(1);
0085: NOP
....................
lcd_output_rw(0);
0086: BCF 06.2
....................
delay_cycles(1);
0087: NOP
....................
lcd_output_enable(0);
0088: BCF 06.0
....................
lcd_send_nibble(n >> 4);
0089:
SWAPF 38,W
008A:
MOVWF 39
008B:
MOVLW 0F
008C:
ANDWF 39,F
008D: MOVF
39,W
008E: MOVWF
3A
008F: CALL 049
....................
lcd_send_nibble(n & 0xf);
0090: MOVF 38,W
0091:
ANDLW 0F
0092:
MOVWF 39
0093:
MOVWF 3A
0094: CALL 049
.................... }
0095: RETURN
....................
.................... void lcd_init(void)
.................... {
....................
BYTE i;
....................
....................
#if defined(__PCB__)
....................
set_tris_lcd(LCD_OUTPUT_MAP);
....................
#else
....................
#if (defined(LCD_DATA4) && defined(LCD_DATA5) &&
defined(LCD_DATA6) && defined(LCD_DATA7))
....................
output_drive(LCD_DATA4);
....................
output_drive(LCD_DATA5);
....................
output_drive(LCD_DATA6);
....................
output_drive(LCD_DATA7);
....................
#else
....................
lcdtris.data = 0x0;
0096:
MOVLW 0F
0097: BSF 03.5
0098:
ANDWF 06,W
0099:
MOVWF 06
....................
#endif
....................
lcd_enable_tris();
009A: BCF 06.0
....................
lcd_rs_tris();
009B: BCF 06.1
....................
lcd_rw_tris();
009C: BCF 06.2
....................
#endif
....................
....................
lcd_output_rs(0);
009D: BCF 03.5
009E: BCF 06.1
....................
lcd_output_rw(0);
009F: BCF 06.2
....................
lcd_output_enable(0);
00A0: BCF 06.0
....................
....................
delay_ms(15);
00A1:
MOVLW 0F
00A2:
MOVWF 33
00A3: CALL 034
....................
for(i=1;i<=3;++i)
00A4:
MOVLW 01
00A5: MOVWF 25
00A6: MOVF 25,W
00A7:
SUBLW 03
00A8:
BTFSS 03.0
00A9: GOTO 0B2
....................
{
.................... lcd_send_nibble(3);
00AA:
MOVLW 03
00AB:
MOVWF 3A
00AC: CALL 049
.................... delay_ms(5);
00AD: MOVLW 05
00AE:
MOVWF 33
00AF: CALL 034
....................
}
00B0: INCF 25,F
00B1: GOTO 0A6
....................
....................
lcd_send_nibble(2);
00B2:
MOVLW 02
00B3:
MOVWF 3A
00B4: CALL 049
....................
for(i=0;i<=3;++i)
00B5: CLRF 25
00B6: MOVF 25,W
00B7:
SUBLW 03
00B8:
BTFSS 03.0
00B9: GOTO 0C3
.................... lcd_send_byte(0,LCD_INIT_STRING[i]);
00BA: MOVF 25,W
00BB: CALL 004
00BC:
MOVWF 26
00BD: CLRF 37
00BE: MOVF 26,W
00BF:
MOVWF 38
00C0: CALL 05B
00C1: INCF 25,F
00C2: GOTO 0B6
.................... }
00C3: BCF 0A.3
00C4: BCF 0A.4
00C5: GOTO 43B (RETURN)
....................
.................... void lcd_gotoxy(BYTE x, BYTE y)
.................... {
....................
BYTE address;
....................
....................
if(y!=1)
00C6: DECFSZ
34,W
00C7: GOTO 0C9
00C8: GOTO 0CC
.................... address=LCD_LINE_TWO;
00C9:
MOVLW 40
00CA:
MOVWF 35
....................
else
00CB: GOTO 0CD
.................... address=0;
00CC: CLRF 35
....................
....................
address+=x-1;
00CD:
MOVLW 01
00CE:
SUBWF 33,W
00CF:
ADDWF 35,F
....................
lcd_send_byte(0,0x80|address);
00D0: MOVF 35,W
00D1:
IORLW 80
00D2:
MOVWF 36
00D3: CLRF 37
00D4: MOVF 36,W
00D5:
MOVWF 38
00D6: CALL 05B
.................... }
00D7: RETURN
....................
.................... void lcd_putc(char c)
.................... {
....................
switch (c)
....................
{
00D8: MOVF 32,W
00D9:
XORLW 0C
00DA: BTFSC
03.2
00DB: GOTO
0E3
00DC: XORLW
06
00DD: BTFSC
03.2
00DE: GOTO
0EB
00DF: XORLW
02
00E0: BTFSC
03.2
00E1: GOTO
0F1
00E2: GOTO
0F6
.................... case '\f' :
lcd_send_byte(0,1);
00E3: CLRF
37
00E4: MOVLW
01
00E5: MOVWF
38
00E6: CALL 05B
.................... delay_ms(2);
00E7: MOVLW
02
00E8: MOVWF
33
00E9: CALL
034
.................... break;
00EA: GOTO 0FC
....................
.................... case '\n' : lcd_gotoxy(1,2); break;
00EB:
MOVLW 01
00EC:
MOVWF 33
00ED:
MOVLW 02
00EE:
MOVWF 34
00EF: CALL 0C6
00F0: GOTO 0FC
....................
.................... case '\b' : lcd_send_byte(0,0x10); break;
00F1: CLRF 37
00F2:
MOVLW 10
00F3:
MOVWF 38
00F4: CALL 05B
00F5: GOTO 0FC
....................
.................... default : lcd_send_byte(1,c); break;
00F6:
MOVLW 01
00F7:
MOVWF 37
00F8: MOVF 32,W
00F9:
MOVWF 38
00FA: CALL 05B
00FB: GOTO 0FC
....................
}
.................... }
00FC: RETURN
....................
....................
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_output_rs(1);
....................
value = lcd_read_byte();
....................
lcd_output_rs(0);
....................
....................
return(value);
.................... }
....................
.................... Float temperatura;
.................... void main()
.................... {
*
0033: DATA
00,00
*
040B: CLRF 04
040C: BCF 03.7
040D:
MOVLW 1F
040E:
ANDWF 03,F
040F: BSF 03.5
0410: BSF 1F.0
0411: BSF 1F.1
0412: BSF
1F.2
0413: BCF
1F.3
....................
//**************Convertidor de temperatura
.................... //*****************************
.................... setup_adc_ports (RA0_ANALOG);//entrada
lm35
*
0417: BSF 03.5
0418: BCF 1F.0
0419: BSF 1F.1
041A: BSF 1F.2
041B: BSF
1F.3
....................
setup_adc (ADC_CLOCK_INTERNAL); //***convertidor analógico digital o reloj
interno
041C: BCF
03.5
041D: BSF
1F.6
041E: BSF
1F.7
041F: BSF 03.5
0420: BSF 1F.7
0421: BCF 03.5
0422: BSF
1F.0
....................
setup_COUNTERS (RTCC_internal.rtcc_div_1) ; //marca división para convertidor
0423:
MOVLW 08
0424:
MOVWF 77
0425: CLRF 01
0426: MOVLW 81
0427:
MOVWF 04
0428: BCF 03.7
0429: MOVF 00,W
042A:
ANDLW C0
042B:
IORLW 07
042C:
MOVWF 00
042D: CLRWDT
042E: MOVF 00,W
042F:
ANDLW C7
0430:
BTFSC 77.3
0431:
ANDLW C0
0432:
IORWF 77,W
0433:
MOVWF 00
.................... set_adc_channel (0);
0434:
MOVLW 00
0435:
MOVWF 78
0436: MOVF 1F,W
0437:
ANDLW C7
0438:
IORWF 78,W
0439: MOVWF
1F
....................
//*********************************
....................
//****************Inicio del LCD **************
.................... Lcd_init ();//******inicio lcd
043A: GOTO 096
.................... Lcd_gotoxy (2,1);
043B:
MOVLW 02
043C:
MOVWF 33
043D:
MOVLW 01
043E:
MOVWF 34
043F: CALL 0C6
....................
Printf (lcd_putc,"Termometro UNAD");
0440:
MOVLW 0C
0441: BSF 03.6
0442:
MOVWF 0D
0443:
MOVLW 00
0444:
MOVWF 0F
0445: BCF 03.6
0446: CALL 0FD
.................... delay_ms(400);
0447:
MOVLW 02
0448:
MOVWF 25
0449:
MOVLW C8
044A:
MOVWF 33
044B: CALL 034
044C: DECFSZ
25,F
044D: GOTO
449
....................
//******************************************
....................
....................
....................
while(true)
.................... {
....................
temperatura= (float)read_adc()/2 ;// lectura convertidor análogo digital
temperatura
044E: BSF
1F.2
044F: BTFSC
1F.2
0450: GOTO
44F
0451: MOVF
1E,W
0452: MOVWF
7A
0453: BSF
03.5
0454: MOVF
1E,W
0455: BCF
03.5
0456: MOVWF
25
0457: MOVF
1E,W
0458:
MOVWF 26
0459: GOTO 143
045A: MOVF 77,W
045B:
MOVWF 25
045C: MOVF 78,W
045D:
MOVWF 26
045E: MOVF 79,W
045F:
MOVWF 27
0460: MOVF 7A,W
0461:
MOVWF 28
0462:
MOVWF 2C
0463: MOVF 79,W
0464:
MOVWF 2B
0465: MOVF 78,W
0466:
MOVWF 2A
0467: MOVF 77,W
0468:
MOVWF 29
0469: CLRF 30
046A: CLRF 2F
046B: CLRF 2E
046C:
MOVLW 80
046D:
MOVWF 2D
046E: GOTO 162
046F: MOVF 7A,W
0470:
MOVWF 23
0471: MOVF 79,W
0472:
MOVWF 22
0473: MOVF 78,W
0474:
MOVWF 21
0475: MOVF 77,W
0476:
MOVWF 20
.................... lcd_gotoxy (25,1);
0477:
MOVLW 19
0478:
MOVWF 33
0479:
MOVLW 01
047A:
MOVWF 34
047B: CALL 0C6
....................
printf (lcd_putc,"%f",temperatura); //*****%f variable flotante***
047C:
MOVLW 89
047D:
MOVWF 04
047E: MOVF 23,W
047F:
MOVWF 28
0480: MOVF 22,W
0481:
MOVWF 27
0482: MOVF 21,W
0483:
MOVWF 26
0484: MOVF 20,W
0485:
MOVWF 25
0486:
MOVLW 02
0487:
MOVWF 29
0488: GOTO 270
.................... lcd_gotoxy(33,1);
0489:
MOVLW 21
048A:
MOVWF 33
048B:
MOVLW 01
048C:
MOVWF 34
048D: CALL 0C6
....................
printf(lcd_putc,"Grados");
048E: MOVLW
14
048F: BSF 03.6
0490:
MOVWF 0D
0491:
MOVLW 00
0492:
MOVWF 0F
0493: BCF 03.6
0494: CALL 0FD
.................... delay_ms (300);
0495:
MOVLW 02
0496:
MOVWF 25
0497:
MOVLW 96
0498:
MOVWF 33
0499: CALL 034
049A: DECFSZ
25,F
049B: GOTO 497
....................
//***********************Logica para temperatura Normal
....................
if(temperatura<=39&&temperatura>=36)
049C: MOVF
23,W
049D: MOVWF
28
049E: MOVF
22,W
049F: MOVWF
27
04A0: MOVF
21,W
04A1: MOVWF
26
04A2: MOVF
20,W
04A3:
MOVWF 25
04A4: CLRF 2C
04A5: CLRF 2B
04A6:
MOVLW 1C
04A7:
MOVWF 2A
04A8:
MOVLW 84
04A9:
MOVWF 29
04AA: CALL 3CC
04AB:
BTFSC 03.0
04AC: GOTO 4AF
04AD:
BTFSS 03.2
04AE: GOTO
4E7
04AF: CLRF
28
04B0: CLRF 27
04B1:
MOVLW 10
04B2:
MOVWF 26
04B3:
MOVLW 84
04B4:
MOVWF 25
04B5: MOVF 23,W
04B6: MOVWF 2C
04B7: MOVF 22,W
04B8:
MOVWF 2B
04B9: MOVF 21,W
04BA:
MOVWF 2A
04BB: MOVF 20,W
04BC:
MOVWF 29
04BD: CALL 3CC
04BE:
BTFSC 03.0
04BF: GOTO 4C2
04C0:
BTFSS 03.2
04C1: GOTO 4E7
.................... {
.................... output_high(pin_c1); //Led normal
ON
04C2: BCF 24.1
04C3: MOVF 24,W
04C4: BSF 03.5
04C5:
MOVWF 07
04C6: BCF 03.5
04C7: BSF 07.1
.................... output_low(pin_c2); //Led
hipotermia OFF
04C8: BCF 24.2
04C9: MOVF 24,W
04CA: BSF 03.5
04CB:
MOVWF 07
04CC: BCF 03.5
04CD: BCF 07.2
.................... output_low(pin_c3); //Led
Hipertermia ON
04CE: BCF 24.3
04CF: MOVF 24,W
04D0: BSF 03.5
04D1:
MOVWF 07
04D2: BCF 03.5
04D3: BCF 07.3
.................... lcd_gotoxy (6,3); //
04D4:
MOVLW 06
04D5:
MOVWF 33
04D6:
MOVLW 03
04D7:
MOVWF 34
04D8: CALL 0C6
....................
printf(lcd_putc,"Normal");
04D9: MOVLW
18
04DA: BSF
03.6
04DB:
MOVWF 0D
04DC:
MOVLW 00
04DD:
MOVWF 0F
04DE: BCF 03.6
04DF: CALL 0FD
....................
delay_ms(400);
04E0: MOVLW
02
04E1: MOVWF
25
04E2: MOVLW
C8
04E3: MOVWF
33
04E4: CALL
034
04E5: DECFSZ 25,F
04E6: GOTO
4E2
....................
}
....................
//*******************Logica para temperatura alta
....................
if(temperatura<=200&&temperatura>39)
04E7: MOVF
23,W
04E8: MOVWF
28
04E9: MOVF
22,W
04EA: MOVWF
27
04EB: MOVF 21,W
04EC:
MOVWF 26
04ED: MOVF 20,W
04EE:
MOVWF 25
04EF: CLRF 2C
04F0: CLRF 2B
04F1:
MOVLW 48
04F2:
MOVWF 2A
04F3:
MOVLW 86
04F4:
MOVWF 29
04F5: CALL 3CC
04F6:
BTFSC 03.0
04F7: GOTO 4FA
04F8:
BTFSS 03.2
04F9: GOTO 549
04FA: CLRF 28
04FB: CLRF 27
04FC:
MOVLW 1C
04FD:
MOVWF 26
04FE: MOVLW 84
04FF:
MOVWF 25
0500: MOVF 23,W
0501:
MOVWF 2C
0502: MOVF 22,W
0503:
MOVWF 2B
0504: MOVF 21,W
0505:
MOVWF 2A
0506: MOVF 20,W
0507:
MOVWF 29
0508: CALL 3CC
0509:
BTFSS 03.0
050A: GOTO 549
.................... {
.................... output_low(pin_c1); //Led normal
OFF
050B: BCF 24.1
050C: MOVF 24,W
050D: BSF 03.5
050E: MOVWF
07
050F: BCF
03.5
0510: BCF
07.1
.................... output_low(pin_c2); //Led
hipotermia OFF
0511: BCF 24.2
0512: MOVF 24,W
0513: BSF 03.5
0514:
MOVWF 07
0515: BCF 03.5
0516: BCF 07.2
.................... output_high(pin_c3); //Led
Hipertermia ON
0517: BCF 24.3
0518: MOVF 24,W
0519: BSF 03.5
051A:
MOVWF 07
051B: BCF 03.5
051C: BSF 07.3
.................... lcd_gotoxy (6,3); //
051D:
MOVLW 06
051E:
MOVWF 33
051F:
MOVLW 03
0520:
MOVWF 34
0521: CALL 0C6
....................
printf(lcd_putc,"Hipertermia");
0522:
MOVLW 1C
0523: BSF 03.6
0524:
MOVWF 0D
0525:
MOVLW 00
0526:
MOVWF 0F
0527: BCF 03.6
0528: CALL 0FD
.................... delay_ms(400);
0529:
MOVLW 02
052A:
MOVWF 25
052B:
MOVLW C8
052C:
MOVWF 33
052D: CALL 034
052E: DECFSZ
25,F
052F: GOTO 52B
.................... lcd_gotoxy (6,3);
0530:
MOVLW 06
0531:
MOVWF 33
0532:
MOVLW 03
0533:
MOVWF 34
0534: CALL 0C6
.................... printf(lcd_putc," ");
0535:
MOVLW 22
0536: BSF 03.6
0537:
MOVWF 0D
0538:
MOVLW 00
0539:
MOVWF 0F
053A: BCF 03.6
053B: CALL 0FD
.................... output_low(pin_c3); //Led
Hipertermia OFF - BLINK
053C: BCF 24.3
053D: MOVF 24,W
053E: BSF 03.5
053F:
MOVWF 07
0540: BCF 03.5
0541: BCF 07.3
.................... delay_ms(400);
0542:
MOVLW 02
0543: MOVWF 25
0544:
MOVLW C8
0545:
MOVWF 33
0546: CALL 034
0547: DECFSZ 25,F
0548: GOTO
544
.................... }
....................
//***************************Logica para temperatura es baja
....................
if(temperatura<36&&temperatura>=2)
0549: MOVF 23,W
054A:
MOVWF 28
054B: MOVF 22,W
054C:
MOVWF 27
054D: MOVF 21,W
054E:
MOVWF 26
054F: MOVF 20,W
0550:
MOVWF 25
0551: CLRF 2C
0552: CLRF 2B
0553:
MOVLW 10
0554:
MOVWF 2A
0555:
MOVLW 84
0556:
MOVWF 29
0557: CALL 3CC
0558:
BTFSS 03.0
0559: GOTO 5AA
055A: CLRF 28
055B: CLRF 27
055C: CLRF 26
055D:
MOVLW 80
055E:
MOVWF 25
055F: MOVF 23,W
0560:
MOVWF 2C
0561: MOVF 22,W
0562:
MOVWF 2B
0563: MOVF 21,W
0564:
MOVWF 2A
0565: MOVF 20,W
0566:
MOVWF 29
0567: CALL 3CC
0568:
BTFSC 03.0
0569: GOTO 56C
056A:
BTFSS 03.2
056B: GOTO 5AA
.................... {
.................... output_low(pin_c1); //Led normal
OFF
056C: BCF 24.1
056D: MOVF 24,W
056E: BSF 03.5
056F:
MOVWF 07
0570: BCF 03.5
0571: BCF 07.1
.................... output_high(pin_c2); //Led
hipotermia ON
0572: BCF 24.2
0573: MOVF 24,W
0574: BSF 03.5
0575:
MOVWF 07
0576: BCF 03.5
0577: BSF 07.2
.................... output_low(pin_c3); //Led
Hipertermia OFF
0578: BCF 24.3
0579: MOVF 24,W
057A: BSF 03.5
057B:
MOVWF 07
057C: BCF 03.5
057D: BCF 07.3
.................... lcd_gotoxy (6,3); //
057E:
MOVLW 06
057F:
MOVWF 33
0580:
MOVLW 03
0581: MOVWF 34
0582: CALL 0C6
....................
printf(lcd_putc,"Hipotermia");
0583: MOVLW
28
0584: BSF 03.6
0585:
MOVWF 0D
0586:
MOVLW 00
0587:
MOVWF 0F
0588: BCF 03.6
0589: CALL 0FD
.................... delay_ms(400);
058A: MOVLW 02
058B:
MOVWF 25
058C:
MOVLW C8
058D:
MOVWF 33
058E: CALL 034
058F: DECFSZ
25,F
0590: GOTO 58C
.................... lcd_gotoxy (6,3); //
0591:
MOVLW 06
0592:
MOVWF 33
0593:
MOVLW 03
0594:
MOVWF 34
0595: CALL 0C6
.................... printf(lcd_putc," ");
0596:
MOVLW 2E
0597: BSF 03.6
0598:
MOVWF 0D
0599:
MOVLW 00
059A:
MOVWF 0F
059B: BCF 03.6
059C: CALL 0FD
.................... output_low(pin_c2); //Led
hipotermia OFF - BLINK
059D: BCF 24.2
059E: MOVF 24,W
059F: BSF 03.5
05A0:
MOVWF 07
05A1: BCF 03.5
05A2: BCF 07.2
.................... delay_ms(400);
05A3:
MOVLW 02
05A4:
MOVWF 25
05A5:
MOVLW C8
05A6:
MOVWF 33
05A7: CALL 034
05A8: DECFSZ 25,F
05A9: GOTO
5A5
.................... }
.................... }
05AA: GOTO
44E
.................... }
....................
....................
05AB: SLEEP
BIBLIOGRAFIA
·
Quintero, J.
(2013). Instrumentación Médica (1
edición), Bogotá, Universidad Nacional
Abierta Y A Distancia.
·
www.monografias.com/trabajos11
·
www.renovae.org
·
www.microchip.com
No hay comentarios.:
Publicar un comentario