Hola a todos.

Hace unos días que he terminado unas rutinas en ASM. Al parecer van bien, y he pensado que puede que a alguno le interese. La idea al hacer estas rutinas es favorecer la exportabilidad a otros programas, de tal forma que resulte sencillo su uso. Para lograr esto, se me ocurrió emplear "direccionamiento indirecto". Con esto consigo:

* No es necesario adaptar los nombres de las variables, pues no aparece ningún nombre.

* Se puede emplear la memoria de datos de una forma más "dinámica", ya que con el mismo código, los operandos y resultados de la rutina pueden cambiar de posición en sucesivas llamadas dentro del mismo programa.

Por supuesto, no todo son ventajas. El inconveniente es que las rutinas ocupan más espacio en la memoria de programa. Os pego a continuación las rutinas para operaciones básicas en 8 bits.

;********************************************************
;* *
;* SUMA_8: Suma dos operandos de 1 byte dejando el resultado en *
;* la misma posición de los operandos. *
;* *
;* Operando. Dir. de memoria. *
;* #1 [W] *
;* #2 [W+1] *
;* Result. [W:W+1] *
;* *
;*****************************************************

SUMA_8: MOVWF FSR ; Mueve al registro FSR la dirección
MOVF INDF,0
INCF FSR,1
ADDWF INDF,0
MOVWF INDF
DECF FSR,1
CLRF INDF
BTFSC ESTADO,0
INCF INDF
RETURN

;******************************************************
;* *
;* RESTA_8: Resta dos operandos de 1 byte dejando el resultado en *
;* la misma posición de los operandos. *
;* *
;* Operando. Dir. de memoria. *
;* #1 (sustr.) [W] *
;* #2 (minue.) [W+1] *
;* Result. [W:W+1] *
;* *
;******************************************************

RESTA_8: MOVWF FSR
MOVF INDF,0
INCF FSR,1
SUBWF INDF,0
MOVWF INDF
DECF FSR,1
CLRF INDF
BTFSS ESTADO,0
COMF INDF
RETURN

;******************************************************
;* *
;* MULTI_8: Multiplica dos operandos de 1 byte *
;* *
;* Operando. Dir. de memoria. *
;* #1 [W] *
;* #2 [W+1] *
;* Result. [W+2:W+3] *
;* *
;* Emplea la variable [W+4] como contador en el lazo *
;******************************************************

MULTI_8: ADDLW 0x02
MOVWF FSR
CLRF INDF
INCF FSR,1
CLRF INDF
INCF FSR,1
MOVLW 0x08
MOVWF INDF

MULT_81: MOVLW 0x03
SUBWF FSR,1
RRF INDF,1
DECF FSR,1
MOVF INDF,0
INCF FSR,1
INCF FSR,1
BTFSC ESTADO,0
ADDWF INDF,1
RRF INDF,1
INCF FSR,1
RRF INDF,1
INCF FSR,1
DECF INDF,1
BTFSS ESTADO,2
GOTO MULT_81
RETURN

;******************************************************
;* *
;* DIVI_8: Divide dos operandos de 1 byte *
;* *
;* Operando. Dir. de memoria. *
;* #1 (dividendo) [W] *
;* #2 (divisor) [W+1] *
;* Cociente. [W+2] *
;* *
;*********************************************************

DIVI_8: MOVWF FSR
INCF FSR,1
INCF FSR,1
CLRF INDF

DIVI_81: DECF FSR,1
MOVF INDF,0
DECF FSR,1
SUBWF INDF,1
BTFSS ESTADO,0
RETURN
INCF FSR,1
INCF FSR,1
INCF INDF,1
GOTO DIVI_81

Yo las he probado mucho (tanto estas como las de 16 bits) y no me han fallado.Si alguien encuentra algún fallo, agradecería que me lo comunicase.

Un saludo a tod@s

P.D: Si alguien quiere las de 16 bits que no dude en pedírmelas 🙂