AD9102 und 30MHz Sinus

[Marcel D. (diablokiller999)]

Hi Leutz!
Ich habe hier einen AD9102 und möchte einen Sinus zwischen 10 und 30MHz 
mit ihm generieren. Die Kommunikation mit dem Chip klappt einwandfrei, 
leider habe ich keine Idee was ich in den Einstellungen übersehe um 
einen Sinus am Oszi zu sehen.

Ich gebe dem IC sechs 14Bit Werde in den SRAM, stelle als Config DDS 
Output und Waveform von RAM zwischen Start und Stop-Adresse ein (0x6000 
bis 0x6005), ein Tuning Word von 0x400000 und den Analog/Digital Gain. 
Hat hier jemand etwas Beispiel-Quelltext um die Funktionalität dieser 
DDS etwas besser zu verstehen oder kann mir sagen wo es bei meiner 
Umsetzung hakt?

Hier mal mein Arduino Sourcecode

#include <SPI.h>
uint16_t ramvalues[6] = { 8192,16384,16384,8192,0,0};
#define DAC_AGAIN_REG       0x0007
#define RAM_UPDATE_REG      0x001D
#define PAT_STATUS_REG      0x001E
#define PAT_DELAY_REG       0x0020
#define WAV_CONFIG_REG      0x0027
#define DAC_DGAIN_REG       0x0035
#define DDS_TW32_REG        0x003E
#define DDS_TW1_REG         0x003F
#define STOP_ADDR_REG       0x005E
#define SRAM_LOW_ADDR       0x6000
#define SRAM_HIGH_ADDR      0x6FFF
//#########################     COMMANDS #########################
#define PAT_WRITE           0x0004
#define WAV_CONFIG_RAM      0x0030
#define PAT_RUN             0x0001
#define TUNING_WORD_L       0x0000
#define TUNING_WORD_H       0x4000
#define DDS_STOP_ADDR       0x0050
#define DACAGAIN            0x4000
#define DACDGAIN            0x4000
#define START_DELAY         0x0000


void write_lookup();
uint16_t write_register(uint16_t reg, uint16_t value);

const int SPICS = 10;
const int SPIMISO = 12;
const int SPIMOSI = 11;
const int SPISCK = 13;

uint16_t adreg = 0; 
uint16_t adval = 0;
uint16_t answer = 0;


void setup() {
  Serial.begin(115200);
  digitalWrite(SPICS, HIGH);
  // start the SPI library:
  SPI.begin();
  // reduce speed
  SPI.setClockDivider(SPI_CLOCK_DIV8); 
  // initalize the  data ready and chip select pins:
  pinMode(SPIMISO, INPUT);
  pinMode(SPICS, OUTPUT);
  pinMode(SPIMOSI, OUTPUT);
  pinMode(SPISCK, OUTPUT);

  delay(100);
  write_lookup();  
}
void loop() {
  //Wait for command
  while(Serial.available() < 4);
  
  adreg = Serial.read() <<8;
  adreg += Serial.read();
  adval = Serial.read() << 8;
  adval += Serial.read();
  answer = write_register(adreg,adval);
  Serial.write(answer>>8);
  Serial.write(answer);

}

void write_lookup()
{
    write_register(PAT_STATUS_REG,PAT_WRITE);
    for( int i = 0; i <= 5 ; i++)
    {
      write_register(SRAM_LOW_ADDR+i,ramvalues[i]);
    }    
    
    // Select DDS Output / Wave from RAM
    write_register(WAV_CONFIG_REG,WAV_CONFIG_RAM);
    // Set stop address at 6 values
    write_register(STOP_ADDR_REG,DDS_STOP_ADDR);
    // Set tuning word to 0x4000000
    write_register(DDS_TW32_REG,TUNING_WORD_H);
    // No Start Delay
    write_register(PAT_DELAY_REG,START_DELAY);
    // Set analog gain
    write_register(DAC_AGAIN_REG,DACAGAIN);
    // Set digital gain
    write_register(DAC_DGAIN_REG,DACDGAIN);
    // Update Registers
    write_register(RAM_UPDATE_REG,0x0001);
    // Start pattern generation
    write_register(PAT_STATUS_REG,PAT_RUN);
}


uint16_t write_register(uint16_t reg, uint16_t value)
{   uint16_t answer;
    digitalWrite(SPICS,LOW);
    SPI.transfer16(reg);
    answer = SPI.transfer16(value);
    digitalWrite(SPICS,HIGH);
    return answer;
}

[Christoph db1uq K. (christoph_kessler)]

Wenn ich das Datenblatt im kurzen Überflug richtig verstanden habe, kann 
man einen Sinus unabhängig vom SRAM erzeugen, dazu muss noch irgendwo 
ein Sinus-ROM drinstecken. Mit dem "Wahlschalter" in der Mitte des 
Blockschaltbilds schaltet man zwischen Sinus, Arbitrary (aus dem RAM) 
oder Sägezahn um.

"Die Kommunikation mit dem Chip klappt einwandfrei" wie äußert sich das? 
Ich hatte beim ersten Ansteuern eines DDS erst mal garkeine Reaktion, 
der schluckte alle Daten, aber nichts kam heraus. Mein erster Erfolg 
war, dass ich den Taktoszillatorausgang einschalten konnte (es lebt...), 
ab da war es relativ einfach.

[Marcel D. (diablokiller999)]

Christoph db1uq K. schrieb:
> Mit dem "Wahlschalter" in der Mitte des
> Blockschaltbilds schaltet man zwischen Sinus, Arbitrary (aus dem RAM)
> oder Sägezahn um.
Mit dem Command

write_register(WAV_CONFIG_REG,WAV_CONFIG_RAM);

setze ich den Schalter auf Arbitrary (Register 0x27).

> "Die Kommunikation mit dem Chip klappt einwandfrei" wie äußert sich das?
Ich kann die per SPI geschriebenen Werte auch wieder auslesen bzw. die 
Übernahme der Schattenregister

write_register(RAM_UPDATE_REG,0x0001);

triggern.
Leider sieht mir meine Ausgabe weder nach einem Sinus aus, noch hört er 
auf das eingestellte Tuning Word.

[Axel S. (a-za-z0-9)]

Marcel D. schrieb:

> Mit dem Command
>

write_register(WAV_CONFIG_REG,WAV_CONFIG_RAM);

> setze ich den Schalter auf Arbitrary (Register 0x27).

Aha. Und warum machst du das? Warum verwendest du nicht die 
Sinus-Tabelle aus dem ROM? Oder hast du einen Sinus ins RAM geladen?

> Leider sieht mir meine Ausgabe weder nach einem Sinus aus, noch hört er
> auf das eingestellte Tuning Word.

Sondern? Warum muß man dir eigentlich jedes Wort aus der Nase ziehen? 
Eine sinnvolle Problembeschreibung würde enthalten:

1. was du erreichen willst
2. was du genau dazu tust
3. was du statt dessen erhältst

Punkt 3. ist nach wie vor leer

[Marcel D. (diablokiller999)]

Axel S. schrieb:
> Aha. Und warum machst du das? Warum verwendest du nicht die
> Sinus-Tabelle aus dem ROM? Oder hast du einen Sinus ins RAM geladen?

Weil ich mit einer angepassten LUT und Takt einen genaueren Takt/Teiler 
hinbekomme und so einen saubereren Sinus erhalte.


> Eine sinnvolle Problembeschreibung würde enthalten:
>
> 1. was du erreichen willst
Einen Sinus mit unterschiedlichen Frequenzen zwischen 10 und 30MHz so 
sauber wie möglich erzeugen. Das mitgelieferte LabView Programm liefert 
mit der internen ROM-DDS ein unsauberes Signal.
> 2. was du genau dazu tust
Einen Sinus mit 6 Werten in den RAM laden, die DDS über diese 6 Werte 
mit 180MHz iterieren lassen um einen 1/6 Teiler zu erhalten der mir 
einen 30MHz Sinus erzeugen sollte.
> 3. was du statt dessen erhältst
Siehe Bild

[Achim S. (Gast)]

Ich habe das Datenblatt nicht in Gänze durchgelesen, aber als möglicher 
Hinweis: die Daten aus dem RAM scheinen laut Schemazeichnung ja mit 
einer anderen Waveform multipliziert zu werden (mit einer Konstanten 
oder mit Sägezahn oder mit DDS-Sinus). Mit deinem Wave Config Wert von 
0x30 multiplizierst du den Sinus aus dem RAM mit dem Sinus aus der DDS.

Um deinen selbst erzeugten SRAM-Sinus am Ausgang zu sehen würde ich 
erwarten, dass du ihn eher mit einem Constant Value multiplizieren 
musst. Also Wave Config auf 00 und DAC CST auf einen sinnvollen 
konstanten Wert.

Bei diesem recht komplexen Chip gibt es natürlich noch jede Menge 
weiterer Fallstricke, über die man stolpern kann.

Marcel D. schrieb:
> Einen Sinus mit unterschiedlichen Frequenzen zwischen 10 und 30MHz so
> sauber wie möglich erzeugen. Das mitgelieferte LabView Programm liefert
> mit der internen ROM-DDS ein unsauberes Signal.

Eine Sinuskurve mit nur 6 Stützstellen sieht nie besonders sauber aus. 
Wie gut sie ist, hängt primär von den Analogen Filtern hinter dem DAC 
ab. Ich glaube ehrlich gesagt nicht, dass du mit einer "angepassten LUT" 
bessere Kurvenformen hinkriegen kannst als mit der Sinus-LUT, die fest 
im DDS-ROM gespeichert ist.

[Egon D. (Gast)]

Achim S. schrieb:

> Eine Sinuskurve mit nur 6 Stützstellen sieht nie
> besonders sauber aus. Wie gut sie ist, hängt primär
> von den Analogen Filtern hinter dem DAC ab.

"Welches Filter???"

SCNR

[Achim S. (Gast)]

Ach ja, noch ein Punkt, der mir grade im Supermarkt an der Kasse noch 
einfiel: deine Zahlenwerte fürs RAM passen auch nicht zu einem Sinus. 
Der DAC und das SRAM haben 14 Bit. Der Wert 16384 (= 0x4000) ist 15 Bit 
lang und wird als 0 gespeichert.

8192 passt zwar ins SRAM, ich habe aber beim Drüberschauen nicht 
rausgekriegt, ob es als unipolare Binärzahl interpretiert wird (dann 
wäre es gerade der Mittelpunkt des DAC-Bereichs, wie von dir eigentlich 
gewünscht) oder als Zweierkomplementzahl (dann entspräche 8192=0x2000 
der größten negativen Zahl, also nicht das, was du eigentlich willst)

[Achim S. (Gast)]

und gleich noch eins hinterher: du behandelst das Frequency Tuning Word 
als wäre es 32 Bit breit. Tatsächlich hat es nur 24 Bit. Dein Wert 
0x40000000 wird also ebenfalls als 0 interpretiert.

[Marcel D. (diablokiller999)]

Achim S. schrieb:
> Ich habe das Datenblatt nicht in Gänze durchgelesen, aber als möglicher
> Hinweis: die Daten aus dem RAM scheinen laut Schemazeichnung ja mit
> einer anderen Waveform multipliziert zu werden (mit einer Konstanten
> oder mit Sägezahn oder mit DDS-Sinus). Mit deinem Wave Config Wert von
> 0x30 multiplizierst du den Sinus aus dem RAM mit dem Sinus aus der DDS.
>
> Um deinen selbst erzeugten SRAM-Sinus am Ausgang zu sehen würde ich
> erwarten, dass du ihn eher mit einem Constant Value multiplizieren
> musst. Also Wave Config auf 00 und DAC CST auf einen sinnvollen
> konstanten Wert.
Habe die WaveConfig auf 0x0000 gestellt und DAC_CST auf 0x2000, geändert 
hat sich eigentlich nichts soweit ich sehen kann. (Bild)

> Eine Sinuskurve mit nur 6 Stützstellen sieht nie besonders sauber aus.
> Wie gut sie ist, hängt primär von den Analogen Filtern hinter dem DAC
> ab. Ich glaube ehrlich gesagt nicht, dass du mit einer "angepassten LUT"
> bessere Kurvenformen hinkriegen kannst als mit der Sinus-LUT, die fest
> im DDS-ROM gespeichert ist.
Das habe ich soweit nicht getestet, unser Layouter hat den Chip vorher 
auf dem EvalBoard mit einem LabView Programm betrieben, das von Analog 
Devices bereitgestellt wurde und den Output vermessen. Seine Aussage 
war, dass die 6 Punkt LUT im RAM ihm bessere Werte gab als das über die 
interne Routine laufen zu lassen.

Achim S. schrieb:
> Ach ja, noch ein Punkt, der mir grade im Supermarkt an der Kasse noch
> einfiel: deine Zahlenwerte fürs RAM passen auch nicht zu einem Sinus.
> Der DAC und das SRAM haben 14 Bit. Der Wert 16384 (= 0x4000) ist 15 Bit
> lang und wird als 0 gespeichert.
Anders als im Datenblatt, sind die Werte für den RAM 15 - 2 und nicht 13 
- 0. Es werden also nur die unteren Bits abgeschnitten. Das scheint aber 
nicht der einzige Fehler in dem Datenblatt zu sein, den ich schon 
ausfindig gemacht habe.
> 8192 passt zwar ins SRAM, ich habe aber beim Drüberschauen nicht
> rausgekriegt, ob es als unipolare Binärzahl interpretiert wird (dann
> wäre es gerade der Mittelpunkt des DAC-Bereichs, wie von dir eigentlich
> gewünscht) oder als Zweierkomplementzahl (dann entspräche 8192=0x2000
> der größten negativen Zahl, also nicht das, was du eigentlich willst)
Ob die signed oder unsigned sind, ist auch für mich noch immer ein 
großes Mysterium. Habe jetzt mal die LUT wie folgt ersetzt

uint16_t ramvalues[LUTSIZE] = { 0,0x7FFC,0x7FFC,0,0x8000,0x8000};

und bekomme eine ähnliche Form (siehe Bild).

> du behandelst das Frequency Tuning Word
> als wäre es 32 Bit breit. Tatsächlich hat es nur 24 Bit. Dein Wert
> 0x40000000 wird also ebenfalls als 0 interpretiert.
Das Tuningword besteht aus High und Low, das High ist 16Bit und das Low 
8 Bit breit (15 - 8), die 0x40000000 werden also zu 0x400000. Aber das 
Tuning Word hat gar keinen Einfluss auf die Kurve im Bild, ich kann das 
High Word auch auf 0 setzen und bekomme die selbe Frequenz angezeigt.

[Achim S. (Gast)]

Marcel D. schrieb:
> Seine Aussage
> war, dass die 6 Punkt LUT im RAM ihm bessere Werte gab als das über die
> interne Routine laufen zu lassen.

Demnach muss er ja schon eine funktionierende Konfiguration gehabt haben 
- dann würde ich mich an der orientieren.

Marcel D. schrieb:
> geändert
> hat sich eigentlich nichts soweit ich sehen kann. (Bild)

Na ja, ein Faktor 2 in der Amplitude hat sich ergeben. Aber tastsächlich 
weiter kein schöner Sinus.

Marcel D. schrieb:
> und bekomme die selbe Frequenz angezeigt.

Für mich ist da keine ernstzunehmende Frequenz sondern ein einzelner 
negativer Puls (Für einen Einschalt-Glitch des DACs ist es wohl zu 
kräftig). Das Nachschwingen mit ~50MHz ist für mich eher ein 
Messartefakt (oder durch die evtl. vorhandene Filterschaltung bedingt) 
als ein Ergebnis der Signalerzeugung.

[Marcel D. (diablokiller999)]

Achim S. schrieb:
> Demnach muss er ja schon eine funktionierende Konfiguration gehabt haben
> - dann würde ich mich an der orientieren.
Habe nun einen Sinus mit der internen DDS generieren können:

#include <SPI.h>

//#########################     REGISTERS     #########################
#define SPICONFIG_REG               0x0000
#define POWERCONFIG_REG             0x0001
#define CLKCONFIG_REG               0x0002
#define REFRESISTOR_REG             0x0003
#define DAC_AGAIN_REG               0x0007
#define DAC_RANGE_REG               0x0008
#define DAC_RESET_REG               0x000C
#define CAL_CONFIG_REG              0x000D
#define COMP_OFFSET_REG             0x000E
#define RAM_UPDATE_REG              0x001D
#define PAT_STATUS_REG              0x001E
#define PAT_TYPE_REG                0x001F
#define PAT_DELAY_REG               0x0020
#define DAC_DOFFSET_REG             0x0025
#define WAV_CONFIG_REG              0x0027
#define PAT_TIMEBASE_REG            0x0028
#define PAT_PERIOD_REG              0x0029
#define DAC_PAT_REG                 0x002B
#define DOUT_START_REG              0x002C
#define DOUT_CONFIG_REG             0x002D
#define DAC_CST_REG                 0x0031
#define DAC_DGAIN_REG               0x0035
#define SAW_CONFIG_REG              0x0037
#define DDS_TW32_REG                0x003E
#define DDS_TW1_REG                 0x003F
#define DDS_PHASE_OFFSET_REG        0x0043
#define TRIG_TW_SEL_REG             0x0044
#define DDS_CONFIG_REG              0x0045
#define TW_RAM_CONFIG_REG           0x0047
#define START_DLY_REG               0x005C
#define START_ADDR_REG              0x005D
#define STOP_ADDR_REG               0x005E
#define DDS_CYC_REG                 0x005F
#define CFG_ERROR_REG               0x0060
#define SRAM_LOW_ADDR               0x6000
#define SRAM_HIGH_ADDR              0x6FFF
//#########################     COMMANDS     #########################
#define PAT_WRITE                   0x0004
#define PAT_RUN                     0x0001

void write_lookup();
uint16_t write_register(uint16_t reg, uint16_t value);

const int SPICS = 10;
const int SPIMISO = 12;
const int SPIMOSI = 11;
const int SPISCK = 13;

uint16_t adreg = 0; 
uint16_t adval = 0;
uint16_t answer = 0;


void setup() {
  Serial.begin(115200);
  digitalWrite(SPICS, HIGH);
  // start the SPI library:
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV8); //Geschwindigkeit verlangsamen
  // initalize the  data ready and chip select pins:
  pinMode(SPIMISO, INPUT);
  pinMode(SPICS, OUTPUT);
  pinMode(SPIMOSI, OUTPUT);
  pinMode(SPISCK, OUTPUT);

  delay(100);
  write_lookup();
  // give the sensor time to set up:
  
}
void loop() {
  while(Serial.available() < 4);
  
  adreg = Serial.read() <<8;
  adreg += Serial.read();
  adval = Serial.read() << 8;
  adval += Serial.read();
  answer = write_register(adreg,adval);
  Serial.write(answer>>8);
  Serial.write(answer);

}

void write_lookup()
{
    write_register(PAT_STATUS_REG          ,PAT_WRITE);
    write_register(SPICONFIG_REG           ,0x0000);
    write_register(POWERCONFIG_REG         ,0x0e00);
    write_register(CLKCONFIG_REG           ,0x0000);
    write_register(REFRESISTOR_REG         ,0x0000);
    write_register(DAC_AGAIN_REG           ,0x4000);
    write_register(DAC_RANGE_REG           ,0x0000);
    write_register(DAC_RESET_REG           ,0x1f00);
    write_register(CAL_CONFIG_REG          ,0x0000);
    write_register(COMP_OFFSET_REG         ,0x0000);
    write_register(PAT_STATUS_REG          ,0x0000);
    write_register(PAT_TYPE_REG            ,0x0000);
    write_register(PAT_DELAY_REG           ,0x000E);
    write_register(DAC_DOFFSET_REG         ,0x0000);
    write_register(WAV_CONFIG_REG          ,0x1232);
    write_register(PAT_TIMEBASE_REG        ,0x0111);
    write_register(PAT_PERIOD_REG          ,0xffff);
    write_register(DAC_PAT_REG             ,0x0101);
    write_register(DOUT_START_REG          ,0x0003);
    write_register(DOUT_CONFIG_REG         ,0x0000);
    write_register(DAC_CST_REG             ,0x0000);
    write_register(DAC_DGAIN_REG           ,0x4000);
    write_register(SAW_CONFIG_REG          ,0x7E00);
    write_register(DDS_TW32_REG            ,0x0750);
    write_register(DDS_TW1_REG             ,0x7500);
    write_register(DDS_PHASE_OFFSET_REG    ,0x0000);
    write_register(TRIG_TW_SEL_REG         ,0x0002);
    write_register(DDS_CONFIG_REG          ,0x0000);
    write_register(TW_RAM_CONFIG_REG       ,0x0000);
    write_register(START_DLY_REG           ,0x0fa0);
    write_register(START_ADDR_REG          ,0x0000);
    write_register(STOP_ADDR_REG           ,0x0000);
    write_register(DDS_CYC_REG             ,0x7FFF);
    // Update all registers
    write_register(RAM_UPDATE_REG          ,0x0001);
    // Set RUN bit to start wave generation
    write_register(PAT_STATUS_REG          ,PAT_RUN);
}


uint16_t write_register(uint16_t reg, uint16_t value)
{   uint16_t answer;
    digitalWrite(SPICS,LOW);
    SPI.transfer16(reg);
    answer = SPI.transfer16(value);
    digitalWrite(SPICS,HIGH);
    return answer;
}

Trotzdem bin ich grad noch am grübeln, was ich in meiner Implementierung 
bis jetzt übersehen habe.

[Wolfgang (Gast)]

Marcel D. schrieb:
> Weil ich mit einer angepassten LUT und Takt einen genaueren Takt/Teiler
> hinbekomme und so einen saubereren Sinus erhalte.

Bei 180MSPS wird ein sauberer 30MHz Sinus ein Wunschtraum bleiben. Da 
bleiben dir gerade mal 6 Punkte, um eine Sinusperiode zu approximieren.

[Egon D. (Gast)]

Wolfgang schrieb:

> Marcel D. schrieb:
>> Weil ich mit einer angepassten LUT und Takt einen
>> genaueren Takt/Teiler hinbekomme und so einen
>> saubereren Sinus erhalte.
>
> Bei 180MSPS wird ein sauberer 30MHz Sinus ein
> Wunschtraum bleiben.

Klar... seit die EU flächendeckend den Einsatz von
Tiefpässen verboten hat und Ingenieure, die etwas
von Filterentwurf verstehen, überall vom Tode bedroht
sind, kann man praktisch keine sauberen Sinussignale
mehr erzeugen...