Actividad 10 Colaborativo 2

UNIVERSIDAD NACIONAL ABIERTA y a DISTANCIA
ZONA CENTRO BOGOT CUNDINAMARCA

CEAD JOS ACEVEDO y GMEZ
ESCUELA Ciencias Bsicas, Tecnologas e Ingenieras - ECBTI
ACTIVIDAD 6
TRABAJO COLABORATIVO 1
INSTRUMENTACION MDICA
GRUPO
299016-3
INTEGRANTE
ANGEL MARIN GARCIA

COD: 4375696
TUTOR: INGENIERO
SAULO ANDRES
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BSICAS, TECNOLOGA E INGENIERA
(OCTUBRE 2015)
INTRODUCCION
Antes del ao 1900, la medicina se basaba principalmente en el medico, un bolso

negro, y medicinas empricas. El hospital era ms bien un tipo de asilo.
Es hasta el siglo XX que se da un rpido avance tecnolgico y cientfico,

convirtiendo al hospital como el punto focal de la medicina, y utilizando tecnologa
para el diagnstico y tratamiento de patologas.
Por medio del siguiente trabajo se pretende poner en evidencia la alianza que ha
tenido a medicina con la electrnica, permitiendo desarrollar instrumentos de
medicin, diagnstico y procedimientos quirrgicos basados en una nica finalidad
que es salvar vidas.
Encontraran el desarrollo de un Estimulador muscular basado en la electrnica para

la estimulacin de tejidos musculares a travs de corrientes elctricas, las cuales
son usadas para diversos fines el primero puede ser con fin teraputico para hacer
la estimulacin a diversas partes del cuerpo, sirve para la recuperacin muscular
cuando hubo accidentes donde se pierda la movilidad, tambin es usado para hacer
adelgazamiento en zonas que prefiera la persona haciendo que halla un
calentamiento interno y as se genere un disminucin de grasa.
OBJETIVOS
Organizar tareas colectivas aportando y superando las dificultades que se

presenten, con una actitud tolerante hacia las ideas de los compaeros.
Definir mediante acuerdos, responsabilidades individuales que faciliten el

verdadero trabajo en equipo.
Desarrollar habilidades en el planteamiento e interpretacin de problemas,

diseo de soluciones y desarrollo de programas.
Interpretar y aplicar las caractersticas de las estructuras de datos y

reconocer su importancia en la codificacin de programas de lenguaje
estructurado.
Definir y proponer cambios en la mejora del planteamiento y solucin de los

programas.
Trabajar en grupo para realizar la construccin del trabajo colaborativo,

realizando aportes que contribuyan a la buena elaboracin del trabajo.
Interpretar y aplicar las caractersticas de las estructuras de datos y

reconocer su importancia en la codificacin de programas de lenguaje
estructurado.
ACTIVIDAD
Desarrollar el software de programacin de un micro controlador en lenguaje

assembler, aplicado al mdulo de puente H de un equipo de electroterapia del
capitulo 10, numeral 10.5 para generar las ondas electro teraputicas de las figuras
121 a 125, que cumpla con las siguientes condiciones:
1. El microcontrolador ser el PIC16F87.

2. Debe simularse con Proteus.
ESTIMULACIN MUSCULAR
La electro estimulacin es la tcnica que utiliza la corriente elctrica, para provocar

una contraccin muscular, mediante un aparato llamado electro estimulador, para
prevenir, entrenar o tratar los msculos, buscando una finalidad teraputica o una
mejora de su rendimiento.
La tcnica de la electro estimulacin viene emplendose en la rehabilitacin desde

hace mucho tiempo, aportando importantes beneficios en ste campo, sobre todo
para resolver las patologas musculares ms comunes como son: La prevencin y
el tratamiento de la atrofia muscular, la potenciacin, las contracturas, el aumento
de la fuerza para la estabilidad articular, la profilaxis de la trombosis, y la
estimulacin de los msculos paralizados, entre otros, y tambin para el tratamiento
del dolor.
En las personas normalmente inervadas (todas excepto los para y tetrapljicos) el
impulso elctrico no estimula directamente la fibra muscular, sino que lo hace a
travs del nervio motor (motoneuronas), --que slo necesitar una cantidad muy
pequea de energa elctrica-- para conseguir un estmulo eficaz.
QU ES UN ELECTROESTIMULADOR?
Un electro estimulador es un generador de corriente, que produce impulsos

elctricos con la energa suficiente para generar un potencial de accin (PA) en las
clulas excitables: musculares o nerviosas (sensitivas con resultados analgsicos
y eferentes con resultados excitomotrices), y as modificar su estado habitual, que
es el reposo.
QU TIPO DE ESTIMULADOR DEBEMOS UTILIZAR?
Debemos utilizar un aparato de baja frecuencia (de 1 a 120 impulsos por segundo
-Hz-) que nos asegure una contraccin muscular potente, visible y fisiolgica,
exenta de sensaciones elctricas desagradables y que no produzca irritaciones o
quemaduras en la piel como pueden llegar a hacer algunos aparatos.
QU FORMA DEBE TENER LA ONDA ELCTRICA FABRICADA POR EL

ESTIMULADOR?
La onda que debe construir el estimulador, es una informacin imprescindible que

debe indicar el fabricante en las especificaciones tcnicas insertas en los manuales
y deber ser: rectangular- bifsica, y compensada simtricamente, para evitar los
desagradables y temidos efectos polares (sensacin elctrica, irritacin de la piel y
hasta quemaduras), en el lugar de ubicacin de los electrodos por donde pasa la

corriente.
Las corrientes de tipo galvnico estn desaconsejadas, por el elevado riesgo de
quemaduras qumico-elctricas y por la desagradable sensacin de electricidad que
se percibe a intensidades incluso bajas.
PULSOS AISLADOS POSITIVOS
Para obtener pulsos aislados positivos es necesario que el microcontrolador

genere la tensin VG1-3 de pulsos con las condiciones de tiempos TON desde
0.005 ms a 1 s y TOFF desde 1 a 5 s, mientras que la tensin VG2-4 ser todo el
tiempo en cero.
PULSOS AISLADOS NEGATIVOS
Para obtener pulsos aislados negativos, el microcontrolador genera la tensin

VG2-4 con las condiciones anteriores, mientras que la tensin en VG1-3 ser
siempre de cero.
PULSOS MONOFSICOS MANTENIDOS POSITIVOS O NEGATIVOS
Se disminuye el T OFF desde 5 a 20 ms a valores similares de los T ON 0.1 a 5

ms con las mismas tensiones de control para las figuras anteriores.
TRENES DE PULSOS
El micocontrolador es programado con los tiempos de encendido y apagado de los

impulsos descritos anteriormente pero adicionalmente se temporiza durante
cunto tiempo se aplican T ON 2 de 1 a 20 s y durante cunto tiempo no se aplica
T OFF 2 1 a 40 s
PULSOS BIFSICOS
El microcontrolador debe generar los pulsos de puerta negados, es decir, cuando

estn presentes VG1-3 las VG2-4 deben estar en cero y viceversa.
CIRCUITO ELECTRICO EN PROTEUS.

PULSOS BIFSICOS
TRENES DE PULSOS
PULSOS MONOFSICOS
PULSOS AISLADOS
PROGRAMA EN ENSAMBLADOR
CCS PCM C Compiler, Version 4.084, 40722 21-abr-14 21:21
Filename: C:\Users\USR\Desktop\ghsgthstrhrthhst\main.lst
ROM used: 1945 words (24%)

Largest free fragment is 2048
RAM used: 17 (5%) at main() level
32 (9%) worst case
Stack: 2 locations
*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 2C0
0003: NOP
.................... #include "C:\Users\USR\Desktop\ghsgthstrhrthhst\main.h"
.................... #include <16F877A.h>
.................... //////// Standard Header file for the PIC16F877A device ////////////////
.................... #device PIC16F877A
.................... #list
....................
.................... #device adc=8
....................
.................... #FUSES NOWDT //No Watch Dog Timer
.................... #FUSES HS //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
.................... #FUSES PUT //Power Up Timer
.................... #FUSES PROTECT //Code protected from reads
.................... #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 NOWRT //Program memory not write protected
....................
.................... #use delay(clock=10000000)
*
000C: MOVLW 2B
000D: MOVWF 04
000E: BCF 03.7
000F: MOVF 00,W
0010: BTFSC 03.2
0011: GOTO 020
0012: MOVLW 03
0013: MOVWF 78
0014: CLRF 77
0015: DECFSZ 77,F
0016: GOTO 015
0017: DECFSZ 78,F
0018: GOTO 014
0019: MOVLW 3C
001A: MOVWF 77
001B: DECFSZ 77,F
001C: GOTO 01B
001D: GOTO 01E
001E: DECFSZ 00,F
001F: GOTO 012
0020: RETLW 00
0056: MOVLW F0
0057: BSF 03.5
0058: MOVWF 08
.................... lcd.rw = 1;
0059: BCF 03.5
005A: BSF 08.1
.................... delay_cycles(1);
005B: NOP
.................... lcd.enable = 1;
005C: BSF 08.2
.................... delay_cycles(1);
005D: NOP
.................... high = lcd.data;
005E: MOVF 08,W
005F: SWAPF 08,W
0060: ANDLW 0F
0061: MOVWF 2F
.................... lcd.enable = 0;
0062: BCF 08.2
.................... delay_cycles(1);
0063: NOP
.................... lcd.enable = 1;
0064: BSF 08.2
.................... delay_us(1);
0065: GOTO 066
.................... low = lcd.data;
0066: MOVF 08,W
0067: SWAPF 08,W
0068: ANDLW 0F
0069: MOVWF 2E
.................... lcd.enable = 0;
006A: BCF 08.2
.................... set_tris_lcd(LCD_WRITE);
006B: MOVLW 00
006C: BSF 03.5
006D: MOVWF 08
.................... return( (high<<4) | low);
006E: BCF 03.5
006F: SWAPF 2F,W
0070: MOVWF 77
0071: MOVLW F0
0072: ANDWF 77,F
0073: MOVF 77,W
0074: IORWF 2E,W
0075: MOVWF 78
.................... }
....................
....................
.................... void lcd_send_nibble( BYTE n ) {
.................... lcd.data = n;
*
0021: SWAPF 2F,W
0022: ANDLW F0
0023: MOVWF 77
0024: MOVLW 0F
0025: ANDWF 08,W
0026: IORWF 77,W
0027: MOVWF 08
.................... delay_cycles(1);
0028: NOP
.................... lcd.enable = 1;
0029: BSF 08.2
.................... delay_us(2);
002A: GOTO 02B
002B: GOTO 02C
002C: NOP
.................... lcd.enable = 0;
002D: BCF 08.2
.................... }
002E: RETLW 00
....................
....................
.................... void lcd_send_byte( BYTE address, BYTE n ) {
....................
.................... lcd.rs = 0;
*
0055: BCF 08.0
.................... while ( bit_test(lcd_read_byte(),7) ) ;
*
0076: MOVF 78,W
0077: MOVWF 2E
0078: BTFSC 2E.7
0079: GOTO 056
.................... lcd.rs = address;
007A: BTFSS 2C.0
007B: BCF 08.0
007C: BTFSC 2C.0
007D: BSF 08.0
.................... delay_cycles(1);
007E: NOP
.................... lcd.rw = 0;
007F: BCF 08.1
.................... delay_cycles(1);
0080: NOP
.................... lcd.enable = 0;
0081: BCF 08.2
.................... lcd_send_nibble(n >> 4);
0082: SWAPF 2D,W
0083: MOVWF 2E
0084: MOVLW 0F
0085: ANDWF 2E,F
0086: MOVF 2E,W
0087: MOVWF 2F
0088: CALL 021
.................... lcd_send_nibble(n & 0xf);
0089: MOVF 2D,W
008A: ANDLW 0F
008B: MOVWF 2E
008C: MOVWF 2F
008D: CALL 021
.................... }
....................
....................
.................... void lcd_init() {
.................... BYTE i;
.................... set_tris_lcd(LCD_WRITE);
*
002F: MOVLW 00
0030: BSF 03.5
0031: MOVWF 08
.................... lcd.rs = 0;
0032: BCF 03.5
0033: BCF 08.0
.................... lcd.rw = 0;
0034: BCF 08.1
.................... lcd.enable = 0;
0035: BCF 08.2
.................... delay_ms(15);
0036: MOVLW 0F
0037: MOVWF 2B
0038: CALL 00C
.................... for(i=1;i<=3;++i) {
0039: MOVLW 01
003A: MOVWF 2A
003B: MOVF 2A,W
003C: SUBLW 03
003D: BTFSS 03.0
003E: GOTO 047
.................... lcd_send_nibble(3);
003F: MOVLW 03
0040: MOVWF 2F
0041: CALL 021
.................... delay_ms(5);
0042: MOVLW 05
0043: MOVWF 2B
0044: CALL 00C
.................... }
0045: INCF 2A,F
0046: GOTO 03B
.................... lcd_send_nibble(2);
0047: MOVLW 02
0048: MOVWF 2F
0049: CALL 021
.................... for(i=0;i<=3;++i)
004A: CLRF 2A
004B: MOVF 2A,W
004C: SUBLW 03
004D: BTFSS 03.0
004E: GOTO 090
.................... lcd_send_byte(0,LCD_INIT_STRING[i]);
004F: MOVF 2A,W
0050: CALL 004
0051: MOVWF 2B
0052: CLRF 2C
0053: MOVF 2B,W
0054: MOVWF 2D
*
008E: INCF 2A,F
008F: GOTO 04B
.................... }
0090: BCF 0A.3
0091: BCF 0A.4
0092: GOTO 2FC (RETURN)
....................
....................
.................... void lcd_gotoxy( BYTE x, BYTE y) {
.................... BYTE address;
....................
.................... if(y!=1)
.................... address=lcd_line_two;
.................... else
.................... address=0;
.................... address+=x-1;
.................... lcd_send_byte(0,0x80|address);
.................... }
....................
.................... void lcd_putc( char c) {
.................... switch (c) {
.................... case '\f' : lcd_send_byte(0,1);
.................... delay_ms(2);
.................... break;
.................... case '\n' : lcd_gotoxy(1,2); break;
.................... case '\b' : lcd_send_byte(0,0x10); break;
.................... default : lcd_send_byte(1,c); break;
.................... }
.................... }
....................
.................... 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);
.................... }
....................
.................... #use delaY(clock=10000000)
0093: MOVLW 2B
0094: MOVWF 04
0095: BCF 03.7
0096: MOVF 00,W
0097: BTFSC 03.2
0098: GOTO 0A7
0099: MOVLW 03
009A: MOVWF 78
009B: CLRF 77
009C: DECFSZ 77,F
009D: GOTO 09C
009E: DECFSZ 78,F
009F: GOTO 09B

00A0: MOVLW 3C
00A1: MOVWF 77
00A2: DECFSZ 77,F
00A3: GOTO 0A2
00A4: GOTO 0A5
00A5: DECFSZ 00,F
00A6: GOTO 099
00A7: RETLW 00
*
029A: MOVLW 06
029B: SUBWF 2B,F
029C: BTFSS 03.0
029D: GOTO 2AA
029E: MOVLW 2B
029F: MOVWF 04
02A0: BCF 03.7
02A1: BCF 03.0
02A2: RRF 00,F
02A3: MOVF 00,W
02A4: BTFSC 03.2
02A5: GOTO 2AA
02A6: GOTO 2A8
02A7: GOTO 2A8
02A8: DECFSZ 00,F
02A9: GOTO 2A7
02AA: RETLW 00
.................... #use fast_io(b)
.................... #use fast_io(c)
.................... #use fast_io(a)
.................... #byte portb=0x06
.................... #byte portc=0x07
.................... #byte porte=0x09
.................... int pul=1; //Pulsos aislados positivos
*
02CB: MOVLW 01
02CC: BCF 03.5
02CD: MOVWF 20
.................... int pulman=2; //Pulsos mantenidos
02CE: MOVLW 02
02CF: MOVWF 21
.................... int tren=4; //Trenes de pulsos
02D0: MOVLW 04
02D1: MOVWF 22
.................... int pulbi=8; //Pulsos bifasicos
02D2: MOVLW 08
02D3: MOVWF 23
.................... int16 valor;
.................... int16 Ton;
.................... int16 Toff;
....................
.................... void main()
.................... { setup_adc_ports(AN0_AN1_AN3);
*
02C0: CLRF 04
02C1: BCF 03.7
02C2: MOVLW 1F
02C3: ANDWF 03,F
02C4: BSF 03.5
02C5: BSF 1F.0
02C6: BSF 1F.1
02C7: BSF 1F.2
02C8: BCF 1F.3
02C9: MOVLW 07
02CA: MOVWF 1C
*
02D4: BSF 03.5
02D5: BCF 1F.0
02D6: BCF 1F.1
02D7: BSF 1F.2
02D8: BCF 1F.3
.................... setup_psp(PSP_DISABLED);
02D9: BCF 09.4
.................... setup_spi(SPI_SS_DISABLED);
02DA: BCF 03.5
02DB: BCF 14.5
02DC: MOVLW 01
02DD: MOVWF 14
02DE: MOVLW 00
02DF: BSF 03.5
02E0: MOVWF 14
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
02E1: MOVF 01,W
02E2: ANDLW C7
02E3: IORLW 08
02E4: MOVWF 01
.................... setup_timer_1(T1_DISABLED);
02E5: BCF 03.5
02E6: CLRF 10
.................... setup_timer_2(T2_DISABLED,0,1);
02E7: MOVLW 00
02E8: MOVWF 78
02E9: MOVWF 12
02EA: MOVLW 00
02EB: BSF 03.5
02EC: MOVWF 12
.................... setup_comparator(NC_NC_NC_NC);
02ED: MOVLW 07
02EE: MOVWF 1C
02EF: MOVF 05,W
02F0: MOVWF 05
02F1: MOVLW 08
02F2: MOVWF 77
02F3: DECFSZ 77,F
02F4: GOTO 2F3
02F5: MOVF 1C,W
02F6: BCF 03.5
02F7: BCF 0D.6
.................... setup_vref(FALSE);
02F8: BSF 03.5
02F9: CLRF 1D
.................... lcd_init();
02FA: BCF 03.5
02FB: GOTO 02F
....................
.................... // TODO: USER CODE!!
.................... set_tris_b(0x00);
02FC: MOVLW 00
02FD: BSF 03.5
02FE: MOVWF 06
.................... portb=0x00;
02FF: BCF 03.5
0300: CLRF 06
.................... set_tris_c(0x00);
0301: BSF 03.5
0302: MOVWF 07
.................... portc=0x00;
0303: BCF 03.5
0304: CLRF 07
.................... set_tris_e(0xff);
0305: BSF 03.5
0306: BSF 09.0
0307: BSF 09.1
0308: BSF 09.2
.................... while (true)
.................... { if (porte == 1)
0309: BCF 03.5
030A: DECFSZ 09,W
030B: GOTO 54D
.................... {if (portb == pul)
030C: MOVF 20,W
030D: SUBWF 06,W
030E: BTFSS 03.2
030F: GOTO 396
.................... {setup_adc(ADC_CLOCK_INTERNAL);
0310: BSF 03.5
0311: BCF 1F.6
0312: BCF 03.5
0313: BSF 1F.6
0314: BSF 1F.7
0315: BSF 03.5
0316: BCF 1F.7
0317: BCF 03.5
0318: BSF 1F.0
.................... set_adc_channel(0);
0319: MOVLW 00
031A: MOVWF 78
031B: MOVF 1F,W
031C: ANDLW C7
031D: IORWF 78,W
031E: MOVWF 1F
.................... delay_us(20);
031F: MOVLW 10
0320: MOVWF 77
0321: DECFSZ 77,F
0322: GOTO 321
0323: NOP
.................... valor=read_adc();
0324: BSF 1F.2
0325: BTFSC 1F.2
0326: GOTO 325
0327: MOVF 1E,W
0328: CLRF 25
0329: MOVWF 24
.................... setup_adc(adc_off);
032A: BCF 1F.0
.................... if (valor == 0)
032B: MOVF 24,F
032C: BTFSS 03.2
032D: GOTO 333
032E: MOVF 25,F
032F: BTFSS 03.2
0330: GOTO 333
.................... {Ton=0.005;}
0331: CLRF 27
0332: CLRF 26
.................... if (valor>0)
0333: MOVF 24,F
0334: BTFSS 03.2
0335: GOTO 339
0336: MOVF 25,F
0337: BTFSC 03.2
0338: GOTO 33D
.................... {Ton = valor;}
0339: MOVF 25,W
033A: MOVWF 27
033B: MOVF 24,W
033C: MOVWF 26
.................... portc=0x03;
033D: MOVLW 03
033E: MOVWF 07
.................... delay_ms(Ton);
033F: MOVF 27,W
0340: MOVWF 2A
0341: INCF 2A,F
0342: DECF 2A,F
0343: BTFSC 03.2
0344: GOTO 349
0345: MOVLW FF
0346: MOVWF 2B
0347: CALL 093
0348: GOTO 342
0349: MOVF 26,W
034A: MOVWF 2B
034B: CALL 093
.................... portc=0x00;
034C: CLRF 07
.................... setup_adc(adc_clock_internal);
034D: BSF 03.5
034E: BCF 1F.6
034F: BCF 03.5
0350: BSF 1F.6
0351: BSF 1F.7
0352: BSF 03.5
0353: BCF 1F.7
0354: BCF 03.5
0355: BSF 1F.0
.................... set_adc_channel(1);
0356: MOVLW 08
0357: MOVWF 78
0358: MOVF 1F,W
0359: ANDLW C7
035A: IORWF 78,W
035B: MOVWF 1F
.................... delay_us(20);
035C: MOVLW 10
035D: MOVWF 77
035E: DECFSZ 77,F
035F: GOTO 35E
0360: NOP
.................... valor=read_adc();
0361: BSF 1F.2
0362: BTFSC 1F.2
0363: GOTO 362
0364: MOVF 1E,W
0365: CLRF 25
0366: MOVWF 24
.................... setup_adc(adc_off);
0367: BCF 1F.0
.................... if (valor == 0)
0368: MOVF 24,F
0369: BTFSS 03.2
036A: GOTO 372
036B: MOVF 25,F
036C: BTFSS 03.2
036D: GOTO 372
.................... {Toff=1000;}
036E: MOVLW 03
036F: MOVWF 29
0370: MOVLW E8
0371: MOVWF 28
.................... if (valor>0)
0372: MOVF 24,F
0373: BTFSS 03.2
0374: GOTO 378
0375: MOVF 25,F
0376: BTFSC 03.2
0377: GOTO 389
.................... {Toff=1000 + (valor*4);}
0378: RLF 24,W
0379: MOVWF 79
037A: RLF 25,W
037B: MOVWF 7A
037C: RLF 79,F
037D: RLF 7A,F
037E: MOVLW FC
037F: ANDWF 79,F
0380: MOVF 79,W
0381: ADDLW E8
0382: MOVWF 28
0383: MOVF 7A,W
0384: MOVWF 29
0385: MOVLW 03
0386: BTFSC 03.0
0387: MOVLW 04
0388: ADDWF 29,F
.................... delay_ms(Toff);
0389: MOVF 29,W
038A: MOVWF 2A
038B: INCF 2A,F
038C: DECF 2A,F
038D: BTFSC 03.2
038E: GOTO 393
038F: MOVLW FF
0390: MOVWF 2B
0391: CALL 093
0392: GOTO 38C
0393: MOVF 28,W
0394: MOVWF 2B
0395: CALL 093
.................... }
.................... // Secuencia para pulsos mantenidos positivos //

.................... if (portb == pulman)
0396: MOVF 21,W
0397: SUBWF 06,W
0398: BTFSS 03.2
0399: GOTO 450
.................... {setup_adc(adc_clock_internal);
039A: BSF 03.5
039B: BCF 1F.6
039C: BCF 03.5
039D: BSF 1F.6
039E: BSF 1F.7
039F: BSF 03.5
03A0: BCF 1F.7
03A1: BCF 03.5
03A2: BSF 1F.0
.................... set_adc_channel(0);
03A3: MOVLW 00
03A4: MOVWF 78
03A5: MOVF 1F,W
03A6: ANDLW C7
03A7: IORWF 78,W
03A8: MOVWF 1F
.................... delay_us(20);
03A9: MOVLW 10
03AA: MOVWF 77
03AB: DECFSZ 77,F
03AC: GOTO 3AB
03AD: NOP
.................... valor=read_adc();
03AE: BSF 1F.2
03AF: BTFSC 1F.2
03B0: GOTO 3AF
03B1: MOVF 1E,W
03B2: CLRF 25
03B3: MOVWF 24
.................... setup_adc(adc_off);
03B4: BCF 1F.0
.................... if (valor == 0)
03B5: MOVF 24,F
03B6: BTFSS 03.2
03B7: GOTO 3BE
03B8: MOVF 25,F
03B9: BTFSS 03.2

03BA: GOTO 3BE
.................... {Ton=100;}
03BB: CLRF 27
03BC: MOVLW 64
03BD: MOVWF 26
.................... if (valor > 0);
03BE: MOVF 24,F
03BF: BTFSS 03.2
03C0: GOTO 3C4
03C1: MOVF 25,F
03C2: BTFSS 03.2
03C3: GOTO 3C4
.................... {Ton=100 + (valor*4.9);}
03C4: MOVF 25,W
03C5: MOVWF 2B
03C6: MOVF 24,W
03C7: MOVWF 2A
03C8: CALL 0A8
03C9: MOVF 7A,W
03CA: MOVWF 2D
03CB: MOVF 79,W
03CC: MOVWF 2C
03CD: MOVF 78,W
03CE: MOVWF 2B
03CF: MOVF 77,W
03D0: MOVWF 2A
03D1: MOVLW CD
03D2: MOVWF 31
03D3: MOVLW CC
03D4: MOVWF 30
03D5: MOVLW 1C
03D6: MOVWF 2F
03D7: MOVLW 81
03D8: MOVWF 2E
03D9: CALL 0C5
03DA: BCF 03.1
03DB: CLRF 2D
03DC: CLRF 2C
03DD: MOVLW 48
03DE: MOVWF 2B
03DF: MOVLW 85
03E0: MOVWF 2A
03E1: MOVF 7A,W

03E2: MOVWF 31
03E3: MOVF 79,W
03E4: MOVWF 30
03E5: MOVF 78,W
03E6: MOVWF 2F
03E7: MOVF 77,W
03E8: MOVWF 2E
03E9: CALL 13A
03EA: MOVF 7A,W
03EB: MOVWF 2D
03EC: MOVF 79,W
03ED: MOVWF 2C
03EE: MOVF 78,W
03EF: MOVWF 2B
03F0: MOVF 77,W
03F1: MOVWF 2A
03F2: CALL 27B
03F3: MOVF 79,W
03F4: MOVWF 27
03F5: MOVF 78,W
03F6: MOVWF 26
.................... portc=0x03;
03F7: MOVLW 03
03F8: MOVWF 07
.................... delay_us(Ton);
03F9: MOVF 27,W
03FA: MOVWF 2A
03FB: INCF 2A,F
03FC: DECF 2A,F
03FD: BTFSC 03.2
03FE: GOTO 403
03FF: MOVLW FF
0400: MOVWF 2B
0401: CALL 29A
0402: GOTO 3FC
0403: MOVF 26,W
0404: MOVWF 2B
0405: CALL 29A
.................... portc=0x00;
0406: CLRF 07
0407: BSF 03.5
0408: BCF 1F.6

0409: BCF 03.5
040A: BSF 1F.6
040B: BSF 1F.7
040C: BSF 03.5
040D: BCF 1F.7
040E: BCF 03.5
040F: BSF 1F.0
.................... set_adc_channel(1);
0410: MOVLW 08
0411: MOVWF 78
0412: MOVF 1F,W
0413: ANDLW C7
0414: IORWF 78,W
0415: MOVWF 1F
.................... delay_us(20);
0416: MOVLW 10
0417: MOVWF 77
0418: DECFSZ 77,F
0419: GOTO 418
041A: NOP
.................... valor=read_adc();
041B: BSF 1F.2
041C: BTFSC 1F.2
041D: GOTO 41C
041E: MOVF 1E,W
041F: CLRF 25
0420: MOVWF 24
.................... setup_adc(adc_off);
0421: BCF 1F.0
.................... if (valor == 0)
0422: MOVF 24,F
0423: BTFSS 03.2
0424: GOTO 42C
0425: MOVF 25,F
0426: BTFSS 03.2
0427: GOTO 42C
.................... {Toff=5000;}
0428: MOVLW 13
0429: MOVWF 29
042A: MOVLW 88
042B: MOVWF 28
.................... if (valor > 0);
042C: MOVF 24,F

042D: BTFSS 03.2
042E: GOTO 432
042F: MOVF 25,F
0430: BTFSS 03.2
0431: GOTO 432
.................... {Toff=5000 + (valor *15);}
0432: MOVF 25,W
0433: MOVWF 2B
0434: MOVF 24,W
0435: MOVWF 2A
0436: CLRF 2D
0437: MOVLW 0F
0438: MOVWF 2C
0439: CALL 2AB
043A: MOVF 78,W
043B: ADDLW 88
043C: MOVWF 28
043D: MOVF 79,W
043E: MOVWF 29
043F: MOVLW 13
0440: BTFSC 03.0
0441: MOVLW 14
0442: ADDWF 29,F
.................... delay_us(Toff);
0443: MOVF 29,W
0444: MOVWF 2A
0445: INCF 2A,F
0446: DECF 2A,F
0447: BTFSC 03.2
0448: GOTO 44D
0449: MOVLW FF
044A: MOVWF 2B
044B: CALL 29A
044C: GOTO 446
044D: MOVF 28,W
044E: MOVWF 2B
044F: CALL 29A
.................... }
.................... // Secuencia para trenes de pulsos positivos //
.................... if (portb == tren)
0450: MOVF 22,W
0451: SUBWF 06,W
0452: BTFSS 03.2

0453: GOTO 483
.................... { portc=0x03;
0454: MOVLW 03
0455: MOVWF 07
.................... delay_ms(3);
0456: MOVWF 2B
0457: CALL 093
.................... portc=0x00;
0458: CLRF 07
.................... delay_ms(10);
0459: MOVLW 0A
045A: MOVWF 2B
045B: CALL 093
.................... portc=0x03;
045C: MOVLW 03
045D: MOVWF 07
.................... delay_ms(3);
045E: MOVWF 2B
045F: CALL 093
.................... portc=0x00;
0460: CLRF 07
.................... delay_ms(10);
0461: MOVLW 0A
0462: MOVWF 2B
0463: CALL 093
.................... portc=0x03;
0464: MOVLW 03
0465: MOVWF 07
.................... delay_ms(3);
0466: MOVWF 2B
0467: CALL 093
.................... portc=0x00;
0468: CLRF 07
.................... delay_ms(10);
0469: MOVLW 0A
046A: MOVWF 2B
046B: CALL 093
.................... portc=0x03;
046C: MOVLW 03
046D: MOVWF 07
.................... delay_ms(3);
046E: MOVWF 2B
046F: CALL 093

.................... portc=0x00;
0470: CLRF 07
.................... delay_ms(10);
0471: MOVLW 0A
0472: MOVWF 2B
0473: CALL 093
.................... portc=0x03;
0474: MOVLW 03
0475: MOVWF 07
.................... delay_ms(3);
0476: MOVWF 2B
0477: CALL 093
.................... portc=0x00;
0478: CLRF 07
.................... delay_ms(10);
0479: MOVLW 0A
047A: MOVWF 2B
047B: CALL 093
....................
.................... delay_ms(500);
047C: MOVLW 02
047D: MOVWF 2A
047E: MOVLW FA
047F: MOVWF 2B
0480: CALL 093
0481: DECFSZ 2A,F
0482: GOTO 47E
.................... }
.................... // Secuencia para pulsos bifasicos //
.................... if (portb == pulbi)
0483: MOVF 23,W
0484: SUBWF 06,W
0485: BTFSS 03.2
0486: GOTO 54D
0487: BSF 03.5
0488: BCF 1F.6
0489: BCF 03.5
048A: BSF 1F.6
048B: BSF 1F.7
048C: BSF 03.5
048D: BCF 1F.7
048E: BCF 03.5

048F: BSF 1F.0
.................... set_adc_channel(0);
0490: MOVLW 00
0491: MOVWF 78
0492: MOVF 1F,W
0493: ANDLW C7
0494: IORWF 78,W
0495: MOVWF 1F
.................... delay_us(20);
0496: MOVLW 10
0497: MOVWF 77
0498: DECFSZ 77,F
0499: GOTO 498
049A: NOP
.................... valor=read_adc();
049B: BSF 1F.2
049C: BTFSC 1F.2
049D: GOTO 49C
049E: MOVF 1E,W
049F: CLRF 25
04A0: MOVWF 24
.................... setup_adc(adc_off);
04A1: BCF 1F.0
.................... if (valor == 0)
04A2: MOVF 24,F
04A3: BTFSS 03.2
04A4: GOTO 4AB
04A5: MOVF 25,F
04A6: BTFSS 03.2
04A7: GOTO 4AB
.................... {Ton=100;}
04A8: CLRF 27
04A9: MOVLW 64
04AA: MOVWF 26
.................... if (valor > 0);
04AB: MOVF 24,F
04AC: BTFSS 03.2
04AD: GOTO 4B1
04AE: MOVF 25,F
04AF: BTFSS 03.2
04B0: GOTO 4B1
.................... {Ton=100 + (valor*4.9);}
04B1: MOVF 25,W

04B2: MOVWF 2B
04B3: MOVF 24,W
04B4: MOVWF 2A
04B5: CALL 0A8
04B6: MOVF 7A,W
04B7: MOVWF 2D
04B8: MOVF 79,W
04B9: MOVWF 2C
04BA: MOVF 78,W
04BB: MOVWF 2B
04BC: MOVF 77,W
04BD: MOVWF 2A
04BE: MOVLW CD
04BF: MOVWF 31
04C0: MOVLW CC
04C1: MOVWF 30
04C2: MOVLW 1C
04C3: MOVWF 2F
04C4: MOVLW 81
04C5: MOVWF 2E
04C6: CALL 0C5
04C7: BCF 03.1
04C8: CLRF 2D
04C9: CLRF 2C
04CA: MOVLW 48
04CB: MOVWF 2B
04CC: MOVLW 85
04CD: MOVWF 2A
04CE: MOVF 7A,W
04CF: MOVWF 31
04D0: MOVF 79,W
04D1: MOVWF 30
04D2: MOVF 78,W
04D3: MOVWF 2F
04D4: MOVF 77,W
04D5: MOVWF 2E
04D6: CALL 13A
04D7: MOVF 7A,W
04D8: MOVWF 2D
04D9: MOVF 79,W
04DA: MOVWF 2C
04DB: MOVF 78,W
04DC: MOVWF 2B
04DD: MOVF 77,W
04DE: MOVWF 2A
04DF: CALL 27B
04E0: MOVF 79,W
04E1: MOVWF 27
04E2: MOVF 78,W
04E3: MOVWF 26
.................... portc=0x03;
04E4: MOVLW 03
04E5: MOVWF 07
.................... delay_us(Ton);
04E6: MOVF 27,W
04E7: MOVWF 2A
04E8: INCF 2A,F
04E9: DECF 2A,F
04EA: BTFSC 03.2
04EB: GOTO 4F0
04EC: MOVLW FF
04ED: MOVWF 2B
04EE: CALL 29A
04EF: GOTO 4E9
04F0: MOVF 26,W
04F1: MOVWF 2B
04F2: CALL 29A
.................... portc=0x00;
04F3: CLRF 07
.................... portc=0x0c;
04F4: MOVLW 0C
04F5: MOVWF 07
.................... delay_us(Ton);
04F6: MOVF 27,W
04F7: MOVWF 2A
04F8: INCF 2A,F
04F9: DECF 2A,F
04FA: BTFSC 03.2
04FB: GOTO 500
04FC: MOVLW FF
04FD: MOVWF 2B
04FE: CALL 29A
04FF: GOTO 4F9
0500: MOVF 26,W
0501: MOVWF 2B
0502: CALL 29A

.................... portc=0x00;
0503: CLRF 07
0504: BSF 03.5
0505: BCF 1F.6
0506: BCF 03.5
0507: BSF 1F.6
0508: BSF 1F.7
0509: BSF 03.5
050A: BCF 1F.7
050B: BCF 03.5
050C: BSF 1F.0
.................... set_adc_channel(1);
050D: MOVLW 08
050E: MOVWF 78
050F: MOVF 1F,W
0510: ANDLW C7
0511: IORWF 78,W
0512: MOVWF 1F
.................... delay_us(20);
0513: MOVLW 10
0514: MOVWF 77
0515: DECFSZ 77,F
0516: GOTO 515
0517: NOP
.................... valor=read_adc();
0518: BSF 1F.2
0519: BTFSC 1F.2
051A: GOTO 519
051B: MOVF 1E,W
051C: CLRF 25
051D: MOVWF 24
.................... setup_adc(adc_off);
051E: BCF 1F.0
.................... if (valor == 0)
051F: MOVF 24,F
0520: BTFSS 03.2
0521: GOTO 529
0522: MOVF 25,F
0523: BTFSS 03.2
0524: GOTO 529
.................... {Toff=5000;}
0525: MOVLW 13
0526: MOVWF 29
0527: MOVLW 88
0528: MOVWF 28
.................... if (valor > 0);
0529: MOVF 24,F
052A: BTFSS 03.2
052B: GOTO 52F
052C: MOVF 25,F
052D: BTFSS 03.2
052E: GOTO 52F
.................... {Toff=5000 + (valor *15);}
052F: MOVF 25,W
0530: MOVWF 2B
0531: MOVF 24,W
0532: MOVWF 2A
0533: CLRF 2D
0534: MOVLW 0F
0535: MOVWF 2C
0536: CALL 2AB
0537: MOVF 78,W
0538: ADDLW 88
0539: MOVWF 28
053A: MOVF 79,W
053B: MOVWF 29
053C: MOVLW 13
053D: BTFSC 03.0
053E: MOVLW 14
053F: ADDWF 29,F
.................... delay_us(Toff);
0540: MOVF 29,W
0541: MOVWF 2A
0542: INCF 2A,F
0543: DECF 2A,F
0544: BTFSC 03.2
0545: GOTO 54A
0546: MOVLW FF
0547: MOVWF 2B
0548: CALL 29A
0549: GOTO 543
054A: MOVF 28,W
054B: MOVWF 2B
054C: CALL 29A
.................... }
.................... }
....................
.................... if (porte == 3)
054D: MOVF 09,W
054E: SUBLW 03
054F: BTFSS 03.2
0550: GOTO 797
.................... { if (portb == pul)
0551: MOVF 20,W
0552: SUBWF 06,W
0553: BTFSS 03.2
0554: GOTO 5DB
.................... {setup_adc(ADC_CLOCK_INTERNAL);
0555: BSF 03.5
0556: BCF 1F.6
0557: BCF 03.5
0558: BSF 1F.6
0559: BSF 1F.7
055A: BSF 03.5
055B: BCF 1F.7
055C: BCF 03.5
055D: BSF 1F.0
.................... set_adc_channel(0);
055E: MOVLW 00
055F: MOVWF 78
0560: MOVF 1F,W
0561: ANDLW C7
0562: IORWF 78,W
0563: MOVWF 1F
.................... delay_us(20);
0564: MOVLW 10
0565: MOVWF 77
0566: DECFSZ 77,F
0567: GOTO 566
0568: NOP
.................... valor=read_adc();
0569: BSF 1F.2
056A: BTFSC 1F.2
056B: GOTO 56A
056C: MOVF 1E,W
056D: CLRF 25
056E: MOVWF 24
.................... setup_adc(adc_off);
056F: BCF 1F.0
.................... if (valor == 0)
0570: MOVF 24,F
0571: BTFSS 03.2
0572: GOTO 578
0573: MOVF 25,F
0574: BTFSS 03.2
0575: GOTO 578
.................... {Ton=0.005;}
0576: CLRF 27
0577: CLRF 26
.................... if (valor>0)
0578: MOVF 24,F
0579: BTFSS 03.2
057A: GOTO 57E
057B: MOVF 25,F
057C: BTFSC 03.2
057D: GOTO 582
.................... {Ton = valor;}
057E: MOVF 25,W
057F: MOVWF 27
0580: MOVF 24,W
0581: MOVWF 26
.................... portc=0x0c;
0582: MOVLW 0C
0583: MOVWF 07
.................... delay_ms(Ton);
0584: MOVF 27,W
0585: MOVWF 2A
0586: INCF 2A,F
0587: DECF 2A,F
0588: BTFSC 03.2
0589: GOTO 58E
058A: MOVLW FF
058B: MOVWF 2B
058C: CALL 093
058D: GOTO 587
058E: MOVF 26,W
058F: MOVWF 2B
0590: CALL 093
.................... portc=0x00;
0591: CLRF 07
0592: BSF 03.5
0593: BCF 1F.6
0594: BCF 03.5
0595: BSF 1F.6
0596: BSF 1F.7
0597: BSF 03.5
0598: BCF 1F.7
0599: BCF 03.5
059A: BSF 1F.0
.................... set_adc_channel(1);
059B: MOVLW 08
059C: MOVWF 78
059D: MOVF 1F,W
059E: ANDLW C7
059F: IORWF 78,W
05A0: MOVWF 1F
.................... delay_us(20);
05A1: MOVLW 10
05A2: MOVWF 77
05A3: DECFSZ 77,F
05A4: GOTO 5A3
05A5: NOP
.................... valor=read_adc();
05A6: BSF 1F.2
05A7: BTFSC 1F.2
05A8: GOTO 5A7
05A9: MOVF 1E,W
05AA: CLRF 25
05AB: MOVWF 24
.................... setup_adc(adc_off);
05AC: BCF 1F.0
.................... if (valor == 0)
05AD: MOVF 24,F
05AE: BTFSS 03.2
05AF: GOTO 5B7
05B0: MOVF 25,F
05B1: BTFSS 03.2
05B2: GOTO 5B7
.................... {Toff=1000;}
05B3: MOVLW 03
05B4: MOVWF 29
05B5: MOVLW E8
05B6: MOVWF 28
.................... if (valor>0)
05B7: MOVF 24,F
05B8: BTFSS 03.2
05B9: GOTO 5BD
05BA: MOVF 25,F
05BB: BTFSC 03.2
05BC: GOTO 5CE
.................... {Toff=1000 + (valor*4);}
05BD: RLF 24,W
05BE: MOVWF 79
05BF: RLF 25,W
05C0: MOVWF 7A
05C1: RLF 79,F
05C2: RLF 7A,F
05C3: MOVLW FC
05C4: ANDWF 79,F
05C5: MOVF 79,W
05C6: ADDLW E8
05C7: MOVWF 28
05C8: MOVF 7A,W
05C9: MOVWF 29
05CA: MOVLW 03
05CB: BTFSC 03.0
05CC: MOVLW 04
05CD: ADDWF 29,F
.................... delay_ms(Toff);
05CE: MOVF 29,W
05CF: MOVWF 2A
05D0: INCF 2A,F
05D1: DECF 2A,F
05D2: BTFSC 03.2
05D3: GOTO 5D8
05D4: MOVLW FF
05D5: MOVWF 2B
05D6: CALL 093
05D7: GOTO 5D1
05D8: MOVF 28,W
05D9: MOVWF 2B
05DA: CALL 093
.................... }
.................... if (portb == pulman)
05DB: MOVF 21,W
05DC: SUBWF 06,W

05DD: BTFSS 03.2
05DE: GOTO 695
05DF: BSF 03.5
05E0: BCF 1F.6
05E1: BCF 03.5
05E2: BSF 1F.6
05E3: BSF 1F.7
05E4: BSF 03.5
05E5: BCF 1F.7
05E6: BCF 03.5
05E7: BSF 1F.0
.................... set_adc_channel(0);
05E8: MOVLW 00
05E9: MOVWF 78
05EA: MOVF 1F,W
05EB: ANDLW C7
05EC: IORWF 78,W
05ED: MOVWF 1F
.................... delay_us(20);
05EE: MOVLW 10
05EF: MOVWF 77
05F0: DECFSZ 77,F
05F1: GOTO 5F0
05F2: NOP
.................... valor=read_adc();
05F3: BSF 1F.2
05F4: BTFSC 1F.2
05F5: GOTO 5F4
05F6: MOVF 1E,W
05F7: CLRF 25
05F8: MOVWF 24
.................... setup_adc(adc_off);
05F9: BCF 1F.0
.................... if (valor == 0)
05FA: MOVF 24,F
05FB: BTFSS 03.2
05FC: GOTO 603
05FD: MOVF 25,F
05FE: BTFSS 03.2
05FF: GOTO 603
.................... {Ton=100;}
0600: CLRF 27
0601: MOVLW 64
0602: MOVWF 26
.................... if (valor > 0);
0603: MOVF 24,F
0604: BTFSS 03.2
0605: GOTO 609
0606: MOVF 25,F
0607: BTFSS 03.2
0608: GOTO 609
.................... {Ton=100 + (valor*4.9);}
0609: MOVF 25,W
060A: MOVWF 2B
060B: MOVF 24,W
060C: MOVWF 2A
060D: CALL 0A8
060E: MOVF 7A,W
060F: MOVWF 2D
0610: MOVF 79,W
0611: MOVWF 2C
0612: MOVF 78,W
0613: MOVWF 2B
0614: MOVF 77,W
0615: MOVWF 2A
0616: MOVLW CD
0617: MOVWF 31
0618: MOVLW CC
0619: MOVWF 30
061A: MOVLW 1C
061B: MOVWF 2F
061C: MOVLW 81
061D: MOVWF 2E
061E: CALL 0C5
061F: BCF 03.1
0620: CLRF 2D
0621: CLRF 2C
0622: MOVLW 48
0623: MOVWF 2B
0624: MOVLW 85
0625: MOVWF 2A
0626: MOVF 7A,W
0627: MOVWF 31
0628: MOVF 79,W
0629: MOVWF 30
062A: MOVF 78,W
062B: MOVWF 2F
062C: MOVF 77,W
062D: MOVWF 2E
062E: CALL 13A
062F: MOVF 7A,W
0630: MOVWF 2D
0631: MOVF 79,W
0632: MOVWF 2C
0633: MOVF 78,W
0634: MOVWF 2B
0635: MOVF 77,W
0636: MOVWF 2A
0637: CALL 27B
0638: MOVF 79,W
0639: MOVWF 27
063A: MOVF 78,W
063B: MOVWF 26
.................... portc=0x0c;
063C: MOVLW 0C
063D: MOVWF 07
.................... delay_us(Ton);
063E: MOVF 27,W
063F: MOVWF 2A
0640: INCF 2A,F
0641: DECF 2A,F
0642: BTFSC 03.2
0643: GOTO 648
0644: MOVLW FF
0645: MOVWF 2B
0646: CALL 29A
0647: GOTO 641
0648: MOVF 26,W
0649: MOVWF 2B
064A: CALL 29A
.................... portc=0x00;
064B: CLRF 07
064C: BSF 03.5
064D: BCF 1F.6
064E: BCF 03.5
064F: BSF 1F.6
0650: BSF 1F.7

0651: BSF 03.5
0652: BCF 1F.7
0653: BCF 03.5
0654: BSF 1F.0
.................... set_adc_channel(1);
0655: MOVLW 08
0656: MOVWF 78
0657: MOVF 1F,W
0658: ANDLW C7
0659: IORWF 78,W
065A: MOVWF 1F
.................... delay_us(20);
065B: MOVLW 10
065C: MOVWF 77
065D: DECFSZ 77,F
065E: GOTO 65D
065F: NOP
.................... valor=read_adc();
0660: BSF 1F.2
0661: BTFSC 1F.2
0662: GOTO 661
0663: MOVF 1E,W
0664: CLRF 25
0665: MOVWF 24
.................... setup_adc(adc_off);
0666: BCF 1F.0
.................... if (valor == 0)
0667: MOVF 24,F
0668: BTFSS 03.2
0669: GOTO 671
066A: MOVF 25,F
066B: BTFSS 03.2
066C: GOTO 671
.................... {Toff=5000;}
066D: MOVLW 13
066E: MOVWF 29
066F: MOVLW 88
0670: MOVWF 28
.................... if (valor > 0);
0671: MOVF 24,F
0672: BTFSS 03.2
0673: GOTO 677
0674: MOVF 25,F

0675: BTFSS 03.2
0676: GOTO 677
.................... {Toff=5000 + (valor *15);}
0677: MOVF 25,W
0678: MOVWF 2B
0679: MOVF 24,W
067A: MOVWF 2A
067B: CLRF 2D
067C: MOVLW 0F
067D: MOVWF 2C
067E: CALL 2AB
067F: MOVF 78,W
0680: ADDLW 88
0681: MOVWF 28
0682: MOVF 79,W
0683: MOVWF 29
0684: MOVLW 13
0685: BTFSC 03.0
0686: MOVLW 14
0687: ADDWF 29,F
.................... delay_us(Toff);
0688: MOVF 29,W
0689: MOVWF 2A
068A: INCF 2A,F
068B: DECF 2A,F
068C: BTFSC 03.2
068D: GOTO 692
068E: MOVLW FF
068F: MOVWF 2B
0690: CALL 29A
0691: GOTO 68B
0692: MOVF 28,W
0693: MOVWF 2B
0694: CALL 29A
.................... }
.................... if (portb == pulbi)
0695: MOVF 23,W
0696: SUBWF 06,W
0697: BTFSS 03.2
0698: GOTO 75F
0699: BSF 03.5
069A: BCF 1F.6

069B: BCF 03.5
069C: BSF 1F.6
069D: BSF 1F.7
069E: BSF 03.5
069F: BCF 1F.7
06A0: BCF 03.5
06A1: BSF 1F.0
.................... set_adc_channel(0);
06A2: MOVLW 00
06A3: MOVWF 78
06A4: MOVF 1F,W
06A5: ANDLW C7
06A6: IORWF 78,W
06A7: MOVWF 1F
.................... delay_us(20);
06A8: MOVLW 10
06A9: MOVWF 77
06AA: DECFSZ 77,F
06AB: GOTO 6AA
06AC: NOP
.................... valor=read_adc();
06AD: BSF 1F.2
06AE: BTFSC 1F.2
06AF: GOTO 6AE
06B0: MOVF 1E,W
06B1: CLRF 25
06B2: MOVWF 24
.................... setup_adc(adc_off);
06B3: BCF 1F.0
.................... if (valor == 0)
06B4: MOVF 24,F
06B5: BTFSS 03.2
06B6: GOTO 6BD
06B7: MOVF 25,F
06B8: BTFSS 03.2
06B9: GOTO 6BD
.................... {Ton=100;}
06BA: CLRF 27
06BB: MOVLW 64
06BC: MOVWF 26
.................... if (valor > 0);
06BD: MOVF 24,F
06BE: BTFSS 03.2

06BF: GOTO 6C3
06C0: MOVF 25,F
06C1: BTFSS 03.2
06C2: GOTO 6C3
.................... {Ton=100 + (valor*4.9);}
06C3: MOVF 25,W
06C4: MOVWF 2B
06C5: MOVF 24,W
06C6: MOVWF 2A
06C7: CALL 0A8
06C8: MOVF 7A,W
06C9: MOVWF 2D
06CA: MOVF 79,W
06CB: MOVWF 2C
06CC: MOVF 78,W
06CD: MOVWF 2B
06CE: MOVF 77,W
06CF: MOVWF 2A
06D0: MOVLW CD
06D1: MOVWF 31
06D2: MOVLW CC
06D3: MOVWF 30
06D4: MOVLW 1C
06D5: MOVWF 2F
06D6: MOVLW 81
06D7: MOVWF 2E
06D8: CALL 0C5
06D9: BCF 03.1
06DA: CLRF 2D
06DB: CLRF 2C
06DC: MOVLW 48
06DD: MOVWF 2B
06DE: MOVLW 85
06DF: MOVWF 2A
06E0: MOVF 7A,W
06E1: MOVWF 31
06E2: MOVF 79,W
06E3: MOVWF 30
06E4: MOVF 78,W
06E5: MOVWF 2F
06E6: MOVF 77,W
06E7: MOVWF 2E
06E8: CALL 13A

06E9: MOVF 7A,W
06EA: MOVWF 2D
06EB: MOVF 79,W
06EC: MOVWF 2C
06ED: MOVF 78,W
06EE: MOVWF 2B
06EF: MOVF 77,W
06F0: MOVWF 2A
06F1: CALL 27B
06F2: MOVF 79,W
06F3: MOVWF 27
06F4: MOVF 78,W
06F5: MOVWF 26
.................... portc=0x03;
06F6: MOVLW 03
06F7: MOVWF 07
.................... delay_us(Ton);
06F8: MOVF 27,W
06F9: MOVWF 2A
06FA: INCF 2A,F
06FB: DECF 2A,F
06FC: BTFSC 03.2
06FD: GOTO 702
06FE: MOVLW FF
06FF: MOVWF 2B
0700: CALL 29A
0701: GOTO 6FB
0702: MOVF 26,W
0703: MOVWF 2B
0704: CALL 29A
.................... portc=0x00;
0705: CLRF 07
.................... portc=0x0c;
0706: MOVLW 0C
0707: MOVWF 07
.................... delay_us(Ton);
0708: MOVF 27,W
0709: MOVWF 2A
070A: INCF 2A,F
070B: DECF 2A,F
070C: BTFSC 03.2
070D: GOTO 712
070E: MOVLW FF
070F: MOVWF 2B
0710: CALL 29A
0711: GOTO 70B
0712: MOVF 26,W
0713: MOVWF 2B
0714: CALL 29A
.................... portc=0x00;
0715: CLRF 07
0716: BSF 03.5
0717: BCF 1F.6
0718: BCF 03.5
0719: BSF 1F.6
071A: BSF 1F.7
071B: BSF 03.5
071C: BCF 1F.7
071D: BCF 03.5
071E: BSF 1F.0
.................... set_adc_channel(1);
071F: MOVLW 08
0720: MOVWF 78
0721: MOVF 1F,W
0722: ANDLW C7
0723: IORWF 78,W
0724: MOVWF 1F
.................... delay_us(20);
0725: MOVLW 10
0726: MOVWF 77
0727: DECFSZ 77,F
0728: GOTO 727
0729: NOP
.................... valor=read_adc();
072A: BSF 1F.2
072B: BTFSC 1F.2
072C: GOTO 72B
072D: MOVF 1E,W
072E: CLRF 25
072F: MOVWF 24
.................... setup_adc(adc_off);
0730: BCF 1F.0
.................... if (valor == 0)
0731: MOVF 24,F
0732: BTFSS 03.2

0733: GOTO 73B
0734: MOVF 25,F
0735: BTFSS 03.2
0736: GOTO 73B
.................... {Toff=5000;}
0737: MOVLW 13
0738: MOVWF 29
0739: MOVLW 88
073A: MOVWF 28
.................... if (valor > 0);
073B: MOVF 24,F
073C: BTFSS 03.2
073D: GOTO 741
073E: MOVF 25,F
073F: BTFSS 03.2
0740: GOTO 741
.................... {Toff=5000 + (valor *15);}
0741: MOVF 25,W
0742: MOVWF 2B
0743: MOVF 24,W
0744: MOVWF 2A
0745: CLRF 2D
0746: MOVLW 0F
0747: MOVWF 2C
0748: CALL 2AB
0749: MOVF 78,W
074A: ADDLW 88
074B: MOVWF 28
074C: MOVF 79,W
074D: MOVWF 29
074E: MOVLW 13
074F: BTFSC 03.0
0750: MOVLW 14
0751: ADDWF 29,F
.................... delay_us(Toff);
0752: MOVF 29,W
0753: MOVWF 2A
0754: INCF 2A,F
0755: DECF 2A,F
0756: BTFSC 03.2
0757: GOTO 75C
0758: MOVLW FF
0759: MOVWF 2B
075A: CALL 29A
075B: GOTO 755
075C: MOVF 28,W
075D: MOVWF 2B
075E: CALL 29A
.................... }
.................... if (portb == tren)
075F: MOVF 22,W
0760: SUBWF 06,W
0761: BTFSS 03.2
0762: GOTO 797
.................... { portc=0x0c;
0763: MOVLW 0C
0764: MOVWF 07
.................... delay_ms(3);
0765: MOVLW 03
0766: MOVWF 2B
0767: CALL 093
.................... portc=0x00;
0768: CLRF 07
.................... delay_ms(10);
0769: MOVLW 0A
076A: MOVWF 2B
076B: CALL 093
.................... portc=0x0c;
076C: MOVLW 0C
076D: MOVWF 07
.................... delay_ms(3);
076E: MOVLW 03
076F: MOVWF 2B
0770: CALL 093
.................... portc=0x00;
0771: CLRF 07
.................... delay_ms(10);
0772: MOVLW 0A
0773: MOVWF 2B
0774: CALL 093
.................... portc=0x0c;
0775: MOVLW 0C
0776: MOVWF 07
.................... delay_ms(3);
0777: MOVLW 03
0778: MOVWF 2B
0779: CALL 093
.................... portc=0x00;
077A: CLRF 07
.................... delay_ms(10);
077B: MOVLW 0A
077C: MOVWF 2B
077D: CALL 093
.................... portc=0x0c;
077E: MOVLW 0C
077F: MOVWF 07
.................... delay_ms(3);
0780: MOVLW 03
0781: MOVWF 2B
0782: CALL 093
.................... portc=0x00;
0783: CLRF 07
.................... delay_ms(10);
0784: MOVLW 0A
0785: MOVWF 2B
0786: CALL 093
.................... portc=0x0c;
0787: MOVLW 0C
0788: MOVWF 07
.................... delay_ms(3);
0789: MOVLW 03
078A: MOVWF 2B
078B: CALL 093
.................... portc=0x00;
078C: CLRF 07
.................... delay_ms(10);
078D: MOVLW 0A
078E: MOVWF 2B
078F: CALL 093
....................
.................... delay_ms(500);
0790: MOVLW 02
0791: MOVWF 2A
0792: MOVLW FA
0793: MOVWF 2B
0794: CALL 093
0795: DECFSZ 2A,F
0796: GOTO 792
.................... }
.................... }
.................... }
0797: GOTO 30A
.................... }
....................
0798: SLEEP
Configuration Fuses:
Word 1: 1F32 HS NOWDT PUT PROTECT NODEBUG NOBROWNOUT NOLVP NOCPD NOWRT
CONCLUSIONES
Conocer los procesos de aprendizajes donde se proponen metas para la verificacin

de competencias y logros de un conocimiento mediante investigaciones dando como
resultado la identificacin de fortalezas, estrategias, dificultades y posibles
soluciones.
Se trabaj con el programa proteus para la elaboracin y simulacin del circuito

exigido, se diseo el circuito en programa brindando la posibilidad de generar cada
tipo de onda que se mostraba durante la comprobacin de la actividad.
BIBLIOGRAFIA.
Mdulo INSTRUMENTACION MDICA. UNAD.

Programa PROTEUS para la elaboracin del circuito.
Campus virtual. INSTRUMENTACION MDICA. UNAD.

Actividad 10 Colaborativo 2

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Actividad 10 Colaborativo 2

Загружено:

Авторское право:

Доступные форматы

UNIVERSIDAD NACIONAL ABIERTA y a DISTANCIA

ZONA CENTRO BOGOT CUNDINAMARCA

ANGEL MARIN GARCIA

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Antes del ao 1900, la medicina se basaba principalmente en el medico, un bolso

Es hasta el siglo XX que se da un rpido avance tecnolgico y cientfico,

Encontraran el desarrollo de un Estimulador muscular basado en la electrnica para

Organizar tareas colectivas aportando y superando las dificultades que se

Definir mediante acuerdos, responsabilidades individuales que faciliten el

Desarrollar habilidades en el planteamiento e interpretacin de problemas,

Interpretar y aplicar las caractersticas de las estructuras de datos y

Definir y proponer cambios en la mejora del planteamiento y solucin de los

Trabajar en grupo para realizar la construccin del trabajo colaborativo,

Interpretar y aplicar las caractersticas de las estructuras de datos y

Desarrollar el software de programacin de un micro controlador en lenguaje

1. El microcontrolador ser el PIC16F87.

La electro estimulacin es la tcnica que utiliza la corriente elctrica, para provocar

La tcnica de la electro estimulacin viene emplendose en la rehabilitacin desde

Un electro estimulador es un generador de corriente, que produce impulsos

QU TIPO DE ESTIMULADOR DEBEMOS UTILIZAR?

QU FORMA DEBE TENER LA ONDA ELCTRICA FABRICADA POR EL

La onda que debe construir el estimulador, es una informacin imprescindible que

hasta quemaduras), en el lugar de ubicacin de los electrodos por donde pasa la

PULSOS AISLADOS POSITIVOS

Para obtener pulsos aislados positivos es necesario que el microcontrolador

PULSOS AISLADOS NEGATIVOS

Para obtener pulsos aislados negativos, el microcontrolador genera la tensin

PULSOS MONOFSICOS MANTENIDOS POSITIVOS O NEGATIVOS

Se disminuye el T OFF desde 5 a 20 ms a valores similares de los T ON 0.1 a 5

El micocontrolador es programado con los tiempos de encendido y apagado de los

El microcontrolador debe generar los pulsos de puerta negados, es decir, cuando

CIRCUITO ELECTRICO EN PROTEUS.

CCS PCM C Compiler, Version 4.084, 40722 21-abr-14 21:21

ROM used: 1945 words (24%)

009F: GOTO 09B

.................... // Secuencia para pulsos mantenidos positivos //

03B9: BTFSS 03.2

03E1: MOVF 7A,W

0408: BCF 1F.6

042C: MOVF 24,F

0452: BTFSS 03.2

046F: CALL 093

048E: BCF 03.5

04B1: MOVF 25,W

0502: CALL 29A

05DC: SUBWF 06,W

0650: BSF 1F.7

0674: MOVF 25,F

069A: BCF 1F.6

06BE: BTFSS 03.2

06E8: CALL 13A

0732: BTFSS 03.2

Conocer los procesos de aprendizajes donde se proponen metas para la verificacin

Se trabaj con el programa proteus para la elaboracin y simulacin del circuito

Mdulo INSTRUMENTACION MDICA. UNAD.

Вам также может понравиться