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 ---
Forum général sur l'Assembleur !

Modérateur : mazertoc

Caisse à outils
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 589
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#1 Message par F6FCO » jeu. 5 avr. 2018 12:20

Bonjour à tous,
Çà ne casse pas trois pattes à un canard mais çà peut être pratique, comme tout bon bricoleur j'aime bien avoir des outils et j'ai commencé à remplir ma caisse en codant des routines d'addition et soustraction sur 16 et 32bits.
Çà m'évitera de réinventer la roue à chaque fois que j'en aurai besoin.
Si çà peut servir... :wink:


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
;   
;
;                                                                     
;**********************************************************************
    
    
    List p=16F88    
    #include <p16F88.inc>

    __CONFIG    _CONFIG1, _CP_OFF & _CCP1_RB0 & _DEBUG_OFF & _WRT_PROTECT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _MCLR_ON & _PWRTE_OFF & _WDT_OFF & _XT_OSC
    __CONFIG    _CONFIG2, _IESO_OFF & _FCMEN_OFF
      
OPTIONVAL    EQU    H'
0008'            

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

    CBLOCK 0x020  
        valeur1:4     ; déclarée en 32bits
        valeur2:4    ; déclarée en 32bits
    ENDC                                                                                  

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

    org     0x0000                ; Adresse de départ après reset
init
    bsf        STATUS,RP0            ; bank1
    clrf    ANSEL                ; broches du CAN en I/O
    movlw    OPTIONVAL            ; charger masque
    movwf    OPTION_REG            ; initialiser registre option
    clrf    TRISB                ; PORTB en sortie 
    bcf        STATUS,5            ; bank0
    
main
    ; cette partie est un exemple d'
utilisationon va soustraire 16C3284E-324AFF12le résultat sera E478293C stocké dans valeur2
    
raz des variables    
    clrf    valeur1
    clrf    valeur1
+1
    clrf    valeur1
+2
    clrf    valeur1
+3
    clrf    valeur2
    clrf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    
Stockage des valeurs dans les variableson place la première valeur dans valeur1
    movlw    0x4e
    movwf    valeur1
    movlw    0x28
    movwf    valeur1
+1
    movlw    0xC3
    movwf    valeur1
+2
    movlw    0x16
    movwf    valeur1
+3    
    
on place la valeur à soustraire dans valeur2
    movlw    0x12
    movwf    valeur2
    movlw    0xff
    movwf    valeur2
+1
    movlw    0x4A
    movwf    valeur2
+2
    movlw    0x32
    movwf    valeur2
+3
    
    
;call     addition16            appel de la routine d'addition sur 16bits, résultat dans valeur2 et valeur2+1
    ;call     addition32            ; appel de la routine d'
addition sur 32bitsrésultat dans valeur2 et valeur2+1valeur2+2  valeur2+3
    
;call    soustraction16         appel de la routine de soustraction sur 16bitsrésultat dans valeur2 et valeur2+1
    call    soustraction32         
appel de la routine de soustraction sur 32bitsrésultat dans valeur2valeur2+1valeur2+2 et valeur2+3

    
goto     main
    
;********************************************************************
;                   
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 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+1valeur1+2valeur1+3.            *
Placer le poids faible de la valeur à additionner dans valeur2    *
et les poids forts dans valeur2+1valeur2+2valeur2+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    
    
;********************************************************************
;                   
Soustraction 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 à soustraire dans valeur2        *
et le poids fort 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 fait le complément à 2 de valeur2 et valeur2+1
    movf    valeur2
,W
    xorlw    0xFF
    addlw    0x1
    movwf    valeur2
    movf    valeur2
+1,w
    xorlw    0xFF
    movwf    valeur2
+1
    
addition des poids faibles
    movf    valeur1
,W
    addwf    valeur2
    
addition du carry
    movf    STATUS
,W
    andlw    0x1
    addwf    valeur2
+1
    
addition des poids fortsrésultat dans valeur2/valeur2+1
    movf     valeur1
+1,W
    addwf    valeur2
+1
    
return
    
;********************************************************************
;                   
Soustraction sur 32bits                            *
;     
Il faut prélablement déclarer les variables sur 32bits            
;             
valeur1:4    et valeur2:4                                *
;                                                                    *
Placer le poids faible de la première valeur dans valeur1            *
et les poids forts dans valeur1+1valeur+2valeur+3                *
Placer le poids faible de la valeur à soustraire dans valeur2        *
et les poids forts dans valeur2+1valeur2+2valeur2+3              *   
;                                                                    *
Appeler la procédure soustraction16 et le résultat de             *
valeur1-valeur2 sur 32bits sera dans les 4 octets de valeur2         *
;********************************************************************
soustraction32
    
on fait le complément à 2 de tous les octets de valeur2
    movf    valeur2
,W
    xorlw    0xFF
    addlw    0x1
    movwf    valeur2    
    movf    valeur2
+1,w
    xorlw    0xFF
    movwf    valeur2
+1
    movf    valeur2
+2,w
    xorlw    0xFF
    movwf    valeur2
+2
    movf    valeur2
+3,w
    xorlw    0xFF
    movwf    valeur2
+3
    
addition des octets faibles
    movf    valeur1
,W
    addwf    valeur2
    
addition du carry
    movf    STATUS
,W
    andlw    0x1
    addwf    valeur2
+1
    
addition des octets+1résultat dans valeur2+1
    movf     valeur1
+1,W
    addwf    valeur2
+1
    
addition du carry
    movf    STATUS
,W
    andlw    0x1
    addwf    valeur2
+2
    
addition des octets+2résultat dans valeur2+2
    movf     valeur1
+2,W
    addwf    valeur2
+2
    
addition du carry
    movf    STATUS
,W
    andlw    0x1
    addwf    valeur2
+3
    
addition des octets+3résultat dans valeur2+3
    movf     valeur1
+3,W
    addwf    valeur2
+3
    
return

    
    
END             


Une porte nand prend 2 bits en entrée... cochonne va !!!

Caisse à outils
ducran lapoigne
Avatar de l’utilisateur
Débutant
Débutant
Messages : 96
Enregistré en : septembre 2015

#2 Message par ducran lapoigne » jeu. 5 avr. 2018 22:18

allez puisqu'on y est et pour que JC se sente moins seul :-D

encore une (petite) boite a outils

je suppose que toute traduction est superflue

Code : Tout sélectionner

;-----------------------------------------------------------------
;
if A=B goto Equal_to
;-----------------------------------------------------------------
    movf    A,w
    xorwf    B
,w
    btfsc    STATUS
,Z
    goto     Equal_to
;-----------------------------------------------------------------
;
if A>B goto Greater_than
;-----------------------------------------------------------------
    movf     A,w
    subwf     B
,w
    btfss     STATUS
,C
    goto     Greater_than
;-----------------------------------------------------------------
;
if A<B goto Less_than
;-----------------------------------------------------------------
    movf     B,w
    subwf     A
,w
    btfss     STATUS
,C
    goto     Less_than
;-----------------------------------------------------------------
;
if A=>B goto Eq_or_gr
;-----------------------------------------------------------------
    movf     B,w
    subwf     A
,w
    btfss     STATUS
,C
    goto     Eq_or_gr
;-----------------------------------------------------------------
;
if A=<B goto Eq_or_less
;-----------------------------------------------------------------
    movf     A,w
    subwf     B
,w
    btfsc     STATUS
,C
    goto     Eq_or_less
;-----------------------------------------------------------------
;
if A>B and C>D goto and_A_gr_B_gr
;-----------------------------------------------------------------
    movf     A,w
    subwf     B
,w
    btfss     STATUS
,C
    goto    suite
    movf     C
,w
    subwf     D
,w
    btfss     STATUS
,C
    goto     and_A_gr_B_gr
suite    
....
;-----------------------------------------------------------------
;
if A>B or C>D goto or_A_gr_B_gr
;-----------------------------------------------------------------
    movf     A,w
    subwf     B
,w
    btfss     STATUS
,C
    goto    suite
    movf     C
,w
    subwf     D
,w
    btfss     STATUS
,C
suite    goto     or_A_gr_B_gr
;-----------------------------------------------------------------
;
 For A= 1 to 5 -> action -> next A
;-----------------------------------------------------------------
    movlw    1
    movwf    A
test
    
.....
    .....
    movf    A,w
    addlw    0x01
    movwf    A
    sublw     5        
;5--> w
    btfsc    STATUS
,C
    goto test

;-----------------------------------------------------------------
;
 complement a 1 de W
;-----------------------------------------------------------------
    xorlw 0xff
ou bien
    sublw 0xff
;-----------------------------------------------------------------
;
 complement a 2 de W
;-----------------------------------------------------------------
    xorlw     0xff
    addlw    0x01
;-----------------------------------------------------------------
;
 incrémenter w
;-----------------------------------------------------------------
    addlw    0x01
    
;-----------------------------------------------------------------
;
 décrémenter w
;-----------------------------------------------------------------
    addlw    0xff        ; never sublw 0x01 !!
    
;-----------------------------------------------------------------
 

Caisse à outils
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 589
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#3 Message par F6FCO » jeu. 5 avr. 2018 22:49

ducran lapoigne a écrit :je suppose que toute traduction est superflue


Effectivement :-D . Bien pratique cet aide-mémoire, la caisse se remplit.
Une porte nand prend 2 bits en entrée... cochonne va !!!

Caisse à outils
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 954
Enregistré en : juillet 2016
Localisation : Terre

#4 Message par Temps-x » ven. 6 avr. 2018 01:55

Bonjour F6FCO, ducran lapoigne, et tout le forum,

:bravo: bien cogité F6FCO et ducran lapoigne pour vos code. 8-)

Un petit lien ou vous allez vous régaler : http://www.piclist.com/techref/microchi ... /index.htm

:sifflotte: Ben moi j'ai pas grand chose à vous proposé, mais j'ai une routine toute basic pour conversion hexa vers ascii 16bits
avec cette méthode on peu même faire du 32 bits. 8-)

Code : Tout sélectionner



decode_lcd

; "16 bits"

      clrf unite                
      clrf dizaine              
      clrf centaine             
      clrf millieme             
      clrf dix_millieme         

      btfss res16
,7
      goto 
$+D'11'            

      movlw D
'3'                          ; 32768  
      addwf dix_millieme
,F
      movlw D
'2'                          ;  2768  
      addwf millieme
,F
      movlw D
'7'                          ;   768
      addwf centaine
,F                 
      movlw D
'6'                          ;    68
      addwf dizaine
,F                 
      movlw D
'8'                          ;     8
      addwf unite
,F                 


      btfss res16
,6
      goto 
$+D'11'            

      movlw D
'1'                          ; 16384  
      addwf dix_millieme
,F
      movlw D
'6'                          ;  6384  
      addwf millieme
,F
      movlw D
'3'                          ;   384
      addwf centaine
,F                 
      movlw D
'8'                          ;    84
      addwf dizaine
,F                 
      movlw D
'4'                          ;     4
      addwf unite
,F                 


      btfss res16
,5
      goto 
$+D'9'            

      movlw D
'8'                          ; 8192  
      addwf millieme
,F
      movlw D
'1'                          ;  192
      addwf centaine
,F                 
      movlw D
'9'                          ;   92
      addwf dizaine
,F                 
      movlw D
'2'                          ;    2
      addwf unite
,F                 


      btfss res16
,4
      goto 
$+D'9'            

      movlw D
'4'                          ; 4096  
      addwf millieme
,F
      movlw D
'0'                          ;  096
      addwf centaine
,F                 
      movlw D
'9'                          ;   96
      addwf dizaine
,F                 
      movlw D
'6'                          ;    6
      addwf unite
,F                 


      btfss res16
,3
      goto 
$+D'9'            

      movlw D
'2'                          ; 2048  
      addwf millieme
,F
      movlw D
'0'                          ;  048
      addwf centaine
,F                 
      movlw D
'4'                          ;   48
      addwf dizaine
,F                 
      movlw D
'8'                          ;    8
      addwf unite
,F                 


      btfss res16
,2
      goto 
$+D'9'            

      movlw D
'1'                          ; 1024  
      addwf millieme
,F
      movlw D
'0'                          ;  024
      addwf centaine
,F                 
      movlw D
'2'                          ;   24
      addwf dizaine
,F                 
      movlw D
'4'                          ;    4
      addwf unite
,F                 


      btfss res16
,1
      goto 
$+D'7'            

      movlw D
'5'                          ;  512
      addwf centaine
,F                 
      movlw D
'1'                          ;   12
      addwf dizaine
,F                 
      movlw D
'2'                          ;    2
      addwf unite
,F                 


      btfss res16
,0
      goto 
$+D'7'            

      movlw D
'2'                          ;  256
      addwf centaine
,F                 
      movlw D
'5'                          ;   56
      addwf dizaine
,F                 
      movlw D
'6'                          ;    6
      addwf unite
,F                 

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

; "8 bits"

      btfss res8,7
      goto 
$+D'7'            

      movlw D
'1'                          ;  128
      addwf centaine
,F                 
      movlw D
'2'                          ;   28
      addwf dizaine
,F                 
      movlw D
'8'                          ;    8
      addwf unite
,F                 


      btfss res8
,6
      goto 
$+D'5'            

      movlw D
'6'                          ;   64
      addwf dizaine
,F                 
      movlw D
'4'                          ;    4
      addwf unite
,F                 


      btfss res8
,5
      goto 
$+D'5'            

      movlw D
'3'                          ;   32
      addwf dizaine
,F                 
      movlw D
'2'                          ;    2
      addwf unite
,F                 

      btfss res8
,4
      goto 
$+D'5'            

      movlw D
'1'                          ;   16
      addwf dizaine
,F                    
      movlw D
'6'                          ;    6
      addwf unite
,F                 

      movlw B
'00001111'     
      andwf res8
,W    

      addwf unite
,F                    

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

total_unite
      movfw unite
      movwf tmps    
      movfw dizaine
    
      call decompose  

      movwf dizaine
      movfw tmps
      movwf unite

total_dizaine
      movfw dizaine
      movwf tmps    
      movfw centaine
    
      call decompose  

      movwf centaine
      movfw tmps
      movwf dizaine

total_centaine
      movfw centaine
      movwf tmps    
      movfw millieme
    
      call decompose  

      movwf millieme
      movfw tmps
      movwf centaine


total_millieme
      movfw millieme
      movwf tmps    
      movfw dix_millieme
    
      call decompose  

      movwf dix_millieme
      movfw tmps
      movwf millieme 

      movlw D
'48'  

      addwf unite
,F
      addwf dizaine
,F
      addwf centaine
,F
      addwf millieme
,F
      addwf dix_millieme
,F

fin
      goto fin      

;**********************************************************************************************
;
                                       sous programme
;**********************************************************************************************
decompose 
      
      movwf temps

      movfw tmps
      sublw D
'10'                             ; retir 10 de W
      btfsc STATUS
,Z                      ; si le bit Z est à 1 on va à la ligne 1                                       
      goto 
$+D'4'                             ; si Z = 1 , résultat égal
      btfss STATUS
,C                      ; si le bit C est à 0 on va à la ligne 1
      goto 
$+D'2'
      goto $+D'5'                         
      movlw D
'10' 
      subwf tmps
,F   
      incf temps
,F  
      goto 
$-D'10'

      movfw temps
 return    

      END       


humour!! Si on continu comme ça, on va réécrire MikroC :langue: bon j'arrête là parce que.......:sifflotte:

==> A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Caisse à outils
Jérémy
Administrateur du site
Administrateur du site
Messages : 2155
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#5 Message par Jérémy » ven. 6 avr. 2018 07:27

 ! Message de modération :
Bonjour ici,

Que penseriez-vous d'ouvrir un post dans la partie "Tutoriels". Le premier post serait un post avec les liens des routines (pointant vers les autres posts à la suite) que vous rajouterez au fur et à mesure. ( comme ici ).

Ainsi un membre clic sur le lien et cela l'emmene directement à la routine choisie ?

Car j'ai bien peur que de un AN on ne retoruve ces précieuses aides.
Il suffirait d'éttayer un psot vos messages en expliquant votre facon de faire et ce que fait la routine. Histoire qu'un membre novice puisse comprendre. Avec des commentaires. Il faut toujours se mettre à la place du novice qui n'y connait pas grand chose.

Ca vous tente ?
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Caisse à outils
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 589
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#6 Message par F6FCO » ven. 6 avr. 2018 09:53

Je trouve que c'est une bonne idée, si tout le monde y va de sa petite idée on devrait pouvoir se faire une bibliothèque d'outils bien pratique :wink:
Une porte nand prend 2 bits en entrée... cochonne va !!!

Caisse à outils
ducran lapoigne
Avatar de l’utilisateur
Débutant
Débutant
Messages : 96
Enregistré en : septembre 2015

#7 Message par ducran lapoigne » ven. 6 avr. 2018 16:21

pas d' objection, ce serait super bien d' avoir un seul endroit pour rechercher toutes ces infos

Caisse à outils
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 954
Enregistré en : juillet 2016
Localisation : Terre

#8 Message par Temps-x » ven. 6 avr. 2018 18:23

Bonjour tout le forum,

Bien sur c'est la meilleur solution.

humour!! ça permettras à Jérémy de comprendre les routines ASM oops exit dehors!!

==> A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Caisse à outils
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 589
Âge : 64
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#9 Message par F6FCO » ven. 6 avr. 2018 20:16

J'ai cru comprendre qu'il y avait une histoire de tour Eiffel...
Une porte nand prend 2 bits en entrée... cochonne va !!!

Caisse à outils
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 954
Enregistré en : juillet 2016
Localisation : Terre

#10 Message par Temps-x » ven. 6 avr. 2018 22:14

Bonsoir tout le forum,

F6FCO a écrit :
Source du message J'ai cru comprendre qu'il y avait une histoire de tour Eiffel...


Chalenge offert par Jérémy, ICI, JMarc avait passé commande de la réplique de la Tour Eiffel échelle 1 :sifflotte:

Reste à voir pour la suite ......

==> A+
Modifié en dernier par Temps-x le sam. 7 avr. 2018 00:50, modifié 1 fois.
Quand la souris nargue le chat, c'est que son trou n'est pas loin.


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 2 invités