[F6FCO]

Division sur 32 bits

Code : Tout sélectionner

;********************************************************************
;                Division sur entiers 32bits - F6FCO                  
;     Il faut préalablement déclarer les variables sur 32 bits         
;         dividende32, diviseur32, quotient32    et reste16                
;                                                                    
; poids faible dans dividende32                                    
; poids forts  dans dividende32+1, +2 et +3                            
;                                                                    
; poids faible dans diviseur32                                        
; poids forts du diviseur dans diviseur32+1, +2    et +3                
;                                                                    
; Le résultat sera dans quotient32, quotient32+1, +2  et +3              
; Le reste sera dans reste32, reste32+1, reste32+2    et +3                    
;                                                                    
; Cette division utilise la routine soustraction32                         
; il faut donc aussi avoir déclaré les variables sur                                             
;                 32 bits valeur1 et valeur2                                
;********************************************************************   
division32    
            ; on vérifie si c'est une division par zéro, si c'est le cas on charge le dividende dans le quotient.
            ; dividende/0=dividende, pas cohérent mathématiquement mais nécessaire dans le projet en cas de ligne
            ; horizontale (Y=0) ou verticale (X=0).
            movf    diviseur32,diviseur32
            btfss    STATUS,Z
            bra        div32            
div_zero32        movf    diviseur32+1,diviseur32+1
            btfsc    STATUS,Z
            movf    diviseur32+2,diviseur32+2
            btfsc    STATUS,Z
            movf    diviseur32+3,diviseur32+3
            btfsc    STATUS,Z
            bra        div_quot32
div32        ; on initialise quotient=0
            clrf    quotient32
            clrf    quotient32+1
            clrf    quotient32+2
            clrf    quotient32+3
            ; reste=dividende
            movff    dividende32,reste32
            movff    dividende32+1,reste32+1
            movff    dividende32+2,reste32+2
            movff    dividende32+3,reste32+3
div32_0        ; test poids3
            movf    reste32+3,w
            subwf    diviseur32+3,w            
            ; test si poids3 reste>diviseur ?
            btfss    STATUS,C                    
            bra    div32_3            
            ; test si poids2 reste=diviseur ? sinon on sort    
            bz    div32_1
findiv32        return
div32_1        ; test poids2
            movf    reste32+2,w
            subwf    diviseur32+2,w            
            ; test si poids2 reste>diviseur ?
            btfss    STATUS,C                    
            bra    div32_3            
            ; test si poids2 reste=diviseur ? sinon on sort    
            bz    div32_2
            return
div32_2        ; test poids1
            movf    reste32+1,w
            subwf    diviseur32+1,w            
            ; test si poids1 reste>diviseur ?
            btfss    STATUS,C                    
            bra    div32_3            
            ; test si poids1 reste=diviseur ? sinon on sort
            bz    div32_22
            return
div32_22    ; test si poids0 reste>=diviseur
            movff    reste32,WREG
            subwf    diviseur32,w
            btfss    STATUS,C
            bra    div32_3
            bz    div32_3
            return
div32_3        ; reste=dividende-diviseur
            nop
            movff    reste32,valeur1
            movff    reste32+1,valeur1+1
            movff    reste32+2,valeur1+2
            movff    reste32+3,valeur1+3
            movff    diviseur32,valeur2
            movff    diviseur32+1,valeur2+1
            movff    diviseur32+2,valeur2+2
            movff    diviseur32+3,valeur2+3
            call    soustraction32            ; résultat dans valeur1, +1, +2 et +3
            movff    valeur1,reste32
            movff    valeur1+1,reste32+1
            movff    valeur1+2,reste32+2
            movff    valeur1+3,reste32+3
            ; quotient +1
            bcf    STATUS,C
            movlw    1
            addwf    quotient32
            ; on additionne le carry dans les poids forts
            movf    STATUS,C
            andlw    0x1
            addwf    quotient32+1
            movf    STATUS,C
            andlw    0x1
            addwf    quotient32+2
            movf    STATUS,C
            andlw    0x1
            addwf    quotient32+3
            bra    div32_0
div_quot32    ; en cas de division par zéro on charge le dividende dans le quotient
            movff    dividende32,quotient32
            movff    dividende32+1,quotient32+1
            movff    dividende32+2,quotient32+2
            movff    dividende32+3,quotient32+3
            return