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 !
Proposer un Tutoriel ou une routine
FantasPic
Avatar de l’utilisateur
Administrateur du site
Administrateur du site
Messages : 44
Enregistré en : juillet 2015
Contact :

#1 Message par FantasPic » jeu. 17 sept. 2015 10:28

Bonjour à tous,

:!!: NE PAS RÉPONDRE A CE POST SI VOUS NE SOUHAITEZ PAS PROPOSER UN TUTORIEL. :!!:

Vous voulez proposer un Tutoriel afin de partager votre savoir, votre expérience ou même vos recherches !!
Vous avez créer une routine, une macro ou un soft aidant à la programmation, partagez-le !.

Alors n’hésitez pas et apportez votre pierre à l'édifice ! :D

Les Tutoriels présentés ici, devront répondre à certains critères et être approuvés par un administrateur avant publication. Ceci dans le seul but de vérifier leur contenu. L'objectif principal du tutoriel sera d’être pédagogique et instructif.
Ils devront porter sur une fonction/tâche très précise effectuée par le Micro-contrôleur, ou sur l'utilisation de modules spécifiques ( I²C - boucle - conversion - LCD - Wifi ....)

Quelques conseils :
  • Gardez en tête de toujours vous mettre à la place de la personne qui lira votre Tuto.
  • Votre code devra être extrêmement commenté, et chaque lignes expliquées aussi clairement que possible.
  • Les commentaires et explications seront en français.
  • N’oubliez pas de fournir les documents nécessaires en lien ( Data-Sheet , mode d'emploi etc ....)
  • La routine ou le tuto devront être testés en condition réelle .
  • Merci de mettre en en-tête, le titre que vous voulez pour votre Tuto.

Si votre tuto remplit ces critères, vous pouvez alors le proposer à la communauté en suivant ces consignes:
  1. Mettez votre Tutoriel à la suite de ce post en cliquant sur le Bouton "répondre".
  2. Écrivez votre texte, placez vos photos et/ou vos vidéos, faite la mise en forme avec soin ( Utilisez la fonction "Aperçu").
  3. Cette réponse sera ensuite validée avant d'être publiée pas un membre de l'équipe Fantas-Pic ( détachement de votre réponse pour créer un post à vous).

Conseils de mise en forme :
  • La mise en forme de votre Tuto est importante et doit être soignée pour être compréhensible et donner envie d'être lue.
  • Utilisez les outils mis à votre disposition pour cela (texte flottant, alignement , surlignage etc ..)
  • Faites régulièrement un aperçu de votre texte et sauvegardez le en brouillon de temps en temps.
  • Préférez les photos en format miniatures ou vignettes , cela prend moins de place à l'écran et reste "cliquable" pour zoomer.

PS : D'autre part, si vous avez des idées ou des suggestions concernant la forme de cette catégorie, n'hésitez pas à en discuter avec l’Équipe Fantas-Pic.

Proposer un Tutoriel ou une routine
JJE
Amateur
Amateur
Messages : 122
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#2 Message par JJE » mer. 20 juin 2018 18:02

Je suis en mesure de proposer un tutoriel qui reprend et complète mon post
Il comporte un fichier .inc (400 lignes) un programme de test en programmation standard (600 lignes) et sa version utilisant la directive while (11 lignes)
il illustre l'usage de macros et donne un exemple de mise en oeuvre de la directive while dont j'ai parlé ici
Cependant, les posts précédents n'ayant pas eu d'écho (en fait, un seul que je n'ai pas compris), je me demande si ça vaut le coup.

Cordialement
JJE

Proposer un Tutoriel ou une routine
Jérémy
Administrateur du site
Administrateur du site
Messages : 2042
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#3 Message par Jérémy » mer. 20 juin 2018 18:23

Bonjour JJE,

Pas de soucis, il te suffit de le poster ici .

JE m'occuperai de le mettre au bon endroit !

Cependant, les posts précédents n'ayant pas eu d'écho (en fait, un seul que je n'ai pas compris), je me demande si ça vaut le coup.

Je ne comprends pas ce que tu veux dire par la ?
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Proposer un Tutoriel ou une routine
JJE
Amateur
Amateur
Messages : 122
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#4 Message par JJE » jeu. 21 juin 2018 14:51

Salut Jérémy,


Je ne comprends pas ce que tu veux dire par la ?


Rien de particulier, c'est simplement le seul post du sous-forum ASM qui a 0 réponse, je peux me demander si le sujet intéresse et s'il vaut le coup de passer un moment à rédiger un nouveau post.
Enfin, je vais m'y atteler, rien de tel pour mettre les idées en place.

Cordialement.
JJE

Proposer un Tutoriel ou une routine
Jérémy
Administrateur du site
Administrateur du site
Messages : 2042
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#5 Message par Jérémy » jeu. 21 juin 2018 16:21

JE comprends JJE . Il a eu 0 réponse mais 30 vues !

Peut être que ton post n'attirait pas de réponse particulière. JE ne pratique pas L"ASM, mais ça à l'air assez bien expliqué et je te félicite.

Il ne faut pas lâcher. Je ne suis pas en mesure pas de dire ce qui ne vas pas dans ton post. Était-ce un tuto ? ou juste le partage d'une expérience ?
J'ai fais beaucoup de chose sans réponse moi aussi.
Un forum apprend parfois des règles de vie, et se montre bien cruel. Il ne faut pas donner pour attendre en retour mais pour le plaisir de donner.

Je pense que FantasPIC risque de s'éteindre car de nombreuses personnes se servent sans rien donner, et à la longue sa lasse les personnes ( moi le premier).
FantasPIC compte plus de 500 membres et a peine une vingtaine d'habitués , les gens viennent, lisent, prenne ou apprenne et s'en vont . C'est ainsi dorénavant .... :cry:
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Proposer un Tutoriel ou une routine
JJE
Amateur
Amateur
Messages : 122
Âge : 78
Enregistré en : novembre 2017
Localisation : Picardie

#6 Message par JJE » jeu. 21 juin 2018 17:46

Bonjour à chacun,

Je reprend mon post du sujet "Caisse à outils" par ce post qui corrige quelques défauts et complète.
Je rappelle que sur une idée de ducran lapoigne j'avais proposé quelques macros simulant les instructions du type (en pseudo langage évolué :

Code : Tout sélectionner


    if a
<b then goto ici


Les macros proposées couvrent les 6 tests (< ; <= ; == ; != ; >= ; >)
pour a et b variables 8 bits non signées ou signées
pour a variable signée ou non signée et b constante (signée ou non)
Une dernière macro (Si) encapsule toutes les autres pour n'avoir pas à mémoriser tous les noms


Ci dessous, trois fichiers :
MacrosTest.inc contient l'ensemble des macros
TestMacroTest1.asm un programme de test très "bourrin" qui se contente d'invoquer chacune des macros dans chacune des situations possibles
TestMacroTest2.asm un autre programme de test qui, en utilisant la directive while présente un code source beaucoup plus compact (mais pas forcément plus lisible bien sûr) mais qui génère un code .hex aussi long que le précédent

Quelques commentaires suivent chacun des fichiers

MacrosTest.inc

Code : Tout sélectionner

;**********************************************************************
;
            Macros de test sur Octet avec branchement                  *  
;                                                                     *
;**********************************************************************
;
                                                                     *
;
    NOM:      MacrosTest                                              *
;
    Date:     21/01/2018                                             *
;
    Version:  1.0                                                    *
;
    Circuit:  sans objet                                             *
;
    Auteur:   JJE                                                     *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Notes:                                                           *
;
        L'usage de ces macros remplace, dans bien des cas               *
;        l'
utilisation des instructions btfsc ou btfsc                  *
;
        Les paramètres d'appel sont supposés 8 bits 
;        non signés pour les macros If*
;        signés pour les lacros If8S*
;        Ils doivent être dans la banque active
;                                                                     *
;**********************************************************************
    ifndef    _MacrosTest
        #DEFINE _MacrosTest
        
    ifndef    STATUS
        #DEFINE STATUS    3
    endif
    ifndef    C
        #DEFINE C 0
    endif
    ifndef    Z
        #DEFINE Z 2
    endif
    
;**********************************************************************
;**********************************************************************
;                                NON SIGNÉS
;**********************************************************************
;**********************************************************************
    
;**********************************************************************
;    test sur deux variables
;**********************************************************************
    
; if(A<AA) then goto Là    ; A et AA 8 bits 
IfAStrictInfBgoto macro A,AA,Là
    movf     AA,W
    subwf    A,w
    btfsc    STATUS,C
    goto      Là
    endm

; if(A<=AA) then goto Là    ; A et AA 8 bits 
IfAInfOuEgalBgoto macro A,AA,Là
    movf     A,W
    subwf    AA,w
    btfsc    STATUS,C
    goto Là
    endm

; if(A=AA) then goto Là    ; A et AA 8 bits 
IfAEgalBgoto macro A, AA, Là
    movf     AA,W
    xorwf    A,w
    btfsc    STATUS,Z
    goto     Là
    endm

; if(A!=AA) then goto Là    ; A et AA 8 bits 
IfANonEgalBgoto macro A, AA, Là
    movf     AA,W
    xorwf    A,w
    btfss    STATUS,Z
    goto     Là
    endm    
    
; if(A>AA) then goto Là    ; A et AA 8 bits 
IfAStrictSupBgoto macro A,AA,Là
    movf     A,W
    subwf    AA,w
    btfss    STATUS,C
    goto     Là
    endm

; if(A>=AA) then goto Là    ; A et AA 8 bits 
IfASupOuEgalBgoto macro A,AA,Là
    movf     AA,W
    subwf    A,w
    btfsc    STATUS,C
    goto Là
    endm

;**********************************************************************
;    test sur une variable et un littéral (deuxième paramètre)
;**********************************************************************

; if(A<0Xxx) then goto Là    ; A 8 bits 
IfAStrictInfLitBgoto macro A,AA,Là
    movlw    AA
    subwf     A,w
    btfsc    STATUS,C
    goto Là
    endm

; if(A<=0Xxx) then goto Là    ; A 8 bits 
IfAInfOuEgalLitBgoto macro A,AA,Là
    movf     A,W
    sublw    AA
    btfsc    STATUS,C
    goto Là
    endm
    
; if(A=0Xxx) then goto Là    ; A 8 bits 
IfAEgalLitBgoto macro A,AA,Là
    movlw     AA
    subwf    A,w
    btfsc    STATUS,Z
    goto Là
    endm
    
; if(A!=0Xxx) then goto Là    ; A 8 bits 
IfANonEgalLitBgoto macro A, AA, Là
    movlw     AA
    subwf    A,w
    btfss    STATUS,Z
    goto     Là
    endm    

; if(A>=0Xxx) then goto Là    ; A 8 bits 
IfASupOuEgalLitBgoto macro A,AA,Là
    movlw     AA
    subwf    A,w
    btfss    STATUS,C
    goto     ici
    btfss    STATUS,Z
    goto Là
    local    ici
ici
    endm

; if(A>0Xxx) then goto Là    ; A 8 bits 
IfAStrictSupLitBgoto macro A,AA,Là
    movlw    AA
    subwf    A,w
    btfsc    STATUS,C
    goto Là
    endm
    
;**********************************************************************
;**********************************************************************
;                                 SIGNÉS
;**********************************************************************
;**********************************************************************

; Comparer A et AA signé
; si même signe, dans l'
ordre de leur représentation
; si de signes différents
;    A<0 et AA>=0 résultat A<AA
;    A>=0 et AA<0 résultat A>AA

;**********************************************************************
;
    test sur deux variables
;**********************************************************************

;
 if le signe de A diffère de celui de AA goto Là
IfASignDifBgoto macro A
, AA, Là
    movlw    0x80
    andwf    A
,W
    xorwf    AA
,W
    andlw    0x80
    
; ici, WREG <>(donc WREG,7=0) si A et AA sont de signe différent
    btfss    STATUS
,Z
    goto     Là
    endm

; if(A<AA) then goto Là    ; A et AA 8 bits signés 
If8SAStrictInfBgoto macro A
, AA, Là
    IfASignDifBgoto A
, AA, ici    ; $+7
    IfAStrictInfBgoto A
, AA, Là
    btfsc    A
,7
    goto Là
    local ici
ici    
    endm

; if(A<=AA) then goto Là    ; A et AA 8 bits signés 
If8SAInfOuEgalBgoto macro A
, AA, Là
    IfASignDifBgoto A
, AA, ici    ; $+9
    IfAInfOuEgalBgoto A
, AA, Là
    btfsc    A
,7
    goto Là
    local ici
ici    
    endm
    
; if(A=AA) then goto Là    ; A et AA 8 bits signés 
If8SAEgalBgoto macro A
, AA, Là
    IfAEgalBgoto A
, AA, Là
    endm

; if(A!=AA) then goto Là    ; A et AA 8 bits signés 
If8SANonEgalBgoto macro A
, AA, Là
    IfANonEgalBgoto A
, AA, Là
    endm
    
; if(A>AA) then goto Là    ; A et AA 8 bits signés 
If8SAStrictSupBgoto macro A
,AA,
    IfASignDifBgoto A
, AA, ici    ; $+8
    IfAStrictSupBgoto A
, AA, Là
    goto    
$+3
    btfss    A
,7
    goto Là
    local ici
ici    
    endm

; if(A>=AA) then goto Là    ; A et AA 8 bits signés 
If8SASupOuEgalBgoto macro A
,AA,
    IfASignDifBgoto A
, AA, ici    ; $+6
    IfASupOuEgalBgoto A
,AA,
    goto    ici    
;    $+3
    btfss    A
,7
    goto Là
    local ici
ici    
    endm
;**********************************************************************
;
    test sur une variable et un littéral (deuxième paramètre)
;**********************************************************************

;
 if le signe de A diffère de celui du littéral goto Là
IfASignDifLitBgoto macro A
, AA, Là
    movlw    0x80
    andwf    A
,W
    xorlw    AA
    xorlw    0x80
    
; ici, WREG,7 est armé (donc WREG <>0) si A et AA sont de signe différent
    btfsc    STATUS
,Z
    goto     Là
    endm

; if(A<0Xxx) then goto Là    ; A 8 bits signés 
If8SAStrictInfLitBgoto macro A
,AA,
    IfASignDifLitBgoto A
, AA, ici    ; $+7
    IfAStrictInfLitBgoto A
, AA, Là
    btfsc    A
,7
    goto Là
    local ici
ici    
    endm

; if(A<=0Xxx) then goto Là    ; A 8 bits signés 
If8SAInfOuEgalLitBgoto macro A
,AA,
    IfASignDifLitBgoto A
, AA, ici    ; $+9
    IfAInfOuEgalLitBgoto A
, AA, Là
    btfsc    A
,7
    goto Là
    local ici
ici    
    endm
    
; if(A=0Xxx) then goto Là    ; A 8 bits signés 
If8SAEgalLitBgoto macro A
,AA,
    IfASignDifLitBgoto A
, AA, ici    ; $+5
    IfAEgalLitBgoto A
,AA,
    btfss    A
,7
    goto Là
    local ici
ici    
    endm
    
; if(A!=0Xxx) then goto Là    ; A 8 bits signés 
If8SANonEgalLitBgoto macro A
, AA, Là
    IfANonEgalLitBgoto A
, AA, Là
    endm    

; if(A>=0Xxx) then goto Là    ; A 8 bits signés 
If8SASupOuEgalLitBgoto macro A
,AA,
    IfASignDifLitBgoto A
, AA, ici    ; $+5
    IfAStrictSupLitBgoto A
, AA, Là
    btfss    A
,7
    goto Là
    local ici
ici    
    endm

; if(A>0Xxx) then goto Là    ; A 8 bits signés 
If8SAStrictSupLitBgoto macro A
,AA,
    IfASignDifLitBgoto A
, AA, ici    ; $+7
    IfASupOuEgalLitBgoto A
,AA,
    btfss    A
,7
    goto Là
    local ici
ici    
    endm    
    
;**********************************************************************
;
    Macro globale
;**********************************************************************


jump        EQU    .0
Signé        EQU    0x80

StrictInf    EQU .0
Inf         EQU    .1
Egal         EQU    .2
NonEgal     EQU    .3
Sup         EQU    .4
StrictSup    EQU    .5
StrictInfLit    EQU .6
InfLit         EQU    .7
EgalLit     EQU    .8
NonEgalLit     EQU    .9
SupLit         EQU    .10
StrictSupLit    EQU    .11

; s'invoque par exemple par
; Si V1, StrictSup, V2, jump, Là
; ou
; Si V1, StrictSup+Signé, V2, jump, Là
; équivalent du Basic
; if V1>V2 then goto Là

Si macro    A, Test, AA, VV, Là
    if (Test & 0x7F) > StrictSupLit
        error "opérateur illegal"
    else
    if (Test & 0x80) == 0
        if    Test==StrictInf
            IfAStrictInfBgoto A, AA, Là
        endif
        if    Test==Inf
            IfAInfOuEgalBgoto A, AA, Là
        endif
        if    Test==Egal
            IfAEgalBgoto A, AA, Là
        endif
        if    Test==NonEgal
            IfANonEgalBgoto A, AA, Là
        endif
        if    Test==Sup
            IfASupOuEgalBgoto A, AA, Là
        endif
        if    Test==StrictSup
            IfAStrictSupBgoto A, AA, Là
        endif
        if    Test==StrictInfLit
            IfAStrictInfLitBgoto A, AA, Là
        endif
        if    Test==InfLit
            IfAInfOuEgalLitBgoto A, AA, Là
        endif
        if    Test==EgalLit
            IfAEgalLitBgoto A, AA, Là
        endif
        if    Test==NonEgalLit
            IfANonEgalLitBgoto A, AA, Là
        endif
        if    Test==SupLit
            IfASupOuEgalLitBgoto A, AA, Là
        endif
        if    Test==StrictSupLit
            IfAStrictSupLitBgoto A, AA, Là
        endif
    else
        if    (Test & 0x7F)==StrictInf
            If8SAStrictInfBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==Inf
            If8SAInfOuEgalBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==Egal
            If8SAEgalBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==NonEgal
            If8SANonEgalBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==Sup
            If8SASupOuEgalBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==StrictSup
            If8SAStrictSupBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==StrictInfLit
            If8SAStrictInfLitBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==InfLit
            If8SAInfOuEgalLitBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==EgalLit
            If8SAEgalLitBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==NonEgalLit
            If8SANonEgalLitBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==SupLit
            If8SASupOuEgalLitBgoto A, AA, Là
        endif
        if    (Test & 0x7F)==StrictSupLit
            If8SAStrictSupLitBgoto A, AA, Là
        endif
    endif
    endif
    
    endm
    
    endif


Le programme est encadré par

Code : Tout sélectionner


    ifndef    _MacrosTest
        
#DEFINE _MacrosTest
        .../...
    endif        

procédé classique pour éviter des erreurs si ce fichier était inclus deux fois

Toutes ces macros se comprennent sans difficulté, la différence entre les deux cas, b est une variable et b est un littéral, est visible au movf A, w dans le premier cas et movlw b dans le deuxième qu'on ne peut pas contourner.
On peut cependant noter dans la macro

Code : Tout sélectionner


IfASupOuEgalLitBgoto macro A
,AA,
    movlw     AA
    subwf    A
,w
    btfss    STATUS
,C
    goto     ici
    btfss    STATUS
,Z
    goto Là
    local    ici
ici
    endm


l'usage de la directive local qui permet d'éviter des doubles définitions au cas où cette macro est invoquée deux fois.

Seule la dernière mérite peut-être quelques commentaires.

On commence par définir quelques constantes

Code : Tout sélectionner


jump        EQU    .0
Signé        EQU    0x80

StrictInf    EQU .0
Inf         EQU    .1
Egal         EQU    .2
NonEgal     EQU    .3
Sup         EQU    .4
StrictSup    EQU    .5
StrictInfLit    EQU .6
InfLit         EQU    .7
EgalLit     EQU    .8
NonEgalLit     EQU    .9
SupLit         EQU    .10
StrictSupLit    EQU    .11


jump n'est qu'un marqueur censé augmenter la lisibilité d'une invocation de la macro Si,
Signé signal des tests signés
les 12 suivant précisent à la macro Si celle des macros précédentes qu'elle doit invoquer.
SI pas de suffixe à la constante c'est l'une des If * si suffixe Lit, c'est l'une des If *Lit
En ajoutant Signé, Si invoquera respectivement If8S * ou If8s * Lit
La macro débute par

Code : Tout sélectionner


    if 
(Test & 0x7F) > StrictSupLit
        error 
"opérateur illegal"
    else


qui permet d'assurer, à l'assemblage, que la valeur passée en deuxième paramètre est correcte.

La suite du code n'est que le code utile à l'assembleur pour sélectionner la macro à invoquer. Le premier test

Code : Tout sélectionner


    if 
(Test & 0x80) == 0


illustre le rôle de la constante Signé pour séparer les tests sur variable signées ou non

TestMacroTest1.asm

Code : Tout sélectionner

;**********************************************************************
;
                       Test des Macros de test                          *
;
                            Version sans while 
;                                                                     *
;**********************************************************************
;
                                                                     *
;
    NOM:      TestMacrosTest1                                         *
;
    Date:     20/06/2018                                             *
;
    Version:  1.0                                                    *
;
    Circuit:  sans objet                                             *
;
    Auteur:   JJE                                                     *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Fichier requis: MacrosTest.inc                                   *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Notes: 
;    Ce petit programme permet de tester les macros du fichier inclus  *
;
    sous le simulateur de MPLAB
;                                                                     *
;**********************************************************************
    

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

    CBLOCK 0x020                   ; Début de la zone des variables  
    
; variables utiles 

    A    
: 1
    AA    
: 1
    
    
    ENDC                        
; Fin de la zone
     
    

;*********************************************************************
;
                             MACRO                                  *
;*********************************************************************
    
    include    
"..\MacrosTest.inc"

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

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

init
    movlw    .100
    movwf    A
    
;**********************************************************************
;
                         tests non signés
;**********************************************************************
;
 on appelle chacune des macros If* avec 
;    le premier paramètre égal à .100
;     le deuxième successivement égal à 
;        .110
;        .100
;        .90
;     si le test est satisfait, on enchaîne sur le suivant
;     si le test n'est pas satisfait, on passe par le SSP Erreur
;**********************************************************************
    
Test1
    movlw    .110
    movwf    AA
    IfAStrictInfBgoto A, AA, Test1_1
    call    Erreur
Test1_1    
    movlw    .100
    movwf    AA
    IfAStrictInfBgoto A, AA, Test1_2
    call    Erreur
Test1_2    
    movlw    .90
    movwf    AA
    IfAStrictInfBgoto A, AA, Test2
    call    Erreur
    
Test2
    movlw    .110
    movwf    AA
    IfAInfOuEgalBgoto A, AA, Test2_1
    call    Erreur
Test2_1    
    movlw    .100
    movwf     AA
    IfAInfOuEgalBgoto A, AA, Test2_2
    call    Erreur
Test2_2
    movlw    .90
    movwf    AA
    IfAInfOuEgalBgoto A, AA, Test3
    call    Erreur
    
Test3
    movlw    .110
    movwf    AA
    IfAEgalBgoto A, AA, Test3_1
    call    Erreur
Test3_1
    movlw    .100
    movwf    AA
    IfAEgalBgoto A, AA, Test3_2
    call    Erreur
Test3_2
    movlw    .90
    movwf    AA
    IfAEgalBgoto A, AA, Test4
    call    Erreur
    
Test4
    movlw    .110
    movwf    AA
    IfANonEgalBgoto A, AA, Test4_1
    call    Erreur
Test4_1
    movlw    .100
    movwf    AA
    IfANonEgalBgoto A, AA, Test4_2
    call    Erreur
Test4_2
    movlw    .90
    movwf    AA
    IfANonEgalBgoto A, AA, Test5
    call    Erreur
    
Test5
    movlw    .110
    movwf    AA
    IfASupOuEgalBgoto A, AA, Test5_1
    call    Erreur
Test5_1
    movlw    .100
    movwf    AA
    IfASupOuEgalBgoto A, AA, Test5_2
    call    Erreur
Test5_2
    movlw    .90
    movwf    AA
    IfASupOuEgalBgoto A, AA, Test6
    call    Erreur
    
Test6
    movlw    .110
    movwf    AA
    IfAStrictSupBgoto A, AA, Test6_1
    call    Erreur
Test6_1
    movlw    .100
    movwf    AA
    IfAStrictSupBgoto A, AA, Test6_2
    call    Erreur
Test6_2
    movlw    .90
    movwf    AA
    IfAStrictSupBgoto A, AA, Test8
    call    Erreur
    
;**********************************************************************
; le deux premier paramètre est une variable
; le deuxième un littéral
;**********************************************************************

Test8    
    IfAStrictInfLitBgoto A, .110, Test8_1
    call    Erreur
Test8_1    
    IfAStrictInfLitBgoto A, .100, Test8_2
    call    Erreur
Test8_2    
    IfAStrictInfLitBgoto A, .90, Test9
    call    Erreur
    
Test9
    IfAInfOuEgalLitBgoto A, .110, Test9_1
    call    Erreur
Test9_1    
    IfAInfOuEgalLitBgoto A, .100, Test9_2
    call    Erreur
Test9_2
    IfAInfOuEgalLitBgoto A, .90, Test10
    call    Erreur
    
Test10
    IfAEgalLitBgoto A, .110, Test10_1
    call    Erreur
Test10_1
    IfAEgalLitBgoto A, .100, Test10_2
    call    Erreur
Test10_2
    IfAEgalLitBgoto A, .90, Test11
    call    Erreur
    
Test11
    IfANonEgalLitBgoto A, .110, Test11_1
    call    Erreur
Test11_1
    IfANonEgalLitBgoto A, .100, Test11_2
    call    Erreur
Test11_2
    IfANonEgalLitBgoto A, .90, Test12
    call    Erreur
    
Test12
    IfAStrictSupLitBgoto A, .110, Test12_1
    call    Erreur
Test12_1
    IfAStrictSupLitBgoto A, .100, Test12_2
    call    Erreur
Test12_2
    IfAStrictSupLitBgoto A, .90, Test13
    call    Erreur
    
Test13
    IfASupOuEgalLitBgoto A, .110, Test13_1
    call    Erreur
Test13_1
    IfASupOuEgalLitBgoto A, .100, Test13_2
    call    Erreur
Test13_2
    IfAStrictSupLitBgoto A, -.90, TestsSignés
    call    Erreur

;**********************************************************************
;                                 tests signés
;**********************************************************************
; on appelle chacune des macros If8S* avec 
;    le premier paramètre égal à .100
;     le deuxième successivement égal à 
;        .110
;        .100
;        .90
;        -.90
;        -.100
;        -.110
;     si le test est satisfait, on enchaîne sur le suivant
;     si le test n'
est pas satisfait, on passe par le SSP Erreur
;
;
    puis le premier paramètre égal à -.100
;     le deuxième successivement égal à 
;        .110
;        .100
;        .90
;        -.110
;        -.100
;        -.90
;     si le test est satisfait, on enchaîne sur le suivant
;     si le test n'est pas satisfait, on passe par le SSP Erreur
;
;**********************************************************************

;**********************************************************************
; les deux premiers paramètres sont des variables
;**********************************************************************

TestsSignés
    movlw    .100
    movwf    A
    
Test14
    movlw    .110
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test14_1
    call    Erreur
Test14_1    
    movlw    .100
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test14_2
    call    Erreur
Test14_2    
    movlw    .90
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test14_3
    call    Erreur
Test14_3
    movlw    -.110
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test14_4
    call    Erreur
Test14_4    
    movlw    -.100
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test14_5
    call    Erreur
Test14_5    
    movlw    -.90
    movwf    AA
    If8SAStrictInfBgoto A, AA, Test15
    call    Erreur
    
Test15    
    movlw    .110
    movwf    AA
    If8SAInfOuEgalBgoto A, AA, Test15_1
    call    Erreur
Test15_1    
    movlw    .100
    movwf     AA
    If8SAInfOuEgalBgoto A, AA, Test15_2
    call    Erreur
Test15_2
    movlw    .90
    movwf    AA
    If8SAInfOuEgalBgoto A, AA, Test15_3
    call    Erreur
Test15_3
    movlw    -.110
    movwf    AA
    If8SAInfOuEgalBgoto A, AA, Test15_4
    call    Erreur
Test15_4    
    movlw    -.100
    movwf     AA
    If8SAInfOuEgalBgoto A, AA, Test15_5
    call    Erreur
Test15_5 
    movlw    -.90
    movwf    AA
    If8SAInfOuEgalBgoto A, AA, Test16
    call    Erreur

Test16    
    movlw    .110
    movwf    AA
    If8SAEgalBgoto A, AA, Test16_1
    call    Erreur
Test16_1
    movlw    .100
    movwf    AA
    If8SAEgalBgoto A, AA, Test16_2
    call    Erreur
Test16_2
    movlw    .90
    movwf    AA
    If8SAEgalBgoto A, AA, Test16_3
    call    Erreur
Test16_3
    movlw    -.110
    movwf    AA
    If8SAEgalBgoto A, AA, Test16_4
    call    Erreur
Test16_4
    movlw    -.100
    movwf    AA
    If8SAEgalBgoto A, AA, Test16_5
    call    Erreur
Test16_5
    movlw    -.90
    movwf    AA
    If8SAEgalBgoto A, AA, Test17
    call    Erreur

Test17    
    movlw    .110
    movwf    AA
    If8SANonEgalBgoto A, AA, Test17_1
    call    Erreur
Test17_1
    movlw    .100
    movwf    AA
    If8SANonEgalBgoto A, AA, Test17_2
    call    Erreur
Test17_2
    movlw    .90
    movwf    AA
    If8SANonEgalBgoto A, AA, Test17_3
    call    Erreur
Test17_3    
    movlw    -.110
    movwf    AA
    If8SANonEgalBgoto A, AA, Test17_4
    call    Erreur
Test17_4
    movlw    -.100
    movwf    AA
    If8SANonEgalBgoto A, AA, Test17_5
    call    Erreur
Test17_5
    movlw    -.90
    movwf    AA
    If8SANonEgalBgoto A, AA, Test18
    call    Erreur
    
Test18
    movlw    .110
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test18_1
    call    Erreur
Test18_1
    movlw    .100
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test18_2
    call    Erreur
Test18_2
    movlw    .90
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test18_3
    call    Erreur
Test18_3
    movlw    -.110
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test18_4
    call    Erreur
Test18_4
    movlw    -.100
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test18_5
    call    Erreur
Test18_5
    movlw    -.90
    movwf    AA
    If8SAStrictSupBgoto A, AA, Test19
    call    Erreur
    
Test19
    movlw    .110
    movwf    AA
    If8SASupOuEgalBgoto A, AA, Test19_1
    call    Erreur
Test19_1
    movlw    .100
    movwf    AA
    If8SASupOuEgalBgoto A, AA, Test19_2
    call    Erreur
Test19_2
    movlw    .90
    movwf    AA
    If8SASupOuEgalBgoto A, AA, Test19_3
    call    Erreur
Test19_3    
    movlw    -.110
    movwf    AA
    If8SASupOuEgalBgoto A, AA, Test19_4
    call    Erreur
Test19_4
    movlw    -.100
    movwf    AA
    If8SASupOuEgalBgoto A, AA, Test19_5
    call    Erreur
Test19_5
    movlw    -.90
    movwf    AA
    IfAStrictSupBgoto A, AA, Test19_6
    call    Erreur
Test19_6
    
; reprise de ces tests avec A = -.100
    btfsc    A, 7
    goto    Test20
    movlw    -.100
    movwf    A
    goto    Test14
    
        
;**********************************************************************
; le premier paramètre est une variable
; le deuxième un littéral
;**********************************************************************

    movlw    .100
    movwf    A
    
Test20
    If8SAStrictInfLitBgoto A, .110, Test20_1
    call    Erreur
Test20_1    
    If8SAStrictInfLitBgoto A, .100, Test20_2
    call    Erreur
Test20_2    
    If8SAStrictInfLitBgoto A, .90, Test20_3
    call    Erreur
Test20_3
    If8SAStrictInfLitBgoto A, -.110, Test20_4
    call    Erreur
Test20_4    
    If8SAStrictInfLitBgoto A, -.100, Test20_5
    call    Erreur
Test20_5    
    If8SAStrictInfLitBgoto A, -.90, Test21
    call    Erreur
    
Test21    
    If8SAInfOuEgalLitBgoto A, .110, Test21_1
    call    Erreur
Test21_1    
    If8SAInfOuEgalLitBgoto A, .100, Test21_2
    call    Erreur
Test21_2
    If8SAInfOuEgalLitBgoto A, .90, Test21_3
    call    Erreur
Test21_3
    If8SAInfOuEgalLitBgoto A, -.110, Test21_4
    call    Erreur
Test21_4    
    If8SAInfOuEgalLitBgoto A, -.100, Test21_5
    call    Erreur
Test21_5 
    If8SAInfOuEgalLitBgoto A, -.90, Test22
    call    Erreur

Test22    
    If8SAEgalLitBgoto A, .110, Test22_1
    call    Erreur
Test22_1
    If8SAEgalLitBgoto A, .100, Test22_2
    call    Erreur
Test22_2
    If8SAEgalLitBgoto A, .90, Test22_3
    call    Erreur
Test22_3
    If8SAEgalLitBgoto A, -.110, Test22_4
    call    Erreur
Test22_4
    If8SAEgalLitBgoto A, -.100, Test22_5
    call    Erreur
Test22_5
    If8SAEgalLitBgoto A, -.90, Test23
    call    Erreur

Test23    
    If8SANonEgalLitBgoto A, .110, Test23_1
    call    Erreur
Test23_1
    If8SANonEgalLitBgoto A, .100, Test23_2
    call    Erreur
Test23_2
    If8SANonEgalLitBgoto A, .90, Test23_3
    call    Erreur
Test23_3    
    If8SANonEgalLitBgoto A, -.110, Test23_4
    call    Erreur
Test23_4
    If8SANonEgalLitBgoto A, -.100, Test23_5
    call    Erreur
Test23_5
    If8SANonEgalLitBgoto A, -.90, Test24
    call    Erreur
    
Test24
    If8SAStrictSupLitBgoto A, .110, Test24_1
    call    Erreur
Test24_1
    If8SAStrictSupLitBgoto A, .100, Test24_2
    call    Erreur
Test24_2
    If8SAStrictSupLitBgoto A, .90, Test24_3
    call    Erreur
Test24_3
    If8SAStrictSupLitBgoto A, -.110, Test24_4
    call    Erreur
Test24_4
    If8SAStrictSupLitBgoto A, -.100, Test24_5
    call    Erreur
Test24_5
    If8SAStrictSupLitBgoto A, -.90, Test19
    call    Erreur
        
Test25
    If8SASupOuEgalLitBgoto A, .110, Test25_1
    call    Erreur
Test25_1
    If8SASupOuEgalLitBgoto A, .100, Test25_2
    call    Erreur
Test25_2
    If8SASupOuEgalLitBgoto A, .90, Test25_3
    call    Erreur
Test25_3    
    If8SASupOuEgalLitBgoto A, -.110, Test25_4
    call    Erreur
Test25_4
    If8SASupOuEgalLitBgoto A, -.100, Test25_5
    call    Erreur
Test25_5
    If8SAStrictSupLitBgoto A, -.90, Test25_6
    call    Erreur

Test25_6
    
; reprise de ces tests avec A = -.100
    btfsc    A, 7
    goto    Fin
    movlw    -.100
    goto    Test20
    

Fin
    goto $

Erreur
    return        

    END             ; directive fin de programme



Programmation très sommaire qui ne nécessite aucun commentaire en plus de deux du programme (du moins j'espère)

TestMacroTest2.asm

Code : Tout sélectionner

;**********************************************************************
;
                       Test des Macros de test                          *  
;                                Avec while
;                                                                     *
;**********************************************************************
;
                                                                     *
;
    NOM:      TestMacrosTest2                                         *
;
    Date:     20/06/2018                                             *
;
    Version:  1.0                                                    *
;
    Circuit:  sans objet                                             *
;
    Auteur:   JJE                                                     *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Fichier requis: MacrosTest.inc                                   *
;
                                                                     *
;**********************************************************************
;
                                                                     *
;
    Notes: 
;    Ce petit programme permet de tester les macros du fichier inclus  *
;
    sous le simulateur de MPLAB
;                                                                     *
;**********************************************************************
    

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

    CBLOCK 0x020                   ; Début de la zone des variables  
    
; variables utiles 

    A    
: 1
    AA    
: 1
    
    
    ENDC                        
; Fin de la zone
     
    

;*********************************************************************
;
                             MACRO                                  *
;*********************************************************************
    
    include    
"..\MacrosTest.inc"

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

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

Valeurs    dt .110, .100, .90
    
init
    movlw    .100
    movwf    A
    
    
;**********************************************************************
;
 les deux premiers paramètres sont des variables pour i<StrictInfLit
; pour les valeurs suivantes, le deuxième paramètre est un littéral
;**********************************************************************
Test_Si

    variable jmax 
= .2
    variable s 
= 0
    while s 
< .2        
        variable i 
= StrictInf
        while i 
<= StrictSupLit
            variable j 
= 0
            while j
<=jmax
                if    i 
<    StrictInfLit
                    call    Valeurs
+j
                    movwf    AA
                    Si A
,(+ s*0x80),AA,jump,$+2
                else
                    if j
<=2
                        Si A
,(+ s*0x80),.110-.10*j,jump,$+2
                    else
                        Si A
,(+ s*0x80),-(.110-.10*(j-3)),jump,$+2
                    endif
                endif
                call    Erreur

+= 1
            endw
+= 1
        endw
+= 1
jmax set .5
    endw
    

Fin
    goto 
$

Erreur
    return        


    END             
; directive fin de programme



Ce programme est composé de trois boucles while imbriquées.
Pour les lecteurs qui utilisent peu ces directives, il faut lire ce texte en se plaçant à la place de l'assembleur, d'habitude, quand on lit un code source, on se met plutôt à la place du processeur qui va effectuer les instructions qu'on lui propose.

La boucle externe

Code : Tout sélectionner


    variable jmax 
= .2
    variable s 
= 0
    while s 
< .2        
        
.../...
+= 1
jmax set .5
    endw


gère le problème test signés ou non, dans le premier passage où s == 0, les tests non signés seront invoqués, dans le deuxième ce seront les signés. la variable s vaudra 1 grâce au s += 1 de fin de boucle

La boucle intermédiaire gère les différents tests proposés

Code : Tout sélectionner


    variable jmax 
= .2
    variable s 
= 0
    while s 
< .2        
        variable i 
= StrictInf
        while i 
<= StrictSupLit
        
.../...
+= 1
        endw
+= 1
jmax set .5
    endw
    


Les tests étant repérés par un entier de 0 (StrictInf) à 11 ( StrictSupLit) voir fichier .inc,, la variable i sera utilisée pour appeler la macro Si avec la bonne valeur. la ligne i += 1 de fin de boucle permet à i de parcourir tous les entiers de StrictInf à StrictSupLit.

La boucle la plus intérieure sélectionne la valeur à quoi on compare le premier paramètre

Code : Tout sélectionner


            while j
<=jmax
                if    i 
<    StrictInfLit
                    call    Valeurs
+j
                    movwf    AA
                    Si A
,(+ s*0x80),AA,jump,$+2
                else
                    if j
<=2
                        Si A
,(+ s*0x80),.110-.10*j,jump,$+2
                    else
                        Si A
,(+ s*0x80),-(.110-.10*(j-3)),jump,$+2
                    endif
                endif
                call    Erreur

+= 1
            endw


jmax est initialisé à 2 en début de macro et le reste jusqu'à la fin de la boucle externe où il prend la valeur 5. en effet, on fait 3 tests sur les non signés (110, 100, 90 affectés à AA) donnés par la table valeurs du début de programme mais on en fait 6 pour les signés (110, 100, 90, -90, -100, -110), valeurs données par les formules (i + s*0x80),.110-.10*j et (i + s*0x80),-(.110-.10*(j-3)). Voulant garder le même ordre de tests que dans la version sans while, je n'ai pas trouvé d'arithmétique qui permettrait de se passer du if j<=2.

Remarquons enfin qu'on a là beaucoup de chance par rapport à mon post récent. On sait calculer l'adresse d'une référence en avant sans avoir besoin d'étiquette
En effet, si vous observez les macros du fichier .inc, vous pourrez constater qu'elles se terminent toutes par "goto Là" où Là est le dernier paramètre d'appel de la macro Si et que ce paramètre n'est pas utilisé ailleurs. Cette instruction sera donc, dans le code généré celle qui précédera le call Erreur, d'où le $+2.

Pour finir, il me faut bien reconnaître que ce code source, bien que très nettement plus court que la version sans while m'a demandé nettement plus de travail et de temps. Je manquais d'expérience sur cette directive.

Cordialement
JJE


Retourner vers « Langage ASM »

Qui est en ligne

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