AD9850-Modul mit AtMega steuern

[KLS (Gast)]

Hallo,


ich habe mir neulich ein AD9850-Modul wie im Anhang zugelegt.

Es soll als Rechteckgenerator verwendet und mit einem M88 o.ä. 
angesteuert werden (plus LC-Display für die Frequenz-Anzeige).


Weiß jemand, ob es hierzu schon irgendwo ein fertiges Projekt gibt?

Habe beim Googeln zwar einige Treffer erhalten, aber leider ohne 
verwertbaren Inhalt.

[KLS (Gast)]

Wenn niemand ein entsprechendes Projekt kennt, werde ich mich wohl 
selber ans Proggen machen müssen...

[Andreas B. (andreasb)]

Hallo

ggf. bringt dich das ein wenig weiter: 
http://alhin.de/arduino/index.php?n=7
Ist aber alles andere als ein fertiges Projekt.

Du darfst aber auch der erste sein der dann ein fertiges Projekt in die 
Codesammlung stellt;-)



mfg Andreas

[KLS (Gast)]

Danke für den Link!

Zu Arduino habe ich das hier gefunden:
http://de.wikipedia.org/wiki/Arduino-Plattform

Will mich da aber nicht weiter einarbeiten und das ganze lieber direkt 
mit dem AVR-Studio umsetzen.

In dem EF_AD8950.cpp-File (s. Anhang) findet man unter anderem folgenden 
Programminhalt:

void EF_AD9850::wr_serial(unsigned char w0,double frequence)
  {
    unsigned char i,w;
    long int y;
    double x;
    
    //Calculate the frequency of the HEX value
    x=4294967295/125;//Suitable for 125M Crystal 
    frequence=frequence/1000000;
    frequence=frequence*x;
    y=frequence;

Momentan überlege ich, wo die Variable frequence ihren Wert zugewiesen 
bekommt...

Ich vermute, vor der Zeile

frequence=frequence/1000000;

sollte "von Hand" die Frequenz in [Hz] zugewiesen werden, z.B. für 
10MHz:

frequence=10000000; //für 10MHz, in der Praxis natürlich als Variable ;)

!!?

y wäre dann der Wert, der an den AD9850 übertragen wird, um die 
vorgegebene Frequenz zu generieren...

[B e r n d W. (smiley46)]

Im Prinzip so:

void AD9850_wr_serial(unsigned char w0, double freq)
{
  unsigned char i, w;
  long y;
  double x;
    
  // 4294967295 = 0xFFFFFFFF
  // x = 0xFFFFFFFF/125;    // 125 MHz Crystal 
  x = (double)34359738.36;  // 
  freq /= 1000000L;         // das MHz kürzt sich weg
  y = freq * x;
  ...
}

//Aufruf:
void main()
{
  P0 = 0x00;
  P1 = 0x00;
  P2 = 0x00;
  P3 = 0x00;

  ad9850_reset_serial();
  ad9850_wr_serial(0x00, 1e7);

  while(1) {
    // Do something else
  }
}

> wo die Variable frequence ihren Wert zugewiesen
Durch den Aufruf aus main.

Aber IMHO werden double im AVR-Studio als float behandelt. Also 8Bit 
Exponent, Vorzeichen und 23Bit Mantisse. Deshalb gehen hier relevante 
Stellen verloren. So wie ich das verstanden habe, hat das Uwe mit dem 
AD9834 etwas anders umgesetzt, also mit reduzierter Auflösung, aber 
immer noch gut genug:

Beitrag "Re: Ladderfilter berechnen und bauen"

[B e r n d W. (smiley46)]

Es gibt hier schon einiges auch mit ATmega:
http://www.mikrocontroller.net/articles/DDS

[fiffi (Gast)]

steht det nicht im Datenblatt, wie die Frequenz berechnet wird?

[B e r n d W. (smiley46)]

> steht det nicht im Datenblatt, wie die Frequenz berechnet wird?
Schon, aber wenn einem double nicht zur Verfügung steht, fangen die 
Klimmzüge an. Wieso soll man jedesmal das Rad neu erfinden, wenn das 
schon mal jemand gemacht hat.

[Jörg W. (dl8dtl) (Moderator)]

Ich hab's mit 64-bit-Integern gelöst.  Langsam, aber genau. ;-)

#define MASTERCLOCK 99999200ull  /* gemessen ;) */


static
uint32_t val_to_dds(uint32_t v)
{
  uint64_t x;

  x = v * 0x100000000ull;
  x /= MASTERCLOCK;

  return x;
}

static void
fq_ud(uint32_t fq)
{
  union
  {
    uint32_t l;
    uint8_t b[5];
  }
  u;
  uint8_t i;

  u.l = fq;
  /*
   * W32..W39: no phase angle, no power-down, control bits = 0
   */
  u.b[4] = 0;

  for (i = 0; i < 5; i++)
    {
      SPDR = u.b[i];
      while ((SPSR & _BV(SPIF)) == 0)
        /* wait */;
    }

  /* Update now. */
  PORTC |= _BV(1);
  PORTC &= ~_BV(1);
}

//...
int
main(void)
{
  uint32_t ddsval = 1000000ul;
  //...

    fq_ud(val_to_dds(ddsval));
  //...
}

[Uwe (de0508)]

Hallo,

B e r n d W. schrieb:
> Aber IMHO werden double im AVR-Studio als float behandelt. Also 8Bit
> Exponent, Vorzeichen und 23Bit Mantisse. Deshalb gehen hier relevante
> Stellen verloren. So wie ich das verstanden habe, hat das Uwe mit dem
> AD9834 etwas anders umgesetzt, also mit reduzierter Auflösung, aber
> immer noch gut genug:

ich muss anmerken, die Berechnung läuft nur mit 32 Bit ab und das FTW 
wird über einen Kettenbruch berechnet. Was aber fest ist, ist die DDS 
Taktfrequenz von 75MHz!
Nach zusammenfassen der Terme erhält man diese einfache Berechnung.

http://www.qrpforum.de/index.php?page=Thread&threadID=6976&highlight=ad9834

In meinem Beispiel ist die Frequenz-Auflösung ist nicht reduziert.
Das FTW kann sich um 1Bit vom exakt gerechneten unterscheiden, ist aber 
vernachlässigbar.

[KLS (Gast)]

Hallo,

Danke für eure Postings.

Habe heute endlich das LCD für die Frequenzanzeige am AVR zum Laufen 
gebracht und schon mal ein kleines Menü zur Bedienung erstellt.


Gibt es eigentlich keinen einfachen linearen Zusammenhang wie

f = bw / c

wobei

f = Frequenz in Hz
bw= 32-bit-Wort
c = 687,12  (oder ähnlicher Faktor)

?

Im Datenblatt finde ich nichts in der Richtung (jedenfalls nichts 
Prägnantes).

@ Bernd:
wenn man uint32 Variablen verwendet, umschifft man das Problem mit 
double und float... (hoffe ich jedenfalls ;-))

[B e r n d W. (smiley46)]

Hallo KLS

> Gibt es eigentlich keinen einfachen linearen Zusammenhang?
Natürlich ist der Zusammenhang linear. Aber bei einer 32 Bit Variablen 
gibt es ohne weitere Maßnahmen bei der ersten Multiplikation einen 
Überlauf. Deshalb würde ich Jörgs Variante vorziehen.

#define MASTERCLOCK 125000000ULL

static void
AD9850_wr_serial(uint32_t freq)
{
  union {
    uint32_t l;
    uint8_t b[5];
  }u;
  uint8_t i;

  u.l = (uint64_t)freq * 0x100000000ULL / MASTERCLOCK;

  // W32..W39: no phase angle
  //           no power-down
  //           control bits = 0
  u.b[4] = 0;

  // send 5 Bytes per SPI
  for (i = 0; i < 5; i++) {
    SPDR = u.b[i];     // send 1 byte
    while ((SPSR & _BV(SPIF)) == 0) {
      // wait while busy
    }
  }

  // Update now.
  PORTC |= _BV(1);     // set PORTC.Bit1
  PORTC &= ~_BV(1);    // res PORTC.Bit1
}

void 
main(void)
{
  uint32_t ddsval = 1000000ul;
  AD9850_wr_serial(ddsval);   // 1MHz

  while(1) {
    // Do something else
  }
}

[richie (Gast)]

Jörg Wunsch schrieb:
> 99999200ull

> 125000000ULL

> 1000000ul

Welche Bedeutung haben die Buchstaben hinter den Zahlen?

[B e r n d W. (smiley46)]

> Welche Bedeutung haben die Buchstaben hinter den Zahlen?
Die bestimmen, in welchem Zahlenformat, die Konstante im 
Programmspeicher angelegt wird:

L = long = int32_t
UL = unsigned long = uint32_t
ULL = unsigned long long = uint64_t
usw.

[richie (Gast)]

B e r n d W. schrieb:
> L = long = int32_t
> UL = unsigned long = uint32_t
> ULL = unsigned long long = uint64_t
> usw.

braucht man einen speziellen Header, damit die Schreibweise 
funktioniert?

Wieso hat dieses IC-Ding keine anschlüsse für "inc frequenz" oder "dec 
frequenz", dann könnte man es über eine Schleife steuern.

[Jörg W. (dl8dtl) (Moderator)]

richie schrieb:

> braucht man einen speziellen Header, damit die Schreibweise
> funktioniert?

Nein.  Ein C-Standard genügt. ;-)

Im Gegensatz zum Rest von C ist bei den Suffixen übrigens die Groß-
und Kleinschreibung egal.

> Wieso hat dieses IC-Ding keine anschlüsse für "inc frequenz" oder "dec
> frequenz", dann könnte man es über eine Schleife steuern.

Weil du dann morgen noch nicht fertig wärst mit dem QSY.

[Karl H. (kbuchegg)]

richie schrieb:
> B e r n d W. schrieb:
>> L = long = int32_t
>> UL = unsigned long = uint32_t
>> ULL = unsigned long long = uint64_t
>> usw.
>
> braucht man einen speziellen Header, damit die Schreibweise
> funktioniert?

Nein.

> Wieso hat dieses IC-Ding keine anschlüsse für "inc frequenz" oder "dec
> frequenz", dann könnte man es über eine Schleife steuern.

Schon mal nachgerechnet, wie lang das bei größeren Zahlen dauern würde?
Ausserdem hindert dich ja keiner daran, so was in Software zu machen.

[Uwe (de0508)]

richie Du brauchst ein C Buch !

Einige würden schreiben, Ende der ersten Klasse der "C" Programmierung.

Der AD9850 und der AD9851 sind so einfach zu steuern, man kann doch noch 
eine Software-Ebene einführen, die genau deine Anforderungen erfüllt.

Dem "C" Programmierer sind doch kaum Grenzen gegeben !

Im Datenblatt und den Application Notes ist die Programmierung sehr 
ausführlich dargestellt.

PeDa, Peter hat einen Beitrag zu schnellen 64-Bit Routinen verfasst, der 
ist lesenswert:

- 
http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=113673

Ich habe mir diese Idee auch mal angesehen:

- Beitrag "Re: Rechnen mit AVR"

Aus alle dem ist eine, für mich, schnelle 64-Bit Multiplikation und 
Division 'abgefallen'.


richie schrieb:
> B e r n d W. schrieb:
>> L = long = int32_t
>> UL = unsigned long = uint32_t
>> ULL = unsigned long long = uint64_t
>> usw.
>
> braucht man einen speziellen Header, damit die Schreibweise
> funktioniert?
>
> Wieso hat dieses IC-Ding keine anschlüsse für "inc frequenz" oder "dec
> frequenz", dann könnte man es über eine Schleife steuern.

[richie (Gast)]

Karl Heinz Buchegger schrieb:
>> Wieso hat dieses IC-Ding keine anschlüsse für "inc frequenz" oder "dec
>> frequenz", dann könnte man es über eine Schleife steuern.
>
> Schon mal nachgerechnet, wie lang das bei größeren Zahlen dauern würde?
> Ausserdem hindert dich ja keiner daran, so was in Software zu machen.

hätte der Hersteller ja benutzerfreundlich in Hz-Schritten 
implementieren können.

Wenn man es als Software macht, dauert es wirklich lange! ;v)

[Uwe (de0508)]

richie schrieb:
> Wenn man es als Software macht, dauert es wirklich lange! ;v)

Nein, dann hast Du das "System" DDS nicht verstanden !

Hier läuft alles direkt und hat direkte Auswirkungen auf die Hardware 
(DDS).

Die nächste Ebene / Schnittstelle ist dann deine.

[richie (Gast)]

Jörg Wunsch schrieb:
> Im Gegensatz zum Rest von C ist bei den Suffixen übrigens die Groß-
> und Kleinschreibung egal.

wie werden Variablen mit Vorzeichen als Suffix abgekürzt?


> uint32_t ddsval = 1000000ul;

Ist das doppelt gemoppelt?

[Jörg W. (dl8dtl) (Moderator)]

richie schrieb:
> Jörg Wunsch schrieb:
>> Im Gegensatz zum Rest von C ist bei den Suffixen übrigens die Groß-
>> und Kleinschreibung egal.
>
> wie werden Variablen mit Vorzeichen als Suffix abgekürzt?

Bahnhof?

>> uint32_t ddsval = 1000000ul;
>
> Ist das doppelt gemoppelt?

Zur Hälfte.  Den Typ "long" würde die Konstante 10000000 bereits von
sich aus bekommen (statt "int"), aber erst durch die Zuweisung wird
daraus ein "unsigned long", implizit wäre sie als Dezimalkonstante
erst einmal vorzeichenbehaftet.

Wie Uwe schon schrieb, du brauchst ein C-Buch (und danach eins über
DDS).

[./. (Gast)]

LOL.
Wenn man die Klimmzüge hier sieht.
Mit 8 32 bit-Konstanten die man nur passend aufsummieren muß,
kann man jede Frequenz zwischen 1 Hz und 99999999 Hz einstellen.
Ganz ohne Gleitkomma und solches Teufelszeug.

Ihr solltet vielleicht mal auf Brain 1.0 upgraden.

[Jörg W. (dl8dtl) (Moderator)]

./. schrieb:
> Mit 8 32 bit-Konstanten

Schön.  Für jede neue Frequenz eine neue Firmware?

[Uwe (de0508)]

Hallo Jörg,

er meint, vorher einmal 8x FTW für 10MHz, 1MHz, 100kHz usw. zu berechnen 
und dann, wie beim Abzählen eines Geldbetrages, aufsummieren.

[./. (Gast)]

Uwe S. schrieb:
> aufsummieren

Endlich mal einer der mitdenkt.

[Jörg W. (dl8dtl) (Moderator)]

./. schrieb:
> Endlich mal einer der mitdenkt.

Gut, dass wir dich haben.  Keinen Namen, keinen Code, aber zumindest
den nötigen Durchblick.  Hilft bloß keinem was.

[KLS (Gast)]

So, ich habe jetzt einen Bresenham-Algo umgebaut für die 
Frequenzberechnung.
Das funktioniert ganz gut und kommt auch ohne komplizierte Berechnungen 
aus (und ich komme gleichzeitig mit meinen eher kleinen C-Kenntnissen 
aus ;-)).

Die ausgegebenen Frequenzen scheinen so weit zu stimmen (zumindest lt. 
rundfunksenderkalibriertem Weltempfänger).

Werde das aber noch eingehender prüfen, wenn ich wieder aus dem Urlaub 
zurück bin.
Dann auch mit Filter(n) vor dem Rechteck usw.

Derweilen vielen Dank an alle Poster und schöne Zeit!

[Uwe (de0508)]

Hallo KLS,

jetzt wäre es noch nett, wenn Du hier deinen Code mal einstellen 
könntest.

_

[Andreas B. (andreasb)]

Uwe S. schrieb:
> Hallo KLS,
>
> jetzt wäre es noch nett, wenn Du hier deinen Code mal einstellen
> könntest.
>
> _

Nachdem nun 14 Tage vergangen sind pushe ich das hier nochmals...

Ich wäre auch interessiert am Code...



mfg Andreas

[Andreas B. (andreasb)]

Dann eben nicht...

Habe nochmals gegoogelt, und nichts schlaues gefunden. Habe dann auf 
Basis des nicht schlauen Codes selbst etwas geschrieben...

Beispiel im Anhang. Es wird kein Double verwendet, zum Vergleich mit 
Double ist dieser Code ca. 1k kleiner.

Ich habe meine Rechnungen verifiziert, und ich weiss das diese nicht 
korrekt sind. Mein Oszilloskop zeigt aber "nur" 4 Nachkommastellen an 
bei 20MHz und diese haben sich im Vergleich zu Double nichts geändert.

Ich lads jetzt mal hier hoch, sobald ich dann weiss, dass das ganze 
läuft etc. werde ich den Code noch in der Codesammlung hochladen.

Wer den Code testet soll doch kurz ein Feedback hinterlassen obs passt 
oder nicht. Danke.


Der Code zum prüfen meiner Lösung (nicht für AVR!)

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main(void) {
  const uint64_t frequency = 4000000;

  uint64_t tmp1 = frequency;
  tmp1 <<= 32;
  tmp1 /= 125; // 125 MHz
  tmp1 /= 1000000;
  uint32_t sollResultat = (uint32_t) tmp1;

  uint32_t tmp = frequency;
  // Faktor: 34.359'738'368

  tmp = frequency * 35; //35
  tmp -= frequency / 10 * 6; //34.4
  tmp -= frequency / 100 * 4; //34.36
  tmp -= frequency / 10000 * 2; //34.359'8
  tmp -= frequency / 100000 * 6; //34.359'74
  tmp -= frequency / 1000000 * 2; //34.359'738

  uint32_t istResultat = tmp;

  if (istResultat == sollResultat) {
    printf("Stimmt!\n");
  } else {
    printf("Strimmt nicht! soll: %d; ist: %d\n", sollResultat, istResultat);
  }

  return EXIT_SUCCESS;
}

mfg Andreas

[Alex (Gast)]

Ist zwar schon etwas länger her, aber nur ein kleiner Hinweis an 
Andreas' code im Anhang. An der markierten Stelle hat er wohl vergessen, 
das erste Byte vom 32bit-Frequenzwort zum AD9850 zu übertragen:

void AD9850_write(...)
{
...
AD9850_writeByte(tmp);  <<<< Dieses erste Frequenzbyte fehlt in Andreas 
Code!
AD9850_writeByte(tmp >> 8);
AD9850_writeByte(tmp >> 16);
AD9850_writeByte(tmp >> 24);
AD9850_writeByte(w0);
...
}


Habe heute den ganzen Tag gebraucht, um den Fehler zu finden. Die 
Frequenz stimmte nicht mit der berechneten überein. Jetzt passt es 
wunderbar. Mein Dank geht an Andreas' und seine Vorarbeit.


Mfg Alex