[F6FCO]

Division sur 16 bits.

Code : Tout sélectionner

;********************************************************************
;                Division sur entiers 16bits _ F6FCO                  
;     Il faut préalablement déclarer les variables ci-dessous sur 16 bits         
; dividende16, diviseur16, quotient16, reste16, valeur1 et valeur2 sur 16bits                
;                                                                
; poids faible dans dividende16                                        
; poids fort de la valeur à diviser dans dividende16+1,               
;                                                                
; poids faible dans diviseur16                                        
; poids fort du diviseur dans diviseur16+1                            
;                                                                
; Le résultat sera dans quotient16 et quotient16+1                       
; Le reste sera dans reste16 et reste16+1                                    
;                                                                
; Cette division utilise la routine soustraction16                         
;                                        
;********************************************************************   
division16    
        ; 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    diviseur16,diviseur16
        btfss    STATUS,Z
        bra    div16
div_zero    movf    diviseur16+1,diviseur16+1
        btfsc    STATUS,Z
        bra    div_quot
div16        ; on initialise quotient=0
        clrf    quotient16
        clrf    quotient16+1
        ; reste=dividende
        movff    dividende16,reste16
        movff    dividende16+1,reste16+1
div16_1        movf    reste16+1,w
        subwf    diviseur16+1,w
        ; test si poids fort reste>diviseur ?
        btfss    STATUS,C                    
        bra    div16_3
        ; test si poids fort reste=diviseur ? sinon on sort
div16_4        bz    div16_2
findiv16    return
div16_2        ; test si poids faible reste>=diviseur
        movff    reste16,WREG
        subwf    diviseur16,w
        btfss    STATUS,C
        bra    div16_3
        bz    div16_3
        bra    findiv16
div16_3        ; reste=dividende-diviseur
        nop
        movff    reste16,valeur1
        movff    reste16+1,valeur1+1
        movff    diviseur16,valeur2
        movff    diviseur16+1,valeur2+1
        call    soustraction16            ; résultat dans valeur1, valeur1+1
        movff    valeur1+1,reste16+1
        movff    valeur1,reste16
        ; quotient +1
        bcf    STATUS,C
        movlw    1
        addwf    quotient16
        ; on additionne le carry dans le poids fort
        movf    STATUS,C
        andlw    0x1
        addwf    quotient16+1
        bra    div16_1
div_quot    ; en cas de division par zéro on charge le dividende dans le quotient
        movff    dividende16,quotient16
        movff    dividende16+1,quotient16+1
        return