[uc 80C51] Division 16 bits

[invite7990ec44]

Bonjour,

je recherche un code assembleur, pour diviser un nombre sur 16 bits par un nombre sur 8 bits.

Si vous pocedez cela, D'avance merci.
-----

[invite7b66e893]

Salut

J'ai ecrit une routine de division non signée 16bits par 16bits pour les pics 16F, a toi de l'adapter dans ton cas:

;************************************************
; Division non signée 16 bits par 16 bits
;************************************************
; ENTREES : 
;	- AccA : 16 bits : MSB=AccA+b0, LSB=AccA+b1
;	- AccB : 16 bits : MSB=AccB+b0, LSB=AccB+b1
;************************************************
; FONCTION :
; 	AccA = AccA / AccB 
; 	Reste sur 16 bits		: MSB=Reste+b0, LSB=Reste+b1
; /!\ AccB > 0; si AccA = 0 ==> Resultat = Reste = 0
;************************************************
; Adresses programme utilisées = 24
; Nombre max de cycle machine = 4+16*20+1 = 325
; Nombre min de cycle machine = 4+16*18+1 = 293
;************************************************
UDIV16_16
	clrf		Reste+b0
	clrf		Reste+b1
	movlw	D'16'
	movwf	Cmpt3
Loop_udiv16
	rlf		AccA+b0,w		; Msb du Dividende dans Carry
	rlf		Reste+b1,f		; Msb du Dividende dans Lsb Reste
	rlf		Reste+b0,f
	movf	AccB+b1,w
	subwf	Reste+b1,w
	movwf	Temp+b1
	movf	AccB+b0,w
	btfss	STATUS,C		; resultat positif?
	incfsz	AccB+b0,w		; non on propage la retenue sur le MSB
	subwf	Reste+b0,w
	btfss	STATUS,C		; resultat positif?
	goto	$+4				; non
	movwf	Reste+b0		; oui on charge le resultat de la soustraction dans le Reste
	movf	Temp+b1,w
	movwf	Reste+b1
	rlf		AccA+b1,f
	rlf		AccA+b0,f
	decfsz	Cmpt3,f
	goto	Loop_udiv16
	return

[invite7990ec44]

ok, merci.. l'adaptation n'est pas evidente pour passer du PIC à un 80C51... le code n'a rien avoir...

Par contre le code que tu as fais prend peu de place.. il va interresser beaucoup de PicMAster.. ^^ Si tu as l'algo, je serais bien interressais.

Si non, je pocede un code pour des div de 16 par 16 bits. mais pour un soucis d'optimisation ( car elle sera utilisé tres souvent ) je recherche ce lui d'un 16 bits / 8 Bits.

[invite7b66e893]

Je n'ai plus l'algo sous la main de celle ci, par contre si tu as deja un code pour du 16/16, qu est ce qui t empeches de le modifier pour le passer en 16/8 ? le plus gros du travail est deja fait (enfin si tu as compris comment fonctionne la division)

A+

[A voir en vidéo sur Futura]

[invite7990ec44]

le code que j'ai recuperais me semble assez complexe.. pas de commentaire pour comprendre.. si je ne trouve pas d'autre code.. je reflechirais.. mais si ca déja été realiser par quelqu'un... ca evite de perdre du temps pour cette partie..

[invite936c567e]

Bonjour

Tu peux poster le code "complexe" que tu as ?

On pourrait peut-être le commenter, et l'adapter à ton besoin.

[invite7990ec44]

J'ai oublié de preciser... pour obtimiser au max le code...

LE 80C51 pocéde les instrcutions suivantes:
decallage, 8bits / 8 bits...

de plus j'ai besoins de divisé par 8 et par 6 un nombre de 16 bits..

Par 8, il suffit de décaller de 3 rangs à droite le nombre..

Mais par 6, je ne vois pas une solution rapide..

[invite7990ec44]

ok, je suis tombé sur cette page.. tres interresante. ca montre comment le pc effectue des divisions..

http://www2.ift.ulaval.ca/~marchand/...rt/Arithm.html

Merci eedy pour le lien ( IRC Teepi, canal #lelectronique)

[invite7b66e893]

La methode la plus simple pour divisier par 6 est la suivante:

Une division par 6 est en fait une division par 2, puis par 3.

Tu fais donc une premiere fois X/2 => Y

Puis une division par 3, a partir de division par 2 peut se faire sous cette forme:

1/3 = 1/2 - (SOMMES de 1 à n de: 1/(2^(2n+1)))

Pour faire plus simple:
1/3 = 1/2 - 1/8 -1/32 - 1/128 - 1/512 etc....


A toi de voir la precision qui te suffit afin de determiner le nombre d'iterations necessaires.

Donc pour une division par 6: X/6
1) Y=X/2
2) Resultat=Y/2 - Y/8 - Y/32 - Y/128 - Y/512 etc...

A+

[invite7990ec44]

Bonjour,

voila, pour la fin j'ai opté sur cette solution ( si plus rapide en cycle processeur je prend )

le 80C51 pocéde une instruction de division 8bits/8bits...
'6' est codé en binaire: 110 (3 bits)

j'effectue 3 opérations: les explications sont dans l'algorithme:

[invite7990ec44]

je met a jours ce post avec mon code en assembleur pour la serie ( 80C51). J'utilise se code, en partie, pour convertir les coordonnées X Y en adresse pour permettre d'afficher un pixel sur un LCD graphique.

;-------------------------------------------------------------------------------------------
; Fonction: Division d'un nombre de 16 bits par un nombre de 4bits.
; 05/05/2007 - V1.00 - by Mastronic ( carte59.free.fr) - version original
; xx/xx/20xx - V1.01 - by xxx     - ajoue les complements...                      
; in:   	R1 R0	, 16bits à diviser
;			R2		, le diviseur, sur 4 bits 
; out: 		R1 R0	, resultat
;			R2		, le reste de la division
; Utilise:  A,B
; Nb cycle sans empactage dans une fonction: 36 cycles  ( moy: 36/23 = 1,56 par instruction)
; Nb cycle avec empactage dans une fonction: 50 cycles  ( moy: 50/30 = 1,67 par instruction) 
;------------------------------------------------------------------------------------------
DIV16_4 	EQU $
			PUSH PSW		; sauve le contexte
			PUSH ACC
			PUSH B
		
;1er etape	(1er division)
			MOV A,R1		; descend le 1er et le 2eme quartets de bits de poid Fort
			MOV B,R2
			DIV AB			
			MOV R1,A		; Sauve le Resultat
			
;2eme etape (2eme division)
			MOV A,R0		; descend le 3eme quartets de bits
			SWAP A
			ANL A,#0Fh		
			XCH A,B				
			SWAP A			
			ADD A,B			; --> reste (4bits)de la 1er divition en msb et le 3 quartet en lsb
			MOV B,R2		
			DIV AB			
			SWAP A
			XCH A,R0		; Sauve le resultat dans le msb de R0
			
;3eme etape (3eme division)
			;MOV A,R0		; descend le 4eme quartets de bits ( deja descendu via XCH A,R0)
			ANL A,#0Fh
			XCH A,B
			SWAP A
			ADD A,B			; --> reste (4bits)de la 2eme divition en msb et le 4 quartet en lsb
			MOV B,R2
			DIV AB
			ADD A,R0		; Sauve le resultat dans le lsb de R0
			MOV R0,A

;Division terminé
			MOV R2,B		; Sauve le reste 
			
			POP B			; Recupere le contexte
			POP ACC
			POP PSW						
			RET

et l'Algorithme pour comprendre au mieux se code ( image de meilleurs qualitée que celle au dessus )