Changes between Initial Version and Version 1 of doc-assembleur-pic16

Timestamp:

Mar 25, 2007, 11:34:26 PM (19 years ago)

Author:

Franck Wajsburt

Comment:

--

doc-assembleur-pic16

@@ +1 @@
+{{{
+#!comment
+Page d'aide assembleur
+}}}
+[[PageOutline]]
+{{{
+#!html
+<h1><u>Page d'aide assembleur</u></h1>
+}}}
+
+= Préambule =  
+  
+La difficulté de la programmation en assembleur PIC se résume en deux points:
+ * ''seulement 35 instructions'',[[BR]]
+   '''mais pas de structures de contrôle, pas de fonctions...'''
+ * ''et quelques centaines d'octets de mémoire'',[[BR]]
+   '''mais pas de typage, pas de pointeurs, pas de fichiers...'''
+
+La pauvreté du langage entraine des difficultés pour exprimer des choses aussi simples qu'un test IF-THEN-ELSE. Le but de
+cette page est de vous donner une aide sur la bonne façon d'écrire de l'assembleur PIC efficacement. Il n'y a aucune utilisation
+des périphériques internes ou externes du PIC.
+
+Le code que vous trouverez ici est issu de nombreuses <a href="liens.html">sources</a> à la fois sur internet et dans les
+livres. Les auteurs (ou sources) sont cités quand ils sont connus.
+
+= liste des instructions pic 16 = #instruction
+
+ __'''Instructions sur les registres octet'''__::
+||'''`Mnémotique `'''||'''`arguments`'''||'''`Commentaire                       `'''||'''`drapeaux`'''||'''`cycles  `'''||
+|| addwf  || ''reg'', ''dst'' || add w to ''reg'', result in ''dst''                 || z, dc, c || 1             ||
+|| andwf  || ''reg'', ''dst'' || and w and ''reg'', result in ''dst''                || z        || 1             ||
+|| clrf   || ''reg''          || write zero to ''reg''                               || z        || 1             ||
+|| clrw   ||                  || write zero to w i                                   || Z        || 1             ||
+|| comf   || ''reg'', ''dst'' || complement ''reg'', result in ''dst''               || Z        || 1             ||
+|| decf   || ''reg'', ''dst'' || decrement ''reg'', result in ''dst'' Z              || Z        || 1             ||
+|| incf   || ''reg'', ''dst'' || Increment ''reg'', result in ''dst'' Z              || Z        || 1             ||
+|| iorwf  || ''reg'', ''dst'' || Or W and ''reg'', result in ''dst''                 || Z        || 1             ||
+|| movf   || ''reg'', ''dst'' || Move ''reg'' to ''dst''                             || Z        || 1             ||
+|| movwf  || ''reg''          || Move W to ''reg''                                   || none     || 1             ||
+|| nop    ||                  || No operation                                        || none     || 1             ||
+|| rlf    || ''reg'', ''dst'' || Rotate ''reg'' left, result in ''dst''              || C        || 1             ||
+|| rrf    || ''reg'', ''dst'' || Rotate ''reg'' right, result in ''dst''             || C        || 1             ||
+|| subwf  || ''reg'', ''dst'' || Subtract W from ''reg'', result in ''dst''          || Z, DC, C || 1             ||
+|| swapf  || ''reg'', ''dst'' || Swap nibbles of ''reg'', result in ''dst''          || none     || 1             ||
+|| xorwf  || ''reg'', ''dst'' || Xor W and ''reg'', result in ''dst''                || Z        || 1             ||
+|| decfsz || ''reg'', ''dst'' || Decrement ''reg'', result in ''dst'', skip IF zero  || none     || 1 (2 if skip) ||
+|| incfsz || ''reg'', ''dst'' || Increment ''reg'', result in ''dst'', skip IF zero  || none     || 1 (2 if skip) ||
+ 
+ __'''Instructions sur les bits'''__::
+||'''`Mnémotique `'''||'''`arguments`'''||'''`Commentaire                       `'''||'''`drapeaux`'''||'''`cycles  `'''||
+|| bcf    || ''reg'', ''bit'' || Clear ''bit'' of ''reg''                            || none     || 1             ||
+|| bsf    || ''reg'', ''bit'' || Set ''bit'' of ''reg''                              || none     || 1             ||
+|| btfsc  || ''reg'', ''bit'' || Skip next instruction IF ''bit'' of ''reg'' is clear|| none     || 1 (2 if skip) ||
+|| btfss  || ''reg'', ''bit'' || Skip next instruction IF ''bit'' of ''reg'' is set  || none     || 1 (2 if skip) ||
+
+ __'''Instructions sur les immediats'''__::
+||'''`Mnémotique `'''||'''`arguments`'''||'''`Commentaire                       `'''||'''`drapeaux`'''||'''`cycles  `'''||
+|| addlw  || ''imm''          || Add immediate to W                                  || Z, DC, C || 1             ||
+|| andlw  || ''imm''          || And immediate to W                                  || Z        || 1             ||
+|| iorlw  || ''imm''          || Inclusive OR littéral to W                          || Z        || 1             ||
+|| movlw  || ''imm''          || Move littéral to W                                  || none     || 1             ||
+|| retlw  || ''imm''          || Load W with immediate and return                    || none     || 2             ||
+|| sublw  || ''imm''          || Subtract W from littéral                            || Z, DC, C || 1             ||
+|| xorlw  || ''imm''          || Xor W and littéral                                  || Z        || 1             ||
+
+ __'''Instructions de controle'''__::
+||'''`Mnémotique `'''||'''`arguments`'''||'''`Commentaire                       `'''||'''`drapeaux`'''||'''`cycles  `'''||
+|| clrwdt ||                  || Reset watchdog timer                                || TO, PD   || 1             ||
+|| call   || ''addr''         || Call subroutine                                     || none     || 2             ||
+|| goto   || ''addr''         || Go to ''addr''                                      || none     || 2             ||
+|| retfie ||                  || Return from interrupt                               || GIE      || 2             ||
+|| return ||                  || Return from subroutine                              || none     || 2             ||
+|| sleep  ||                  || Enter sleep mode                                    || TO, PD   || 1             ||
+
+= Structures de contrôle = #struc_ctrl
+
+== ` ` Branchements conditionnels == #test
+
+Comme vous le savez en assembleur, pour faire une rupture de séquence on ne sait faire qu'une chose: tester une condition et
+si cette condition est vraie ou fausse alors sauter à une adresse, c'est peu. En outre, en assembleur PIC, il y a une
+difficulté supplémentaire: si la condition est vraie on se contente de sauter une instruction.
+
+En PIC, il existe 4 instructions de sauts conditionnels: ''decfsz'', ''incfsz'', ''btfss'', ''btfsc.'' Les deux
+première instructions sont surtout utilisés pour les boucles. Nous allons ici, nous intéresser au comparaisons sur les nombres
+8 bits signés (en complément à 2) et non signés, il y a 6 possibles:
+ * égalité (== ou BEQ)
+ * inégalité (!= ou BNE)
+ * inférioité stricte (< ou BLT ou BLTS)
+ * supériorité stricte (> ou BGT ou BGTS)
+ * inférioité ou égalité (<= ou BLE ou BLES)
+ * supériorité ou égalité (>= ou BGE ou BGES)
+
+Les registres doivent être dans le même banc. Le tableau qui suit donne en commentaire (après les ;) une notation de type
+macro instruction. Les comparaisons sont dépendent du type des données qui peuvent être non signées (valeur de 0 à 255) ou
+signées (valeurs de -128 à +127). Il est parfois nécessaire d'utiliser un registres temporaire TMP
+
+ Égalité registre/registre et registre/immédiat::
+{{{
+    ; si (REG1 == REG2) goto LAB
+    ; BEQ REG1, REG2, goto, LAB 
+      movf    REG1, W
+      xorwf   REG2, W
+      btfsc   STATUS, Z
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 != REG2) goto LAB
+    ; BNE REG1, REG2, goto, LAB 
+      movf    REG1, W
+      xorwf   REG2, W
+      btfss   STATUS, Z
+      goto    LAB
+}}}
+{{{
+    ; si (REG == IMM) goto LAB
+    ; BEQ REG, IMM, goto, LAB 
+      movlw   IMM
+      xorwf   REG, W
+      btfsc   STATUS, Z
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 != IMM) goto LAB
+    ; BNE REG1, IMM, goto, LAB 
+      movlw   IMM
+      xorwf   REG, W
+      btfss   STATUS, Z
+      goto    LAB
+}}}
+
+ Comparaisons registre/registre sur des nombres non signés::
+{{{
+    ; si (REG1 < REG2) goto LAB
+    ; BLT REG1, REG2, goto, LAB 
+      movf    REG2, W
+      subwf   REG1, W 
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 > REG2) goto LAB
+    ; BGT REG1, REG2, goto, LAB 
+      movf    REG1, W
+      subwf   REG2, W
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 <= REG2) goto LAB
+    ; BLE REG1, REG2, goto, LAB 
+      movf    REG1, W
+      subwf   REG2, W
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 >= REG2) goto LAB
+    ; BGE REG1, REG2, goto, LAB 
+      movf    REG2, W
+      subwf   REG1, W 
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+
+ Comparaisons registre/immediat sur des nombres non signés::
+{{{
+    ; si (REG > IMM) goto LAB
+    ; BGT REG, IMM, goto, LAB 
+      movf    REG, W
+      sublw   IMM
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG < IMM) goto LAB
+    ; BLT REG, IMM, goto, LAB 
+      movlw   IMM
+      subwf   REG, W   
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG <= IMM) goto LAB
+    ; BLE REG, IMM, goto, LAB 
+      movf    REG, W
+      sublw   IMM
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG >= IMM) goto LAB
+    ; BGE REG, IMM, goto, LAB 
+      movlw   IMM
+      subwf   REG, W  
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+
+ Comparaisons immediat/registre sur des nombres non signés::
+{{{
+    ; si (IMM < REG) goto LAB
+    ; BLT IMM, REG, goto, LAB 
+      movf    REG,W
+      sublw   IMM
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (IMM > REG) goto LAB
+    ; BGT IMM, REG, goto, LAB 
+      movlw   IMM
+      subwf   REG,W   
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (IMM <= REG) goto LAB
+    ; BLE IMM, REG, goto, LAB 
+      movlw   IMM
+      subwf   REG,W    
+      btfsc   STATUS, C
+      goto    LAB
+
+}}}
+{{{
+    ; si (IMM >= REG) goto LAB
+    ; BGE IMM, REG, goto, LAB 
+      movf    REG,W
+      sublw   IMM
+      btfsc   STATUS, C
+      goto    LAB
+
+}}}
+
+ comparaisons registre/registre sur des nombres signés:: 
+{{{
+    ; si (REG1 < REG2) goto LAB
+    ; BLTS REG1, REG2, goto, LAB 
+      movf    REG1, W
+      addlw   0x80
+      movwf   TMP
+      movf    REG2, W
+      addlw   0x80
+      subwf   TMP, W
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 > REG2) goto LAB
+    ; BGTS REG1, REG2, goto, LAB 
+      movf    REG2, W
+      addlw   0x80
+      movwf   TMP
+      movf    REG1, W
+      addlw   0x80
+      subwf   TMP, W
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 <= REG2) goto LAB
+    ; BLES REG1, REG2, goto, LAB 
+      movf    REG2, W
+      addlw   0x80
+      movwf   TMP
+      movf    REG1, W
+      addlw   0x80
+      subwf   TMP, W
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG1 >= REG2) goto LAB
+    ; BGES REG1, REG2, goto, LAB 
+      movf    REG1, W
+      addlw   0x80
+      movwf   TMP
+      movf    REG2, W
+      addlw   0x80
+      subwf   TMP, W
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+ Comparaisons registre/immediat sur des nombres signés::
+{{{
+    ; si (REG < IMM) goto LAB
+    ; BLTS REG, IMM, goto, LAB 
+      movf    REG, W
+      addlw   0x80
+      movwf   TMP
+      movlw   0x80 | IMM
+      subwf   TMP, W
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG > IMM) goto LAB
+    ; BGTS REG, IMM, goto, LAB 
+      movf    REG, W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfss   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG <= IMM) goto LAB
+    ; BLES REG, IMM, goto, LAB 
+      movf    REG, W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfsc   STATUS, C
+      goto    LAB
+}}}
+{{{
+    ; si (REG >= IMM) goto LAB
+    ; BGES REG, IMM, goto, LAB 
+      movf    REG, W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfss   STATUS,Z
+      btfss   STATUS, C
+      goto    LAB
+}}}
+ Comparaisons immediat/registre sur des nombres signés::
+{{{
+    ; si (IMM < REG) goto LAB
+    ; BLTS IMM, REG, goto, LAB 
+      movf    REG,W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfss   STATUS, C
+      goto    LAB
+
+}}}
+{{{
+    ; si (IMM > REG) goto LAB
+    ; BGTS IMM, REG, goto, LAB 
+      movf    REG,W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfsc   STATUS,Z
+      goto    $+3
+      btfsc   STATUS,C
+      goto    LAB
+}}}
+{{{
+    ; si (IMM <= REG) goto LAB
+    ; BLES IMM, REG, goto, LAB 
+      movf    REG,W
+      addlw   0x80
+      movwf   TMP
+      movlw   0x80 | IMM
+      subwf   TMP,W
+      btfsc   STATUS, C
+      goto    LAB
+
+}}}
+{{{
+    ; si (IMM >= REG) goto LAB
+    ; BGES IMM, REG, goto, LAB 
+      movf    REG,W
+      addlw   0x80
+      sublw   0x80 | IMM
+      btfsc   STATUS, C
+      goto    LAB
+
+}}}
+
+== ` ` If condition then else == #if_then_else
+
+Pour pouvoir faire une alternative, il faut savoir faire un <a href="#test">branchement conditionnel</a>. Nous supposons que
+nous savons le faire. Dans une alternative ''si-alors-sinon'', nous allons mettre la séquence ''alors'' avant la séquence
+''sinon''. Ce choix permet, a priori, une plus grande lisibilité du code, car il est plus proche du code écrit dans les
+langages évolués de type C ou Pascal. Pour respecter cet ordre, il est souvent nécessaire d'inverser le test. En effet, si la
+condition est fausse, il faut sauter à la séquence ''sinon'' et donc simplement continuer si la condition est vraie.
+
+Quand les conditions sont plus complexes, qu'elles sont le résultat d'une expression Booléenne, il faut faire des séquences
+de test. Le tableau suivant contient quelques exemples permettant de comprendre la méthode à suivre. Ce n'est pas une méthode générale
+
+ SI test ALORS sequence_alors SINON sequence_sinon FIN::
+ * Cas général: 
+{{{
+       IFNOT test GOTO sinon
+alors  sequence_alors
+       goto  fin
+sinon  sequence_sinon
+fin
+}}}
+   Exemple: si (reg1==reg2) alors sequence_alors SINON sequence_sinon FIN 
+{{{
+si     ; BNE reg1, reg2, goto, sinon
+       movf  reg1,w
+       xorwf reg2,w
+       btfss STATUS, Z
+       goto  sinon
+
+alors  sequence_alors
+       goto  fin
+
+sinon  sequence_sinon
+fin
+}}}
+
+ SI test1 ET test2 ALORS sequence_alors SINON sequence_sinon FIN::
+{{{
+si     IFNOT test1 GOTO sinon
+       IFNOT test2 GOTO sinon
+alors  sequence_alors
+       goto  fin
+sinon  sequence_sinon
+fin
+}}}
+
+ SI test1 OU test2 ALORS sequence_alors SINON sequence_sinon FIN::
+{{{
+si     IF test1 GOTO alors
+       IFNOT test2 GOTO sinon
+alors  sequence_alors
+       goto  fin
+sinon  sequence_sinon
+fin
+}}}
+ SI (test1 OU test2) ET (test3 OU test4) ALORS sequence_alors SINON sequence_sinon FIN::
+{{{
+si     IF test1 GOTO si2
+       IFNOT test2 GOTO sinon
+si2    IF test3 GOTO alors
+       IFNOT test4 GOTO sinon
+alors  sequence_alors
+       goto  fin
+sinon  sequence_sinon
+fin
+}}}
+ SI (test1 ET test2) OU (test3 ET test4) ALORS sequence_alors SINON sequence_sinon::
+{{{
+si     IFNOT test1 GOTO si2
+       IF test2 GOTO alors
+si2    IFNOT test3 GOTO sinon
+       IFNOT test4 GOTO sinon
+alors  sequence_alors
+       goto  fin
+sinon  sequence_sinon
+fin
+}}}
+
+== ` ` Faire n fois == #faire_n_fois
+
+On traite deux cas, si N est sur 8 bits ou si N est sur 16 bits. Dans le cas 8 bits, la valeur 0 est en fait 256. Dans le
+    cas 16 bits, la valeur 0 c'est vraiment 0 (c'est-à-dire qu'on n'exécute pas la séquence_corps).
+
+    <table cellpadding="10" summary="fairenfois">
+      <tr>
+        <td colspan="4"><a name="fairenfois8bits"><b>Faire N fois (8 bits) sequence_corps FIN</b></a></td>
+      </tr>
+      <tr valign="top">
+        <td></td>
+        <td>
+          Si N est une valeur immédiate. 
+{{{
+       movlw   N
+       movwf   REG
+corps  sequence_corps
+       decfsz  REG
+       goto    corps
+}}}
+        </td>
+        <td>
+          Si N est dans un registre. 
+{{{
+       movf    REG_N, W
+       movwf   REG
+corps  sequence_corps
+       decfsz  REG
+       goto    corps
+}}}
+ * Faire N fois (16 bits) sequence_corps FIN
+ Si N est une valeur immédiate::
+{{{
+       movlw   (HIGH N) + 1
+       movwf   REG+1
+       movlw   LOW N
+       movwf   REG
+       movf    REG, F
+       btfsc   STATUS, Z
+       goto    testh
+corps  sequence_corps
+       decfsz  REG
+       goto    corps
+testh  decfsz  REG+1
+       goto    corps
+fin
+}}}
+ Si N est dans une paire de registres successifs::
+{{{
+       incf    REG_N+1, W
+       movwf   REG+1
+       movf    REG_N, W
+       movwf   REG
+       btfsc   STATUS, Z
+       goto    testh
+corps  sequence_corps
+       decfsz  REG
+       goto    corps
+testh  decfsz  REG+1
+       goto    corps
+fin
+}}}
+
+== ` ` Switch case == #switchcase
+
+Le switch case est un test à choix multiples. Il existe dans tous les langages évolués et permet entre autre de décrire les
+    automates d'états finis particulièrement important dans la programmation en assembleur.
+
+ La forme générale du switch case est::
+{{{
+    switch reg
+    case CST1 : sequence_cst1; break;
+    case CST2 : sequence_cst2; break;
+    case CST3 : sequence_cst3; break;
+    default   : sequence_default
+    end
+}}}
+
+Les valeurs CST peuvent être quelconque. Dans ce cas, il n'y a d'autres choix que de faire les tests les uns après les
+autres en séquence. Dans le code qui suit, on suppose que les constantes sont bien des valeurs immédiates mais en fait il peut
+s'agir de registres. On peut même faire des tests différents. C'est très général mais évidemment ce n'est pas très effice et
+tous les tests ne sont pas équivalent vis à vis du temps de traitement. Le premier est favorisé par rapport au dernier.
+
+ switch general::
+   Si les valeurs constantes sont quelconques:
+{{{
+    ; BEQ reg, CST1, goto, label_cst1
+    movlw  CST1
+    xorwf  reg,  W
+    btfsc  STATUS, Z
+    goto   label_cst1
+
+    ; BEQ reg, CST2, goto, label_cst2
+    movlw  CST2
+    xorwf  reg,  W
+    btfsc  STATUS, Z
+    goto   label_cst2
+
+    ; BEQ reg, CST3, goto, label_cst3
+    movlw  CST3
+    xorwf  reg,  W
+    btfsc  STATUS, Z
+    goto   label_cst3
+
+    ; BEQ reg, CST4, goto, label_cst4
+    movf   CST4
+    xorwf  reg,  W
+    btfsc  STATUS, Z
+    goto   label_cst4
+}}}
+{{{
+        ; puis a la suite des tests
+        ; les sequences a executer
+
+        sequence_default    
+
+label_cst1
+        sequence_cst1    
+        goto  fin 
+
+label_cst2
+        sequence_cst2    
+        goto  fin 
+
+label_cst3
+        sequence_cst3    
+        goto  fin 
+
+label_cst4
+        sequence_cst4    
+        goto  fin 
+
+fin
+}}}
+
+mais pour être efficace, il est souhaitable de se contraindre dans le choix des valeurs.
+
+== ` ` Tantque condition faire == #tantque
+
+= Arithmétiques = #arith
+
+== ` ` Entière 8 bits == #int9
+
+ * Addition
+ * Soustraction
+ * Multiplication
+ * Division
+
+== ` ` Entière 16 bits == #int16
+
+== ` ` Virgule fixe 16 bits == #vfixe16
+
+== ` ` Flottante 16 bits == #float16
+
+= Expressions = #expr
+
+== ` ` Boolèennes == #exp_bool
+
+== ` ` Arithmétiques == #exp_arith
+
+= Structures de données = #struc_data
+
+== ` ` Tableaux de données == #tables
+
+ * Dans les registres
+ * Dans le programme
+
+== ` ` Liste chainée == #listes
+
+== ` ` Pile == #piles
+
+= Macroinstructions = #macros
+
+= Automates = #automates
+
+= Routines diverses (snippets) = #snippets
+
+== ` ` Mathématiques == #snippets_math
+
+ * Parité
+ * Moyenne glissante
+ * PGCD