Caisse à outils

[F6FCO]

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...

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'utilisation, on va soustraire 16C3284E-324AFF12, le 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 variables, on 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 32bits, résultat dans valeur2 et valeur2+1, valeur2+2  valeur2+3
    ;call    soustraction16         ; appel de la routine de soustraction sur 16bits, résultat dans valeur2 et valeur2+1
    call    soustraction32         ; appel de la routine de soustraction sur 32bits, résultat dans valeur2, valeur2+1, valeur2+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+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    
    
;********************************************************************
;                   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 forts, ré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+1, valeur+2, valeur+3                *
; Placer le poids faible de la valeur à soustraire dans valeur2        *
; et les poids forts 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
    ; 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+1, ré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+2, ré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+3, résultat dans valeur2+3
    movf     valeur1+3,W
    addwf    valeur2+3
    return

    
    END             




[ducran lapoigne]

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

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 -> 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 !!
    
;-----------------------------------------------------------------
 

[F6FCO]

je suppose que toute traduction est superflue

Effectivement . Bien pratique cet aide-mémoire, la caisse se remplit.

[Temps-x]

Bonjour F6FCO, ducran lapoigne, et tout le forum,

bien cogité F6FCO et ducran lapoigne pour vos code.

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

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.

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       


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

A+

[Jérémy]

!

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 ?

[F6FCO]

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

[ducran lapoigne]

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

[Temps-x]

Bonjour tout le forum,

Bien sur c'est la meilleur solution.

ça permettras à Jérémy de comprendre les routines ASM

A+

[F6FCO]

J'ai cru comprendre qu'il y avait une histoire de tour Eiffel...

[Temps-x]

Bonsoir tout le forum,

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

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

A+