Vocabulaire d'assembleur des pic

bly51 · Messagepar **bly51** » sam. 23 janv. 2021 11:50

Bonjour
je suis entraîne de déchiffré le code division suivant donné par l'ami claudiuss01 que je le remercier
mais malheureusement jusque maintenant je n'arrive pas comprendre quelque ligne
par exemple
1)

Code : Tout sélectionner

 M_STOR_STATUS macro WHERE
    movf    STATUS,w
    movwf   WHERE
    endm

pour quoi le registre WHERE n'est pas déclaré dans la zone des variable ?
est ce que ce code est normale?
2)

Code : Tout sélectionner

btfss   REG_T2,C

est ce que REG_T2 est un registre spéciale avec un bit C ?

Code : Tout sélectionner

#include <p16F688.inc>          ; remove this if not necessary

#define PRECISION 20             ; byte size for registers
[color=red]
M_STOR_STATUS macro WHERE
    movf    STATUS,w
    movwf   WHERE
    endm
[/color]
M_RETR_STATUS macro WHERE
    movf    WHERE,w
    movwf   STATUS
    endm

    cblock 0x20
    REG_X:PRECISION
    REG_Y:PRECISION
    REG_Z:PRECISION
    REG_COUNTER
    REG_STATUS
    REG_T1
    REG_T2
    REG_ROT_COUNTER
    endc


M_CLR                           ; clear a register
    movwf   FSR
    movlw   PRECISION
    movwf   REG_COUNTER
M_CLR_loop
    clrf    INDF
    incf    FSR,f
    decf    REG_COUNTER,f
    btfss   STATUS,Z
    goto    M_CLR_loop
    return

M_ROL                           ; rotate a register to the left
    movwf   FSR
    M_STOR_STATUS REG_STATUS
    clrf    REG_COUNTER
M_ROL_loop
    M_RETR_STATUS REG_STATUS
    rlf     INDF,f
    M_STOR_STATUS REG_STATUS
    incf    FSR,f
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_ROL_loop
    return


M_ROR                           ; rotates a register to the right
    movwf   FSR
    movlw   PRECISION-1
    addwf   FSR,f
    M_STOR_STATUS REG_STATUS
    clrf    REG_COUNTER
M_ROR_loop
    M_RETR_STATUS REG_STATUS
    rrf     INDF,f
    M_STOR_STATUS REG_STATUS
    decf    FSR,f
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_ROR_loop
    return


M_CMP                           ; Z <=> X -> STATUS(C,Z)
                                ; STATUS,C set if Z => X;
                                ; STATUS,Z set if Z == X
    clrf    REG_COUNTER
M_CMP_loop
    movf    REG_COUNTER,w
    sublw   REG_Z+PRECISION-1
    movwf   FSR
    movf    INDF,w
    movwf   REG_T1
    movf    REG_COUNTER,w
    sublw   REG_X+PRECISION-1
    movwf   FSR
    movf    INDF,w
    subwf   REG_T1,f
    btfss   STATUS,Z
    return
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_CMP_loop
    return


M_SUB                           ; Z - X -> Z
    clrf    REG_COUNTER
    bsf     REG_STATUS,C
M_SUB_loop
    bsf     REG_T2,C
    movlw   REG_Z
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
    movwf   REG_T1
    movlw   REG_X
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
   subwf   REG_T1,f
    btfss   STATUS,C
  [color=red]  bcf     REG_T2,C[/color]
    btfsc   REG_STATUS,C
    goto    M_SUB_no_carry
    movlw   0x01
    subwf   REG_T1,f
    btfss   STATUS,C
    bcf     REG_T2,C
M_SUB_no_carry
    movlw   REG_Z
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    REG_T1,w
    movwf   INDF
    bsf     REG_STATUS,C
    btfss   REG_T2,C
    bcf     REG_STATUS,C
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_SUB_loop
    btfss   REG_STATUS,C
    bcf     STATUS,C
    return


M_DIV                           ; Z / X -> Y;  remainder -> Z
    movlw   REG_Y
    call    M_CLR
    movlw   PRECISION*8
    movwf   REG_ROT_COUNTER
M_DIV_rot_loop
    btfsc   REG_X+PRECISION-1,7
    goto    M_DIV_loop
    movlw   REG_X
    bcf     STATUS,C
    call    M_ROL
    decf    REG_ROT_COUNTER,f
    btfss   STATUS,Z
    goto    M_DIV_rot_loop
    bsf     STATUS,Z
    return
M_DIV_loop
    call    M_CMP
    M_STOR_STATUS REG_T2
    movlw   REG_Y
    call    M_ROL
   [color=red] M_RETR_STATUS REG_T2[/color]
    btfsc   STATUS,C
    call    M_SUB
    bcf     STATUS,Z
    bcf     STATUS,C
    movlw   REG_X
    call    M_ROR
    incf    REG_ROT_COUNTER,f
    movlw   PRECISION*8+1
    subwf   REG_ROT_COUNTER,w
    btfss   STATUS,Z
    goto    M_DIV_loop
    return    

    END

[/QUOTE]
j'ajoute que ce code vien de ce site
http://avtanski.net/projects/math/
merci

Claudius · Messagepar **Claudius** » sam. 23 janv. 2021 14:07

Bonjour,

1 -

Code : Tout sélectionner

 M_STOR_STATUS macro WHERE
    movf    STATUS,w
    movwf   WHERE
    endm

Le code ci-dessus est la définition d'une macro (en l’occurrence M_STOR_STATUS) utilisée par exemple comme:

Code : Tout sélectionner

M_STOR_STATUS REG_T2

où REG_T2 est un registre du PIC défini dans la liste

Code : Tout sélectionner

    cblock 0x20
    REG_X:PRECISION
    REG_Y:PRECISION
    REG_Z:PRECISION
    REG_COUNTER
    REG_STATUS
    REG_T1
    REG_T2
    REG_ROT_COUNTER
    endc

2 - L'instruction btfss REG_T2,C est un abus de langage, celle-ci teste et se branche suivant l'état du bit 0 du registre REG_T2
(car C est implicitement définie comme le bit 0 du registre STATUS)

En effet, le code généré est (si PRECISION est égale à 4):

Code : Tout sélectionner

     btfss   0x2f, 0             btfss   REG_T2,C

Cf. par exemple la datasheet 16f628a (Page 24 - REGISTER 4-1: STATUS – STATUS REGISTER)

bly51 · Messagepar **bly51** » sam. 23 janv. 2021 15:05

Claudius a écrit :Bonjour,

1 -
Code : Tout sélectionner
M_STOR_STATUS macro WHERE movf STATUS,w movwf WHERE endm

Le code ci-dessus est la définition d'une macro (en l’occurrence M_STOR_STATUS) utilisée par exemple comme:

Bonjour
peut etre que j'ai mal compris les macro mais a ma connaissance normamalement cette macro ce écrit

Code : Tout sélectionner

 M_STOR_STATUS macro 
    movf    STATUS,w
    movwf   WHERE
    endm

sans WHERE ?

chaque fois que la macro M_STOR_STATUS sera rencontrée, elle sera
remplacée au moment de l’assemblage par les 2 lignes :

Code : Tout sélectionner

    movf    STATUS,w
    movwf   WHERE
    endm

et le contenu de STATUS sera transféré a le registre WHERE mais le problème quell est le adresse de registre WHERE ?

bly51 · Messagepar **bly51** » sam. 23 janv. 2021 17:37

j'ai compris WHERE = REG_T1 et WHERE = STATUS
merci infiniment Claud

Claudius · Messagepar **Claudius** » sam. 23 janv. 2021 19:24

Ok Merci bly51, mais c'est pas tout a fait cela (cf. MPASM Directives ;-)

WHERE prendra la valeur passée dans l'argument de la macro (ici le 1st argument, mais une macro peut attendre plusieurs arguments)

bly51 · Messagepar **bly51** » sam. 23 janv. 2021 20:37

oui c'est vrai il me reste beaucoup a apprendre
bonne nuit a vous et tous le monde

bly51 · Messagepar **bly51** » ven. 12 févr. 2021 12:08

Bonjour Claudius
le programme que vous m'avez donné marche bien , j'ai intégré ce programme dans mon programmes a la place de mon programme de division
pour calculé l'operation suivant 253*[(1/fx)^2-(1/fY)^2]

Code : Tout sélectionner

#include <p16F84.inc>          ; remove this if not necessary
   
#define PRECISION 8             ; byte size for registers

M_STOR_STATUS macro WHERE
    movf    STATUS,w
    movwf   WHERE
    endm

M_RETR_STATUS macro WHERE
    movf    WHERE,w
    movwf   STATUS
    endm
    
    x0 equ 0x0C 
    x1 equ 0x0D
    x2 equ 0x0E 
    x3 equ 0x0F 
    x4 equ 0x10
    x5 equ 0x11
    x6  equ 0x12 
    x7 equ 0x13
    y0 equ 0x14 
    y1 equ 0x15 
    y2 equ 0x16
    y3 equ 0x17 
    y4 equ 0x18
    y5 equ 0x19 
    y6 equ 0x1A 
    y7 equ 0x1B
    z0 equ 0x1C
    z1 equ 0x1D
    z2 equ 0x1E
    z3 equ 0x1F
    z4 equ 0x20
    z5 equ 0x21
    z6 equ 0x22
    z7 equ 0x23
   




    cblock 0x0C
    REG_X:PRECISION
    REG_Y:PRECISION
    REG_Z:PRECISION
    REG_COUNTER
    REG_STATUS
    REG_T1
    REG_T2
    REG_ROT_COUNTER
    fx0
    fx1
    fy0
    fy1
    A0
    A1
    A2
    A3
    A4
    A5
    A6
    A7
   
   
    B0
    B1
    B2
    B3
    B4
    B5
    B6
    B7
    T3
    T4
    T5
    T6
    T7
    endc
   


    GOTO STAR


M_CLR                           ; clear a register
    movwf   FSR
    movlw   PRECISION
    movwf   REG_COUNTER
M_CLR_loop
    clrf    INDF
    incf    FSR,f
    decf    REG_COUNTER,f
    btfss   STATUS,Z
    goto    M_CLR_loop
    return

M_ROL                           ; rotate a register to the left
    movwf   FSR
    M_STOR_STATUS REG_STATUS
    clrf    REG_COUNTER
M_ROL_loop
    M_RETR_STATUS REG_STATUS
    rlf     INDF,f
    M_STOR_STATUS REG_STATUS
    incf    FSR,f
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_ROL_loop
    return


M_ROR                          ; rotates a register to the right
    movwf   FSR
    movlw   PRECISION-1
    addwf   FSR,f
    M_STOR_STATUS REG_STATUS
    clrf    REG_COUNTER
M_ROR_loop
    M_RETR_STATUS REG_STATUS
    rrf     INDF,f
    M_STOR_STATUS REG_STATUS
    decf    FSR,f
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_ROR_loop
    return


M_ADD                           ; Z + X -> Z
    bcf     STATUS,C
    clrf    REG_STATUS
    clrf    REG_COUNTER
M_ADD_loop
    clrf    REG_T1
    btfsc   REG_STATUS,C
    incf    REG_T1,f
    clrf    REG_STATUS
    movlw   REG_X
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
    addwf   REG_T1,f
    btfsc   STATUS,C
    bsf     REG_STATUS,C
    movlw   REG_Z
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
    addwf   REG_T1,f
    btfsc   STATUS,C
    bsf     REG_STATUS,C
    movf    REG_T1,w
    movwf   INDF
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_ADD_loop
    return


M_MUL                           ; X * Y -> Z
    movlw   REG_Z
    call    M_CLR
    movlw   PRECISION*8+1
    movwf   REG_ROT_COUNTER
M_MUL_loop
    decf    REG_ROT_COUNTER,f
    btfsc   STATUS,Z
    return
    btfsc   REG_Y,0
    call    M_ADD
    bcf     STATUS,C
    movlw   REG_Y
    call    M_ROR
    bcf     STATUS,C
    movlw   REG_X
    call    M_ROL
    goto    M_MUL_loop
    return
M_CMP                           ; Z <=> X -> STATUS(C,Z)
                                ; STATUS,C set if Z => X;
                                ; STATUS,Z set if Z == X
    clrf    REG_COUNTER
M_CMP_loop
    movf    REG_COUNTER,w
    sublw   REG_Z+PRECISION-1 ; chargé  l'adresse  de  dernier  byte  de  Z  dans  fsr,puis chargé  l'avant dernier byte de Z dans fsr  en deuxiemme  boucle .......ext
    movwf   FSR
    movf    INDF,w
    movwf   REG_T1   ;    z4>>T1  transfré  le  contenu  de dernier  byte  de  Z  dans  un  registre temporaire T1 tous  ça  pour  utulisé  fsr  pour  d'autre  aplication (x>fsr)
    movf    REG_COUNTER,w
    sublw   REG_X+PRECISION-1 ; chargé  l'adresse  de  dernier  byte  de  X  dans  fsr,puis chargé  l'avant dernier byte de z dans fsr  en deuxiemme  boucle .......ext
    movwf   FSR
    movwf   FSR;
    movf    INDF,w          ;z4-x4, puis  z3-x3 dans  la  deuxieme  boucle ; puis......
    subwf   REG_T1,f
    btfss   STATUS,Z
    return                  ;  si  z4<x4   returne  en  programme  principale pour 
    incf    REG_COUNTER,f   ; Z = X
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_CMP_loop
    return

M_SUB                           ; Z - X -> Z
    clrf    REG_COUNTER
    bsf     REG_STATUS,C
M_SUB_loop
    bsf     REG_T2,C
    movlw   REG_Z
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
    movwf   REG_T1
    movlw   REG_X
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    INDF,w
    subwf   REG_T1,f
    btfss   STATUS,C
    bcf     REG_T2,C
    btfsc   REG_STATUS,C
    goto    M_SUB_no_carry
    movlw   0x01
    subwf   REG_T1,f
    btfss   STATUS,C
    bcf     REG_T2,C
M_SUB_no_carry
    movlw   REG_Z
    addwf   REG_COUNTER,w
    movwf   FSR
    movf    REG_T1,w
    movwf   INDF
    bsf     REG_STATUS,C
    btfss   REG_T2,C
    bcf     REG_STATUS,C
    incf    REG_COUNTER,f
    movlw   PRECISION
    subwf   REG_COUNTER,w
    btfss   STATUS,Z
    goto    M_SUB_loop
    btfss   REG_STATUS,C
    bcf     STATUS,C
    return


M_DIV                           ; Z / X -> Y;  remainder -> Z
    movlw   REG_Y
    call    M_CLR
    movlw   PRECISION*8
    movwf   REG_ROT_COUNTER
M_DIV_rot_loop
    btfsc   REG_X+PRECISION-1,7
    goto    M_DIV_loop
    movlw   REG_X
    bcf     STATUS,C
    call    M_ROL
    decf    REG_ROT_COUNTER,f
    btfss   STATUS,Z
    goto    M_DIV_rot_loop
    bsf     STATUS,Z
    return
M_DIV_loop
    call    M_CMP
    M_STOR_STATUS REG_T2
    movlw   REG_Y
    call    M_ROL
    M_RETR_STATUS REG_T2
    btfsc   STATUS,C
    call    M_SUB
    bcf     STATUS,Z
    bcf     STATUS,C
    movlw   REG_X
    call    M_ROR
    incf    REG_ROT_COUNTER,f
    movlw   PRECISION*8+1
    subwf   REG_ROT_COUNTER,w
    btfss   STATUS,Z
    goto    M_DIV_loop
    return 

EXP12
    MOVLW 0x00
    MOVWF z0
    MOVLW 0x10
    MOVWF z1
    MOVLW 0xA5
    MOVWF z2 
    MOVLW 0xD4
    MOVWF z3
    MOVLW 0xE8
    MOVWF z4
    CLRF  z5
    CLRF z6
    CLRF  z5
    CLRF z7
    RETURN
   
n1000000000000DIVf0
    CALL EXP12

    MOVF fx0,w
    MOVWF x0
    MOVF  fx1,w
    MOVWF x1
    CLRF  x2
    CLRF  x3
    CLRF  x4
    CLRF  x5
    CLRF  x6
    CLRF  x7

    CALL M_DIV  ;  Z / X -> Y  ;..................10000000000000/f0
    RETURN





n1000000000000DIVf1

    CALL  EXP12
    
    MOVF  fy0,w
    MOVWF x0
    MOVF  fy1,w
    MOVWF x1
    CLRF  x2       ;  fy >>>x
    CLRF  x3
    CLRF  x4
    CLRF  x5
    CLRF  x6
    CLRF  x7 

    CALL M_DIV ;  Z / X -> Y.......................1000000000000/f1
YTOZ
   MOVLW z0-y0
   MOVWF  REG_T1  ; attention  le   trouve  M_CLR M_ROL M_ROR  donc a M-div et m-mul
   MOVLW y0  ;le  debut  d'adresse  d'origine 
   CALL transfer

    RETURN    
ZTOX
   MOVLW x0-z0
   MOVWF    REG_T1  
   MOVLW z0  ;le  debut  d'adresse  d'origine 
   CALL transfer
   RETURN
transfer   
   MOVWF FSR
   MOVLW  0X08
   MOVWF   REG_COUNTER  ; attention  le   trouve  M_CLR M_ROL M_ROR  donc a M-div et m-mul
LP
   MOVF INDF,w
   MOVWF REG_T2
   MOVF REG_T1,w
   ADDWF FSR 
   MOVF REG_T2,W
   MOVWF  INDF
   MOVF REG_T1,w
   SUBWF  FSR
   INCF   FSR
   DECF   REG_COUNTER
   BTFSS  STATUS,Z  
   GOTO   LP
   RETURN
  
   
STAR

    MOVLW 0x60
    MOVWF fx0
    MOVLW 0xEA 
    MOVWF fx1  
 
    MOVLW 0xA0
    MOVWF fy0
    MOVLW 0x0F 
    MOVWF fy1
     
    CALL    n1000000000000DIVf0
   MOVLW A0-y0
   MOVWF  REG_T1    ; y>>>>>A
   MOVLW y0  ;le  debut  d'adresse  d'origine 
   CALL transfer

    
    
    CALL  n1000000000000DIVf1
   MOVLW x0-A0 ; resultat négatif
   MOVWF  REG_T1    ; A>>>>>X
   MOVLW A0  ;le  debut  d'adresse  d'origine 
   CALL transfer 

   
    CALL M_SUB  ;Z - X -> Z...........................10000000000000/f1-10000000000000/f0

   MOVLW A0-z0
   MOVWF  REG_T1    ; A>>>>>X
   MOVLW z0  ;le  debut  d'adresse  d'origine 
   CALL transfer


    


   CALL   n1000000000000DIVf0
   MOVLW B0-y0
   MOVWF  REG_T1    ; A>>>>>X
   MOVLW y0  ;le  debut  d'adresse  d'origine 
   CALL transfer
    
   CALL n1000000000000DIVf1
   MOVLW x0-B0
   MOVWF  REG_T1    ; A>>>>>X
   MOVLW B0  ;le  debut  d'adresse  d'origine 
   CALL transfer
     
 
   CALL M_ADD  ; Z + X -> Z ;.....................1000000000000/f0+1000000000000/f1
   CALL ZTOX

   MOVLW y0-A0
   MOVWF  REG_T1    ; A>>>>>X
   MOVLW A0  ;le  debut  d'adresse  d'origine 
   CALL transfer

 
    CALL M_MUL    ; X * Y -> Z........................(1000000000000/f0-1000000000000/f1)*(1000000000000/f0+1000000000000/f1)
    CALL ZTOX

    MOVLW 0XFD
    MOVWF y0
    
    CLRF  y2   ; 253 >>y
    CLRF  y3
    CLRF  y4
    CLRF  y5
    CLRF  y6
    CLRF  y7
 
   CALL   M_MUL  ; X * Y -> Z   .....................253*(1000000000000/f0-1000000000000/f1)*(1000000000000/f0+1000000000000/f1)  
   MOVLW 0X03
   MOVWF T4
LOOOP
   DECF  T4
   MOVLW 0X3C
   MOVWF T3
LOOP  
   MOVLW  0X0A
   MOVWF  x0
   CLRF   x1
   CLRF   x1
   CLRF   x2
   CLRF   x3
   CLRF   x4
   CLRF   x5
   CLRF   x6
   CLRF   x7
   CALL   M_DIV                           ; Z / X -> Y;  remainder -> Z*
   MOVF T3,w
   MOVWF FSR 
   MOVF  z0,w
   MOVWF INDF 
   
   MOVF y0,w
   MOVWF z0
   MOVF y1,w
   MOVWF z1
   MOVF y2,w
   MOVWF z2
   MOVF y3,w
   MOVWF z3
  MOVF y4,w
   MOVWF z4
   MOVF y5,w
   MOVWF z5
   MOVF y6,w
   MOVWF z6
   MOVF y7,w
   MOVWF z7 
   DECF  T3
   MOVLW  0X32
   SUBWF T3,w
   BTFSS STATUS,Z
   GOTO  LOOP
   MOVLW 0X1
   SUBWF  T4,w
   BTFSS STATUS,Z
   GOTO LOOOP
PON
    NOP
    GOTO  PON

    END

si vous avez des remarque elle sont les bien venu

NEWTON · Messagepar **NEWTON** » mer. 5 mai 2021 08:04

Bonjour a tous,je suis un debutant en programmation des PIC,J'aime vraiment tout ce que vous publiez.Merci a tous

FantasPic