Division mit AVR

[LinuxMan]

;************************************************************************
;*									*
;*			unsigned division 16 bit			*
;*			fast						*
;*									*
;************************************************************************

udiv16rnd:
	mov	a, op2l
	mov	i, op2h
	lsr	i			;2.operand / 2
	ror	a
	add	op1l, a			;1.Op = 1.Op + 2.Op / 2
	adc	op1h, i

;cycles: 94/186 (min/max)
;words: 33
udiv16:
	tst	op2h
	brne	udi4
	ldi	i, 16			;divisor < 256
udi1:	lsl	op1l			;loop: 16 * 11 - 1 = 175 cycles
	rol	op1h
	rol	op2h
	brcs	udi2
	cp	op2h, op2l
	brcs	udi3
udi2:	sub	op2h, op2l
	inc	op1l
udi3:	dec	i
	brne	udi1
	mov	op2l, op2h		;store remainder
	clr	op2h
	ret

udi4:	ldi	i, 8			;divisor >= 256
	clr	a
udi5:	lsl	op1l			;loop: 8 * 12 - 1 = 95 cycles
	rol	op1h
	rol	a
	cp	op1h, op2l		;test
	cpc	a, op2h
	brcs	udi6
	sub	op1h, op2l
	sbc	a, op2h
	inc	op1l
udi6:	dec	i
	brne	udi5
	mov	op2l, op1h		;store remainder
	mov	op2h, a
	clr	op1h
	ret
;------------------------------------------------------------------------

[hrrh]

Bei der C-controll1:
a=b/c
Basic ist doch einfacher, wenn auch langsamer!!!

In AVR-Basic (Bascom):

a=b/c

Nur halt viel schneller als bei der C-Control und zudem noch genauer - nämlich wahlweise auch mit Nachkommastellen

[REB]

Wie war dieGeschichte mit den Prgrammierern und der Großwildjagd noch mal?
Man kann natürlich alles in Assembler programmieren oder in Basic / C++ / iC, Delphi,... . Wenns denn sein muss auch in VBA.
Manches ist aber nicht sehr sinnvoll.
Assembler hat seine unereichbaren Vorteile bei dem Speicher / Portzugriff bzw. ~manipulation; ist aber bei Rechenoperationen etwas umständlich. Für den Rest der Sprachen gilt das vice versa.

REB

[cht]

Das hab ich gerade produziert: es lehnt an die schriftliche Division aus der Grundschule (verschlafen?) an, wie man sieht funzt dieses Verfahren auch in Binär. Es ist zwar Delphi-Code weil ich zum Testen nicht extra den µC proggen wollte, aber wens interessiert, der kanns ja in assembler übersetzen.

procedure TForm1.Button1Click(Sender: TObject);
var
  r16, r18, r20:word;//r16=Dividend, r18=Divisor, r20=Ergebnis
  i:byte;            //Schleifenzähler
begin
  r16:=StrToIntDef(Edit1.Text,1);//Dividend laden, bei Mist im Eingabefeld 1
  r18:=StrToIntDef(Edit2.Text,1);//Divisor laden
  while (r18<high(r16) shr 1) do //Divisor bis zum Anschlag...
    r18:=r18 shl 1;              //nach links schieben.
  for i:=0 to 15 do begin        //Schleife, für jedes Ergebnis-Bit
    r20:=r20 shl 1;              //Ergebnis weiterschieben
    if (r16>=r18) then begin     //wenns reinpasst...
      r16:=r16-r18;              //einmal subtrahieren ...
      r20:=r20 or 1;             //und ne Eins ins Ergebnis.
    end;                         //Ende If.
    r18:=r18 shr 1;              //Divisor weiterschieben
  end;                           //Ende Schleife.
  r18:=StrToIntDef(Edit2.Text,1);//Divisor nochmal laden
  while (r18>1) do begin         //Ergebnis so oft...
    r20:=r20 shr 1;              //nach rechts schieben...
    r18:=r18 shr 1;              //...wie der Divisor lang ist.
  end;                           //Ende Schleife.
  Edit3.Text:=IntToStr(r20);     //Ergebnis ausgeben.
end;

Das Ergebnis wird immer ABgerundet, wer will kann den Code ja so midifizieren dass er richtig rundet. Ich denke, für natürliche Zahlen oder Festkommawerte ist das eine praktische Lösung. Oder weiss jemand was schnelleres? Bitte posten!

mfG

cht