Berechnung der Frequenzwörter eines AD9850 auf einem Atmega in ASM

[asmfreak (Gast)]

Hi,

ich habe eine Funktion in Assembler geschrieben, die es erlaubt, von 
einer beliebigen Frequenz die Steuerwörter für den DDS Baustein zu 
bilden. Augenmerk lag dabei auf die Ausführungsgeschwindigkeit. Mit 67 
bis 74 Takten dürfte dies mit die schnellste Version sein (bei 16MHz 
sind das nur 4,2 bis 4,6µs). Die maximale Abweichung vom exakten 
Ergebnis sollte bei 1 Bit liegen (dürfte nur selten auftreten).

Ich würde nun gerne wissen, wie man diese Funktion platzsparend als 
Schleife ausführen könnte. Mein Ansatz wäre, den Abschnitt calcAA über 
alle Bereiche laufen zu lassen (ggf. mit einer weiteren internen 
Schleife). Die "magischen Zahlen" könnten doch mittels Pointer zugeführt 
werden. Man könnte auch einen zweiten Pointer über die Register laufen 
lassen (oder über den Ram), wo die Frequenz hinterlegt ist. Allerdings 
komme ich da auf die dreifache Laufzeit. Lässt sich hier Speicherplatz 
überhaupt sinvoll einsparen?

Das sind meine ersten Schritte mit Assembler und Atmega, Kommentare sind 
also gerne erwünscht. Als größeres Ziel habe ich mir gesetzt, einen 
kleinen Signalgenerator zu bauen, der auch simple Modulationsverfahren 
beherrscht (erst einmal Sachen wie OOK, FSK). Der Code kann gerne 
kopiert werden.

;table:
;you could get another bit of resolution out of this, if you shift all bits in the table one time to the left (the AD9850 accepts words up to 7FFFFFFF). 
;if you want to sacrifice the X0Mhz range, you could get even further
;if you want to gain more speed, you can drop the rounding and the .XX Hz range 
;12 34 56 78.90 Hz                                                                     / 2^8               calculated
;.. .. .. .. EE                                     01010111  x  90  =           7830  30,5859375          30,9237645312
;.. .. .. DD ..                            00100010 01011100  x  78  =         686088  2680,03125          2680,059592704
;.. .. CC .. ..                   00001101 01101011 11111001  x  56  =       49258104  192414,46875        192414,5348608
;.. BB .. .. ..          00000101 00111110 00101101 01100010  x  34  =     2990671620  11682311,015625     11682311,04512
;AA .. .. .. .. 00000010 00001100 01001001 10111010 01011110  x  12  =   105553116264  412316860,40625     412316860,416
;                                                                   +=   108593739906  424194296,5078125   424194296,9793380352

.def rFreqE = r16
.def rFreqD = r17 ;Word 4
.def rFreqC = r18 ;Word 3
.def rFreqB = r19 ;Word 2
.def rFreqA = r20 ;Word 1
.def rPhase = r21
.def rTemp = r22
.def rZero = r23
.def rAA = r24 ;XX000000.00Hz
.def rBB = r25 ;00XX0000.00Hz
.def rCC = r26 ;0000XX00.00Hz
.def rDD = r27 ;000000XX.00Hz
.def rEE = r28 ;00000000.XXHz

calcWord:
calcAA:
  ldi rTemp,0b01011110
  mul rTemp,rAA
;  adc rFreqE,r0
;  adc rFreqD,r1
;saves 1 instruction
  movw rFreqE,r0
  ldi rTemp,0b10111010
  mul rTemp,rAA
  adc rFreqD,r0
  adc rFreqC,r1
  ldi rTemp,0b01001001
  mul rTemp,rAA
  adc rFreqC,r0
  adc rFreqB,r1
  ldi rTemp,0b00001100
  mul rTemp,rAA
  adc rFreqB,r0
  adc rFreqA,r1
;  ldi rTemp,0b00000010
;  mul rTemp,rAA
;  adc rFreqA,r0
;saves 1 instruction
  mov rTemp,rAA
  lsl rTemp
  adc rFreqA,rTemp
calcBB:
  ldi rTemp,0b01100010
  mul rTemp,rBB
  adc rFreqE,r0
  adc rFreqD,r1
  ldi rTemp,0b00101101
  mul rTemp,rBB
  adc rFreqD,r0
  adc rFreqC,r1
  ldi rTemp,0b00111110
  mul rTemp,rBB
  adc rFreqC,r0
  adc rFreqB,r1
  ldi rTemp,0b00000101
  mul rTemp,rBB
  adc rFreqB,r0
  adc rFreqA,r1
calcCC:
  ldi rTemp,0b11111001
  mul rTemp,rCC
  adc rFreqE,r0
  adc rFreqD,r1
  ldi rTemp,0b01101011
  mul rTemp,rCC
  adc rFreqD,r0
  adc rFreqC,r1
  ldi rTemp,0b00001101
  mul rTemp,rCC
  adc rFreqC,r0
  adc rFreqB,r1
calcDD:
  ldi rTemp,0b01011100
  mul rTemp,rDD
  adc rFreqE,r0
  adc rFreqD,r1
  ldi rTemp,0b00100010
  mul rTemp,rDD
  adc rFreqD,r0
  adc rFreqC,r1
;calcEE:;optional
;  ldi rTemp,0b01010111
;  mul rTemp,rEE
;  adc rFreqE,r0
;  adc rFreqD,r1
;rounding:;optional
;  rol rFreqE
;  adc rFreqD,rZero

[W.S. (Gast)]

Gratulation..

W.S.

[Karl M. (Gast)]

Hallo,

und auf welcher DDS-Taktfrequenz basiert der Ansatz ?
Wie kann die DDS-Taktfrequenz korrigiert werden ?
Wenn die Taktfrequenz etwas daneben liegt ?

[Arduinoquäler (Gast)]

Hinausgeschieben müssen die 32 Bit ja auch noch. Und da das
nicht beliebig schnell geht bietet es sich vielleicht an
geschachtelt (interleaved) zu rechnen. Also ein Byte rechnen
und gleich rausschreiben, wieder ein Byte rechnen usw. Dann
kann man - während die SPI aktiv ist - ein Byte rechnen ohne
auf das Busy Flag zu warten. Das muss man aber später noch
nachholen ....

So haben wir das früher auf dem Apple (II/IIGS) gemacht.