se busca info asm avanzado

Saludos kamaradas, hace tiempo que no pasaba por estos lares, principalmente porque ya no agarro tan seguido los pics jeje. Pero necesito de su ayuda.
Resulta que quiero hacer un código pero pienso usar macros y todo lo que me permita usar el máximo potencial de asm, he visto en internet varios códigos que usan "condicionales", directivas, metacáracteres, hasta parece "lenguaje de alto nivel", y pss no le entiendo, he aquí algunos ejemplos:

Código:


IO EQU #                    ; Define Bit Number
#define IOBit PORT#, IO

iorlw 1 << IO              ; Set the Specific Bit

andlw 0x0FF ^ (1 << IO)    ; Reset the Specific Bit


No entiendo que es lo que hacen las << ni el ^, antes a w se le carga el valor de PORT#, no? o como funciona?

También he visto que a las instrucciones 'goto' se les pone de argumento $ y un número positivo o negativo, leí por algún lado que el signo $ significa pocisión actual y se le va sumando o restando lugares para dar el salto, pero necesito más info.

Código:


CBLOCK
              ; Define Application Variables
FirstVar, SecondVar  ;Declare Two eight bit Variables
ThirdVar:2  ;Declare a sixteen bit Variable
endc


En este aunque ya he usado CBLOCK, la parte que me intriga es que declara una variable de 16 bits, como puedo manipular una variable de este tipo???????

Estos ejemplos los he visto de http://www.rentron.com/Myke8.htm

Ya busque en internet pero no encuentro mucho (igual y no sé buscar), hace tiempo me encontré unas notas de aplicación de macros de microchip pero ya no las encuentro T_T

Así que pido su colaboración para que me pasen algo de info sobre asm avanzado.

De una vez les doy las gracias, jeje

Buena Vibra!

Que tal aztk?

Si que está interesante el tema este, hay muchas cosas que se pueden hacer a nivel de directivas.

Escribo al final: Bueno.. me he liado a contar incluso las cosas que no preguntabas... pero bueno, quizás le sea util a otros.

Respecto al primer ejemplo que pones, pienso que es algo genérico, para usarlo habría que poner algunos valores, por ejemplo:

Código:


IO EQU 3                    ; Define Bit Number
#define IOBit PORTA, IO

iorlw 1 << IO              ; Set the Specific Bit

andlw 0x0FF ^ (1 << IO)    ; Reset the Specific Bit


IO EQU 3 :
Cada vez que en el programa aparezca: "IO" será sustituido por el valor numérico: 3

#define IOBit PORTA, IO :
Cada vez que en el programa aparezca: "IOBIT" será sustituido por la cadena: "PORTA, 3" (IO se sustituye por 3)

iorlw 1 << IO:
Esto queda así: iorlw 1 << 3
1 << 3 : rota a la izquierda el valor 1 tres veces : 0000 0001 -> 0000 1000
y el resultado hace un ior con lo que haya en W.
Entonces lo que hace es poner a 1 el bit 3 de W y lo demás lo deja coma está.

andlw 0x0FF ^ (1 << IO):
Esto hace lo mismo, pero pone el bit a 0
^ : esto es un Xor (creo)
0x0FF ^ (1 << IO) : esto queda así: 1111 1111 xor 0000 1000 = 1111 0111
Al final hace un and de este valor con lo que haya en W, y pone a 0 el bit 3 dejando igual todo lo demás.


Respecto a esto:

Código:

CBLOCK
              ; Define Application Variables
FirstVar, SecondVar  ;Declare Two eight bit Variables
ThirdVar:2  ;Declare a sixteen bit Variable
endc

Creo que no es más que reservar espacio para variables. Realmente no creas una variable de dos bytes, solo reservas un "hueco" de 2 bytes; la siguiente variable se colocará 2 bytes después.

para usar esos dos bytes: se supone que "ThirdVar" te lleva al primer byte, para acceder al segundo quizás tengas que hacer: ThirdVar+1, pero nunca vas a poder hacer operaciones de 16 bits.
Al fin y al cabo el ensamblador solo trabaja con direcciones de memoria (en numero). Y los nombres de variables son sustituidos por el número de la direccion de memoria. Entonces Thirvar será sustituido por un número de direccion de memoria... la siguiente debería ser Thirdvar+1

EDITO: se me olvidaba:

También he visto que a las instrucciones 'goto' se les pone de
argumento $ y un número positivo o negativo, leí por algún lado que el
signo $ significa pocisión actual y se le va sumando o restando lugares
para dar el salto, pero necesito más info.

Pues no es más que eso: goto $-1 va al paso anterior, goto $+123 va 123 pasos adelante.

Pero hay una cosa: en realidad lo que haces es incrementar el contador de programa, así que hay que tener en cuenta que algunas instrucciones ocupan 2 "pasos" del contador.

Por ejemplo suponiendo lineas de programa e instrucciones:

Código:

99  ......
100 btfsc PORTA,3
101 goto  $+3 ;............ Aquí salta a la linea 103
102 goto  $+2 ;.............Aquí salta a la linea 104
103 movf  PORTA,W
104 return

El tema es que para saltar de la 101 a la 103 tiene que saltar un goto, que ocupa 2 instrucciones, por lo tanto el contador de programa tiene que avanzar 3 pasos.
Para saltar de la linea 102 a la 104 solo salta sobre una instruccion de 1 paso, así que el salto tiebne que ser de 2 pasos.

Normalmente se relaciona goto $+x con saltar x lineas o instrucciones, pero en realidad son "pasos" o "ciclos" o como quieras llamarlos.


Saludos.

Acerca del uso de la directiva $ ,lo que realizamos es decirle al ensamblador que remplace la dirección del salto según lo indicado por $, ya sea + o - lugares según nuestro posición actual,

También he visto que a las instrucciones 'goto' se les pone de
argumento $ y un número positivo o negativo, leí por algún lado que el
signo $ significa pocisión actual y se le va sumando o restando lugares
para dar el salto,

Si no me equivoco aqui va un ejemplo.

Código:


Pregunta1 btfsc porta,2
            goto  Pregunta1                        ;Salta a etiquea Pregunta1, si porta.2=1 
Pregunta2  btfsc porta,3          ; 
              goto  Accion                ;Salta a Accion si porta.3 =1 
              goto Pregunta2              ;Salta a etiqueta Pregunta2 si porta.3=0 
Accion                    bsf portb,1          ;

 

Con los $ Seria algo asi.Es util para no colocar tantas etiquetas a algunas saltos.

Código:

 
btfsc porta,2 
goto  $-1 ;Salta una Direccion atras ,si porta.2=1
btfsc porta,3          ; 
goto $+2                  ;Salta a para set portb.1 si  porta,3 =1
goto $-2              ;Salta  si porta.3=0                                                                           
bsf portb,1          ;
 

Es lo que entiendo yo de esa directiva.

Sobre el CBLOCK , comparto la opinión pikitin que nunca realizaras operacion de 16bit directamente (solo manejas registros de 8bit). quizá exista alguna forma de diferenciar los 2 byte que componen la variable ThirdVar ( previamente definida con CBLOCK y ThirdVar:2) sin embargo desconozco como.. Voy a investigar un poco espero encontrar la repuesta..


Atte.
RiSanti

Hey Pikitin y Risanti! muchas muchas gracias por la info!

Pikitin: Je, que buena explicación lo de los << y ^, ya le entendí!

Sobre lo de la disque variable de 16bits, sé que un micro de la gama media como los que estoy acostumbrado a usar solo puede hacer operaciones de 8bits, lo que me tenia confundido era el como "invocarla", me imaginaba a que era algo como Thirdvar(high) para la parte alta y Thirdvar(low) para la parte baja, pero ya veo que es Thirdvar+1 y Thirdvar, Pikitin gracias también sobre esa info.

Ahora sobre lo del goto y el $, pss me quedo con la explicación de Risanti, que la parte de que son ciclos y no localidades de memoria de código de lo que habla Pikitin no me convence. Gracias Risanti!

Pss bien kamaradas, por ahora haré mi código con estos "trucos", pero si encuentro alguna buena documentación de todo esto pss claro que se las paso!

Buena Vibra!

Ahora sobre lo del goto y el $, pss me quedo con la explicación de
Risanti, que la parte de que son ciclos y no localidades de memoria de
código de lo que habla Pikitin no me convence. Gracias Risanti!

Solo hay una manera de estar seguro: haz la prueba.

Lo que pasa es que a veces la diferencia no es evidente, por ejemplo el código que puso Risanti funciona, pero ¿que crees que pasará con este código:

Código:


 LIST p=16F876A, r=DEC
#include
 __CONFIG _HS_OSC & _WDT_OFF & _LVP_OFF & _PWRTE_ON

;********************************************************************************
    ORG    0

Bucle
    banksel    PORTA
    bsf    PORTA,3
    btfsc    PORTA,2
    goto    $-1
    btfsc    PORTA,3
    goto    $+3            ; Aquí debería ir a: bsf PORTB,0 ... no?
    goto    $-2
    bsf    PORTB,1
    bsf PORTB,0
    goto    Bucle

;********************************************************************************
 END

En la linea que he marcado debería ir a bsf PORTB,0 ... no? ... simúlalo en Gpsim a ver que pasa...

goto en realidad no es una instruccion propiamente dicha, es algo así como una macro compuesta de dos instrucciones.
Pasa lo mismo con call, return y todas las de ese tipo, también con banksel..

Una vez me pasó eso, utlicé el goto $+2 (EDITO: fué con un $+3 parecido al codigo que puse arriba) cuando había otro goto después... y no me funcionaba, me volví loco buscando el fallo hasta que me contaron como funcionaba el tema.

Saludos.

Va, Pikitin, haré la prueba para estar seguro, pero será otro día que ya me dio sueño, jejeje acá es de noche-madrugada.

Hey, creo ya encontré una buena fuente de información, se trata de unas notas de aplicación de microchip son un montón de páginas y ahora solo las he "hojeado" pero parece ser lo que busco: http://ww1.microchip.com/downloads/en/DeviceDoc/33014K.pdf

Pss bien, ya tengo bastante para estudiar, jeje

Saludos!

Bueno... no te molestes en probarlo... Risanti tenía razón, el tema de los saltos de 2 no pasa con los goto, sino con los banksel. Por ejemplo algo como esto:

Código:


 LIST p=16F876A, r=DEC
#include <P16F876A.inc>
 __CONFIG _HS_OSC & _WDT_OFF & _LVP_OFF & _PWRTE_ON

;********************************************************************************
    ORG    0

Bucle
    banksel    PORTA
    bsf    PORTA,3
    btfsc    PORTA,3
    goto    $+3
    banksel TRISB
    bsf    TRISB,1
    bsf PORTB,0
    goto    Bucle

;********************************************************************************
 END

No funciona, habría que poner: goto $+4 para que salte a: bsf PORTB,0

Hola a todos..
Esta bastante interesante eso... ya que cada dia se aprende algo nuevo..
Bastante bueno la informacion de michochip aztk, alli explica bastante acerca de nuestras preguntas y confima lo del cblock. (Mivar y Mivar +1).
Acerca de la directiva banksel, el ensamblador genera dos instrucciones segun el registro que se desee acceder( segun lo que interpreto de la informarcion aztk).por ejemplo:

En el apunte que entrego aztk dice lo siguiente

For 14-bit instruction width (most PIC12/PIC16) devices, bit set/clear instructions on
the STATUS register will be generated.

asi que me imagino que hacer :
banksel Registro
el ensamblador genera las siguientes instrucciones que al remplaza al banksel al momento de generar el hex

si el registro esta en el banco 0

Código:


bcf status,RP0
bcf status,RP1


o si el registro esta en el banco 1 ensamblador genera
[code]
bsf status,RP0
bcf status,RP1
[code]

Pienso que debe ser por eso que pikitin debe poner goto $+4 para realizar bsf portb,0

habría que poner: goto $+4 para que salte a: bsf PORTB,0

Y otra vez aztk muy buena la información.. Ahora solo nos queda aplicar


Saludos RiSanti.

Hola:

Es bueno buscar información del ASM avanzado, cosas como estas.

Negar W. Hallando su complemento a 2, es decir, restándole de cero. www.pic16f84a.org, página del libro 109. Hay muchos trucos.

Código:

sublw    0      ; ya que 0 - (W)=-(W)

Donde van a encontrar ya ensamblador avanzado es con los nuevos PIC16F de núcleo mejorado con 49 instrucciones frente a los 35 actuales.

Tengo ganas de usar esos nuevos PIC, encima más optimizado para C, sin comparar con los 18F claro.

Ver noticia 1
Ver noticia 2.

Saludo.

Je, complementando algo más este hilo. Para ver un resumen de las directivas que se pueden usar en MPASM (y creo que son soportadas por GPUTILS) ver http://perso.wanadoo.es/pictob/directivas_mpasm.htm

Saludos!

Hey Piktin tu primer comentario fue muy bueno... pero ya la pusiste xP...

Les recomiendo a todos que se lean bien el datasheet y en la ayuda del MPLAB IDE o algún manual que puedan descargar de la Microchip de MPASM si es que por usar el gpasm no quieran nada que ver con el MPLAB (por cierto que a la fecha de hoy, el MPLABX tiene versión nativa para Linux) léanse también las directivas del compilador, aprenderán como hacer códigos relativos, hacer reservaciones de memoria, definir macros, crear sus propias librerías y llamar macros desde otros archivos, etc

El goto es una instrucción del set de instrucciones del PIC, es decir se ejecuta por hardaware, las directivas pagsel y banksel son del compilador y las traduce a dos líneas de código cada una.

El goto ocupa UN SOLO ESPACIO en la memoria flash, aunque se ejecute en dos ciclos de instrucción eso nada tiene que ver con el espacio que ocupa en la memoria, si alguna vez alguien tuvo problemas para dar correctamente los saltos es porque seguro tenían un banksel o un pagesel de por medio.

Aquí un ejemplo para dar saltos a la instrucción "bsf PORTB,7"

Código:

    goto $+3
    nop
    nop
    bsf PORTB,7      ;Correcto, si previamente el banco está bien seleccionado.

    goto $+3
    banksel PORTB
    nop
    bsf PORTB,7      ;Incorrecto, el banksel ocupa dos espacios.