Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

30/09/2008 #1


Manejo de tablas mas allá de 256 bytes
Hola a todos,

espero que me puedan colaborar con el siguiente problema:

Resulta que al programar un microcontrolador para mostrar mensajes en un LCD solo me permite colocar como máximo 8 tablas (7 mensajes de 32bits y una para manejar teclado matricial), al agregar una tabla mas, pasa de los 256 bytes iniciales de memoria de la primera pagina y el programa funciona incorrectamente o sale el display en blanco.

he consultado y me sugieren paginar con org para ubicar las tablas adicionales en otra dirección de memoria, pero la verdad no me ha funcionado o no supe hacerlo bien, y en algunas ocasiones me saca error de sobreescritura de memoria.

si es posible ojalá pudiesen colocar un pedazo de código para ubicarme sobre como hacer dicho proceso, u otra solución.

de antemano muchas gracias y hasta pronto.
30/09/2008 #2

Avatar de pepechip

"capitulo 11: manejo de tablas"
http://www.pic16f84a.org/index.php?o...id=3&Itemid=59 -
30/09/2008 #3

Avatar de Meta

11.4 OPERADORES LOW Y HIGH
Para facilitar la tarea de programación el ensamblador MPASM permite utilizar
múltiples operadores aritméticos que actúan sobre los operandos. En el apéndice C se
detallan algunos. En este tema se van a utilizar los operadores LOW que retorna el byte bajo
del valor de una etiqueta multi-byte y HIGH que retorna el byte alto. Ejemplo:
Código:
; .... ...
Valor EQU 027A ; Constante con un valor de 16 bits.
; .... ....
movlw LOW Valor ; W se carga con 0x7A.
; .... ....
movlw HIGH Valor ; W se carga con 02.

11.5 TABLAS EN LIMITES DE PÁGINA DE 256 BYTES

Al final del tema 9 sobre saltos se demostró como la instrucción addwf PCL,F no
funciona correctamente cuando el valor de PCL se desborda sin que el registro PCLATH se
incremente convenientemente (figura 9-8). Para solucionarlo se planteó la conveniencia que
los saltos indexados no se utilicen por encima de las primeras 256 posiciones de memoria
ROM.
A veces, la utilización de tablas provoca que supere este valor y la tabla se extiende
inevitablemente más allá de la posición 0xFF de memoria de programa. Para solucionarlo se
utiliza el procedimiento descrito en el siguiente ejemplo que permite el correcto
funcionamiento de las tablas situadas en cualquier lugar de la memoria de programa.
Código:
;************************************* Tablas_07.asm *************************************
;
; Repetir el ejercicio Tablas_03.asm, pero situando la tabla en una posición tal que desborde
; la página de las primeras 256 posiciones de memoria de programa ROM.
;
; ZONA DE DATOS **********************************************************************
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC
LIST P=16F84A
INCLUDE <P16F84A.INC>
CBLOCK 0x0C
GuardaOffset
ENDC
; ZONA DE CÓDIGOS ********************************************************************
ORG 0 ; El programa comienza en la dirección 0.
Inicio
bsf STATUS,RP0 ; Acceso al Banco 1.
clrf TRISB ; Las líneas del Puerto B se configuran como salida.
movlw b'00011111' ; Las 5 líneas del Puerto A se configuran como entrada.
movwf TRISA
bcf STATUS,RP0 ; Acceso al Banco 0.
Principal
movf PORTA,W ; Lee el valor de las variables de entrada.
andlw b'00000111' ; Se queda con los tres bits bajos de entrada.
movwf GuardaOffset ; Guarda el offset del salto.
movlw LOW (TablaVerdad+1) ; Obtiene los 8 bits bajos de la dirección de memoria
; de programa donde está situada la tabla real.
addwf GuardaOffset,F ; Y halla el valor del salto absoluto dentro de la tabla.
movlw HIGH (TablaVerdad+1) ; Cinco bits alto de la dirección de memoria de
; programa donde está situada la tabla real.
btfsc STATUS,C ; ¿Ha desbordado la página de 256 bytes?
addlw 1 ; Sí, entonces añade una unidad al PCH.
movwf PCLATH ; Prepara el PCLATH.
movf GuardaOffset,W ; El offset se cargará en el PCL.
call TablaVerdad ; Obtiene la configuración de salida.
movwf PORTB ; Se visualiza por el puerto de salida.
goto Principal
; Subrutina "TablaVerdad" ---------------------------------------------------------------
;
; La tabla de la verdad se sitúa desbordando los primeros 256 bytes de memoria de programa.
ORG .254 ; Cerca del borde de la primera página de 256 bytes.
TablaVerdad ; Posición 0x00FE de memoria de programa (PCH-PCL).
movwf PCL ; El salto dentro de la tabla: PCH=PCLATH, PCL=W.
; (Ver figura 9-8).
retlw b'00001010' ; (Configuración 0). Posición 0x00FF.
retlw b'00001001' ; (Configuración 1). Posición 0x0100.
retlw b'00100011' ; (Configuración 2). Posición 0x0101.
retlw b'00001111' ; (Configuración 3). Posición 0x0102.
retlw b'00100000' ; (Configuración 4). Posición 0x0103.
retlw b'00000111' ; (Configuración 5). Posición 0x0104.
retlw b'00010111' ; (Configuración 6). Posición 0x0105.
retlw b'00111111' ; (Configuración 7). Posición 0x0106.
END
Se comprueba que el manejo de las tablas de datos se complica, por tanto, este
procedimiento sólo se debe utilizar en caso necesario.
30/09/2008 #4

Avatar de asherar

También podés buscar un ejemplo en las App Notes de Microchip.

En la AN655, usan una tabla bastante larga (no conté pero me parece que tiene más de 256 retlw's).
La podés buscar en Microchip ó bajarla de acá.
Editado: Este ejemplo justo tiene menos de 256 !
01/10/2008 #5

Avatar de Meta

Diría demasiado larga. Buena información.

http://www.microchip.com/stellent/id...pnote=en011071
01/10/2008 #6

Avatar de asherar

Este tipo de cosas me decidió a pasarme a C.
Por ejemplo, para cargar tablas largas (bitmaps de hasta 2k, el tamaño de la página) basta con definirlas como const; por ejemplo:

unsigned char const logo[2043] = {
0, 0, 15, 31, 63, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, ...};

Si declaro una cadena en forma explícita:

char texto[]="abcdefghijklmnopqrstuvwxyz67890123456789";

hay un límite y sale un mensaje de error (que no me puse a investigar demasiado).
Preferí resolverlo cargando las cadenas como hace con los bitmaps.

unsigned char const texto[41] = {"abcdefghijklmnopqrstuvwxyz67890123456789"};

para luego invocar haciendo:
...
char ch;
ch=texto[n];
Mostrar_Texto(x, y, &ch);
...

Gano tiempo para hacer otras cosas pero la macana es que ahora no veo bien cómo hace, y se extraña un poco.
Pero, para mi gusto, creo que en aplicaciones medianamente grandes ya vale la pena pensar en pasarse a C.
Al principio cuesta un poco de tiempo rehacer algunas cosas, pero luego uno va más rápido.
01/10/2008 #7


creo que tienes razon alejandro, con c las cosas pueden ser mas manejables, pero me asalta la duda sobre si me permite programar cualquier pic como el mplab o está restringido a unos cuantos (versiones de prueba)?

se puede trabajar con el C# de visual estudio o solo CSS y PICC.

esas dudas no me han dejado pasarme, ya que con mplab aunque mas laborioso siento tener mas control por ser lenguaje de mas bajo nivel.
01/10/2008 #8


meta, ese ejemplo ya lo habia descargado de la red, pero como dice repetir el ejercicio tablas_03.asm ahí quedé loco porque no lo pude hallar y quedé aislado del proceso que se venia haciendo.

hasta donde entendí lo que hace es guardar la posición del pcl, incrementar el pch en 1 si se ha desbordado el pcl y luego retomar el valor pcl para continuar, pero si quisiera un codigo un poco mas sencillo para ver la cosa mas clara , si no es molestia, si lo entendiste y te funcionó mejor por fa me explicas mas detalladamente........

gracias
01/10/2008 #9

Avatar de Meta

Alejandro Sherar dijo:
Este tipo de cosas me decidió a pasarme a C.
Por ejemplo, para cargar tablas largas (bitmaps de hasta 2k, el tamaño de la página) basta con definirlas como const; por ejemplo:

unsigned char const logo[2043] = {
0, 0, 15, 31, 63, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, ...};

Si declaro una cadena en forma explícita:

char texto[]="abcdefghijklmnopqrstuvwxyz67890123456789";

hay un límite y sale un mensaje de error (que no me puse a investigar demasiado).
Preferí resolverlo cargando las cadenas como hace con los bitmaps.

unsigned char const texto[41] = {"abcdefghijklmnopqrstuvwxyz67890123456789"};

para luego invocar haciendo:
...
char ch;
ch=texto[n];
Mostrar_Texto(x, y, &ch);
...

Gano tiempo para hacer otras cosas pero la macana es que ahora no veo bien cómo hace, y se extraña un poco.
Pero, para mi gusto, creo que en aplicaciones medianamente grandes ya vale la pena pensar en pasarse a C.
Al principio cuesta un poco de tiempo rehacer algunas cosas, pero luego uno va más rápido.
Amigo, para eso se hizo el C para PIC. No por amor del arte. Aún así en PIC pequeños, es más eficiente el ASM. Me gustaría hacer los programas que hago de Visual C# en ASM porque es más eficiente, mejor pensando bien, en C porque acabo antes y me lío menos.
01/10/2008 #10

Avatar de Meta

haroldcito dijo:
meta, ese ejemplo ya lo habia descargado de la red, pero como dice repetir el ejercicio tablas_03.asm ahí quedé loco porque no lo pude hallar y quedé aislado del proceso que se venia haciendo.

hasta donde entendí lo que hace es guardar la posición del pcl, incrementar el pch en 1 si se ha desbordado el pcl y luego retomar el valor pcl para continuar, pero si quisiera un codigo un poco mas sencillo para ver la cosa mas clara , si no es molestia, si lo entendiste y te funcionó mejor por fa me explicas mas detalladamente........

gracias
No, no lo entiendo del todo ya que no puse empeño en ello por ahora. Estoy empeñado ahora en los RS232.
01/10/2008 #11


muchachos, en el ejemplo del AN655 las tablas no ocupan mas allá de la posición 0ffh, así que es como tener la cantidad normal que permite el pic.

de todos modos gracias por el intento.
01/10/2008 #12

Avatar de Meta

Pes que hagan el FFFFh, o lo que es lo mismo 0xFFFF donde las dos primeras 0xFF es el alto y las dos FF últimas el bajo. Entiendo eso en el ejemplo del libro.
01/10/2008 #13
Excluido


hola, aun no he comenzado de nuevo con los pic pero me asalta una duda acerca de lo que ponen, por lo que entiendo tablas de mas de una pagina se vuelve un parto.
pero con C si va.
y solo es un lenguaje.
el pic lo hace =

asi que se supone entonces que es cuestion de ver cual es el procedimiento que se usa en C y aplicarlo en assembler .

o me equivoco en algo ?
01/10/2008 #14

Avatar de asherar

fernandob dijo:
...asi que se supone entonces que es cuestion de ver cual es el procedimiento que se usa en C y aplicarlo en assembler .
Eso pensamos todos al principio, pero no te lo recomiendo.
Mejor seguí el procedimiento de Meta.
Lo que pasa es que uno, a las variables normalmente les pone nombres nemotécnicos, fáciles de distinguir
y de seguir en un debug. El compilador C le pone nombres que por ejemplo difieren uno de otro en un solo
caracter. Y a eso, él solo puede seguirle la traza.
Si intentás hacerlo vos, al cabo de una hora vas a odiar al C, al assembler, y te vas a acordar de la madre de
varios informaciónrmaticos famosos.

Editado: Para tener una idea del berenjenal en que te meterías, compará este tramo de assembler generado por el compilador de mikroC, con el textito sobriamente comentariado que escribe uno "normalmente".

Código:
;  ASM code generated by mikroVirtualMachine for PIC - V. 6.2.1.0
;  Date/Time: 11/09/2008 13:34:47
;  Info: http://www.mikroelektronika.co.yu


; ADDRESS	OPCODE	ASM
; ----------------------------------------------
$0000	$160A			BSF	PCLATH, 4
$0001	$2800			GOTO	_main
$0004	$	_interrupt:
$0004	$00FF			MOVWF	STACK_15
$0005	$0E03			SWAPF	STATUS, 0
$0006	$0183			CLRF	STATUS
$0007	$00B7			MOVWF	?saveSTATUS
$0008	$0804			MOVF	FSR, 0
$0009	$00B6			MOVWF	?saveFSR
$000A	$080A			MOVF	PCLATH, 0
$000B	$00B8			MOVWF	?savePCLATH
$000C	$018A			CLRF	PCLATH
;T6963C_A1.c,314 :: 		void interrupt() {
;T6963C_A1.c,315 :: 		if (PIR1.CCP1IF)      // CCP1 Interrupt (Capture) occured?
$000D	$1D0C			BTFSS	PIR1, 2
$000E	$2811			GOTO	L_interrupt_29
;T6963C_A1.c,317 :: 		PIR1.CCP1IF=0;     // Clear CCP1 Interrupt Flag
$000F	$110C			BCF	PIR1, 2
;T6963C_A1.c,321 :: 		}
$0010	$2820			GOTO	L_interrupt_30
$0011	$	L_interrupt_29:
;T6963C_A1.c,322 :: 		else if (PIR1.TMR1IF)
$0011	$1C0C			BTFSS	PIR1, 0
$0012	$2816			GOTO	L_interrupt_31
;T6963C_A1.c,324 :: 		PIR1.TMR1IF=0;    // Clear T1 Overflow Interrupt Flag
$0013	$100C			BCF	PIR1, 0
;T6963C_A1.c,325 :: 		PORTB.F1=1;	      // Pone mensaje (bit) de ERROR
$0014	$1486			BSF	PORTB, 1
;T6963C_A1.c,326 :: 		}
$0015	$2820			GOTO	L_interrupt_32
$0016	$	L_interrupt_31:
;T6963C_A1.c,327 :: 		else if (INTCON.T0IF)
$0016	$1D0B			BTFSS	INTCON, 2
$0017	$281C			GOTO	L_interrupt_33
;T6963C_A1.c,329 :: 		INTCON.T0IF = 0;
$0018	$110B			BCF	INTCON, 2
;T6963C_A1.c,330 :: 		TMR0 -= 100;
$0019	$3064			MOVLW	100
$001A	$0281			SUBWF	TMR0, 1
;T6963C_A1.c,331 :: 		}
$001B	$2820			GOTO	L_interrupt_34
$001C	$	L_interrupt_33:
;T6963C_A1.c,332 :: 		else if (INTCON.RBIF)
$001C	$1C0B			BTFSS	INTCON, 0
$001D	$2820			GOTO	L_interrupt_35
;T6963C_A1.c,334 :: 		INTCON.RBIF = 0;
$001E	$100B			BCF	INTCON, 0
;T6963C_A1.c,335 :: 		PORTB.F1=0;	      //  Limpia mensaje (bit) de ERROR
$001F	$1086			BCF	PORTB, 1
;T6963C_A1.c,336 :: 		}
$0020	$	L_interrupt_35:
$0020	$	L_interrupt_34:
$0020	$	L_interrupt_32:
$0020	$	L_interrupt_30:
;T6963C_A1.c,349 :: 		}// interrupt
$0020	$	L_Interrupt_end:
$0020	$0838			MOVF	?savePCLATH, 0
$0021	$008A			MOVWF	PCLATH
$0022	$0836			MOVF	?saveFSR, 0
$0023	$0084			MOVWF	FSR
$0024	$0E37			SWAPF	?saveSTATUS, 0
$0025	$0083			MOVWF	STATUS
$0026	$0EFF			SWAPF	STACK_15, 1
$0027	$0E7F			SWAPF	STACK_15, 0
$0028	$0009			RETFIE
$0029	$	_sget:
;t6963c_b0_lib.c,89 :: 		unsigned short sget(void)  // get LCD display status byte
;t6963c_b0_lib.c,93 :: 		TRISB=0xFF; //  Deja el puerto como ENTRADA
$0029	$30FF			MOVLW	255
$002A	$1303			BCF	STATUS, RP1
$002B	$1683			BSF	STATUS, RP0
$002C	$0086			MOVWF	TRISB
;t6963c_b0_lib.c,95 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$002D	$1283			BCF	STATUS, RP0
$002E	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,96 :: 		PORTC.F0=1; // CDHI;   // modo status
$002F	$1407			BSF	PORTC, 0
;t6963c_b0_lib.c,97 :: 		PORTC.F4=1; // WRHI;   // desactiva grabacion
$0030	$1607			BSF	PORTC, 4
;t6963c_b0_lib.c,98 :: 		PORTC.F5=0; // RDLO;	 // activa lectura
$0031	$1287			BCF	PORTC, 5
;t6963c_b0_lib.c,100 :: 		PORTC.F3=0; // CELO;	 // activa chip
$0032	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,101 :: 		PORTC.F3=0; // CELO;   // repite para superar los 80 ns
$0033	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,102 :: 		lcd_status=PORTB; // lee el puerto
$0034	$0806			MOVF	PORTB, 0
$0035	$1683			BSF	STATUS, RP0
$0036	$00ED			MOVWF	sget_lcd_status_L0
;t6963c_b0_lib.c,104 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$0037	$1283			BCF	STATUS, RP0
$0038	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,105 :: 		PORTC.F5=1; // RDHI;   // desactiva lectura
$0039	$1687			BSF	PORTC, 5
;t6963c_b0_lib.c,107 :: 		return(lcd_status);
$003A	$1683			BSF	STATUS, RP0
$003B	$086D			MOVF	sget_lcd_status_L0, 0
$003C	$00F0			MOVWF	STACK_0
;t6963c_b0_lib.c,108 :: 		} // sget()
$003D	$0008			RETURN
$003E	$	_espera:
;t6963c_b0_lib.c,73 :: 		void espera()
;t6963c_b0_lib.c,75 :: 		while ((0x03 & sget()) != 0x03) continue;
$003E	$	L_espera_0:
$003E	$2029			CALL	_sget
$003F	$3003			MOVLW	3
$0040	$0570			ANDWF	STACK_0, 0
$0041	$00F1			MOVWF	STACK_1
$0042	$0871			MOVF	STACK_1, 0
$0043	$3A03			XORLW	3
$0044	$1D03			BTFSS	STATUS, Z
$0045	$283E			GOTO	L_espera_0
$0046	$	L_espera_1:
;t6963c_b0_lib.c,76 :: 		}
$0046	$0008			RETURN
$0047	$	_RES032:
$0047	$1303			BCF	STATUS, RP1
$0048	$1283			BCF	STATUS, RP0
$0049	$01F2			CLRF	STACK_2
$004A	$01F1			CLRF	STACK_1
$004B	$01F0			CLRF	STACK_0
$004C	$01F8			CLRF	STACK_8
$004D	$01F3			CLRF	STACK_3
$004E	$3000			MOVLW	0
$004F	$0008			RETURN
$0050	$	_SETFUN32:
$0050	$1303			BCF	STATUS, RP1
$0051	$1283			BCF	STATUS, RP0
$0052	$157B			BSF	STACK_11, 2
$0053	$1FFB			BTFSS	STACK_11, 7
$0054	$285C			GOTO	SETFUN32EEE
$0055	$3001			MOVLW	0x01
$0056	$00F3			MOVWF	STACK_3
$0057	$01F2			CLRF	STACK_2
$0058	$01F1			CLRF	STACK_1
$0059	$01F0			CLRF	STACK_0
$005A	$0DFA			RLF	STACK_10, F
$005B	$0CF2			RRF	STACK_2, F
$005C	$	SETFUN32EEE:
$005C	$30FF			MOVLW	0xFF
$005D	$0008			RETURN
$005E	$	_FIXSIGN32:
$005E	$1303			BCF	STATUS, RP1
$005F	$1283			BCF	STATUS, RP0
$0060	$1FFA			BTFSS	STACK_10, 7
$0061	$13F2			BCF	STACK_2, 7
$0062	$3000			MOVLW	0
$0063	$0008			RETURN
$0064	$	_SETFOV32:
$0064	$1303			BCF	STATUS, RP1
$0065	$1283			BCF	STATUS, RP0
$0066	$14FB			BSF	STACK_11, 1
$0067	$1FFB			BTFSS	STACK_11, 7
$0068	$2870			GOTO	SETFOV32EEE
$0069	$30FF			MOVLW	0xFF
$006A	$00F3			MOVWF	STACK_3
$006B	$00F2			MOVWF	STACK_2
$006C	$00F1			MOVWF	STACK_1
$006D	$00F0			MOVWF	STACK_0
$006E	$0DFA			RLF	STACK_10, F
$006F	$0CF2			RRF	STACK_2, F
$0070	$	SETFOV32EEE:
$0070	$30FF			MOVLW	0xFF
$0071	$0008			RETURN
$0072	$	_dput:
;t6963c_b0_lib.c,132 :: 		void dput(unsigned short byte) // write data byte to LCD module
;t6963c_b0_lib.c,134 :: 		espera();   // Deja el puerto como ENTRADA
$0072	$203E			CALL	_espera
;t6963c_b0_lib.c,136 :: 		TRISB=0;    //  Deja el puerto como SALIDA
$0073	$0186			CLRF	TRISB, 1
;t6963c_b0_lib.c,138 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$0074	$1283			BCF	STATUS, RP0
$0075	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,139 :: 		PORTC.F0=0; // CDLO;   // modo dato
$0076	$1007			BCF	PORTC, 0
;t6963c_b0_lib.c,140 :: 		PORTC.F5=1; // RDHI;	 // desactiva lectura
$0077	$1687			BSF	PORTC, 5
;t6963c_b0_lib.c,141 :: 		PORTC.F4=0; // WRLO;   // activa grabacion
$0078	$1207			BCF	PORTC, 4
;t6963c_b0_lib.c,143 :: 		PORTB=byte; // escribe en el puerto
$0079	$1683			BSF	STATUS, RP0
$007A	$086C			MOVF	FARG_dput+0, 0
$007B	$1283			BCF	STATUS, RP0
$007C	$0086			MOVWF	PORTB
;t6963c_b0_lib.c,144 :: 		PORTC.F3=0; // CELO;	 // activa chip
$007D	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,145 :: 		PORTC.F3=0; // CELO;   // repite para superar los 80 ns
$007E	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,147 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$007F	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,148 :: 		PORTC.F4=1; // WRHI;   // desactiva grabacion
$0080	$1607			BSF	PORTC, 4
;t6963c_b0_lib.c,150 :: 		TRISB=0xFF; //  Deja el puerto como ENTRADA
$0081	$30FF			MOVLW	255
$0082	$1683			BSF	STATUS, RP0
$0083	$0086			MOVWF	TRISB
;t6963c_b0_lib.c,152 :: 		} // end dput()
$0084	$0008			RETURN
$0085	$	_cput:
;t6963c_b0_lib.c,154 :: 		void cput(unsigned short byte) // write command byte to LCD module
;t6963c_b0_lib.c,157 :: 		espera();   // Deja el puerto como ENTRADA
$0085	$203E			CALL	_espera
;t6963c_b0_lib.c,159 :: 		TRISB=0;    //  Deja el puerto como SALIDA
$0086	$0186			CLRF	TRISB, 1
;t6963c_b0_lib.c,161 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$0087	$1283			BCF	STATUS, RP0
$0088	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,162 :: 		PORTC.F0=1; // CDHI;   // modo comando
$0089	$1407			BSF	PORTC, 0
;t6963c_b0_lib.c,163 :: 		PORTC.F5=1; // RDHI;	 // desactiva lectura
$008A	$1687			BSF	PORTC, 5
;t6963c_b0_lib.c,164 :: 		PORTC.F4=0; // WRLO;   // activa grabacion
$008B	$1207			BCF	PORTC, 4
;t6963c_b0_lib.c,166 :: 		PORTB=byte; // escribe en el puerto
$008C	$1683			BSF	STATUS, RP0
$008D	$086C			MOVF	FARG_cput+0, 0
$008E	$1283			BCF	STATUS, RP0
$008F	$0086			MOVWF	PORTB
;t6963c_b0_lib.c,167 :: 		PORTC.F3=0; // CELO;	 // activa chip
$0090	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,168 :: 		PORTC.F3=0; // CELO;   // repite para superar los 80 ns
$0091	$1187			BCF	PORTC, 3
;t6963c_b0_lib.c,170 :: 		PORTC.F3=1; // CEHI;   // desactiva chip
$0092	$1587			BSF	PORTC, 3
;t6963c_b0_lib.c,171 :: 		PORTC.F4=1; // WRHI;   // desactiva grabacion
$0093	$1607			BSF	PORTC, 4
;t6963c_b0_lib.c,173 :: 		TRISB=0xFF; //  Deja el puerto como ENTRADA
$0094	$30FF			MOVLW	255
$0095	$1683			BSF	STATUS, RP0
$0096	$0086			MOVWF	TRISB
;t6963c_b0_lib.c,175 :: 		} // cput()
$0097	$0008			RETURN
$0098	$	_NRM4032:
$0098	$1303			BCF	STATUS, RP1
$0099	$1283			BCF	STATUS, RP0
$009A	$187C			BTFSC	STACK_12, 0
$009B	$28D0			GOTO	NRMRND4032
$009C	$18FC			BTFSC	STACK_12, 1
$009D	$28A1			GOTO	NRM4032
$009E	$197C			BTFSC	STACK_12, 2
$009F	$28EF			GOTO	JMPSETFOV32
$00A0	$289A			GOTO	$-6
$00A1	$	NRM4032:
$00A1	$01A0			CLRF	__math_tempbD
$00A2	$0872			MOVF	STACK_2, W
$00A3	$1D03			BTFSS	STATUS, Z
$00A4	$28C1			GOTO	NORM4032
$00A5	$0871			MOVF	STACK_1, W
$00A6	$00F2			MOVWF	STACK_2
$00A7	$0870			MOVF	STACK_0, W
$00A8	$00F1			MOVWF	STACK_1
$00A9	$0878			MOVF	STACK_8, W
$00AA	$00F0			MOVWF	STACK_0
$00AB	$01F8			CLRF	STACK_8
$00AC	$15A0			BSF	__math_tempbD, 3
$00AD	$0872			MOVF	STACK_2, W
$00AE	$1D03			BTFSS	STATUS, Z
$00AF	$28C1			GOTO	NORM4032
$00B0	$0871			MOVF	STACK_1, W
$00B1	$00F2			MOVWF	STACK_2
$00B2	$0870			MOVF	STACK_0, W
$00B3	$00F1			MOVWF	STACK_1
$00B4	$01F0			CLRF	STACK_0
$00B5	$11A0			BCF	__math_tempbD, 3
$00B6	$1620			BSF	__math_tempbD, 4
$00B7	$0872			MOVF	STACK_2, W
$00B8	$1D03			BTFSS	STATUS, Z
$00B9	$28C1			GOTO	NORM4032
$00BA	$0871			MOVF	STACK_1, W
$00BB	$00F2			MOVWF	STACK_2
$00BC	$01F1			CLRF	STACK_1
$00BD	$15A0			BSF	__math_tempbD, 3
$00BE	$0872			MOVF	STACK_2, W
$00BF	$1903			BTFSC	STATUS, Z
$00C0	$28E3			GOTO	JMPRES032
$00C1	$	NORM4032:
$00C1	$0820			MOVF	__math_tempbD, W
$00C2	$02F3			SUBWF	STACK_3, F
$00C3	$1D03			BTFSS	STATUS, Z
$00C4	$1C03			BTFSS	STATUS, C
$00C5	$28E7			GOTO	JMPSETFUN32
$00C6	$1003			BCF	STATUS, C
$00C7	$	NORM4032A:
$00C7	$1BF2			BTFSC	STACK_2, 7
$00C8	$28D0			GOTO	NRMRND4032
$00C9	$0DF8			RLF	STACK_8, F
$00CA	$0DF0			RLF	STACK_0, F
$00CB	$0DF1			RLF	STACK_1, F
$00CC	$0DF2			RLF	STACK_2, F
$00CD	$0BF3			DECFSZ	STACK_3, F
$00CE	$28C7			GOTO	NORM4032A
$00CF	$28E7			GOTO	JMPSETFUN32
$00D0	$	NRMRND4032:
$00D0	$1B7B			BTFSC	STACK_11, 6
$00D1	$1C70			BTFSS	STACK_0, 0
$00D2	$28EB			GOTO	JMPFIXSIGN32
$00D3	$1FF8			BTFSS	STACK_8, 7
$00D4	$28EB			GOTO	JMPFIXSIGN32
$00D5	$0AF0			INCF	STACK_0, F
$00D6	$1903			BTFSC	STATUS, Z
$00D7	$0AF1			INCF	STACK_1, F
$00D8	$1903			BTFSC	STATUS, Z
$00D9	$0AF2			INCF	STACK_2, F
$00DA	$1D03			BTFSS	STATUS, Z
$00DB	$28EB			GOTO	JMPFIXSIGN32
$00DC	$0CF2			RRF	STACK_2, F
$00DD	$0CF1			RRF	STACK_1, F
$00DE	$0CF0			RRF	STACK_0, F
$00DF	$0AF3			INCF	STACK_3, F
$00E0	$1903			BTFSC	STATUS, Z
$00E1	$28EF			GOTO	JMPSETFOV32
$00E2	$28EB			GOTO	JMPFIXSIGN32
$00E3	$	JMPRES032:
$00E3	$3001			MOVLW	0x01
$00E4	$00FC			MOVWF	STACK_12
$00E5	$2047			CALL	_RES032
$00E6	$28F2			GOTO	NRM4032EEE
$00E7	$	JMPSETFUN32:
$00E7	$3002			MOVLW	0x02
$00E8	$00FC			MOVWF	STACK_12
$00E9	$2050			CALL	_SETFUN32
$00EA	$28F2			GOTO	NRM4032EEE
$00EB	$	JMPFIXSIGN32:
$00EB	$3004			MOVLW	0x04
$00EC	$00FC			MOVWF	STACK_12
$00ED	$205E			CALL	_FIXSIGN32
$00EE	$28F2			GOTO	NRM4032EEE
$00EF	$	JMPSETFOV32:
$00EF	$3008			MOVLW	0x08
$00F0	$00FC			MOVWF	STACK_12
$00F1	$2064			CALL	_SETFOV32
$00F2	$	NRM4032EEE:
$00F2	$0000			NOP
$00F3	$0008			RETURN
$00F4	$	_NRM3232:
$00F4	$1303			BCF	STATUS, RP1
$00F5	$1283			BCF	STATUS, RP0
$00F6	$01A0			CLRF	__math_tempbD
$00F7	$0872			MOVF	STACK_2, W
$00F8	$1D03			BTFSS	STATUS, Z
$00F9	$290B			GOTO	NORM3232
$00FA	$0871			MOVF	STACK_1, W
$00FB	$00F2			MOVWF	STACK_2
$00FC	$0870			MOVF	STACK_0, W
$00FD	$00F1			MOVWF	STACK_1
$00FE	$01F0			CLRF	STACK_0
$00FF	$15A0			BSF	__math_tempbD, 3
$0100	$0872			MOVF	STACK_2, W
$0101	$1D03			BTFSS	STATUS, Z
$0102	$290B			GOTO	NORM3232
$0103	$0871			MOVF	STACK_1, W
$0104	$00F2			MOVWF	STACK_2
$0105	$01F1			CLRF	STACK_1
$0106	$11A0			BCF	__math_tempbD, 3
$0107	$1620			BSF	__math_tempbD, 4
$0108	$0872			MOVF	STACK_2, W
$0109	$1903			BTFSC	STATUS, Z
$010A	$2919			GOTO	JPNRES032
$010B	$	NORM3232:
$010B	$0820			MOVF	__math_tempbD, W
$010C	$02F3			SUBWF	STACK_3, F
$010D	$1D03			BTFSS	STATUS, Z
$010E	$1C03			BTFSS	STATUS, C
$010F	$291D			GOTO	JPNSETFUN32
$0110	$1003			BCF	STATUS, C
$0111	$	NORM3232A:
$0111	$1BF2			BTFSC	STACK_2, 7
$0112	$2921			GOTO	JMPNFIXSIGN32
$0113	$0DF0			RLF	STACK_0, F
$0114	$0DF1			RLF	STACK_1, F
$0115	$0DF2			RLF	STACK_2, F
$0116	$0BF3			DECFSZ	STACK_3, F
$0117	$2911			GOTO	NORM3232A
$0118	$291D			GOTO	JPNSETFUN32
$0119	$	JPNRES032:
$0119	$3001			MOVLW	0x01
$011A	$00FC			MOVWF	STACK_12
$011B	$2047			CALL	_RES032
$011C	$2924			GOTO	NORM32EEE
$011D	$	JPNSETFUN32:
$011D	$3002			MOVLW	0x02
$011E	$00FC			MOVWF	STACK_12
$011F	$2050			CALL	_SETFUN32
$0120	$2924			GOTO	NORM32EEE
$0121	$	JMPNFIXSIGN32:
$0121	$3004			MOVLW	0x04
$0122	$00FC			MOVWF	STACK_12
$0123	$205E			CALL	_FIXSIGN32
$0124	$	NORM32EEE:
$0124	$0008			RETURN
$0125	$	_calcular_pos_mem:
;T6963C_B1_lib.c,64 :: 		unsigned short FILA)
;T6963C_B1_lib.c,69 :: 		addr  = BASE;
$0125	$1303			BCF	STATUS, RP1
$0126	$1683			BSF	STATUS, RP0
$0127	$0864			MOVF	FARG_calcular_pos_mem+0, 0
$0128	$00E9			MOVWF	calcular_pos_mem_addr_L0
$0129	$0865			MOVF	FARG_calcular_pos_mem+1, 0
$012A	$00EA			MOVWF	calcular_pos_mem_addr_L0+1
;T6963C_B1_lib.c,70 :: 		valor = 0;
$012B	$01EB			CLRF	calcular_pos_mem_valor_L0, 1
;T6963C_B1_lib.c,71 :: 		while ( valor<FILA )
$012C	$	L_calcular_pos_mem_6:
$012C	$0868			MOVF	FARG_calcular_pos_mem+4, 0
$012D	$026B			SUBWF	calcular_pos_mem_valor_L0, 0
$012E	$1803			BTFSC	STATUS, C
$012F	$2938			GOTO	L_calcular_pos_mem_7
;T6963C_B1_lib.c,73 :: 		valor= valor+ 1;
$0130	$0AEB			INCF	calcular_pos_mem_valor_L0, 1
;T6963C_B1_lib.c,74 :: 		addr = addr + LARGO;
$0131	$0866			MOVF	FARG_calcular_pos_mem+2, 0
$0132	$07E9			ADDWF	calcular_pos_mem_addr_L0, 1
$0133	$0867			MOVF	FARG_calcular_pos_mem+3, 0
$0134	$1803			BTFSC	STATUS, C
$0135	$3F01			ADDLW	1
$0136	$07EA			ADDWF	calcular_pos_mem_addr_L0+1, 1
;T6963C_B1_lib.c,75 :: 		}
$0137	$292C			GOTO	L_calcular_pos_mem_6
$0138	$	L_calcular_pos_mem_7:
;T6963C_B1_lib.c,76 :: 		return (addr);
$0138	$0869			MOVF	calcular_pos_mem_addr_L0, 0
$0139	$00F0			MOVWF	STACK_0
$013A	$086A			MOVF	calcular_pos_mem_addr_L0+1, 0
$013B	$00F1			MOVWF	STACK_0+1
;T6963C_B1_lib.c,77 :: 		} // calcula_pos_mem
$013C	$0008			RETURN
$013D	$	_Div_16x16_U:
$013D	$1303			BCF	STATUS, RP1
$013E	$1283			BCF	STATUS, RP0
$013F	$01F8			CLRF	STACK_8
$0140	$01F9			CLRF	STACK_9
$0141	$3010			MOVLW	16
$0142	$00FC			MOVWF	STACK_12
$0143	$0D71			RLF	STACK_1, W
$0144	$0DF8			RLF	STACK_8, F
$0145	$0DF9			RLF	STACK_9, F
$0146	$0874			MOVF	STACK_4, W
$0147	$02F8			SUBWF	STACK_8, F
$0148	$0875			MOVF	STACK_5, W
$0149	$1C03			BTFSS	STATUS, C
$014A	$0F75			INCFSZ	STACK_5, W
$014B	$02F9			SUBWF	STACK_9, F
$014C	$1803			BTFSC	STATUS, C
$014D	$2955			GOTO	$+8
$014E	$0874			MOVF	STACK_4, W
$014F	$07F8			ADDWF	STACK_8, F
$0150	$0875			MOVF	STACK_5, W
$0151	$1803			BTFSC	STATUS, C
$0152	$0F75			INCFSZ	STACK_5, W
$0153	$07F9			ADDWF	STACK_9, F
$0154	$1003			BCF	STATUS, C
$0155	$0DF0			RLF	STACK_0, F
$0156	$0DF1			RLF	STACK_1, F
$0157	$0BFC			DECFSZ	STACK_12, F
$0158	$2943			GOTO	$-21
$0159	$0008			RETURN
$015A	$	_strlen:
$015A	$1303			BCF	STATUS, RP1
$015B	$1683			BSF	STATUS, RP0
$015C	$0864			MOVF	FARG_strlen+0, 0
$015D	$00E5			MOVWF	strlen_cp_L0
$015E	$	L_strlen_33:
$015E	$0865			MOVF	strlen_cp_L0, 0
$015F	$0084			MOVWF	FSR
$0160	$0AE5			INCF	strlen_cp_L0, 1

$0161	$0800			MOVF	INDF, 0
$0162	$00F0			MOVWF	STACK_0
$0163	$0870			MOVF	STACK_0, 0
$0164	$1D03			BTFSS	STATUS, Z
$0165	$295E			GOTO	L_strlen_33
$0166	$	L_strlen_34:
$0166	$0864			MOVF	FARG_strlen+0, 0
$0167	$0265			SUBWF	strlen_cp_L0, 0
$0168	$00F0			MOVWF	STACK_0
$0169	$3001			MOVLW	1
$016A	$02F0			SUBWF	STACK_0, 1
$016B	$01F1			CLRF	STACK_0+1
$016C	$1C03			BTFSS	STATUS, C
$016D	$03F1			DECF	STACK_0+1, 1
$016E	$0008			RETURN
$016F	$	_glcd_putchar:
;T6963C_B1_lib.c,245 :: 		void glcd_putchar(char *letra)  // send char to LCD
;T6963C_B1_lib.c,248 :: 		c = *letra - 0x20;  // convert ASCII to LCD char address
$016F	$1303			BCF	STATUS, RP1
$0170	$1683			BSF	STATUS, RP0
$0171	$0864			MOVF	FARG_glcd_putchar+0, 0
$0172	$0084			MOVWF	FSR
$0173	$0800			MOVF	INDF, 0
$0174	$00F0			MOVWF	STACK_0
$0175	$3020			MOVLW	32
$0176	$0270			SUBWF	STACK_0, 0
$0177	$00F1			MOVWF	STACK_1
$0178	$01F2			CLRF	STACK_1+1
$0179	$1C03			BTFSS	STATUS, C
$017A	$03F2			DECF	STACK_1+1, 1
...
$0E8E	$3030			MOVLW	48
$0E8F	$00A9			MOVWF	lstr16_T6963C_A1+1
$0E90	$3030			MOVLW	48
$0E91	$00AA			MOVWF	lstr16_T6963C_A1+2
$0E92	$01AB			CLRF	lstr16_T6963C_A1+3
;T6963C_A1.c,275 :: 		void Textos()
;T6963C_A1.c,278 :: 		strcpy(TXT,"000");
$0E93	$302E			MOVLW	_TXT
$0E94	$00CB			MOVWF	FARG_strcpy+0
$0E95	$30A0			MOVLW	lstr14_T6963C_A1
$0E96	$00CC			MOVWF	FARG_strcpy+1
$0E97	$118A			BCF	PCLATH, 3
$0E98	$26A1			CALL	_strcpy
$0E99	$158A			BSF	PCLATH, 3
;T6963C_A1.c,279 :: 		Mostrar_Texto(8, 9,TXT); // TORQUE
$0E9A	$3008			MOVLW	8
$0E9B	$00CB			MOVWF	FARG_Mostrar_Texto+0
$0E9C	$3009			MOVLW	9
$0E9D	$00CC			MOVWF	FARG_Mostrar_Texto+1
$0E9E	$302E			MOVLW	_TXT
$0E9F	$00CD			MOVWF	FARG_Mostrar_Texto+2
$0EA0	$118A			BCF	PCLATH, 3
$0EA1	$24FC			CALL	_Mostrar_Texto
$0EA2	$158A			BSF	PCLATH, 3
;T6963C_A1.c,282 :: 		strcpy(TXT,"000");
$0EA3	$302E			MOVLW	_TXT
$0EA4	$00CB			MOVWF	FARG_strcpy+0
$0EA5	$30A4			MOVLW	lstr15_T6963C_A1
$0EA6	$00CC			MOVWF	FARG_strcpy+1
$0EA7	$118A			BCF	PCLATH, 3
$0EA8	$26A1			CALL	_strcpy
$0EA9	$158A			BSF	PCLATH, 3
;T6963C_A1.c,283 :: 		Mostrar_Texto(8,10,TXT); //RPM);
$0EAA	$3008			MOVLW	8
$0EAB	$00CB			MOVWF	FARG_Mostrar_Texto+0
$0EAC	$300A			MOVLW	10
$0EAD	$00CC			MOVWF	FARG_Mostrar_Texto+1
$0EAE	$302E			MOVLW	_TXT
$0EAF	$00CD			MOVWF	FARG_Mostrar_Texto+2
$0EB0	$118A			BCF	PCLATH, 3
$0EB1	$24FC			CALL	_Mostrar_Texto
$0EB2	$158A			BSF	PCLATH, 3
;T6963C_A1.c,286 :: 		strcpy(TXT,"000");
$0EB3	$302E			MOVLW	_TXT
$0EB4	$00CB			MOVWF	FARG_strcpy+0
$0EB5	$30A8			MOVLW	lstr16_T6963C_A1
$0EB6	$00CC			MOVWF	FARG_strcpy+1
$0EB7	$118A			BCF	PCLATH, 3
$0EB8	$26A1			CALL	_strcpy
$0EB9	$158A			BSF	PCLATH, 3
;T6963C_A1.c,287 :: 		Mostrar_Texto(8,11,TXT); //NPTS);
$0EBA	$3008			MOVLW	8
$0EBB	$00CB			MOVWF	FARG_Mostrar_Texto+0
$0EBC	$300B			MOVLW	11
$0EBD	$00CC			MOVWF	FARG_Mostrar_Texto+1
$0EBE	$302E			MOVLW	_TXT
$0EBF	$00CD			MOVWF	FARG_Mostrar_Texto+2
$0EC0	$118A			BCF	PCLATH, 3
$0EC1	$24FC			CALL	_Mostrar_Texto
$0EC2	$158A			BSF	PCLATH, 3
;T6963C_A1.c,288 :: 		}
$0EC3	$0008			RETURN
$071D	$	_Ver_Maximos:
;T6963C_A1.c,304 :: 		void Ver_Maximos()
;T6963C_A1.c,312 :: 		}
$071D	$0008			RETURN
$1000	$	_main:
$1000	$3054			MOVLW	84
$1001	$1303			BCF	STATUS, RP1
$1002	$1283			BCF	STATUS, RP0
$1003	$00B9			MOVWF	lstr5_T6963C_A1+0
$1004	$306F			MOVLW	111
$1005	$00BA			MOVWF	lstr5_T6963C_A1+1
$1006	$3072			MOVLW	114
$1007	$00BB			MOVWF	lstr5_T6963C_A1+2
$1008	$3071			MOVLW	113
$1009	$00BC			MOVWF	lstr5_T6963C_A1+3
$100A	$3075			MOVLW	117
$100B	$00BD			MOVWF	lstr5_T6963C_A1+4
$100C	$3065			MOVLW	101
$100D	$00BE			MOVWF	lstr5_T6963C_A1+5
$100E	$303D			MOVLW	61
$100F	$00BF			MOVWF	lstr5_T6963C_A1+6
$1010	$01C0			CLRF	lstr5_T6963C_A1+7
$1011	$304E			MOVLW	78
$1012	$00C1			MOVWF	lstr6_T6963C_A1+0
$1013	$306D			MOVLW	109
$1014	$00C2			MOVWF	lstr6_T6963C_A1+1
$1015	$01C3			CLRF	lstr6_T6963C_A1+2
$1016	$3052			MOVLW	82
$1017	$00C4			MOVWF	lstr7_T6963C_A1+0
$1018	$302E			MOVLW	46
$1019	$00C5			MOVWF	lstr7_T6963C_A1+1
$101A	$3050			MOVLW	80
$101B	$00C6			MOVWF	lstr7_T6963C_A1+2
$101C	$302E			MOVLW	46
$101D	$00C7			MOVWF	lstr7_T6963C_A1+3
$101E	$304D			MOVLW	77
$101F	$00C8			MOVWF	lstr7_T6963C_A1+4
$1020	$302E			MOVLW	46
$1021	$00C9			MOVWF	lstr7_T6963C_A1+5
$1022	$303D			MOVLW	61
$1023	$00CA			MOVWF	lstr7_T6963C_A1+6
$1024	$01CB			CLRF	lstr7_T6963C_A1+7
$1025	$3050			MOVLW	80
$1026	$00CC			MOVWF	lstr8_T6963C_A1+0
$1027	$3075			MOVLW	117
$1028	$00CD			MOVWF	lstr8_T6963C_A1+1
$1029	$306E			MOVLW	110
$102A	$00CE			MOVWF	lstr8_T6963C_A1+2
$102B	$3074			MOVLW	116
$102C	$00CF			MOVWF	lstr8_T6963C_A1+3
$102D	$306F			MOVLW	111
$102E	$00D0			MOVWF	lstr8_T6963C_A1+4
$102F	$3073			MOVLW	115
$1030	$00D1			MOVWF	lstr8_T6963C_A1+5
$1031	$303D			MOVLW	61
$1032	$00D2			MOVWF	lstr8_T6963C_A1+6
$1033	$01D3			CLRF	lstr8_T6963C_A1+7
$1034	$304D			MOVLW	77
$1035	$00D4			MOVWF	lstr9_T6963C_A1+0
$1036	$304F			MOVLW	79
$1037	$00D5			MOVWF	lstr9_T6963C_A1+1
$1038	$3044			MOVLW	68
$1039	$00D6			MOVWF	lstr9_T6963C_A1+2
$103A	$304F			MOVLW	79
$103B	$00D7			MOVWF	lstr9_T6963C_A1+3
$103C	$303A			MOVLW	58
$103D	$00D8			MOVWF	lstr9_T6963C_A1+4
$103E	$3020			MOVLW	32
$103F	$00D9			MOVWF	lstr9_T6963C_A1+5
$1040	$3059			MOVLW	89
$1041	$00DA			MOVWF	lstr9_T6963C_A1+6
$1042	$3020			MOVLW	32
$1043	$00DB			MOVWF	lstr9_T6963C_A1+7
$1044	$3076			MOVLW	118
$1045	$00DC			MOVWF	lstr9_T6963C_A1+8
$1046	$3073			MOVLW	115
$1047	$00DD			MOVWF	lstr9_T6963C_A1+9
$1048	$302E			MOVLW	46
$1049	$00DE			MOVWF	lstr9_T6963C_A1+10
$104A	$3020			MOVLW	32
$104B	$00DF			MOVWF	lstr9_T6963C_A1+11
$104C	$3058			MOVLW	88
$104D	$00E0			MOVWF	lstr9_T6963C_A1+12
$104E	$01E1			CLRF	lstr9_T6963C_A1+13
$104F	$3054			MOVLW	84
$1050	$00E2			MOVWF	lstr10_T6963C_A1+0
$1051	$01E3			CLRF	lstr10_T6963C_A1+1
$1052	$3058			MOVLW	88
$1053	$00E4			MOVWF	lstr11_T6963C_A1+0
$1054	$01E5			CLRF	lstr11_T6963C_A1+1
$1055	$3054			MOVLW	84
$1056	$00E6			MOVWF	lstr12_T6963C_A1+0
$1057	$01E7			CLRF	lstr12_T6963C_A1+1
$1058	$302A			MOVLW	42
$1059	$00E8			MOVWF	lstr13_T6963C_A1+0
$105A	$01E9			CLRF	lstr13_T6963C_A1+1
;T6963C_A1.c,96 :: 		void main(void)
;T6963C_A1.c,100 :: 		glcd_config(128,128,6,8);
$105B	$3080			MOVLW	128
$105C	$00EA			MOVWF	FARG_glcd_config+0
$105D	$3080			MOVLW	128
$105E	$00EB			MOVWF	FARG_glcd_config+1
$105F	$3006			MOVLW	6
$1060	$00EC			MOVWF	FARG_glcd_config+2
$1061	$3008			MOVLW	8
$1062	$00ED			MOVWF	FARG_glcd_config+3
$1063	$118A			BCF	PCLATH, 3
$1064	$120A			BCF	PCLATH, 4
$1065	$26BB			CALL	_glcd_config
$1066	$160A			BSF	PCLATH, 4
;T6963C_A1.c,103 :: 		TRISA  = 0b00011111;   // RA5 salida y el resto entradas
$1067	$301F			MOVLW	31
$1068	$1683			BSF	STATUS, RP0
$1069	$0085			MOVWF	TRISA
;T6963C_A1.c,104 :: 		ADCON1 = 0b00000100;   // RA0 analogica y el resto digitales
$106A	$3004			MOVLW	4
$106B	$009F			MOVWF	ADCON1
;T6963C_A1.c,105 :: 		APAGA_LED;
$106C	$1283			BCF	STATUS, RP0
$106D	$1685			BSF	PORTA, 5
;T6963C_A1.c,107 :: 		ADCON0 = 0b00000000;   // Fosc/2, Channel:0, Conversor:OFF
$106E	$019F			CLRF	ADCON0, 1
;T6963C_A1.c,112 :: 		PRENDE_LED;
$106F	$1285			BCF	PORTA, 5
;T6963C_A1.c,113 :: 		glcd_inicio();
$1070	$158A			BSF	PCLATH, 3
$1071	$120A			BCF	PCLATH, 4
$1072	$216B			CALL	_glcd_inicio
$1073	$118A			BCF	PCLATH, 3
$1074	$160A			BSF	PCLATH, 4
;T6963C_A1.c,115 :: 		LIMPIAR_TEXTOS
$1075	$01DB			CLRF	FARG_glcd_put_ptr+0
$1076	$01DC			CLRF	FARG_glcd_put_ptr+1
$1077	$1283			BCF	STATUS, RP0
$1078	$0821			MOVF	__NRO_DE_COLUMNAS_TX, 0
$1079	$1683			BSF	STATUS, RP0
$107A	$00DD			MOVWF	FARG_glcd_put_ptr+2
$107B	$01DE			CLRF	FARG_glcd_put_ptr+3
$107C	$01DF			CLRF	FARG_glcd_put_ptr+4, 1
$107D	$01E0			CLRF	FARG_glcd_put_ptr+5, 1
$107E	$118A			BCF	PCLATH, 3
$107F	$120A			BCF	PCLATH, 4
$1080	$2270			CALL	_glcd_put_ptr
$1081	$160A			BSF	PCLATH, 4
$1082	$3016			MOVLW	22
$1083	$1283			BCF	STATUS, RP0
$1084	$00EA			MOVWF	FARG_glcd_fill_byte+0
$1085	$3010			MOVLW	16
$1086	$00EB			MOVWF	FARG_glcd_fill_byte+1
$1087	$01EC			CLRF	FARG_glcd_fill_byte+2, 1
$1088	$118A			BCF	PCLATH, 3
$1089	$120A			BCF	PCLATH, 4
$108A	$26EF			CALL	_glcd_fill_byte
$108B	$160A			BSF	PCLATH, 4
;T6963C_A1.c,116 :: 		glcd_set_cursor_height(2); // Alto = 3
$108C	$3002			MOVLW	2
$108D	$00EA			MOVWF	FARG_glcd_set_cursor_height+0
$108E	$118A			BCF	PCLATH, 3
$108F	$120A			BCF	PCLATH, 4
$1090	$2708			CALL	_glcd_set_cursor_height
$1091	$160A			BSF	PCLATH, 4
;T6963C_A1.c,117 :: 		glcd_put_cursor(0,0);
$1092	$1283			BCF	STATUS, RP0
$1093	$01EA			CLRF	FARG_glcd_put_cursor+0, 1
$1094	$01EB			CLRF	FARG_glcd_put_cursor+1, 1
$1095	$158A			BSF	PCLATH, 3
$1096	$120A			BCF	PCLATH, 4
$1097	$21E7			CALL	_glcd_put_cursor
$1098	$118A			BCF	PCLATH, 3
$1099	$160A			BSF	PCLATH, 4
;T6963C_A1.c,118 :: 		glcd_activar(_CURS + _PARP + _TEXT);
$109A	$3007			MOVLW	7
$109B	$1283			BCF	STATUS, RP0
$109C	$00EA			MOVWF	FARG_glcd_activar+0
$109D	$118A			BCF	PCLATH, 3
$109E	$120A			BCF	PCLATH, 4
$109F	$2710			CALL	_glcd_activar
$10A0	$160A			BSF	PCLATH, 4
;T6963C_A1.c,120 :: 		LIMPIAR_GRAFICOS
$10A1	$1283			BCF	STATUS, RP0
$10A2	$01EA			CLRF	FARG_glcd_draw_fondo+0, 1
$10A3	$01EB			CLRF	FARG_glcd_draw_fondo+1, 1
$10A4	$3010			MOVLW	16
$10A5	$00EC			MOVWF	FARG_glcd_draw_fondo+2
$10A6	$3080			MOVLW	128
$10A7	$00ED			MOVWF	FARG_glcd_draw_fondo+3
$10A8	$01EE			CLRF	FARG_glcd_draw_fondo+4, 1
$10A9	$158A			BSF	PCLATH, 3
$10AA	$120A			BCF	PCLATH, 4
$10AB	$21FC			CALL	_glcd_draw_fondo
$10AC	$118A			BCF	PCLATH, 3
$10AD	$160A			BSF	PCLATH, 4
;T6963C_A1.c,121 :: 		glcd_put_cursor(0,1);
$10AE	$1283			BCF	STATUS, RP0
$10AF	$01EA			CLRF	FARG_glcd_put_cursor+0, 1
$10B0	$3001			MOVLW	1
...
10D3	$28CE			GOTO	$-5
$10D4	$28CB			GOTO	$-9
$10D5	$30BF			MOVLW	191
$10D6	$00FB			MOVWF	STACK_11
$10D7	$30FF			MOVLW	255
$10D8	$00FA			MOVWF	STACK_10
$10D9	$0BFB			DECFSZ	STACK_11, F
$10DA	$28DC			GOTO	$+2
$10DB	$28DF			GOTO	$+4
$10DC	$0BFA			DECFSZ	STACK_10, F
$10DD	$28DC			GOTO	$-1
$10DE	$28D9			GOTO	$-5
$10DF	$302C			MOVLW	44
$10E0	$00FA			MOVWF	STACK_10
$10E1	$0BFA			DECFSZ	STACK_10, F
$10E2	$28E1			GOTO	$-1
$10E3	$0000			NOP
$10E4	$0000			NOP
$10E5	$300D			MOVLW	13
$10E6	$00FC			MOVWF	STACK_12
$10E7	$30FF			MOVLW	255
$10E8	$00FB			MOVWF	STACK_11
$10E9	$30FF			MOVLW	255
$10EA	$00FA			MOVWF	STACK_10
$10EB	$0BFC			DECFSZ	STACK_12, F
$10EC	$28EE			GOTO	$+2
$10ED	$28F5			GOTO	$+8
$10EE	$0BFB			DECFSZ	STACK_11, F
$10EF	$28F1			GOTO	$+2
$10F0	$28F4			GOTO	$+4
$10F1	$0BFA			DECFSZ	STACK_10, F
$10F2	$28F1			GOTO	$-1
$10F3	$28EE			GOTO	$-5
$10F4	$28EB			GOTO	$-9
$10F5	$30BF			MOVLW	191
$10F6	$00FB			MOVWF	STACK_11
$10F7	$30FF			MOVLW	255
$10F8	$00FA			MOVWF	STACK_10
$10F9	$0BFB			DECFSZ	STACK_11, F
$10FA	$28FC			GOTO	$+2
$10FB	$28FF			GOTO	$+4
$10FC	$0BFA			DECFSZ	STACK_10, F
$10FD	$28FC			GOTO	$-1
$10FE	$28F9			GOTO	$-5
$10FF	$302C			MOVLW	44
$1100	$00FA			MOVWF	STACK_10
$1101	$0BFA			DECFSZ	STACK_10, F
$1102	$2901			GOTO	$-1
$1103	$0000			NOP
$1104	$0000			NOP
$1105	$300D			MOVLW	13
$1106	$00FC			MOVWF	STACK_12
$1107	$30FF			MOVLW	255
$1108	$00FB			MOVWF	STACK_11
$1109	$30FF			MOVLW	255
$110A	$00FA			MOVWF	STACK_10
$110B	$0BFC			DECFSZ	STACK_12, F
$110C	$290E			GOTO	$+2
$110D	$2915			GOTO	$+8
$110E	$0BFB			DECFSZ	STACK_11, F
$110F	$2911			GOTO	$+2
$1110	$2914			GOTO	$+4
$1111	$0BFA			DECFSZ	STACK_10, F
$1112	$2911			GOTO	$-1
$1113	$290E			GOTO	$-5
$1114	$290B			GOTO	$-9
$1115	$30BF			MOVLW	191
$1116	$00FB			MOVWF	STACK_11
$1117	$30FF			MOVLW	255
$1118	$00FA			MOVWF	STACK_10
$1119	$0BFB			DECFSZ	STACK_11, F
$111A	$291C			GOTO	$+2
$111B	$291F			GOTO	$+4
$111C	$0BFA			DECFSZ	STACK_10, F
$111D	$291C			GOTO	$-1
$111E	$2919			GOTO	$-5
$111F	$302C			MOVLW	44
$1120	$00FA			MOVWF	STACK_10
$1121	$0BFA			DECFSZ	STACK_10, F
$1122	$2921			GOTO	$-1
$1123	$0000			NOP
$1124	$0000			NOP
$1125	$300D			MOVLW	13
$1126	$00FC			MOVWF	STACK_12
$1127	$30FF			MOVLW	255
$1128	$00FB			MOVWF	STACK_11
$1129	$30FF			MOVLW	255
$112A	$00FA			MOVWF	STACK_10
$112B	$0BFC			DECFSZ	STACK_12, F
$112C	$292E			GOTO	$+2
$112D	$2935			GOTO	$+8
$112E	$0BFB			DECFSZ	STACK_11, F
$112F	$2931			GOTO	$+2
$1130	$2934			GOTO	$+4
$1131	$0BFA			DECFSZ	STACK_10, F
$1132	$2931			GOTO	$-1
$1133	$292E			GOTO	$-5
$1134	$292B			GOTO	$-9
$1135	$30BF			MOVLW	191
$1136	$00FB			MOVWF	STACK_11
$1137	$30FF			MOVLW	255
$1138	$00FA			MOVWF	STACK_10
$1139	$0BFB			DECFSZ	STACK_11, F
$113A	$293C			GOTO	$+2
$113B	$293F			GOTO	$+4
$113C	$0BFA			DECFSZ	STACK_10, F
$113D	$293C			GOTO	$-1
$113E	$2939			GOTO	$-5
$113F	$302C			MOVLW	44
$1140	$00FA			MOVWF	STACK_10
$1141	$0BFA			DECFSZ	STACK_10, F
$1142	$2941			GOTO	$-1
$1143	$0000			NOP
$1144	$0000			NOP
;T6963C_A1.c,130 :: 		PULSAR_LED();
$1145	$158A			BSF	PCLATH, 3
$1146	$120A			BCF	PCLATH, 4
$1147	$2232			CALL	_PULSAR_LED
$1148	$118A			BCF	PCLATH, 3
$1149	$160A			BSF	PCLATH, 4
;T6963C_A1.c,131 :: 		glcd_desactivar(_TEXT);
$114A	$3004			MOVLW	4
$114B	$00EA			MOVWF	FARG_glcd_desactivar+0
$114C	$158A			BSF	PCLATH, 3
$114D	$120A			BCF	PCLATH, 4
$114E	$22FB			CALL	_glcd_desactivar
$114F	$118A			BCF	PCLATH, 3
$1150	$160A			BSF	PCLATH, 4
;T6963C_A1.c,134 :: 		PULSAR_LED();
$1151	$158A			BSF	PCLATH, 3
$1152	$120A			BCF	PCLATH, 4
$1153	$2232			CALL	_PULSAR_LED
$1154	$118A			BCF	PCLATH, 3
$1155	$160A			BSF	PCLATH, 4
;T6963C_A1.c,135 :: 		glcd_draw_fondo( 0,  0, 16, 14,0);
$1156	$01EA			CLRF	FARG_glcd_draw_fondo+0, 1
$1157	$01EB			CLRF	FARG_glcd_draw_fondo+1, 1
$1158	$3010			MOVLW	16
$1159	$00EC			MOVWF	FARG_glcd_draw_fondo+2
$115A	$300E			MOVLW	14
$115B	$00ED			MOVWF	FARG_glcd_draw_fondo+3
$115C	$01EE			CLRF	FARG_glcd_draw_fondo+4, 1
$115D	$158A			BSF	PCLATH, 3
$115E	$120A			BCF	PCLATH, 4
$115F	$21FC			CALL	_glcd_draw_fondo
$1160	$118A			BCF	PCLATH, 3
$1161	$160A			BSF	PCLATH, 4
;T6963C_A1.c,137 :: 		glcd_draw_fondo( 0,114, 16, 14,0);
$1162	$1283			BCF	STATUS, RP0
$1163	$01EA			CLRF	FARG_glcd_draw_fondo+0, 1
$1164	$3072			MOVLW	114
$1165	$00EB			MOVWF	FARG_glcd_draw_fondo+1
$1166	$3010			MOVLW	16
$1167	$00EC			MOVWF	FARG_glcd_draw_fondo+2
$1168	$300E			MOVLW	14
$1169	$00ED			MOVWF	FARG_glcd_draw_fondo+3
$116A	$01EE			CLRF	FARG_glcd_draw_fondo+4, 1
$116B	$158A			BSF	PCLATH, 3
$116C	$120A			BCF	PCLATH, 4
$116D	$21FC			CALL	_glcd_draw_fondo
$116E	$118A			BCF	PCLATH, 3
$116F	$160A			BSF	PCLATH, 4
;T6963C_A1.c,140 :: 		ESC_Delay_seg(3);
$1170	$3003			MOVLW	3
$1171	$1283			BCF	STATUS, RP0
$1172	$00EA			MOVWF	FARG_ESC_Delay_seg+0
$1173	$3000			MOVLW	0
$1174	$00EB			MOVWF	FARG_ESC_Delay_seg+1
$1175	$158A			BSF	PCLATH, 3
$1176	$120A			BCF	PCLATH, 4
$1177	$230C			CALL	_ESC_Delay_seg
$1178	$118A			BCF	PCLATH, 3
$1179	$160A			BSF	PCLATH, 4
;T6963C_A1.c,143 :: 		while(NRO<2) {
$117A	$	L_main_8:
$117A	$3002			MOVLW	2
$117B	$1303			BCF	STATUS, RP1
$117C	$1283			BCF	STATUS, RP0
$117D	$0232			SUBWF	_NRO, 0
$117E	$1803			BTFSC	STATUS, C
$117F	$2A3D			GOTO	L_main_9
;T6963C_A1.c,144 :: 		if(NRO==0) {
$1180	$0832			MOVF	_NRO, 0
$1181	$3A00			XORLW	0
$1182	$1D03			BTFSS	STATUS, Z
$1183	$2996			GOTO	L_main_10
;T6963C_A1.c,145 :: 		glcd_activar(_GRAF);
$1184	$3008			MOVLW	8
$1185	$00EA			MOVWF	FARG_glcd_activar+0
$1186	$118A			BCF	PCLATH, 3
$1187	$120A			BCF	PCLATH, 4
$1188	$2710			CALL	_glcd_activar
$1189	$160A			BSF	PCLATH, 4
;T6963C_A1.c,146 :: 		glcd_desactivar(_TEXT);
$118A	$3004			MOVLW	4
$118B	$1283			BCF	STATUS, RP0
$118C	$00EA			MOVWF	FARG_glcd_desactivar+0
$118D	$158A			BSF	PCLATH, 3
$118E	$120A			BCF	PCLATH, 4
$118F	$22FB			CALL	_glcd_desactivar
$1190	$118A			BCF	PCLATH, 3
$1191	$160A			BSF	PCLATH, 4
;T6963C_A1.c,147 :: 		NRO=1;
$1192	$3001			MOVLW	1
$1193	$1283			BCF	STATUS, RP0
$1194	$00B2			MOVWF	_NRO
;T6963C_A1.c,148 :: 		}
$1195	$29A8			GOTO	L_main_11
$1196	$	L_main_10:
;T6963C_A1.c,150 :: 		glcd_desactivar(_GRAF);
$1196	$3008			MOVLW	8
$1197	$1303			BCF	STATUS, RP1
$1198	$1283			BCF	STATUS, RP0
$1199	$00EA			MOVWF	FARG_glcd_desactivar+0
$119A	$158A			BSF	PCLATH, 3
$119B	$120A			BCF	PCLATH, 4
$119C	$22FB			CALL	_glcd_desactivar
$119D	$118A			BCF	PCLATH, 3
$119E	$160A			BSF	PCLATH, 4
;T6963C_A1.c,151 :: 		glcd_activar(_TEXT);
$119F	$3004			MOVLW	4
$11A0	$1283			BCF	STATUS, RP0
$11A1	$00EA			MOVWF	FARG_glcd_activar+0
$11A2	$118A			BCF	PCLATH, 3
$11A3	$120A			BCF	PCLATH, 4
$11A4	$2710			CALL	_glcd_activar
$11A5	$160A			BSF	PCLATH, 4
;T6963C_A1.c,152 :: 		NRO=0;
$11A6	$1283			BCF	STATUS, RP0
$11A7	$01B2			CLRF	_NRO, 1
;T6963C_A1.c,153 :: 		}
$11A8	$	L_main_11:
...
$1274	$01DC			CLRF	FARG_glcd_put_ptr+1
$1275	$1283			BCF	STATUS, RP0
$1276	$0821			MOVF	__NRO_DE_COLUMNAS_TX, 0
$1277	$1683			BSF	STATUS, RP0
$1278	$00DD			MOVWF	FARG_glcd_put_ptr+2
$1279	$01DE			CLRF	FARG_glcd_put_ptr+3
$127A	$01DF			CLRF	FARG_glcd_put_ptr+4, 1
$127B	$01E0			CLRF	FARG_glcd_put_ptr+5, 1
$127C	$118A			BCF	PCLATH, 3
$127D	$120A			BCF	PCLATH, 4
$127E	$2270			CALL	_glcd_put_ptr
$127F	$160A			BSF	PCLATH, 4
$1280	$3016			MOVLW	22
$1281	$1283			BCF	STATUS, RP0
$1282	$00EA			MOVWF	FARG_glcd_fill_byte+0
$1283	$3010			MOVLW	16
$1284	$00EB			MOVWF	FARG_glcd_fill_byte+1
$1285	$01EC			CLRF	FARG_glcd_fill_byte+2, 1
$1286	$118A			BCF	PCLATH, 3
$1287	$120A			BCF	PCLATH, 4
$1288	$26EF			CALL	_glcd_fill_byte
$1289	$160A			BSF	PCLATH, 4
;T6963C_A1.c,173 :: 		Mostrar_Texto( 1, 9,"Torque=");
$128A	$3001			MOVLW	1
$128B	$1683			BSF	STATUS, RP0
$128C	$00CB			MOVWF	FARG_Mostrar_Texto+0
$128D	$3009			MOVLW	9
$128E	$00CC			MOVWF	FARG_Mostrar_Texto+1
$128F	$3039			MOVLW	lstr5_T6963C_A1
$1290	$00CD			MOVWF	FARG_Mostrar_Texto+2
$1291	$118A			BCF	PCLATH, 3
$1292	$120A			BCF	PCLATH, 4
$1293	$24FC			CALL	_Mostrar_Texto
$1294	$160A			BSF	PCLATH, 4
;T6963C_A1.c,174 :: 		Mostrar_Texto(12, 9,"Nm");
$1295	$300C			MOVLW	12
$1296	$00CB			MOVWF	FARG_Mostrar_Texto+0
...
$12A0	$00CB			MOVWF	FARG_Mostrar_Texto+0
$12A1	$300A			MOVLW	10
$12A2	$00CC			MOVWF	FARG_Mostrar_Texto+1
$12A3	$3044			MOVLW	lstr7_T6963C_A1
$12A4	$00CD			MOVWF	FARG_Mostrar_Texto+2
$12A5	$118A			BCF	PCLATH, 3
$12A6	$120A			BCF	PCLATH, 4
$12A7	$24FC			CALL	_Mostrar_Texto
$12A8	$160A			BSF	PCLATH, 4
;T6963C_A1.c,176 :: 		Mostrar_Texto( 1,11,"Puntos=");
$12A9	$3001			MOVLW	1
$12AA	$00CB			MOVWF	FARG_Mostrar_Texto+0
$12AB	$300B			MOVLW	11
$12AC	$00CC			MOVWF	FARG_Mostrar_Texto+1
$12AD	$304C			MOVLW	lstr8_T6963C_A1
$12AE	$00CD			MOVWF	FARG_Mostrar_Texto+2
$12AF	$118A			BCF	PCLATH, 3
$12B0	$120A			BCF	PCLATH, 4
$12B1	$24FC			CALL	_Mostrar_Texto
$12B2	$160A			BSF	PCLATH, 4
;T6963C_A1.c,182 :: 		Mostrar_Texto(1,15,"MODO: Y vs. X");
$12B3	$3001			MOVLW	1
$12B4	$00CB			MOVWF	FARG_Mostrar_Texto+0
$12B5	$300F			MOVLW	15
$12B6	$00CC			MOVWF	FARG_Mostrar_Texto+1
$12B7	$3054			MOVLW	lstr9_T6963C_A1
$12B8	$00CD			MOVWF	FARG_Mostrar_Texto+2
$12B9	$118A			BCF	PCLATH, 3
$12BA	$120A			BCF	PCLATH, 4
$12BB	$24FC			CALL	_Mostrar_Texto
$12BC	$160A			BSF	PCLATH, 4
;T6963C_A1.c,183 :: 		glcd_activar(_TEXT);
$12BD	$3004			MOVLW	4
$12BE	$1283			BCF	STATUS, RP0
$12BF	$00EA			MOVWF	FARG_glcd_activar+0
$12C0	$118A			BCF	PCLATH, 3
$12C1	$120A			BCF	PCLATH, 4
$12C2	$2710			CALL	_glcd_activar
$12C3	$160A			BSF	PCLATH, 4
;T6963C_A1.c,184 :: 		glcd_activar(_GRAF);
$12C4	$3008			MOVLW	8
$12C5	$1283			BCF	STATUS, RP0
$12C6	$00EA			MOVWF	FARG_glcd_activar+0
$12C7	$118A			BCF	PCLATH, 3
$12C8	$120A			BCF	PCLATH, 4
$12C9	$2710			CALL	_glcd_activar
$12CA	$160A			BSF	PCLATH, 4
;T6963C_A1.c,185 :: 		PULSAR_LED();
$12CB	$158A			BSF	PCLATH, 3
$12CC	$120A			BCF	PCLATH, 4
$12CD	$2232			CALL	_PULSAR_LED
$12CE	$118A			BCF	PCLATH, 3
$12CF	$160A			BSF	PCLATH, 4
;T6963C_A1.c,188 :: 		NPTS=0;
$12D0	$01AC			CLRF	_NPTS, 1
;T6963C_A1.c,189 :: 		CANAL=1;
$12D1	$3001			MOVLW	1
$12D2	$00B3			MOVWF	_CANAL
;T6963C_A1.c,190 :: 		NRO=0; // Empieza en modo gráfico
$12D3	$01B2			CLRF	_NRO, 1
;T6963C_A1.c,191 :: 		inicio_CCPx();
$12D4	$158A			BSF	PCLATH, 3
$12D5	$120A			BCF	PCLATH, 4
$12D6	$23A6			CALL	_inicio_CCPx
$12D7	$118A			BCF	PCLATH, 3
$12D8	$160A			BSF	PCLATH, 4
;T6963C_A1.c,193 :: 		VTGMIN=10;  // Umbral de trigger
$12D9	$300A			MOVLW	10
$12DA	$00B4			MOVWF	_VTGMIN
;T6963C_A1.c,194 :: 		TRIGGER=0;  // Bandera de trigger
$12DB	$01B5			CLRF	_TRIGGER, 1
;T6963C_A1.c,195 :: 		while(1)
$12DC	$	L_main_14:
;T6963C_A1.c,197 :: 		Mediciones();
$12DC	$158A			BSF	PCLATH, 3
$12DD	$120A			BCF	PCLATH, 4
$12DE	$23BF			CALL	_Mediciones
$12DF	$118A			BCF	PCLATH, 3
$12E0	$160A			BSF	PCLATH, 4
;T6963C_A1.c,198 :: 		if(NRO==0) {
$12E1	$1303			BCF	STATUS, RP1
$12E2	$1283			BCF	STATUS, RP0
$12E3	$0832			MOVF	_NRO, 0
$12E4	$3A00			XORLW	0
$12E5	$1D03			BTFSS	STATUS, Z
$12E6	$2B05			GOTO	L_main_16
;T6963C_A1.c,199 :: 		NPTS = SLAMDA *(121./127.);
$12E7	$082A			MOVF	_SLAMDA, 0
$12E8	$00F0			MOVWF	STACK_0
$12E9	$118A			BCF	PCLATH, 3
$12EA	$120A			BCF	PCLATH, 4
$12EB	$2586			CALL	_byte2double
$12EC	$160A			BSF	PCLATH, 4
$12ED	$30D0			MOVLW	208
$12EE	$00F4			MOVWF	STACK_4
$12EF	$30E7			MOVLW	231
$12F0	$00F5			MOVWF	STACK_4+1
$12F1	$3073			MOVLW	115
$12F2	$00F6			MOVWF	STACK_4+2
$12F3	$307E			MOVLW	126
$12F4	$00F7			MOVWF	STACK_4+3
$12F5	$118A			BCF	PCLATH, 3
$12F6	$120A			BCF	PCLATH, 4
$12F7	$243C			CALL	_mul_32x32_fp
$12F8	$160A			BSF	PCLATH, 4
$12F9	$118A			BCF	PCLATH, 3
$12FA	$120A			BCF	PCLATH, 4
$12FB	$2596			CALL	_double2byte
$12FC	$160A			BSF	PCLATH, 4
$12FD	$0870			MOVF	STACK_0, 0
$12FE	$00AC			MOVWF	_NPTS
;T6963C_A1.c,200 :: 		Graficas_YX();
$12FF	$158A			BSF	PCLATH, 3
$1300	$120A			BCF	PCLATH, 4
$1301	$24AB			CALL	_Graficas_YX
$1302	$118A			BCF	PCLATH, 3
$1303	$160A			BSF	PCLATH, 4
;T6963C_A1.c,201 :: 		}
$1304	$2B6F			GOTO	L_main_17
$1305	$	L_main_16:
;T6963C_A1.c,203 :: 		SENO = 30 * (sin(PI*NPTS/30) + 1);
$1305	$1303			BCF	STATUS, RP1
$1306	$1283			BCF	STATUS, RP0
$1307	$082C			MOVF	_NPTS, 0
$1308	$00F0			MOVWF	STACK_0
$1309	$118A			BCF	PCLATH, 3
$130A	$120A			BCF	PCLATH, 4
$130B	$2586			CALL	_byte2double
$130C	$160A			BSF	PCLATH, 4
$130D	$30DB			MOVLW	219
$130E	$00F4			MOVWF	STACK_4
$130F	$300F			MOVLW	15
$1310	$00F5			MOVWF	STACK_4+1
$1311	$3049			MOVLW	73
$1312	$00F6			MOVWF	STACK_4+2
$1313	$3080			MOVLW	128
$1314	$00F7			MOVWF	STACK_4+3
$1315	$118A			BCF	PCLATH, 3
$1316	$120A			BCF	PCLATH, 4
$1317	$243C			CALL	_mul_32x32_fp
$1318	$160A			BSF	PCLATH, 4
$1319	$3000			MOVLW	0
$131A	$00F4			MOVWF	STACK_4
$131B	$3000			MOVLW	0
$131C	$00F5			MOVWF	STACK_4+1
$131D	$3070			MOVLW	112
$131E	$00F6			MOVWF	STACK_4+2
$131F	$3083			MOVLW	131
$1320	$00F7			MOVWF	STACK_4+3
$1321	$158A			BSF	PCLATH, 3

$1322	$120A			BCF	PCLATH, 4
$1323	$20C7			CALL	_div_32x32_fp
$1324	$118A			BCF	PCLATH, 3
$1325	$160A			BSF	PCLATH, 4
$1326	$0870			MOVF	STACK_0, 0
$1327	$00EA			MOVWF	FARG_sin+0
$1328	$0871			MOVF	STACK_0+1, 0
$1329	$00EB			MOVWF	FARG_sin+1
$132A	$0872			MOVF	STACK_0+2, 0
$132B	$00EC			MOVWF	FARG_sin+2
$132C	$0873			MOVF	STACK_0+3, 0
$132D	$00ED			MOVWF	FARG_sin+3
$132E	$158A			BSF	PCLATH, 3
$132F	$120A			BCF	PCLATH, 4
$1330	$24BC			CALL	_sin
$1331	$118A			BCF	PCLATH, 3
$1332	$160A			BSF	PCLATH, 4
$1333	$3000			MOVLW	0
$1334	$00F4			MOVWF	STACK_4
$1335	$3000			MOVLW	0
$1336	$00F5			MOVWF	STACK_4+1
$1337	$3000			MOVLW	0
$1338	$00F6			MOVWF	STACK_4+2
$1339	$307F			MOVLW	127
$133A	$00F7			MOVWF	STACK_4+3
$133B	$118A			BCF	PCLATH, 3
$133C	$120A			BCF	PCLATH, 4
$133D	$21A2			CALL	_add_32x32_fp
$133E	$160A			BSF	PCLATH, 4
$133F	$3000			MOVLW	0
$1340	$00F4			MOVWF	STACK_4
$1341	$3000			MOVLW	0
$1342	$00F5			MOVWF	STACK_4+1
$1343	$3070			MOVLW	112
$1344	$00F6			MOVWF	STACK_4+2
$1345	$3083			MOVLW	131
$1346	$00F7			MOVWF	STACK_4+3
$1347	$118A			BCF	PCLATH, 3
$1348	$120A			BCF	PCLATH, 4
$1349	$243C			CALL	_mul_32x32_fp
$134A	$160A			BSF	PCLATH, 4
$134B	$118A			BCF	PCLATH, 3
$134C	$120A			BCF	PCLATH, 4
$134D	$2596			CALL	_double2byte
$134E	$160A			BSF	PCLATH, 4
$134F	$0870			MOVF	STACK_0, 0
$1350	$00AD			MOVWF	_SENO
;T6963C_A1.c,204 :: 		Graficas_YT();
$1351	$158A			BSF	PCLATH, 3
$1352	$120A			BCF	PCLATH, 4
$1353	$2631			CALL	_Graficas_YT
$1354	$118A			BCF	PCLATH, 3
$1355	$160A			BSF	PCLATH, 4
;T6963C_A1.c,205 :: 		if(TORQUE > VTGMIN)
$1356	$1283			BCF	STATUS, RP0
$1357	$0829			MOVF	_TORQUE, 0
$1358	$0234			SUBWF	_VTGMIN, 0
$1359	$1803			BTFSC	STATUS, C
$135A	$2B68			GOTO	L_main_18
;T6963C_A1.c,207 :: 		TRIGGER=2;
$135B	$3002			MOVLW	2
$135C	$00B5			MOVWF	_TRIGGER
;T6963C_A1.c,208 :: 		Mostrar_Texto(13,15,"T");
$135D	$300D			MOVLW	13
$135E	$1683			BSF	STATUS, RP0
$135F	$00CB			MOVWF	FARG_Mostrar_Texto+0
$1360	$300F			MOVLW	15
$1361	$00CC			MOVWF	FARG_Mostrar_Texto+1
$1362	$3062			MOVLW	lstr10_T6963C_A1
$1363	$00CD			MOVWF	FARG_Mostrar_Texto+2
$1364	$118A			BCF	PCLATH, 3
$1365	$120A			BCF	PCLATH, 4
$1366	$24FC			CALL	_Mostrar_Texto
$1367	$160A			BSF	PCLATH, 4
;T6963C_A1.c,209 :: 		}
$1368	$	L_main_18:
;T6963C_A1.c,210 :: 		if(TRIGGER>1)
$1368	$1303			BCF	STATUS, RP1
$1369	$1283			BCF	STATUS, RP0
$136A	$0835			MOVF	_TRIGGER, 0
$136B	$3C01			SUBLW	1
$136C	$1803			BTFSC	STATUS, C
$136D	$2B6F			GOTO	L_main_19
;T6963C_A1.c,211 :: 		NPTS++;
$136E	$0AAC			INCF	_NPTS, 1
$136F	$	L_main_19:
;T6963C_A1.c,212 :: 		}
$136F	$	L_main_17:
;T6963C_A1.c,213 :: 		Textos();
$136F	$1303			BCF	STATUS, RP1
$1370	$1283			BCF	STATUS, RP0
$1371	$158A			BSF	PCLATH, 3
$1372	$120A			BCF	PCLATH, 4
$1373	$267C			CALL	_Textos
$1374	$118A			BCF	PCLATH, 3
$1375	$160A			BSF	PCLATH, 4
;T6963C_A1.c,215 :: 		if(BOTONLED==1)
$1376	$3000			MOVLW	0
$1377	$1303			BCF	STATUS, RP1
$1378	$1283			BCF	STATUS, RP0
$1379	$1A05			BTFSC	PORTA, 4
$137A	$3001			MOVLW	1
$137B	$00F4			MOVWF	STACK_4
$137C	$0874			MOVF	STACK_4, 0
$137D	$3A01			XORLW	1
$137E	$1D03			BTFSS	STATUS, Z
$137F	$2B85			GOTO	L_main_20
;T6963C_A1.c,217 :: 		NRO = 1 - NRO;
$1380	$0832			MOVF	_NRO, 0
$1381	$3C01			SUBLW	1
$1382	$00B2			MOVWF	_NRO
;T6963C_A1.c,218 :: 		NPTS=122;
$1383	$307A			MOVLW	122
$1384	$00AC			MOVWF	_NPTS
;T6963C_A1.c,219 :: 		}
$1385	$	L_main_20:
;T6963C_A1.c,221 :: 		while(BOTONLED==1)
$1385	$	L_main_21:
$1385	$3000			MOVLW	0
$1386	$1303			BCF	STATUS, RP1
$1387	$1283			BCF	STATUS, RP0
$1388	$1A05			BTFSC	PORTA, 4
$1389	$3001			MOVLW	1
$138A	$00F4			MOVWF	STACK_4
$138B	$0874			MOVF	STACK_4, 0
$138C	$3A01			XORLW	1
$138D	$1903			BTFSC	STATUS, Z
$138E	$2B85			GOTO	L_main_21
;T6963C_A1.c,222 :: 		PULSAR_LED;
$138F	$	L_main_22:
;T6963C_A1.c,224 :: 		if (NPTS>121)
$138F	$1303			BCF	STATUS, RP1
$1390	$1283			BCF	STATUS, RP0
$1391	$082C			MOVF	_NPTS, 0
$1392	$3C79			SUBLW	121
$1393	$1803			BTFSC	STATUS, C
$1394	$2BE6			GOTO	L_main_23
;T6963C_A1.c,226 :: 		Ver_Maximos(); // Máximos de TORQUE Y RPM
$1395	$118A			BCF	PCLATH, 3
$1396	$120A			BCF	PCLATH, 4
$1397	$271D			CALL	_Ver_Maximos
$1398	$160A			BSF	PCLATH, 4
;T6963C_A1.c,227 :: 		PULSAR_LED();
$1399	$158A			BSF	PCLATH, 3
$139A	$120A			BCF	PCLATH, 4
$139B	$2232			CALL	_PULSAR_LED
$139C	$118A			BCF	PCLATH, 3
$139D	$160A			BSF	PCLATH, 4
;T6963C_A1.c,228 :: 		LIMPIAR_GRAFICOS
$139E	$01EA			CLRF	FARG_glcd_draw_fondo+0, 1
$139F	$01EB			CLRF	FARG_glcd_draw_fondo+1, 1
$13A0	$3010			MOVLW	16
$13A1	$00EC			MOVWF	FARG_glcd_draw_fondo+2
$13A2	$3080			MOVLW	128
$13A3	$00ED			MOVWF	FARG_glcd_draw_fondo+3
$13A4	$01EE			CLRF	FARG_glcd_draw_fondo+4, 1
$13A5	$158A			BSF	PCLATH, 3
$13A6	$120A			BCF	PCLATH, 4
$13A7	$21FC			CALL	_glcd_draw_fondo
$13A8	$118A			BCF	PCLATH, 3
$13A9	$160A			BSF	PCLATH, 4
;T6963C_A1.c,229 :: 		glcd_draw_rectangle( 2, 2, 125, 68, 1);
$13AA	$3002			MOVLW	2
$13AB	$1283			BCF	STATUS, RP0
$13AC	$00EA			MOVWF	FARG_glcd_draw_rectangle+0
$13AD	$3002			MOVLW	2
$13AE	$00EB			MOVWF	FARG_glcd_draw_rectangle+1
$13AF	$307D			MOVLW	125
$13B0	$00EC			MOVWF	FARG_glcd_draw_rectangle+2
$13B1	$3044			MOVLW	68
$13B2	$00ED			MOVWF	FARG_glcd_draw_rectangle+3
$13B3	$3001			MOVLW	1
$13B4	$00EE			MOVWF	FARG_glcd_draw_rectangle+4
$13B5	$158A			BSF	PCLATH, 3
$13B6	$120A			BCF	PCLATH, 4
$13B7	$2358			CALL	_glcd_draw_rectangle
$13B8	$118A			BCF	PCLATH, 3
$13B9	$160A			BSF	PCLATH, 4
;T6963C_A1.c,231 :: 		if(NRO==0) {
$13BA	$1283			BCF	STATUS, RP0
$13BB	$0832			MOVF	_NRO, 0
$13BC	$3A00			XORLW	0
$13BD	$1D03			BTFSS	STATUS, Z
$13BE	$2BCB			GOTO	L_main_24
;T6963C_A1.c,232 :: 		Mostrar_Texto(13,15,"X");
$13BF	$300D			MOVLW	13
$13C0	$1683			BSF	STATUS, RP0
$13C1	$00CB			MOVWF	FARG_Mostrar_Texto+0
$13C2	$300F			MOVLW	15
$13C3	$00CC			MOVWF	FARG_Mostrar_Texto+1
$13C4	$3064			MOVLW	lstr11_T6963C_A1
$13C5	$00CD			MOVWF	FARG_Mostrar_Texto+2
$13C6	$118A			BCF	PCLATH, 3
$13C7	$120A			BCF	PCLATH, 4
$13C8	$24FC			CALL	_Mostrar_Texto
$13C9	$160A			BSF	PCLATH, 4
;T6963C_A1.c,233 :: 		}
$13CA	$2BE2			GOTO	L_main_25
$13CB	$	L_main_24:
;T6963C_A1.c,235 :: 		Mostrar_Texto(13,15,"T");
$13CB	$1303			BCF	STATUS, RP1
$13CC	$1683			BSF	STATUS, RP0
$13CD	$300D			MOVLW	13
$13CE	$1303			BCF	STATUS, RP1
$13CF	$1683			BSF	STATUS, RP0
$13D0	$00CB			MOVWF	FARG_Mostrar_Texto+0
$13D1	$300F			MOVLW	15
$13D2	$00CC			MOVWF	FARG_Mostrar_Texto+1
$13D3	$3066			MOVLW	lstr12_T6963C_A1
$13D4	$00CD			MOVWF	FARG_Mostrar_Texto+2
$13D5	$118A			BCF	PCLATH, 3
$13D6	$120A			BCF	PCLATH, 4
$13D7	$24FC			CALL	_Mostrar_Texto
$13D8	$160A			BSF	PCLATH, 4
;T6963C_A1.c,236 :: 		Mostrar_Texto( 0, 9,"*");
$13D9	$01CB			CLRF	FARG_Mostrar_Texto+0, 1
$13DA	$3009			MOVLW	9
$13DB	$00CC			MOVWF	FARG_Mostrar_Texto+1
$13DC	$3068			MOVLW	lstr13_T6963C_A1
$13DD	$00CD			MOVWF	FARG_Mostrar_Texto+2
$13DE	$118A			BCF	PCLATH, 3
$13DF	$120A			BCF	PCLATH, 4
$13E0	$24FC			CALL	_Mostrar_Texto
$13E1	$160A			BSF	PCLATH, 4
;T6963C_A1.c,237 :: 		}
$13E2	$	L_main_25:
;T6963C_A1.c,238 :: 		TRIGGER=0;
$13E2	$1303			BCF	STATUS, RP1
$13E3	$1283			BCF	STATUS, RP0
$13E4	$01B5			CLRF	_TRIGGER, 1
;T6963C_A1.c,239 :: 		NPTS=0;
$13E5	$01AC			CLRF	_NPTS, 1
;T6963C_A1.c,240 :: 		}
$13E6	$	L_main_23:
;T6963C_A1.c,241 :: 		}
$13E6	$2ADC			GOTO	L_main_14
;T6963C_A1.c,242 :: 		} // main()
$13E7	$2BE7			GOTO	$
26/08/2013 #15

Avatar de BKAR

Hola!! reviviendo el Tema...
no entiendo porque mi codigo no corre (almenos no como espero)

Tengo varias tablas..., bueno en este caso seria de la forma DT" QWERTYUIOASFDSF....DSFGSDG" por ejemplo.
las tablas no superan 256bytes, pero tengo varias...

jugando con macros hice un programa que me mandara cada caracter via Serie , todo bien.
entiendo como hace la "magia" de addwf PCL,F dt" cualqueir cosa", dentro de la primera pagina no hay problema(0x00 hasta 0xFF)

pero si quisiera poner la tablaS en la siguiente pagina de memoria(a partir de 0x100) y la tabla es de menos de 256bytes no debería tener problemas!!! cierto?

pero casualmente nose que sucede!!.
mencione que tenia un programa con macros, pero los quite, y solo quisiera que me hagan entender que estoy haciendo mal!!!

me explico:
Código:
list p=16F628A  		 ; Microcontrolador utilizado.-
#include P16F628A.inc    ; Definicion de registros SFR.-

 __CONFIG   _XT_OSC & _PWRTE_ON & _WDT_OFF & _CP_OFF & _MCLRE_ON & _BOREN_OFF & _LVP_OFF
; XT=4Mhz.-

;**** Definicion de variables ****
	Cont_cadena	equ	0x20	; Contador de Cadena.-
	
	Tx	equ	2	; RB2
	Rx	equ	1	; RB1
	
	fin equ 7 ;bandera que me indica si acabo de enviar toda la cadena de caracteres
	
Reset	
	org		0x00		; Aqui comienza el micro.-
	goto	Inicio		; Salto a inicio de mi programa.-
;**** Programa Principal ****
Cadena1
	addwf	PCL,F
	DT		"No Hay Problema!!!"
	bsf		Cont_cadena,fin ; pongo a 1 mi bandera
	return
; tengo un limite de 127 caracteres para enviar antes que "Cont_cadena"
; al incrementar toque el bit 7 que a la Vez es mi Indicador para finalizar

Inicio	
	bsf		STATUS,RP0 	; Pasamos de Banco 0 a Banco 1.-
	bsf		TRISB,Rx	; Rx Entrada.-
	bcf		TRISB,Tx	; Tx Salida.-

;**** Configuracion Modulo USART ***
	movlw	0x04		; configuramos USART en asincrono,alta velocidad BRGH=1.-
	movwf	TXSTA
	movlw	d'25'		; Velocidad a 9600 Baudios <--> XT=4Mhz.-
	movwf	SPBRG

;**** Habilitar Tranmision-Recepcion ***
	bsf 	TXSTA,TXEN	; Habilitacion Transmision.-
	bcf		STATUS,RP0 	; Pasamos de Banco 1 a Banco 0.-
	bsf		RCSTA,SPEN	; Habilitacion Puerto Serie.-
	
Principal
 	movlw	0x0A	; nueva linea
 	call	ENVIA_Tx
  	movlw	0x0D	; retorno de carro
	call	ENVIA_Tx
	
   	clrf	Cont_cadena
 	movf	Cont_cadena,W
 	call	Cadena1   ; Llama a devolver un valor de la Tabla
 	btfss	Cont_cadena,fin
 	goto	$+2
 	goto	$+4
 	call	ENVIA_Tx  ; aqui, W contiene el valor de un ASCII
 	incf	Cont_cadena,F  ; Incremento mi Contador de cadena
 	goto	$-7 ; Regreso

	nop
	goto	$-1

;**** Subrutina Enviar Tx ****
ENVIA_Tx
	bsf		STATUS,RP0 	; Pasamos de Banco 0 a Banco 1.-
	btfss	TXSTA,TRMT	; Ocupado?.-
	goto	$-1
	bcf		STATUS,RP0 	; Pasamos de Banco 1 a Banco 0.-
	movwf	TXREG
	return

	end
funciona correctamente...(adjunto simulacion en proteus).

pero si inicializo mi cadena en 0x100(simplemente poner un org 0x100 antes de la tabla),esto hace que todo el resto del código se ponga despues de la tabla, no hay nada de malo ahi no?(yo creo que no)

no se que rayos pasa!! deberia ejecutar el addwf PCL,F sin problemas pero no!! el PC se queda ahi, en esa instruccion(MPLAB SIM), donde rayos llega a parar!! y regresa al vector de Reset he inicia todo denuevo.

poniendo un org 0x100 antes de la etiqueta "inicio" corre bien, pero si pongo org 0x100 antes de la etiqueta "Cadena1" sucede lo que ya comente...

pd: ¿Porque no varia en PCLATH en la simulación, con el correr de cada instrucción(aun asi después de 0x100)? (no sucede nada en WATCH en MPLABSIM)
Archivos Adjuntos
Tipo de Archivo: rar ayuda!.rar (13,1 KB (Kilobytes), 19 visitas)
26/08/2013 #16

Avatar de Daniel Meza

Saludos, veo que trabajas con el PIC16F628 y con este no se puede hacer lectura de su propia FLASH para implementar éste método

[Aporte] Otra forma de manejar tablas en algunos PIC16F

Con respecto a tu pregunta del PCLATH, en la hoja de aplicación AN556 se aclara que éste solo se modifica con instrucciónes goto o call

CALL and GOTO Instructions
When executing a CALL or GOTO, the low 11-bits are
loaded directly from the instruction opcode. The high
2-bits are loaded from bits 3 and 4 of the PCLATH register.
It is a good practice to pre-load PCLATH with the
high byte of the routine’s address before executing the
routine.
27/08/2013 #17

Avatar de BKAR

leyendo [Aporte] Otra forma de manejar tablas en algunos PIC16F

pero entonces, al grano
PUEDO HACER TABLAS(forma "clasica")?aun sea de menos de 256 bytes pero fuera de 0x00 - 0xFF(no me funciona a mi)? eso es básicamente con lo que quiero lidiar.
27/08/2013 #18
Moderador

Avatar de Chico3001

Si se puede... solo necesitas cargar PCLATH antes de modificar PCL...

http://serdis.dis.ulpgc.es/~itis-dsm...blas%20PIC.ppt

Como tip yo ponia las tablas en una posicion fija de memoria en los ulltimos 256 bytes... osea si el PIC que usaba paginaba de 0x000 a 0x0FFF ponia las tablas en la posicion 0x0FF0

Código:
ORG 0x0000
goto inicio

ORG 0x0004
{rutinas de interrupcion}

{programa principal y subrutinas}

ORG 0x0FF0
{tabla 1}
{tabla 2}
...
...
...
{tabla n}
30/08/2013 #19

Avatar de BKAR

TABLAS en muchas Paginas!
Porfin!! Porfin!!
sabes cual era mi problema? algo sencillo!!, hasta hace poco entendí como funionan PCLATH!! y su relación con las instrucciones de salto!!

ahh me equivoque!! creí saber lo "suficiente" del ASM para los PICs(almenos para los 12f y 16f) :(

pero si que me tarde... gracias!!

logre hacer mis tablas en diferentes paginas, pero cuando rebase el 0x800, tuve problemas.. ahaha y recién arregle(comprendi!) mi codigo

aquí mi aporte!!
y ademas aprendí que el operador $, por ejemplo $-12 NO ES LO MISMO!!--> que $-d'12'... por defecto esta en HEX!, yo pensaba que lo interpretaba todo decimal.. primera ves que escribo un $-d'12'

pd: sugerencias para no usar macros?? nose, es la mejor manera?... punteros se puede usar.. nolose, es solo capricho, optimizar ese codigo.
Archivos Adjuntos
Tipo de Archivo: zip Comprendi!.zip (32,6 KB (Kilobytes), 64 visitas)
27/11/2013 #20

Avatar de Meta

Hola:

El problema que he tenido trabajar en asm, precisamente es lo de las tablas, me dan ganas de pasarme al C solo por eso, a parte de otras cosas engorrosas que te puedes pegar media vida con ensamblador y lenguaje C no tanto, como operaciones o ecuanciones grandes matemáticas. Ahí la potencia del C.

He usado un LCD con muchos mensajes, y en asm no era capaz de usar más de 255 carácteres para el LCD. Los mensajes aunque sea independientes, se van sumando hasta llegar los 256.

Cuando te pasas, hay que tener cuidado porque el PIC no se comporta igual, con lo cual, tendrás un commportamiento no deseado.

Mi objetivo lo cambié por usar una EEPROM 24LC256 solo para muchos mensajes y largos, se puede crear mensajes directamente desde un porgramador con el ic-prog y el winpic800. En este caso caben 32.768 carácteres, 128 mensajes de hasta 256 caracteres cada uno. La desventaja es que sse necesita un protocolo de comunicaciçon I2C y más electrónica. Como el PIC tiene mucho espacio en su interior, prefiero arriesgarme en aprender como se almacena hasta reventar muchos mensajes para el LCD. Con C no hay problemas de ese tipo.

A pesar de que te explica abajo como resolver el problema, si alguien sabe con soltura. Pueden hacer un ejemplo como el dibujo de abajo, en asm claro. El PIC que tenga mucha memoria como el PIC16F88 o el PIC16F886/7.

Ver documento de tablas mayor de 256 bytes.

Un saludo.

Edito:


Ejemplos:

Programa para comprobar el efecto de un uso incorrecto de la instrucción "addwf PCL,F".
Se debe comprobar con el simulador del MPLAB.

Código:
;************************************** Indexado_03.asm
;
; ZONA DE DATOS **********************************************************************

    LIST        P=16F84A
    INCLUDE        <P16F84A.INC>
    __CONFIG    _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC

; ZONA DE CÓDIGOS ********************************************************************

    ORG     0
Inicio
    goto    Principal            ; Posición 000h de memoria de programa.
    clrw                        ; Posición 001h de memoria de programa.
    goto    Inicio                ; Posición 002h de memoria de programa.

    ORG    0xFE                    ; Fija la posición de la memoria de programa en 0x0FE.
Principal
    movlw    .1                    ; Posición 0FEh de memoria de programa.
    addwf    PCL,F                ; Posición 0FFh de memoria de programa.
    goto    Configuracion0        ; Posición 100h de memoria de programa.
    goto    Configuracion1        ; Posición 101h de memoria de programa.
    
; La intención de la instrucción "addwf PCL,F" es saltar a la posición de la instrucción 
; "goto Configuracion1", que está en la posición 101h de memoria de programa pero, como
; el contenido del registro PCLATH no ha cambiado de valor, realmente salta a la posición
; que indica el contador de programa que en este caso es (PC)=(PCLATH)(PCL) = 0001h, es 
; decir, ha  saltado a la posición donde se encuentra la instrucción "clrw". El salto se
; ha descontrolado.

Configuracion0
Configuracion1

    END
En la nota de palicación de www.microchip.com AN556 explica más datos sobre él.

Estas tablas y mensajes se sitúan al principio del programa con el propósito que no
supere la posición 0FFh de memoria ROM de programa. De todas formas, en caso que así
fuera se visualizaría el siguiente mensaje de error en el proceso de ensamblado:


Código:
IF (FinTablas > 0xFF)
        ERROR    "Atención: La tabla ha superado el tamaño de la página de los"
        MESSG    "primeros 256 bytes de memoria ROM. NO funcionará correctamente."
    ENDIF
Ejemplo sacado de un reloj calendario. (Pedazo de código par ensamblador, sin contar con las librerías a parte que también tiene su código). Cosas pequeñas para sam y C para grandes.

Código:
;********************************** I2C_Reloj_01.asm ************************************
;
;    ===================================================================
;      Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;      E. Palacios, F. Remiro y L. López.        www.pic16f84a.com
;       Editorial Ra-Ma.  www.ra-ma.es
;    ===================================================================
;
; Programa para un reloj digital en tiempo real con puesta en hora. Visualiza los datos del
; reloj en formato:    "Día  Mes  Año" (Primera línea)
;         "Día_de_la_Semana   Horas:Minutos:Segundos", (Segunda línea)
; (por ejemplo    " 7 Diciemb. 2004" (Primera línea).
;        "Martes   8:47:39" (Segunda línea).
;
; La actualización del reloj se consigue leyendo el chip DS1307, que es un reloj y
; calendario en tiempo real compatible con bus I2C.
;
; El DS1307 se configura para que genere una señal cuadrada de un 1 Hz por su pin SQW/OUT.
; Esta señal se aplica al pin de interrupción INT del PIC16F84A de manera que genera una
; interrupción cada segundo, que es cuando realiza la lectura del DS1307 y la visualiza.
;
; La "PuestaEnHora" se logra mediante dos pulsadores: "MODO" e "INCREMENTAR".
; Su modo de operación es:
;     1º    Pulsa MODO, los "Años" se ponen intermitente y se ajustan mediante el
;        pulsador INCREMENTAR.
;   2º    Pulsa MODO y pasa a ajustar los "Meses" de forma similar.
;   3º    Se va pulsando MODO secuencialmente para ajustar del modo anteriormente
;        explicado los días del mes, los días de la semana, las horas y los minutos.
;   4º    Pulsa MODO y se acabó la "PuestaEnHora", pasando a visualización normal.
;
; Cuando se ajusta una variable de tiempo, ésta debe aparecer en intermitencia.
;
; Los pulsadores MODO e INCREMENTAR se conectan a líneas del Puerto B y su
; funcionamiento se basa en interrupción por cambio en la línea del Puerto B:
;
; ZONA DE DATOS **********************************************************************

    LIST        P=16F84A
    INCLUDE        <P16F84A.INC>
    __CONFIG    _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC

    CBLOCK  0x0C
    Auxiliar                    ; Registro auxiliar.
    Intermitencia    ; Para lograr la intermitencia. Si es 0, apaga en intermitencia.
    FlagsAjuste                    ; Guarda los flags para establecer los
    ENDC                        ; ajustes de día, mes, año, hora, etc.

#DEFINE  ModoPulsador            PORTB,7        ; Los pulsadores se conectan a estos
#DEFINE  IncrementarPulsador    PORTB,6        ; pines del Puerto B.
#DEFINE  OndaCuadrada_DS1307    PORTB,0        ; La onda cuadrada al pin RBO/INT.
#DEFINE  F_AjusteAnho        FlagsAjuste,5    ; Flags para los diferentes modos de
#DEFINE  F_AjusteMes        FlagsAjuste,4    ; ajustes.
#DEFINE  F_AjusteDia        FlagsAjuste,3
#DEFINE  F_AjusteDiaSemana    FlagsAjuste,2
#DEFINE  F_AjusteHora        FlagsAjuste,1
#DEFINE  F_AjusteMinuto        FlagsAjuste,0

; ZONA DE CÓDIGOS ********************************************************************

    ORG     0
    goto    Inicio
    ORG    4
    goto    ServicioInterrupcion

Mensajes
    addwf    PCL,F
MensajeLunes
    DT "Lunes   ", 0x00
MensajeMartes
    DT "Martes  ", 0x00
MensajeMiercoles
    DT "Mierc.  ", 0x00
MensajeJueves
    DT "Jueves  ", 0x00
MensajeViernes
    DT "Viernes ", 0x00
MensajeSabado
    DT "Sabado  ", 0x00
MensajeDomingo
    DT "Domingo ", 0x00
;
MensajeEnero
    DT "  Enero ", 0x00
MensajeFebrero
    DT " Febrero", 0x00
MensajeMarzo
    DT "  Marzo ", 0x00
MensajeAbril
    DT "  Abril ", 0x00
MensajeMayo
    DT "  Mayo  ", 0x00
MensajeJunio
    DT "  Junio ", 0x00
MensajeJulio
    DT "  Julio ", 0x00
MensajeAgosto
    DT " Agosto ", 0x00
MensajeSeptiembre
    DT "Septiem.", 0x00
MensajeOctubre
    DT "Octubre ", 0x00
MensajeNoviembre
    DT "Noviemb.", 0x00
MensajeDiciembre
    DT "Diciemb.", 0x00
MensajeBlanco
    DT "        ", 0x00            ; Ocho espacios en blanco.
;
DiasSemana
    addwf    PCL,F
    nop                            ; No hay día 0 de la semana. Empiezan en
    retlw    MensajeLunes        ; el día 1 de la semana (Lunes).
    retlw    MensajeMartes        ; Día 2 de la semana.
    retlw    MensajeMiercoles    ; Día 3 de la semana.
    retlw    MensajeJueves        ; Día 4 de la semana.
    retlw    MensajeViernes        ; Día 5 de la semana.
    retlw    MensajeSabado        ; Día 6 de la semana.
    retlw    MensajeDomingo        ; Día 7 de la semana.
Meses
    addwf    PCL,F
    nop                            ; No hay mes 0x00.
    retlw    MensajeEnero        ; Empiezan en el mes 1 (Enero).
    retlw    MensajeFebrero        ; Mes 0x02
    retlw    MensajeMarzo        ; Mes 0x03
    retlw    MensajeAbril        ; Mes 0x04
    retlw    MensajeMayo            ; Mes 0x05
    retlw    MensajeJunio        ; Mes 0x06
    retlw    MensajeJulio        ; Mes 0x07
    retlw    MensajeAgosto        ; Mes 0x08
    retlw    MensajeSeptiembre    ; Mes 0x09
    nop                            ; (Como el DS1307 trabaja en BCD,
    nop                            ; estos meses se rellenan con
    nop                            ; "nop").
    nop
    nop
    nop
    retlw    MensajeOctubre        ; Mes 0x10
    retlw    MensajeNoviembre    ; Mes 0x11
    retlw    MensajeDiciembre    ; Mes 0x12
FinTablas

; Estas tablas y mensajes se sitúan al principio del programa con el propósito que no
; supere la posición 0FFh de memoria ROM de programa. De todas formas, en caso que así
; fuera se visualizaría el siguiente mensaje de error en el proceso de ensamblado:
;
    IF (FinTablas > 0xFF)
        ERROR    "Atención: La tabla ha superado el tamaño de la página de los"
        MESSG    "primeros 256 bytes de memoria ROM. NO funcionará correctamente."
    ENDIF

; Instrucciones de inicialización. ------------------------------------------------------
;
Inicio
    call    LCD_Inicializa
    bsf        STATUS,RP0            ; Acceso banco 1.
    bcf        OPTION_REG,NOT_RBPU    ; Se activan las resistencias de Pull-Up del Puerto B.
    bsf        ModoPulsador        ; Los pulsadores se configuran como entrada.
    bsf        IncrementarPulsador
    bsf        OndaCuadrada_DS1307
    bcf        OPTION_REG,INTEDG    ; Interrupción INT activa por flanco de bajada.
    bcf        STATUS,RP0            ; Acceso banco 0.
    clrf    FlagsAjuste            ; Inicializa todos los flags de la puesta en hora.
    call    DS1307_Inicializa    ; Configura la señal cuadrada que genera el 
                                ; DS1307 en su pin SQW/OUT a 1 Hz.
;
; Ahora lee el bit 7 de los segundos para saber el estado anterior del reloj antes del
; reset. Este bit es el CH (Control Halt) y permite poner en marcha (CH=0) o parar el
; reloj (CH=1). Tras la lectura pueden ocurrir dos casos:
; -    Si CH está a 0 quiere decir que anteriormente el reloj ya se ha puesto en hora alguna
;    vez y está en modo "respaldo". Es decir, ha fallado la alimentación y el DS1307 se está
;    alimentando por la batería conectada al pin "VBAT", aunque el reloj no se visualice en
;    la pantalla. Por tanto, no debe inicializarse porque se corrompería el contenido del
;    DS1307 que ya está en marcha.
; -    Si CH está a 1, quiere decir que estaba parado y es la primera vez que se pone en hora.
;
    call    DS1307_Lee            ; Lee los segundos en el DS1307 y comprueba el
    btfss    Segundo,7            ; valor del bit CH. Si es "1" salta toda la
    goto    AntesConBateria        ; inicialización de los registros y la puesta
                                ; en hora inicial.
    call    DS1307_CargaInicial    ; Realiza la carga inicial a 1 Enero de 2004.
    movlw    b'10011000'            ; Las interrupciones se deben habilitar después
    movwf    INTCON                ; de la carga inicial del DS1307.
    call    PuestaEnHoraReset    ; Puesta en hora por primera vez.
    goto    Principal
    
AntesConBateria
    movlw    b'10011000'            ; Habilita las interrupciones INT, RBI y la
    movwf    INTCON                ; general GIE.

; La sección "Principal" de mantenimiento. Pasa al modo reposo y sólo espera las
; interrupciones procedentes de la línea "SQW/OUT" del DS1307 que se producen cada
; segundo en funcionamiento normal y cada 500 ms cuando esté en la "PuestaEnHora".

Principal
    sleep
    goto    Principal

; Subrutina "ServicioInterrupcion" ------------------------------------------------------
;
; Detecta qué ha producido la interrupción y ejecuta la subrutina de atención correspondiente.

ServicioInterrupcion
    btfsc    INTCON,INTF            ; Si es una interrupción procedente de la onda
    call    Reloj                ; cuadrada del DS1307 actualiza la visualización.
    btfss    INTCON,RBIF            ; Si es una interrupción RBI lee los pulsadores.
    goto    FinInterrupcion
    btfss    ModoPulsador        ; ¿Está presionado el pulsador de "MODO"?
    call    PuestaEnHora        ; Sí, pasa a poner en hora.
    btfss    IncrementarPulsador    ; ¿Pulsado "INCREMENTAR"?
    call    Incrementar            ; Sí, pasa a incrementar el registro de tiempo
FinInterrupcion                    ; correspondiente.
    bcf        INTCON,RBIF            ; Limpia los flags de reconocimiento de la
    bcf        INTCON,INTF            ; interrupción.
    retfie

; Subrutina "Reloj" ---------------------------------------------------------------------
;
; Esta subrutina actualiza los registros Anho, Mes, Dia, DiaSemana, Hora, Minuto y 
; Segundo leyendo el DS1307 a través del bus I2C. Se ejecuta debido a la petición de
; interrupción de la señal cuadrada de 1 Hz, que procede del pin "SQW/OUT" del DS1307 y
; se ha conectado al pin RB0/INT del PIC16F84A.
;
; Esta interrupción ocurre cada segundo si está en visualización normal y cada 500 ms si
; está en puesta en hora con el objetivo de conseguir la intermitencia.
;
; Si no está en puesta en hora está en funcionamiento normal, por tanto se limita a leer
; el DS1307 y a visualizar la hora.
;
Reloj
    movf    FlagsAjuste,F        ; Si no está en puesta en hora se limita a
    btfsc    STATUS,Z            ; leer el DS1307.
    goto    Leer_DS1307

; Si está en algún modo de ajuste debe interrumpir cada 500 ms para lograr la intermitencia
; alternando la interrupción por flanco de subida o de bajada. Esto lo consigue mediante la
; operación XOR del flag INTEDG con un "1", lo cual invierte este bit cada vez que ejecuta
; la instrucción y por tanto conmuta entre flanco ascendente y descendente.

    bsf        STATUS,RP0            ; Acceso banco 1.
    movlw    b'01000000'            ; El bit INTEDG está en el lugar 6 del registro.
    xorwf    OPTION_REG,F
    bcf        STATUS,RP0            ; Acceso banco 0.

; Además complementa el registro Intermitencia para que se produzca la intermitencia
; cada 500 milisegundos cuando está en la puesta en hora.

    comf    Intermitencia,F
    goto    ActualizaReloj            ; Visualiza el reloj y sale.

Leer_DS1307

; No está en ningún modo de ajuste, sino en funcionamiento normal de reloj y pasa a leer los
; registros del reloj-calendario DS1307 a través del bus I2C. Los registros del DS1307 ya
; trabajan en formato BCD, por tanto no hay que hacer ningún tipo de conversión al leerlos.

    call    DS1307_Lee
ActualizaReloj                        ; Estas dos instrucciones se pueden
;    call    VisualizaReloj            ; obviar, ya que a continuación efectivamente 
;    return                            ; ejecuta la subrutina VisualizaReloj y
                                    ; retorna.
; Subrutina "VisualizaReloj" ------------------------------------------------------------
;
; Visualiza el reloj en formato    "Dia  Mes  Año" (Primera Línea)
;             "Día_de_la_Semana Horas:Minutos:Segundos", (Segunda Línea)
; Por ejemplo        " 7 Diciemb. 2004" (Primera Linea).
;            "Martes   8:47:39" (Segunda Línea).

; La variable ajustada debe aparecer en intermitencia. Esto se logra con ayuda de
; cualquier bit del registro Intermitencia que conmuta cada 500 ms en la subrutina Reloj.
;
VisualizaReloj
    call    LCD_Linea1                ; Se sitúa en la primera línea.
    btfss    F_AjusteDia                ; ¿Está en la puesta en hora?
    goto    EnciendeDia                ; No. Pasa a visualización normal.
    btfss    Intermitencia,0            ; Sí. Pasa a intermitencia si procede.
    goto    ApagaDia                ; Apaga en la intermitencia.
EnciendeDia
    movf    Dia,W                    ; Lo visualiza. El DS1307 ya lo da en BCD.
    call    LCD_Byte                ; Visualiza rechazando cero de las decenas.
    goto    VisualizaMes
ApagaDia
    call    LCD_DosEspaciosBlancos    ; Visualiza dos espacios en blanco.
;
VisualizaMes
    call    LCD_UnEspacioBlanco        ; Visualiza un espacio en blanco.
    btfss    F_AjusteMes                ; ¿Está en la puesta en hora?
    goto    EnciendeMes                ; No. Visualización normal.
    btfss    Intermitencia,0            ; Sí. Intermitencia si procede.
    goto    ApagaMes                ; Apaga en la intermitencia.
EnciendeMes
    movf    Mes,W                    ; Lo visualiza.
    call    EscribeMes
    goto    VisualizaAnho
ApagaMes
    movlw    MensajeBlanco
    call    LCD_Mensaje                ; Visualiza varios espacios en blanco.
;
VisualizaAnho
    btfss    F_AjusteAnho            ; ¿Está en la puesta en hora?
    goto    EnciendeAnho            ; No. Visualización normal.
    btfss    Intermitencia,0            ; Sí. Intermitencia si procede.
    goto    ApagaAnho                ; Apaga en la intermitencia.
EnciendeAnho
    call    LCD_UnEspacioBlanco        ; Visualiza un espacio en blanco.
    movlw    0x20                    ; Visualiza el "20xx", del año "dos mil ...".
    call    LCD_Byte
    movf    Anho,W
    call    LCD_ByteCompleto
    goto    VisualizaDiaSemana
ApagaAnho
    movlw    MensajeBlanco
    call    LCD_Mensaje                ; Visualiza varios espacios en blanco.
;
VisualizaDiaSemana
    call    LCD_Linea2                ; Se sitúa en la segunda línea.
    btfss    F_AjusteDiaSemana        ; ¿Está en la puesta en hora?
    goto    EnciendeDiaSemana        ; No. Visualización normal.
    btfss    Intermitencia,0            ; Sí. Intermitencia si procede.
    goto    ApagaDiaSemana            ; Apaga en la intermitencia.
EnciendeDiaSemana
    movf    DiaSemana,W                ; Lo visualiza.
    call    EscribeDiaSemana
    goto    VisualizaHoras
ApagaDiaSemana
    movlw    MensajeBlanco
    call    LCD_Mensaje                ; Visualiza varios espacios en blanco.
;
VisualizaHoras
    btfss    F_AjusteHora            ; ¿Está en la puesta en hora?
    goto    EnciendeHoras            ; No. Visualización normal.
    btfss    Intermitencia,0            ; Sí. Intermitencia si procede.
    goto    ApagaHoras                ; Apaga las horas en la intermitencia.
EnciendeHoras
    movf    Hora,W                    ; Va a visualizar las horas. 
    call    LCD_Byte                ; Visualiza rechazando cero de las decenas.
    goto    VisualizaMinutos
ApagaHoras
    call    LCD_DosEspaciosBlancos    ; Visualiza dos espacios en blanco.
;
VisualizaMinutos
    movlw    ':'                        ; Envía ":" para separar datos.
    call    LCD_Caracter    
    btfss    F_AjusteMinuto            ; ¿Está en la puesta en hora?.
    goto    EnciendeMinutos
    btfss    Intermitencia,0
    goto    ApagaMinutos
EnciendeMinutos
    movf    Minuto,W                ; Visualiza minutos.
    call    LCD_ByteCompleto
    goto    VisualizaSegundos
ApagaMinutos
    call    LCD_DosEspaciosBlancos    ; Visualiza dos espacios en blanco.
;
VisualizaSegundos
    movlw    ':'                        ; Envía ":" para separar datos.
    call    LCD_Caracter
    movf    Segundo,W                ; Visualiza segundos.
    call    LCD_ByteCompleto
    return
;
; Subrutina "EscribeDiaSemana" ----------------------------------------------------------
;
; Escribe el día de la semana en la posición actual de la pantalla, utilizando la tabla
; "DiaSemana". Supone que el Lunes es el día 1 y el Domingo el 7. 
; En el registro W se le introduce el día de la semana numérico y en la pantalla aparece el
; día de la semana en letras. Así por ejemplo si (W)=0x02 en la pantalla aparecerá "Martes".
;
; Primero comprueba que no ha superado el valor máximo para evitar problemas de saltos
; erráticos con la llamada "call DiasSemana", en caso de una lectura defectuosa de este
; dato por parte del DS1307.
;
EscribeDiaSemana
    sublw    0x07                    ; ¿Ha superado su valor máximo?
    btfsc    STATUS,C
    goto    Llamada_a_DiasSemana
    movlw    0x01                    ; Lo inicializa si ha superado su valor máximo.
    movwf    DiaSemana
Llamada_a_DiasSemana
    movf    DiaSemana,W
    call    DiasSemana
    call    LCD_Mensaje
    return

; Subrutina "EscribeMes" ----------------------------------------------------------------
;
; Escribe el mes del año en la posición actual de la pantalla, utilizando la tabla "Meses". 
;
; Primero comprueba que no ha superado el valor máximo para evitar problemas de saltos
; errático con la llamada "call Meses", en caso de una lectura defectuosa de este dato
; por parte del DS1307.
;
; El DS1307 trabaja en BCD y la tabla en binario natural. Esto es un problema que se 
; soluciona con una correcta distribución de la tabla "Meses".
;
EscribeMes
    sublw    0x12                    ; ¿Ha superado su valor máximo? (Observad que
    btfsc    STATUS,C                ; trabaja en BCD).
    goto    Llamada_a_Meses
    movlw    0x01                    ; Lo inicializa si ha superado su valor máximo.
    movwf    Mes
Llamada_a_Meses
    movf    Mes,W                    ; Retorna el resultado en el registro W.
    call    Meses
    call    LCD_Mensaje
    return

; Subrutina "PuestaEnHora" --------------------------------------------------------------
;
; Subrutina de atención a la interrupción producida por el pulsador MODO que pone en hora
; el reloj. Cada vez que pulsa se desplaza el "1" a través del registro FlagsAjuste,
; pasando a ajustar secuencialmente: años, meses, días, días de la semana, horas y minutos.
;
; Para comprender el funcionamiento de esta subrutina hay que saber que el registro
; FlagsModos contiene 5 flags que permite diferenciar cada uno de los ajustes de registros
; de tiempo:
; - "F_AjusteAnho":            bit 5 de FlagsAjuste, para ajustar los años.
; - "F_AjusteMes":             bit 4 de FlagsAjuste, para ajustar los meses.
; - "F_AjusteDia":             bit 3 de FlagsAjuste, para ajustar los días del mes.
; - "F_AjusteDiaSemana":     bit 2 de FlagsAjuste, para ajustar los días de la semana.
; - "F_AjusteHora":             bit 1 de FlagsAjuste, para ajustar las horas.
; - "F_AjusteMinuto":         bit 0 de FlagsAjuste, para ajustar los minutos.
;
; Así pues el contenido del registro FlagAjuste identifica los siguientes ajustes:
; - (FlagsAjuste)=b'00100000'. Está ajustando el registro Anho (Años).
; - (FlagsAjuste)=b'00010000'. Está ajustando el registro Mes.
; - (FlagsAjuste)=b'00001000'. Está ajustando el registro Dia.
; - (FlagsAjuste)=b'00000100'. Está ajustando el registro DiaSemana (Lunes, Martes, etc).
; - (FlagsAjuste)=b'00000010'. Está ajustando el registro Hora.
; - (FlagsAjuste)=b'00000001'. Está ajustando el registro Minuto.
; - (FlagsAjuste)=b'00000000'. Está en visualización normal del reloj en tiempo real.
;
; Pueden ocurrir tres casos:
; -    Que pulse "MODO" estando en modo de visualización normal identificado porque
;    (FlagsAjuste)=b'0000000'. En este caso debe activar el flag F_AjusteAnho, es decir,
;    carga (FlagsAjuste)=b'00100000', ya que el flag F_AjusteAnho es el bit 5 del registro
;    FlagsAjuste.
; -    Que pulse "MODO" estando ya en la puesta en hora, en cuyo caso debe pasar al
;    ajuste del siguiente registro de tiempo. Ésto lo hace mediante un desplazamiento
;    a derechas. Así por ejemplo, si antes estaba ajustando los meses, es decir: 
;    (FlagsAjuste)=b'00010000', pasará a (FlagsAjuste)=b'00001000' que se identifica
;    como ajuste de los días del mes.
; -    Que pulse "MODO" estando en el último ajuste correspondiente a los minutos,
;    (FlagsAjuste)=b'00000001', pasará a (FlagsAjuste)=b'00000000', indicando que la
;     puesta en hora ha terminado y pasa a visualización normal del reloj en tiempo real.
;
PuestaEnHora
    call    Retardo_20ms            ; Espera a que se estabilicen niveles de tensión.
    btfsc    ModoPulsador            ; Si es un rebote sale fuera.
    goto    FinPuestaEnHora
PuestaEnHoraReset                    ; Al pulsar "MODO" se apaga la variable de
    clrf    Intermitencia            ; tiempo que se va a ajustar.
    btfsc    F_AjusteMinuto            ; Si antes estaba en ajuste de minutos es que
    goto    FuncionamientoNormal    ; ha terminado. Graba datos en el DS1307 y sale.
    movf    FlagsAjuste,F            ; Si antes estaba en funcionamiento normal ahora
    btfss    STATUS,Z                 ; pasa a ajustar el año.
    goto    AjustaSiguiente            ; Sino pasa a ajustar la variable de tiempo siguiente.
    bsf        F_AjusteAnho            ; Pasa a ajustar el año.
    clrf    Segundo                    ; Inicializa contador de segundos.
    goto    FinPuestaEnHora
AjustaSiguiente                        ; Desplaza un uno a la derecha del registro
    bcf        STATUS,C                ; FlagsAjuste para ajustar secuencialmente cada
    rrf        FlagsAjuste,F            ; uno de los registros de tiempo: año, mes, día,
    goto    FinPuestaEnHora            ; día de la semana, hora y minuto.
;
; Lo siguiente se ejecuta si ya ha acabado el ajuste de la hora, es decir, pasa a
; funcionamiento normal. En este caso hay que realizar tres operaciones:
; -    Fijar la interrupción INT solo por flanco de bajada.
; -    Inicializar a cero todos los flags de ajuste contenidos en (FlagsAjuste).
; -    Escribir el DS1307 con los datos de las variables de tiempo contenidas en la
;    memoría RAM del microcontrolador.
;
FuncionamientoNormal
    bsf        STATUS,RP0                ; Acceso banco 1.
    bcf        OPTION_REG,INTEDG        ; Interrupción INT activa por flanco de bajada.
    bcf        STATUS,RP0                ; Acceso banco 0.
    clrf    FlagsAjuste                ; Inicializa los flags de ajuste.
    call    DS1307_Escribe            ; Graba los datos en el DS1307.
FinPuestaEnHora
    call    VisualizaReloj            ; Visualiza los datos del reloj digital.
    btfss    ModoPulsador            ; Ahora espera deje de pulsar.
    goto    FinPuestaEnHora
    return
    
; Subrutina "Incrementar" ---------------------------------------------------------------
;
; Subrutina de atención a la interrupción por cambio de la línea RB6 al cual se ha
; conectado el pulsador "INCREMENTAR".
;
; Incrementa según corresponda una sola de las siguientes variables: (Anho), (Mes),
; (Dia), (DiaSemana), (Hora) o (Minuto).

Incrementar
    call    Retardo_20ms            ; Espera a que se estabilice el nivel de tensión.    
    btfsc    IncrementarPulsador        ; Si es un rebote sale fuera.
    goto    FinIncrementar
    btfsc    F_AjusteAnho
    call    IncrementaAnhos
    btfsc    F_AjusteMes
    call    IncrementaMeses
    btfsc    F_AjusteDia
    call    IncrementaDias
    btfsc    F_AjusteDiaSemana
    call    IncrementaDiasSemana
    btfsc    F_AjusteHora
    call    IncrementaHoras
    btfsc    F_AjusteMinuto
    call    IncrementaMinutos
    movlw    b'11111111'
    movwf    Intermitencia            ; Visualiza siempre mientras incrementa.
    call    VisualizaReloj            ; Visualiza mientras espera que deje
    call    Retardo_200ms            ; de pulsar.
    btfss    IncrementarPulsador        ; Mientras permanezca pulsado
    goto    Incrementar                ; incrementará el dígito.
FinIncrementar
    return

; Subrutina "IncrementaMinutos" ---------------------------------------------------------
;
; Incrementa el valor de la variable Minutos. Si supera los 0x59, lo resetea.
; Este incremento se debe realizar en BCD para ello utiliza la subrutina AjusteBCD.

IncrementaMinutos
    incf    Minuto,F                ; Incrementa los minutos.
    movf    Minuto,W                ; Lo pasa a BCD.
    call    AjusteBCD
    movwf    Minuto                    ; Lo guarda.
    sublw    0x59                    ; ¿Ha superado su valor máximo?
    btfss    STATUS,C    
    clrf    Minuto                    ; Lo inicializa si ha superado su valor máximo.
    return

; Subrutina "IncrementaHoras" -----------------------------------------------------------
;
IncrementaHoras
    incf    Hora,F                    ; Incrementa las Horas.
    movf    Hora,W                    ; Ahora hace el ajuste BCD.
    call    AjusteBCD
    movwf    Hora                    ; Lo guarda.
    sublw    0x23                    ; ¿Ha superado su valor máximo?
    btfss    STATUS,C
    clrf    Hora                    ; Lo inicializa si ha superado su valor máximo.
    return

; Subrutina "IncrementaDiasSemana" ------------------------------------------------------
;
IncrementaDiasSemana
    incf    DiaSemana,F
    movf    DiaSemana,W
    sublw    .7                        ; ¿Ha superado su valor máximo?
    btfsc    STATUS,C
    goto    FinIncrementaDiasSemana
    movlw    .1                        ; Lo inicializa si ha superado su valor máximo.
    movwf    DiaSemana
FinIncrementaDiasSemana
    return

; Subrutina "IncrementaDias" --------------
Un cordial saludo.
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.