DDS.c

//includes

//////////

#include "avr/io.h"

#include <util/delay.h>

//defines

/////////

#define DDS_MCLK     24000000    /* DDS Clock */

#define DDS_CONSTANT   0x10000000   /* 2^28 */

#define DDS_DDR      DDRD    /* data direction reg*/

#define DDS_PORT    PORTD

#define DDS_SDATA    PIN0

#define DDS_SCLCK    PIN1

#define DDS_FSYNC    PIN2

#define A       PINA1 // Schalter A im Drehgeber 

#define B       PINA0 // Schalter B im Drehgeber

#define Geber   PINA  // Drehgeber Port

//predeclarations

void DDS_WriteWord(int16_t wValue);

void ToggleDDSPIN(int nBit);

void RotaryBlink(void);

void DebounceKey(int nPort, int nPin);

void SetFrequency(int32_t dwFreq);

//calculate codeword:

//CW = (Freq / DDS_MCLK) * DDS_CONSTANT

//for 5 mhz with 25 MHz clock:  0x33333333

int main(void)

{

  //variables

  ///////////

  int32_t dwFreq     = 1000000;

  int    richtung    = 0;

  char   alter_status = 0;

  char  step = 0;

    char    neuer_status;

  //port init

  DDS_PORT = 0x0;

  DDS_DDR  = 0xFF;  //all output

  DDRA   = 0x0;    //all input

  PORTA   = 0xFF;  //pull up

  DDRC   = 0xFF;  //all output

  PORTC   = 0x00;  //no pull up

  //wait before we init 

  //the ad9833

  _delay_ms(1000);

  SetFrequency(dwFreq);

  RotaryBlink();

  RotaryBlink();

  while(1)

  {

      neuer_status = Geber & (_BV(A) | _BV(B));     // Änderung einlesen

      if ((neuer_status ^ step)==(_BV(A) | _BV(B)))

       {

        if ((neuer_status ^ alter_status) ==_BV(A))

      {

            richtung +=1; // Es war nach rechts

        RotaryBlink();

        dwFreq += 1000;

        SetFrequency(dwFreq);

      }

         else

      {

            richtung -=1; // Es war nach links

        RotaryBlink();

        dwFreq -= 1000;

        SetFrequency(dwFreq);

      }

      step = neuer_status;

      }

      alter_status = neuer_status;

  /*

    if((PINA & 0x2) == 0x0)

    {

      RotaryBlink();

      dwFreq += 10000;

      SetFrequency(dwFreq);

      DebounceKey(PINA, 0x2);

    };

    if((PINA & 0x4) == 0x0)

    {

      RotaryBlink();

      RotaryBlink();

      dwFreq -= 10000;

      SetFrequency(dwFreq);

      DebounceKey(PINA, 0x4);

    };

  */

  }

  return 0;

}

void SetFrequency(int32_t dwFreq)

{

  //variables

  ///////////

  float     fVal    = ((float)dwFreq / (float)DDS_MCLK);

  int32_t   dwCodeWord   = fVal * DDS_CONSTANT;

  int16_t   wWord       = 0x0;

  //send the control byte

  wWord = 0x2000;                //0010 0000 0000 0000

  DDS_WriteWord(wWord);

  _delay_ms(1);

  //send lsb

  wWord  = (dwCodeWord & 0x00003FFF);        //lsb

  wWord |= 0x4000;

  DDS_WriteWord(wWord);

  _delay_ms(1);

  //send msb

  wWord  = (dwCodeWord & 0x0FFFC000) >> 14;   //msb  

  wWord |= 0x4000;                //set bit 15

  DDS_WriteWord(wWord);    

}

/*

AD9833 to 80C51/80L51 Interface

Figure 12 shows the serial interface between the AD9833 and the

80C51/80L51 microcontroller. The microcontroller is operated

in mode “0” so that TXD of the 80C51/80L51 drives SCLK of

the AD9833, while RXD drives the serial data line SDATA. The

FSYNC signal is again derived from a bit programmable pin on

the port (P3.3 being used in the diagram). When data is to be

transmitted to the AD9833, P3.3 is taken low. The 80C51/80L51

transmits data in 8-bit bytes, thus only eight falling SCLK edges

occur in each cycle. To load the remaining 8 bits to the AD9833,

P3.3 is held low after the first 8 bits have been transmitted, and

a second write operation is initiated to transmit the second byte of

data. P3.3 is taken high following the completion of the second

write operation. SCLK should idle high between the two write

operations. The 80C51/80L51 outputs the serial data in a format

that has the LSB first. The AD9833 accepts the MSB first

(the 4 MSBs being the control information, the next 4 bits being

the address, while the 8 LSBs contain the data when writing to a

destination register). Therefore, the transmit routine of the

80C51/80L51 must take this into account and rearrange the bits

so that the MSB is output first.

6 SDATA Serial Data Input. The 16-bit serial data-word is applied to this input.

7 SCLK Serial Clock Input. Data is clocked into the AD9833 on each falling SCLK edge.

8 FSYNC Active Low Control Input. This is the frame synchronization signal for the

input data. When FSYNC is taken low, the

new word is being loaded into the device.

http://www.roboternetz.de/wissen/index.php/Portexpander_am_AVR#Ohne_SPI-Hardware

*/

void DDS_WriteWord(int16_t wValue)

{

  //variables

  ///////////

  int     nBit = 0;

  int     n   = 0;  

  uint16_t   wVal = wValue;

  //init

  DDS_PORT = DDS_PORT & ~(1 << DDS_SDATA);

  DDS_PORT = DDS_PORT | (1 << DDS_SCLCK);        //set

  DDS_PORT = DDS_PORT | (1 << DDS_FSYNC);        //set

  _delay_ms(1);

  DDS_PORT &= ~(1 << DDS_FSYNC);        //remove

  _delay_ms(1);

  for(n = 0; n < 16; ++n)

  {

    nBit = (wVal & 0x8000) >> 15;

    wVal = wVal << 1;    //shift

    ToggleDDSPIN(nBit);

  };  

  DDS_PORT = DDS_PORT | (1 << DDS_FSYNC);        //set

  _delay_ms(1);

}

void ToggleDDSPIN(int nBit)

{

  if(nBit == 1)

  {

    DDS_PORT = DDS_PORT | (1 << DDS_SDATA);    //set      

  }

  _delay_ms(1);

  DDS_PORT = DDS_PORT & ~(1 << DDS_SCLCK);     //remove

  _delay_ms(1);

  DDS_PORT  = DDS_PORT | (1 << DDS_SCLCK);    //set

  _delay_ms(1);

  DDS_PORT = DDS_PORT & ~(1 << DDS_SDATA);     //remove

}

void RotaryBlink(void)

{

  PORTC = (1 << PIN0);

  _delay_ms(10);

  PORTC &= ~(1 << PIN0);

  _delay_ms(10);

}

void DebounceKey(int nPort, int nPin)

{

  while((nPort & nPin) == 0)

  {

    //do nothing

    _delay_ms(1);

  }

}