breve consulta, como hacer una libreria?

[jhozate]

hola a todos,..no queria hacer de esta consulta un hilo, aun estoy en nivel "huggies" de programacion en asm pero quisiera saber como se hace una libreria .INC , que debo hacer? un archivo de texto con extension .INC? aparte de la rutina que debo escribir? donde lo guardo?

gracias

[alogic.on]

hola, no se si es la forma correcta de hacer una libreria, yo lo que hago es como dices una hoja nueva.inc y en ella pongo las rutinas que mas uso, con la opcion MACRO
       RSI_PB0       MACRO
..........................
................
...........
       ENDM

asi cada vez que necesito ese codigo solo hay que escribir RSI_PB0

un saludo

[jhozate]

al finalizar cada rutina debo utilizar el return? alguna direccion especifica para guardarla?

[alogic.on]

pues eso depende de como vayas a usarlo, por ej para cambiar de banco de memoria
   banko_1      MACRO
              bcf    STATUS,RP1
              bsf    STATUS,RP0
   ENDM
cada vez que pongas en el programa "banco_1" te escribira en la memoria de programa lo que este en la macro, o tambien puedes poner varias rutinas dentro de la macro para situarlas en un lugar especifico de la memoria, esto solo lo puedes usar una vez en el programa porque tienen etiqueta cada una de las rutinas (teclado_1) y si la pusieras varias veces el programa te dara error al haber varias etiquetas con el mismo nombre

    ruitnas_de_teclado     MACRO
teclado_1
     banco_1
     bcf..................
     .....................
     .......
     return

teclado_2
     banco_1
     ....................
     ......
     return

     ENDM

y asi con ORG  0x...
     rutinas_de_teclado
te coloca todas las rutinas que estan dentro de esa macro en la posicion 0x...
usea coloca las macro en el archivo .inc, en el .asm utiliza el include <libreria.inc> y en el programa te ordenas las macros en el orden que necesites

un saludo

[Leon Pic]

Ojo con la utilización del MACRO porque usarlo en forma "irresponsable" hace que se consuma mucha memoria de programa.

Particularmente, la forma en que yo hago las rutinas es para ser llamadas por un CALL y obviamente, tendrá en su última instrucción el RETURN o sus variantes, que dependerá de la rutina.

Se escribe como si se tratase de un programa en ASM y la extensión del archivo debe ser .inc Este archivo, tiene que estar en la carpeta del MPLAB dónde están los archivos xxxxx.inc Luego se debe incluir en el programa principal con la directiva include. Dónde esté esta directiva, será insertada por completo la rutina.

En la rutina puedes o no, configurar los puertos de salidas, darle nombre o no, a las posiciones de memoria RAM (variables) renombrar bit y no es necesario incluir el tipo de pic a utilizar, porque este, estará en el programa principal.

Si quieres más detalle, mira esto Rutina para compartir

[jhozate]

gracias por las respuestas pero me surgen unas dudas...ejemplo creo un archivo llamados rutinas.inc en este archivo tengo el cambio de bancos, configuracion de puertos etc.

Código: [Seleccionar]

BANCO1 MACRO
         BCF STATUS,RP1
         BSF STATUS, RP0
         ENDM

         BIN_A_BCD MACRO
         ....................
         ....................
         ENDM
entonces cuando invoco el macro se inserta todo el texto del macro en mi archivo principal .asm, esto lo podria hacer de forma indefinida pero me ocuparia mas memoria?

pero si el dentro de mi archivo principal .asm llamo el macro a traves de un call, el programa se ejecutaria en el archivo .inc y luego retorna al .asm? asi no consumiria memoria?, cuando se procede a programar el pic que pasa con el codigo que se encuentra en el .inc?

[alogic.on]

jojojo  algo asi pero no, prueba una cosa, hazte una macro y antes de llamarla utiliza el ORG 0x...
y ponlo en una direccion, abrete la pestaña view/program memory. en esta puedes ver como y donde se coloca tu programa, y prueba a poner la macro cada vez en una pagina diferente.
y claro te decia que segun como hicieses las macro, pues puedes repetirlas indefinidamente consumiendo muscha memoria, u les pones una etiqueta y el return, y ale. la llamas cada vez que la necesitas con call que segun para cada cosa se utiliza una u otra forma, segun convenga

un saludo

[Leon Pic]

Hay que diferenciar. Los macros son una cosa y las rutinas son otras.

Las Macros, por cada vez que la invoques serán copiadas, si las invocaste 30 veces, 30 veces será copiado el macro en tu programa principal. Una Macro nunca se llama por medio de un CALL o GOTO.

Las rutinas se colocan una vez en el programa y se llaman tantas veces como desee y no serán copiadas en la misma cantidad que se lo llame. Por ejemplo, si en todo el programa llamas a la rutina 1.000 veces, solo estará 1 vez. En el 99% de los casos, las rutinas están diseñadas para ser llamadas por medio de un CALL y la última instrucción que tiene un rutina será RETURN o sus cariantes, que como dije antes, dependerá la instrucción. Esto es obvio, porque para vaciar la pila, se hacen con esas instrucciones mencionadas.

[jhozate]

de acuerdo  a lo q me han dicho y lo que he leido en el foro, los macros es mejor utilizarlos con rutinas pequeñas, claro esta, no se llaman a traves de un call, solo se invoca el nombre del macro y este pone el codigo en mi programa principal, entonces en el archivo .inc puedo incluir tanto macros como rutinas, es decir poner codigo por ejemplo un macro para cambio de banco y lo invoco con su nombre y una rutina para alguna conversion y la llamo con un call...pero no me han despejado otra duda...si los .inc son archivos independientes del .asm que pasa cuando se va a programar el PIC..donde queda este codigo?

saludos

[Leon Pic]

Te lo había dicho alogic.on cuando te mandó a hacer un pequeño ejercicio

El entorno MPASIM lo pega automáticamente en tu programa principal. ¿En dónde? Las Macro cada vez que se las invoca por el nombre. En el caso de las rutinas .inc, el MPASIM la pegará en el lugar que esté la directiva include xxxxx.inc.

[jhozate]

bueno gracias por la ayuda..resulta q me puse a cambiar una rutina para aplicar lo de los macro, funcionó bien con el cambio de los banco pero no con una rutina que llame BIN_A_BCD, la compilacion resulta bien, la simulacion no, y cuando lo debuggeo en el mplab al llegar a BIN_A_BCD, y me da mensaje de stack under flow, entonces no se si es un codigo muy extendido para usar macro, tambien quite la palabra macro y el endm y desde la rutina principal lo llame con un call..tampoco corre bien...hice bien?? a continuacion pongo la rutina asm y el .inc
programa principal

Código: [Seleccionar]

; programa q convierte lo q hay en portc a BCD, usando libreria.inc
LIST P=16F877A
#INCLUDE "P16F877A.INC"
#INCLUDE "libreria.inc"

CBLOCK 0X20
BCD_CENTENAS
BCD_DECENAS
BCD_UNIDADES
PDel0
PDel1
PDel2
ENDC

GOTO INICIO


INICIO BANCO1
MOVLW 0XFF
MOVWF PORTC
CLRF PORTB
CLRF PORTD
BANCO0

CLRF PORTB
CLRF PORTC
CLRF PORTD


BSF PORTD,0
BSF PORTD,1
BSF PORTD,2
CALL DEMORA


LEE ;MOVF PORTC,W
MOVLW B'11111111'
        BIN_A_BCD
CLRW

MOVF BCD_CENTENAS,W
MOVWF PORTB
BCF PORTD,0 ;PRENDO DISPLAY
CALL DEMORA
BSF PORTD,0 ;APAGO DISPLAY
CLRF PORTB

CLRW
MOVF BCD_DECENAS,W
MOVWF PORTB
BCF PORTD,1
CALL DEMORA
BSF PORTD,1
CLRF PORTB

CLRW
MOVF BCD_UNIDADES,W
MOVWF PORTB
BCF PORTD,2
CALL DEMORA
BSF PORTD,2
CLRF PORTB

GOTO LEE


DEMORA  movlw     .21       ; 1 set numero de repeticion  (B)
        movwf     PDel0     ; 1 |
PLoop1  movlw     .237      ; 1 set numero de repeticion  (A)
        movwf     PDel1     ; 1 |
PLoop2  clrwdt              ; 1 clear watchdog
        decfsz    PDel1, 1  ; 1 + (1) es el tiempo 0  ? (A)
        goto      PLoop2    ; 2 no, loop
        decfsz    PDel0,  1 ; 1 + (1) es el tiempo 0  ? (B)
        goto      PLoop1    ; 2 no, loop
PDelL1  goto PDelL2         ; 2 ciclos delay
PDelL2  clrwdt              ; 1 ciclo delay
        return              ; 2+2 Fin.
END
lo que tengo exactamente en el archivo libreria.inc

Código: [Seleccionar]

ORG 0X00

;############ BANCOS 877 ##########
BANCO1 MACRO
BSF   STATUS,RP0
BCF   STATUS,RP1
ENDM
BANCO0  MACRO
BCF   STATUS,RP0
ENDM
;###################################


;############ BIN_A_BCD  #############################################################################

; CARGAR EN W EL BINARIO A CONVERTIR, EL RESULTADO
;QUEDA EL LOS REGISTROS  BCD_DECENAS, BCD_CENTENAS, BCD_UNIDADES


BIN_A_BCD MACRO
CLRF BCD_CENTENAS ; CARGA LOS REGISTROS CON EL RESULTADO INICIAL.
CLRF BCD_DECENAS ; EN PRINCIPIO LAS CENTENAS Y DECENAS A CERO.
MOVWF BCD_UNIDADES ; SE CARGA EL NÚMERO BINARIO A CONVERTIR.

BCD_RESTA10 MOVLW .10 ; A LAS UNIDADES SE LES VA RESTANDO 10 EN CADA
SUBWF BCD_UNIDADES,W ; PASADA. (W)=(BCD_UNIDADES) -10.
BTFSS STATUS,C ; ¿C = 1?, ¿(W) POSITIVO?, ¿(BCD_UNIDADES)>=10?
GOTO BIN_BCD_FIN ; NO, ES MENOR DE 10. SE ACABÓ.

BCD_INCREMENTADECENAS
MOVWF BCD_UNIDADES ; RECUPERA LO QUE QUEDA POR RESTAR.
INCF BCD_DECENAS,F ; INCREMENTA LAS DECENAS Y COMPRUEBA SI HA LLEGADO
MOVLW .10 ; A 10. LO HACE MEDIANTE UNA RESTA.
SUBWF BCD_DECENAS,W ; (W)=(BCD_DECENAS)-10).
BTFSS STATUS,C ; ¿C = 1?, ¿(W) POSITIVO?, ¿(BCD_DECENAS)>=10?
GOTO BCD_RESTA10 ; NO. VUELVE A DAR OTRA PASADA, RESTÁNDOLE 10 A

BCD_INCREMENTACENTENAS ; LAS UNIDADES.
CLRF BCD_DECENAS ; PONE A CERO LAS DECENAS
INCF BCD_CENTENAS,F ; E INCREMENTA LAS CENTENAS.
GOTO BCD_RESTA10 ; OTRA PASADA: RESTA 10 AL NÚMERO A CONVERTIR.

BIN_BCD_FIN
SWAPF BCD_DECENAS,W ; EN EL NIBBLE ALTO DE (W) TAMBIÉN LAS DECENAS.
ADDWF BCD_UNIDADES,W ; EN EL NIBBLE BAJO DE (W) LAS UNIDADES.
RETURN ; VUELVE AL PROGRAMA PRINCIPAL.
ENDM

;######################################################################################################


otra duda q tengo es: en el hilo "rutinas para compartir" utilizan esto de los macros, y noté que dentro de ellos se pueden definir definir variables con la intruccion cblock, pero tengo entendido que cblock 0x20 guarda las variables a partir de la direccion 0x20, si tambien previamente tengo en el programa .asm la instruccion cblock 0x20 con otras variables, no hay problemas de sobreescritura?

[Leon Pic]

El error que te da es importante stack under flow Esto quiere decir que superaste los niveles del PIC.

Cuando llamaste por medio de un CALL a la rutina, sobrepasaste el nivel de la Pila. La solución es simple pero trabajadora, tienes que replantear tu programa para no usar tantas rutinas anidadas. Ten en cuenta que, si utilizas la interrupción, este consume un nivel de la pila (STACK)

Tiene otro error. La rutina la haces empezar a escribir desde 0x00 y este es el vector de reset. En la librería, pon org 0x05 ya que no utilizas interrupciones así, la rutina, se copiará a partir de esa posición de la memoria de programa.

La directiva cblock, permite nombrar las posiciones de memoria de la RAM (Variables). Esta directiva, se le debe especificar a partir del cual, se empiezan a nombrar la posición en la RAM, puede ser 0x0C; 0x20 etc. Y si, se puede sobreescribir el nombre de la variable y desconozco si trae problemas, porque jamás me pasó.

Personalmente, lo que hago es agregar una etiqueta diciendo que variables debo agregar al programa principal, así se si me sobra memoria o no. Además que puedo hasta ahorrar memoria.

[jhozate]

es raro, por q he hecho otras rutina en donde hago mas uso de los CALL y no ha pasado este problema...mmm desconozco tantas cosas ..pero si pongo todo el programa junto en el asm(config de puerto, rutina de conversion, retardo,programa principal) y no utilizo los macro el programa compila y simula bien sin tirar erroress

[sander]

Por lo que entiendo el problema lo tienes en la "macro" BIN_A_BCD, si te fijas al final de la macro pones la instruccion return, en una macro no debes de poner esa instruccion, porque esa instruccion agarra una direccion de la pila y la pone al contador de programa , y como no usaste  call entonces no hay valor en la pila y es por eso que te sale el error.

saludos

[Leon Pic]

¡Qué tonto! no vi el return 

Es por lo que dice sander. Saca el Return del Macro.