Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Commentez, partagez et proposez des Tutos en langage ASM !
Menu de routines ASM à disposition
Jérémy
Administrateur du site
Administrateur du site
Messages : 1975
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#1 Message par Jérémy » sam. 7 avr. 2018 09:07

Bonjour à tous,

La section ASM vous propose une caisse à outils contenant une liste de routines faites en langage ASM.

Ces routines sont commentées au maximum, afin que tout le monde puisse étudier la routine et comprendre le cheminement de l'auteur. Elles ont été testées par son auteur en condition réelle.

Si vous trouvez un BUG ou un problème dans une routine, merci de NE PAS POSTER A LA SUITE SVP. Il vous faut ouvrir un nouveau post dans la partie langage "ASM" en citant le lien de la routine. Ainsi vous pourrez débattre avec l'auteur ou d'autres experts sur la facon de le corriger.

Il y a de nombreuses façon de faire une routine, le but ici n'ai pas de faire la routine parfaite... mais juste de simplifier la vie des membres de fantasPIC pratiquant l'Assembleur. ceci afin de ne pas ré-inventer la roue à chaque fois.

  1. Addition
  2. Soustraction
  3. A venir....
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Menu de routines ASM à disposition
F6FCO
Avatar de l’utilisateur
Passioné
Passioné
Messages : 313
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#2 Message par F6FCO » mer. 11 avr. 2018 19:23

Bonjour les gens,
Pour mettre dans la caisse à outils voici des routines d'additions sur 16 et 32bits pour nos petits PIC 8bits.
Toutes les explications sont contenues dans les commentaires. J'ai fais le programme sur un 16F88 mais les routines sont utilisables sur n'importe quel autre Pic 8bits utilisant les mêmes instructions.

On peut visualiser le résultat des opérations (valeur1 et valeur2) dans la fenêtre File Register du menu View.

il suffit de renseigner les variables valeur1 et valeur2 et de faire un call vers la routine. Voici les routines :

Addition 16 bits:

Code : Tout sélectionner

;**********************************************************************                                                              
;    NOM:        Caisse à outils                                        
;    Date:       05/04/2018                                           
;    Auteur:     F6FCO  JC Buisson                                       
;     xtal:       4Mhz                                                 
;    
;    Routines d'addition 16 et 32bits
;                                                                        
;**********************************************************************
    CBLOCK 0x020  
        valeur1:2     ; déclarée en 16 bits
        valeur2:2    ; déclarée en 16bits
    ENDC                                                                                  
;********************************************************************
;                   Addition sur 16bits                                *
;     Il faut préalablement déclarer des variables sur 16 bits         *
;             valeur1:2 et valeur2:2                                    *
;                                                                    *
; Placer le poids faible de la première valeur dans valeur1            *
; et le poids fort dans valeur1+1                                    *
; Placer le poids faible de la valeur à additionner dans valeur2    *
; et le poids fort dans valeur2+1                                    *
;                                                                      *   
; Appeler la procédure addition16 et le résultat de                     *
; valeur1+valeur2 sur 16bits sera dans les 2 octets de valeur2           *
;********************************************************************
addition16
        movf    valeur1,W
        addwf    valeur2
        ; on additionne le carry dans le poids fort
        movf    STATUS,W
        andlw    0x1
        addwf    valeur2+1
        movf    valeur1+1,W
        addwf    valeur2+1
        return    



Addition 32 bits

Code : Tout sélectionner

;**********************************************************************
;
                                                                     
;    NOM:        Caisse à outils                                        
;    Date:       05/04/2018                                           
;    Auteur:     F6FCO  JC Buisson                                       
;     xtal:       4Mhz                                                 
;    
;    Routines d'addition et soustraction 16 et 32bits
;                                                                     
;**********************************************************************
    CBLOCK 0x020  
        valeur1:4     ; déclarée en 32bits
        valeur2:4    ; déclarée en 32bits
    ENDC                                                                                  
;********************************************************************
;                   Addition sur 32bits                                *
;     Il faut préalablement déclarer des variables sur 16 bits         *
;             valeur1:4 et valeur2:4                                    *
;                                                                    *
; Placer le poids faible de la première valeur dans valeur1            *
; et les poids forts dans valeur1+1, valeur1+2, valeur1+3.            *
; Placer le poids faible de la valeur à additionner dans valeur2    *
; et les poids forts dans valeur2+1, valeur2+2, valeur2+3            *
;                                                                      *   
; Appeler la procédure addition32 et le résultat de                     *
; valeur1+valeur2 sur 32bits sera dans les 4 octets de valeur2           *
;********************************************************************
addition32
        ; addition poids faibles
        movf    valeur1,W
        addwf    valeur2
        movf    STATUS,W     ; on additionne le carry 
        andlw    0x1
        addwf    valeur2+1
        ; addition poids+1
        movf    valeur1+1,W
        addwf    valeur2+1
        movf    STATUS,W     
        andlw    0x1
        addwf    valeur2+2
        ; addition poids+2
        movf    valeur1+2,W
        addwf    valeur2+2
        movf    STATUS,W      
        andlw    0x1
        addwf    valeur2+3
        ; addition poids+2
        movf    valeur1+3,W
        addwf    valeur2+3
        return    

JC, petit programmeur à 16heures

Menu de routines ASM à disposition
F6FCO
Avatar de l’utilisateur
Passioné
Passioné
Messages : 313
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#3 Message par F6FCO » mer. 11 avr. 2018 22:49

Bonjour les gens,
Pour mettre dans la caisse à outils voici des routines de soustractions sur 16 et 32bits pour nos petits PIC 8bits.
Toutes les explications sont contenues dans les commentaires. J'ai fais le programme sur un 16F88 mais les routines sont utilisables sur n'importe quel autre Pic 8bits utilisant les mêmes instructions.

On peut visualiser le résultat des opérations (valeur1 et valeur2) dans la fenêtre File Register du menu View.

il suffit de renseigner les variables valeur1 et valeur2 et de faire un call vers la routine. Voici les routines :

Soustraction 16 bits

Code : Tout sélectionner

;********************************************************************
;                   
Soustraction sur 16bits                            *
;     
Il faut préalablement déclarer des variables sur 16 bits         *
;             
valeur1:2 et valeur2:2                                    *
;                                                                    *
Placer le poids fort de la première valeur dans valeur1            *
et le poids faible dans valeur1+1                                    *
Placer le poids fort de la valeur à soustraire dans valeur2        *
et le poids faible dans valeur2+1                                   *   
Appeler la procédure soustraction16 et le résultat de             *
valeur1-valeur2 sur 16bits sera dans les 2 octets de valeur2           *
;********************************************************************   
soustraction16
    
; ------------------------------------- on traite valeur2
    movf    valeur2
,w        inversion du poids fort
    xorlw    0xff
    movwf    valeur2
    movf    valeur2
+1,w        complément à 2 du poids faible
    xorlw    0xff
    addlw    0x01
    movwf    valeur2
+
    movf    STATUS
,w        on isole le carry
    andlw    0x01
    addwf    valeur2
,f        et on l'ajoute au poids fort  
    ;----------------------------------- on additionne les deux poids faibles    
    movf    valeur1+1,w
    addwf    valeur2+1,f   
    movf    STATUS,w        ; on isole le carry
    andlw    0x01
    addwf    valeur2,f        ; et on l'
ajoute au poids fort    
    
;--------------------------------- on additionne maintenant les deux poids forts
    movf    valeur1
,w
    addwf    valeur2
,f
    
s'il y a carry il sera perdu car on reste en 16bits   
    return



Soustraction 32 bits

j'y travaille pour l'instant
JC, petit programmeur à 16heures

Menu de routines ASM à disposition
JJE
Débutant
Débutant
Messages : 90
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#4 Message par JJE » ven. 13 avr. 2018 19:34

Bonjour Jeremy, bonjour à tous,
Comment proposer des routines pour la boîte à outils. J'ai 3 routines d’arithmétique 8 bits signés qui pourraient intéresser dans un programme de test qui peut être mis en oeuvre dans le debuger de MPLAB.
Cordialement
JJE

Menu de routines ASM à disposition
Jérémy
Administrateur du site
Administrateur du site
Messages : 1975
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#5 Message par Jérémy » ven. 13 avr. 2018 20:52

Bonsoir JJE,

Pour proposer une routine il faut que tu post à la suite de celui ci : viewforum.php?f=16

il faut tester sa routine et bien la commentée .... merci à toi

PS : je supprimerai ces messages une fois fait
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Menu de routines ASM à disposition
JJE
Débutant
Débutant
Messages : 90
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#6 Message par JJE » ven. 13 avr. 2018 21:32

Bonsoir Jérémy,
en suivant ta procédure, impossible de joindre un fichier .asm par aucune des deux méthode indiquées. Message d'erreur :
Extension de fichier non prise en charge : Test8bitsSignés.asm

Ce fichier faisant 168 lignes, il ne me parait pas opportun de l'insérer dans post.
cordialemnt
JJE

Menu de routines ASM à disposition
F6FCO
Avatar de l’utilisateur
Passioné
Passioné
Messages : 313
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#7 Message par F6FCO » ven. 13 avr. 2018 22:13

Bonsoir JJE,
Il faut que tu fasses un copier/coller de ton programme et que tu l'insères entre les balises "code" que tu trouveras dans les icones au-dessus (la 5eme) de la fenêtre édition. Il apparaitra dans ton post à l'intérieur d'une fenêtre avec ascenseur, la longueur n'est pas un handicap.
JC, petit programmeur à 16heures

Menu de routines ASM à disposition
Jérémy
Administrateur du site
Administrateur du site
Messages : 1975
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#8 Message par Jérémy » ven. 13 avr. 2018 23:37

Re,

@JJE: Le fichier avec l'extension .asm n'est pas autorisé. Il te faut faire comme te le propsoe F6FCO , copier ton code .

F6FCO a écrit :Source du message la longueur n'est pas un handicap.

Jusqu'a 60000 caractéres tout de même, mais bon.... ca laisse de la marge. Mais ca m'est arrivé de dépasser une fois, dans ce cas il faut deux posts :wink:
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Menu de routines ASM à disposition
JJE
Débutant
Débutant
Messages : 90
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#9 Message par JJE » sam. 14 avr. 2018 17:07

Bonjour à tous,
une petite participation à la boîte à outils.
Le programme ci-dessous permet de tester trois routines d'arithmétique 8 bits signés (-128 à +127).
Pour sa mise en oeuvre dans MPLAB,
    créer un nouveau projet,
    ajouter ce fichier dans les sources
    choisir Debugger/Select Tool/Mplab SIM
    ouvrir une fenêtre Watch
    y mettre WREG, STATUS, op1, op2 et result
    lancer en pas à pas en suivant les commentaires
Cordialement


Code : Tout sélectionner

;**********************************************************************
;
   Test de routines arithmétique 8 bits signés                          *  
;                                                                     *
;**********************************************************************
;
                                                                     *
;
    NOM:      Test8bitsSignés                                        *
;
    Date:     13/04/2018                                             *
;
    Version:  1.0                                                    *
;
    Circuit:  sans objet                                             *
;
    Auteur:   JJE                                                     *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Fichier requis: aucun                                      *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Notes: 
;    Ce petit programme permet de tester les routines 8bits signés     *
;
    sous le simulateur de MPLAB
;                                                                     *
;**********************************************************************


;
    LIST          p=PIC12F675         ; Définition du processeur
;    #INCLUDE     <p12F675.inc>         ; Définitions des constantes

STATUS    EQU    .3
C        EQU    0
Z        EQU    2

;    __CONFIG   _CP_OFF & _WDT_OFF & _PWRTE_ON & _CPD_OFF & _BODEN_OFF & _MCLRE_OFF & _HS_OSC


;*********************************************************************
;
                   DECLARATIONS DE VARIABLES                        *
;*********************************************************************

    CBLOCK 0x020                   ; Début de la zone des variables  
    
; sauvegardes pour l'IT
    w_temp : 1                    ; W
    status_temp : 1                ; STATUS

; variables utiles aux sous-progtammes d'
aritmétique 8bits signé    
; ces 3 variables doivent être dans la même banque    
    op1    
: 1
    op2    
: 1
    result    
: 1

    ENDC                        
; Fin de la zone                        

;**********************************************************************
;
                      DEMARRAGE SUR RESET                            *
;**********************************************************************

    org     0x000                 ; Adresse de départ après reset
      goto    init                
; 
      
;**********************************************************************
;
                     ROUTINE INTERRUPTION                            *
;**********************************************************************

            ;sauvegarder registres    
            
;---------------------
    ORG     0x004                ; adresse d'interruption
    movwf    w_temp              ; 1 sauver registre W
    swapf    STATUS,w            ; 2 swap status avec résultat dans w
    movwf    status_temp            ; 3 sauver status swappé
    
restorereg
    swapf    status_temp,w        ; 2 swap ancien status, résultat dans w
    movwf   STATUS                ; 3 restaurer status
    swapf   w_temp,f            ; 4 Inversion L et H de l'
ancien W
                                   
; sans modifier Z
    swapf   w_temp
,w              ; 5 Réinversion de L et H dans W
                                
; W restauré sans modifier status
    retfie                      
; 7 return from interrupt
    

init
      movlw    .1
      movwf    op1
      movlw    
-.1
      movwf    op2
init_1      
      call    opposé_8bits_signé
      
; ici, vous devez constater que op2 vaut 1 et que Z et C sont nuls
      call    add_8bits_signé    
      btfsc    STATUS
,C
      goto    Erreur
      
; ici, vous devez constater que op1 et op2 n'ont pas changé
      ; et que result vaut .2 et que Z et C sont nuls
      call    sub_8bits_signé    
      ; ici, vous devez constater que op1 et op2 n'
ont pas changé
      
; et que result vaut .2 et que Z et C sont nuls
      btfsc    STATUS
,C
      goto    Erreur
      
; ici, modifiez op1 et op2 dans la fenêtre Watch à convenance
      goto    init_1
      
Erreur
    
; ici, en général, on ne sait pas trop quoi faire
    goto    
$
;**********************************************************************
;
                            Sous-programmes                           *
;**********************************************************************

sub_8bits_signé
; réalise la soustraction de deux entiers 8 bits signés
; entrée :
;
     op1 opérande 1 
;     op2 opérande 2
; sortie :
;
     op1 inchangé
;    op2 remplacé par son opposé
;     result contient op1 - op2
;     STATUS,C armé si débordement
;     STATUS,Z armé si résultat nul
; remarque :
;
    utilise un niveau de pile
;     la banque mémoire contenant op1, op2 et result 
;     doit être sélectionnée
;     chaîne sur add_8bits_signé pour gagner un octet de code
    call    opposé_8bits_signé
    btfsc    STATUS
,C
    return

;**********************************************************************

add_8bits_signé
; réalise l'addition de deux entiers 8 bits signés
; entrée :
;     op1 opérande 1 
;     op2 opérande 2
; sortie :
;     op1, op2 inchangés
;     result contient op1 + op2
;     STATUS,C armé si débordement
;     STATUS,Z armé si résultat nul
; remarque :
;     la banque mémoire contenant op1, op2 et result 
;     doit être sélectionnée
    movf    op1,w
    xorwf    op2,w        ; ou exlusif avec op2
    movwf    result        ; pour manipuler le bit 7 du résultat
    btfsc    result,7    ; on ne s'
intéresse qu'au bit de signe
    goto    add_8bits_signé_1
    ; ici, op1 et op2 sont de même signe
    movf    op1,w
    addwf    op2,w
    movwf    result
    bcf        STATUS, C    ; a priori pas de débordement
    movf    op1,w
    xorwf    result,w    ; ou exlusif avec result
    andlw    0x80
    btfss    STATUS, Z
    ; le bit de signe du résultat diffère de celui des opérandes
    ; il y a débordement
    bsf        STATUS, C    ; on indique le débordement
    movf    result, f    ; pour positionner STATUS,Z
    return
    
add_8bits_signé_1
    ; ici op1 et op2 sont de signe différent
    ; il ne peut pas y avoir de débordement,
    ; on les ajoute comme des insignés
    movf    op1,w
    addwf    op2,w    ; positionne STATUS,Z 
    movwf    result
    ; mais on marque le non débordement
    bcf        STATUS, C
    return

;**********************************************************************

opposé_8bits_signé
; calcule l'
opposé d'un entier 8 bits signés
; entrée :
    ; op2 l'
octet à traiter    
; sortie : 
;    op2 contient -op3
;     STATUS, C est armé si dépassement de capacité
;     se produit si la valeur de l'octet traité en entrée est -128 (0x80)
;     on se débarasse de ce cas gènant 
; remarque :
;     la banque mémoire contenant op2 doit être sélectionnée
    movlw    0x80
    subwf    op2, w
    btfsc    STATUS,Z
    ; C est armé en même temps que Z
    return
    bcf        STATUS,C    ; ici, on n'
aura pas de débordement
    comf    op2
, f
    incf    op2
, f
    return
    
    END             
; directive fin de programme

JJE

Menu de routines ASM à disposition
F6FCO
Avatar de l’utilisateur
Passioné
Passioné
Messages : 313
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#10 Message par F6FCO » sam. 14 avr. 2018 17:51

Merci JJE, même si je n'ai pas encore eu l'occasion de travailler avec des nombres signés je vais tester tes routines :-)

Voici le resultat de mon travail sur la soustraction en 32bits.

Code : Tout sélectionner


    
;********************************************************************
;
                   Soustraction sur 32bits                            *
;
     Il faut prélablement déclarer les variables sur 32bits            * 
;             valeur1:4    et valeur2:4                                *
;
                                                                    *
;
 Placer le poids fort de la première valeur dans valeur1            *
;
 et les poids plus faibles dans valeur1+1, valeur+2, valeur+3        *
;
 Placer le poids fort de la valeur à soustraire dans valeur2        *
;
 et les poids faibles dans valeur2+1, valeur2+2, valeur2+3            *   
; Appeler la procédure soustraction16 et le résultat de             *
;
 valeur1-valeur2 sur 32bits sera dans les 4 octets de valeur2         *
;********************************************************************
soustraction32
    
; ------------------------------------- inversion valeur2
    movf    valeur2
+3,w        ; inversions de tous les octets
    xorlw    0xff
    movwf    valeur2
+3
    movf    valeur2
+2,w         
    xorlw    0xff
    movwf    valeur2
+2
    movf    valeur2
+1,w        
    xorlw    0xff
    movwf    valeur2
+1
    movf    valeur2
,w        
    xorlw    0xff
    movwf    valeur2
    
;------------------------- complément à 2 et gestion des dépassements sur valeur2
    movlw    0x01            
    addwf    valeur2
+3,f
    movf    STATUS
,w        ; on isole le carry
    andlw    0x01
    addwf    valeur2
+2,f        ; et on l'ajoute au poids supérieur
    movf    STATUS,w
    andlw    0x01
    addwf    valeur2+1,f        ; et ainsi de suite...
    movf    STATUS,w
    andlw    0x01
    addwf    valeur2,f
    ; s'
il y a un carry de généré on l'ignore, on reste sur 32bits
    ; à partir de là le complément à 2 de valeur2 est fait
    ; on passe à l'
addition des deux valeurs
    
;----------------------------------- additions de valeur1 et valeur2    
    movf    valeur1
+3,w
    addwf    valeur2
+3,f
    movf    STATUS
,w        ; on isole le carry
    andlw    0x01
    addwf    valeur1
+2,f        ; et on l'ajoute au poids sup
    movf    valeur1+2,w
    addwf    valeur2+2,f
    movf    STATUS,w        ; on isole le carry
    andlw    0x01
    addwf    valeur1+1,f        ; et on l'
ajoute au poids sup
    movf    valeur1
+1,w
    addwf    valeur2
+1,f
    movf    STATUS
,w        ; on isole le carry
    andlw    0x01
    addwf    valeur1
,f        ; et on l'ajoute au poids fort
    movf    valeur1,w
    addwf    valeur2,f
    ; s'
il y a carry il sera perdu car on reste en 32bits
    return



Pour ceux que çà intéresse de comprendre la routine, j'ai utilisé la technique de l'addition avec le complément à 2
Voici les séquences de calcul de la routine sur un exemple précis (0x001f-0x00f1):
Désolé pour l'indentation, le forum ne gère pas les tabulations comme mon traitement de texte.

Code : Tout sélectionner


Soit la soustraction sur 32 bits    001f
-00f1=0xffffff2e
Le résultat sera dans valeur2

    00000000 00000000 00000001 11111111            0x001f    valeur1        
-    00000000 00000000 11111111 00000001            0x00f1    valeur2    


inversion des octets de valeur2          
      11111111 11111111 00000000 11111110            0xff0e    valeur2                                    


complément à deux de valeur2      
    11111111 11111111 00000000 11111111              0xff0f    valeur2                                
    

addition de valeur1
+3 et valeur2+3
      00000000 00000000 00000001 11111111               
+    11111111 11111111 00000000 11111111                   
    ___________________________________
                                                c 11111110               0xe  
+carry dans valeur2+3                 

addition du carry dans valeur1
+2  (carry=1)
      00000000 00000000 00000010 11111111                0x2f          valeur1                    
+    00000000 00000000 00000000 11111111                   
    ___________________________________
                                                c 11111110                         
                                     
addition de valeur1
+2 et valeur2+2    
      00000000 00000000 00000010 11111111              
+    00000000 00000000 00000000 11111111              
    ___________________________________
                                 c 00000010 11111110              0x2e  
+ carry    dans valeur2+2 et valeur2+3                    
                     
addition du carry dans valeur1
+1  (carry=1)    
      00000000 00000001 00000010 11111111              0x12f          valeur1                                
+    11111111 11111111 00000000 11111111              0xf0f            valeur2
    ___________________________________
                                 c 00000010 11111110                      
                      
addition de valeur1
+1 et valeur2+1
      00000000 00000001 00000001 11111111                 0x01f          valeur1
+    11111111 11111111 00000000 11111111                 0xf0f            valeur2    
    ___________________________________
                     11111111 00000010 11111110                0xf2e  dans valeur2
+1, valeur2+2 et valeur2+3
             
addition du carry dans valeur1  
(carry=0)
      00000000 00000001 00000010 11111111                  0x12f          valeur1 reste inchangée car c=0                                
+    11111111 11111111 00000000 11111111              
    ___________________________________
                   11111111 00000010 11111110                  
             
addition de valeur1 et valeur2
      00000000 00000001 00000010 11111111                0x012f          valeur1
+    11111111 11111111 00000000 11111111                0xff0f        valeur2    
    ___________________________________
      11111111 11111111 00000010 11111110                0xff2e        dans valeur2
JC, petit programmeur à 16heures


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité