[F6FCO]

Division sur 24 bits.

Code : Tout sélectionner

;********************************************************************
;                Division sur entiers 24bits - F6FCO                  
;     Il faut préalablement déclarer les variables sur 24 bits         
;         dividende24, diviseur24, quotient24    et reste16                
;                                                                    
; poids faible dans dividende24                                    
; poids forts  dans dividende24+1 et +2                                
;                                                                    
; poids faible dans diviseur24                                        
; poids forts du diviseur dans diviseur24+1 et +2                    
;                                                                    
; Le résultat sera dans quotient24, quotient24+1 et +2                    
; Le reste sera dans reste24, reste24+1 et reste24+2                        
;                                                                    
; Cette division utilise la routine soustraction24                         
; il faut donc aussi avoir déclaré les variables sur                                             
;                 24 bits valeur1 et valeur2                                
;********************************************************************   
division24    
            ; 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    diviseur24,diviseur24
            btfss    STATUS,Z
            bra        div24            
div_zero24    movf    diviseur24+1,diviseur24+1
            btfsc    STATUS,Z
            movf    diviseur24+2,diviseur24+2
            btfsc    STATUS,Z
            bra        div_quot24
div24        ; on initialise quotient=0
            clrf    quotient24
            clrf    quotient24+1
            clrf    quotient24+2
            ; reste=dividende
            movff    dividende24,reste24
            movff    dividende24+1,reste24+1
            movff    dividende24+2,reste24+2
div24_1        ; test poids2
            movf    reste24+2,w
            subwf    diviseur24+2,w            
            ; test si poids2 reste>diviseur ?
            btfss    STATUS,C                    
            bra        div24_3            
            ; test si poids2 reste=diviseur ? sinon on sort    
            bz        div24_2
findiv24        return
div24_2        ; test poids1
            movf    reste24+1,w
            subwf    diviseur24+1,w            
            ; test si poids1 reste>diviseur ?
            btfss    STATUS,C                    
            bra        div24_3            
            ; test si poids1 reste=diviseur ? sinon on sort
            bz        div24_22
            return
div24_22    ; test si poids0 reste>=diviseur
            movff    reste24,WREG
            subwf    diviseur24,w
            btfss    STATUS,C
            bra        div24_3
            bz        div24_3
            return
div24_3        ; reste=dividende-diviseur
            nop
            movff    reste24,valeur1
            movff    reste24+1,valeur1+1
            movff    reste24+2,valeur1+2
            movff    diviseur24,valeur2
            movff    diviseur24+1,valeur2+1
            movff    diviseur24+2,valeur2+2
            call    soustraction24            ; résultat dans valeur2, valeur1+1, +2 
            movff    valeur1,reste24
            movff    valeur1+1,reste24+1
            movff    valeur1+2,reste24+2
            ; quotient +1
            bcf        STATUS,C
            movlw    1
            addwf    quotient24
            ; on additionne le carry dans le poids fort
            movf    STATUS,C
            andlw    0x1
            addwf    quotient24+1
            movf    STATUS,C
            andlw    0x1
            addwf    quotient24+2
            bra        div24_1
div_quot24    ; en cas de division par zéro on charge le dividende dans le quotient
            movff    dividende24,quotient24
            movff    dividende24+1,quotient24+1
            movff    dividende24+2,quotient24+2
            return