Hi Shabaz,

I have re-written the sketch entirely. My understanding now is alot simpler than when I started 6 months ago - hopefully it is correct ?

It would appear all that is required is to get the ARDUINO to write data to the registers in the AD9954 ?

I have worked all the values for all the registers, for the AD9954, on a spreadsheet so that I only need to use the sketch to send these values to the DDS.

However there are a few things I still am not clear about.

1. UPD - is this required ? If so when do I activate it > at the end of every transfer for each register ?

2. Surely I only need to write the values to the AD9954 once ? This being the case, then the part of the sketch which writes the values should be included in the void setup, rather than the void loop ?

One other thing, I have an old Tetronix 2465 scope which I am using for this project. I bought it some time ago and have rarely used it. Unfortunately it doesnt appear to trigger so well as I am getting a lot of jitter. This is really just a hobby so I have a very limited budget for test equipment - any suggestions apart from the obvious.

Many thanks, Derek

//************************************************ 

//* SCLK test code for MKRZERO 

//* rev 0.1 December 2019 

//************************************************

// DECLARING / DEFINING VARIABLES & THEIR TYPES

char clockpin = A1;       // declaring or defining the variable named clockpin as a character type which has a value A1

char datapin = A2;        // declaring or defining the variable named datapin as a character type which has a value A2

char resetpin = A3;       // declaring or defining the variable named resetpin as a character type which has a value A3

char ioupdatepin = A4;    // declaring or defining the variable named ioupdatepin as a character type which has a value A4

// DECLARING / DEFINING DDS REGISTERS

// INTEGERS ARE THE PRIMARY DATA TYPE FOR NUMBER STORAGE

// THE DDS HAS 11 REGISTERS WHICH NEED TO BE PROGRAMMED

// REGISTERS HAVE VARIOUS LENGTHS FROM 2 BYTES TO 5 BYTES

// I HAVE DECLARED EACH REGISTER HAS AN ARRAY OF INTEGER TYPE

// THE NUMBERS IN THE ARRAYS ARE DECIMAL NUMBERS

int CFR1 [] = {128, 174, 0, 112, 8};      // declaring or defining the variable named CFR1[] (control function register 1) as a 5 byte array and integer data type

int CFR2 [] = {129, 0, 0, 164};           // declaring or defining the variable named CFR2[] (control function register 2) as a 4 byte array and integer data type

int ASF [] = {130, 0, 0};                 // declaring or defining the variable named ASF[] (amplitude scale factor) as a 3 byte array and integer data type

int ARR [] = {131, 0};                    // declaring or defining the variable named ARR[] (amplitude ramp rate) as a 2 byte array and integer data type

int FTW0 [] = {132, 26, 57, 224, 0};      // declaring or defining the variable named FTW0[] (frequency tuning word 0) as a 5 byte array and integer data type

int POW0 [] = {133, 0, 0};                // declaring or defining the variable named POW0[] (phase offset word) as a 3 byte array and integer data type

int FTW1 [] = {134, 26, 57, 224, 0};      // declaring or defining the variable named FTW0[] (frequency tuning word 1) as a 5 byte array and integer data type

int RSCW0 [] = {135, 0, 0, 0, 0};         // declaring or defining the variable named RSCW0[] (ram segment control word 0) as a 5 byte array and integer data type

int RSCW1 [] = {136, 0, 0, 0, 0};         // declaring or defining the variable named RSCW1[] (ram segment control word 1) as a 5 byte array and integer data type

int RSCW2 [] = {137, 0, 0, 0, 0};         // declaring or defining the variable named RSCW2[] (ram segment control word 2) as a 5 byte array and integer data type

int RSCW3 [] = {138, 0, 0, 0, 0};         // declaring or defining the variable named RSCW3[] (ram segment control word 3) as a 5 byte array and integer data type

void setup() {

  pinMode(clockpin, OUTPUT);    // sets pin A1 as OUTPUT

  pinMode(datapin, OUTPUT);    // sets pin A2 as OUTPUT

  pinMode(resetpin, OUTPUT);    // sets pin A3 as OUTPUT

  pinMode(ioupdatepin, OUTPUT);    // sets pin A4 as OUTPUT

  //reset the AD9954

  digitalWrite(resetpin, LOW);

  delay(1);

  digitalWrite(resetpin,HIGH);

  delay(1);

  digitalWrite(resetpin, LOW);

}

void loop() {

  for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, CFR1[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<4; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, CFR2[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<3; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, ASF[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<2; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, ARR[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, FTW0[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

}

  for (int i=0; i<4; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, POW0[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, FTW1[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, RSCW0[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, RSCW1[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<5; i=i+1) {

shiftOut(datapin, clockpin, MSBFIRST, RSCW2[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

  for (int i=0; i<5; i=i+1) {

  shiftOut(datapin, clockpin, MSBFIRST, RSCW3[i]);  // each bit is approximately 5us. The clock signal also has a period of 5us, 1.5 us ON and 3.5 us OFF.

  }

}

Hello Derek,

Shabaz is correct (almost) re the /CS pin, actually it is essential that you control it - see the diagram on page 24 of the AD9954 data sheet - CS is used to frame the serial control messages.

From page 21 you can see that the IO Update pin must be toggled after a write to registers since the data is transferred from buffers to working registers in the AD9954 only on the rising edge

of UPDATE, synched with the SYNC_CLK (which is an AD5594 output). There is (probably)  no way that the Arduino can sync correctly with the SYNC_CLK so just toggle UPDATE after setting the

registers and hope for the best.

Your scope only has two channels so you will need to be creative about checking the signals:

Use ch1 on SCLK and ch2 on SDIO and trigger from the falling edge of /CS - you should see bursts of clock cycles on SCLK and data patterns on SDIO.

I haven't checked the code in the loop{}, and I've no idea exactly what shiftOut() does - but with your scope you should be able to see if its doing what page 24 requires, if not then let us know !

MK

Hi Derek,

I've now got a MKRZERO board, so I'll try that out, and see if I can get some code to work. I'm going to write the code so it can instruct the DDS to generate a signal, then if you like you can modify that to suit your needs.

Hi Derek,

The code below is confirmed working with the MKR ZERO board. I wired it to my home-built AD9954 board.

The code below puts the value 89 MHz into an array variable called data, and it puts 89.1 MHz into an array called data2,

and then it rapidly writes data into the AD9954, followed by data2.

So, to test, if an FM radio is tuned to around 89MHz, then a loud tone is heard (provided you've got a short length of wire sticking out of the SMA connector).

It is a violation to broadcast at that frequency, so if you have some other legal frequency you can use, then the code can be modified for that, but probably no-one will notice if you only do it for a second or two to confirm operation.

This code should work on your board, if it has a 100 MHz crystal oscillator. My board has that, but your board may have a different value crystal oscillator populated so that needs to be verified by you (it may be printed on the crystal oscillator module, if it is not mentioned in your board documentation).

If the crystal oscillator is of a different value, then the set_sysfreq function needs to be modified (table 12 in the AD9954 documentation PDF specifies what register contents are needed). The AD9954 multiplies up the crystal frequency. I multiplied to the maximum supported in the code for a 100 MHz crystal, i.e. it multiplies to 400 MHz, called the system frequency. If you choose to use a different system frequency, then the SYSFREQ definition in the code will also need to be modified.

//************************************************
//* dds test code for MKRZERO
//* rev 0.2 Nov 2019
//************************************************




// ************** definitions ******************** 
#define IO_UPD_LOW digitalWrite(A4, LOW)
#define IO_UPD_HIGH digitalWrite(A4, HIGH)
#define SCLK_LOW digitalWrite(A1, LOW)
#define SCLK_HIGH digitalWrite(A1, HIGH)
#define SDIO_LOW digitalWrite(A2, LOW)
#define SDIO_HIGH digitalWrite(A2, HIGH)
#define CS_BAR_LOW digitalWrite(A5, LOW)
#define CS_BAR_HIGH digitalWrite(A5, HIGH)
#define RESET_LOW digitalWrite(A3, LOW)
#define RESET_HIGH digitalWrite(A3, HIGH)
#define LED_ON digitalWrite(LED_BUILTIN, HIGH)
#define LED_OFF digitalWrite(LED_BUILTIN, LOW)
// DDS registers
#define CFR1 0
#define CFR2 1
#define ASF 2
#define ARR 3
#define FTW0 4
#define FTW1 6
#define RSCW0 7
#define RAM 0x0b




#define SYSFREQ 400E6
#define TWLEN 4294967296
#define FOREVER 1




// This disables the comparator. Set this to zero if
// square wave output is required!
#define COMPDIS 1






// ********** function prototypes *******************
void set_sysfreq(void); // set SYSFREQ
void set_amplitude(unsigned int amp); // set amplitude register
void freq2ftw(double freq, unsigned char* data); // convert freq into 4 bytes that represent it
void write_bytes(unsigned char instr, unsigned char* data, int len); // write instruction and data to AD9954






// ************** initialization code ***************
void setup() {
  int i;
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT);


  // wait a short while for power to stabilise in the system.
  // blink an LED while we wait
  for (i=0; i<5; i++) {
    LED_ON;
    delay(50);
    LED_OFF;
    delay(50);
  }
  
  // Reset the AD9954 and get the pins into a known state
  RESET_HIGH;
  CS_BAR_HIGH; // initialize *CS to be high
  IO_UPD_LOW; // initialise IO_UPD to be low
  SCLK_LOW; // initialise SCLK to be low (data is toggled in on the rising edge)
  RESET_LOW; // bring the DDS board out of reset


  delay(50);


}








// *************** main loop ************************
void loop() {
  unsigned int asf;
  double freq; // desired frequency
  unsigned char data[12];
  
  double freq2;
  unsigned char data2[12];
  
  asf=16383; // max amplitude is (2^14)-1 i.e. 16383
  freq=89000000; // default to a 89 MHz signal
  freq2=89100000; // this is 89.1 MHz








  data[0]=0x06; // OSK Enable; we need this to have amplitude control
  data[1]=0; data[2]=0x02; data[3]=0x00; // We always stick to MSB first mode. 0x42
  if (COMPDIS) data[3]|=0x40; // disable comparator
  write_bytes(CFR1, data, 4);
    
  data[0]=255;
  write_bytes(ARR, data, 1); // set amplitude ramp rate register
    
  set_sysfreq();
  set_amplitude(asf); // 0x3fff is max amplitude
    
  freq2ftw(freq, data); // convert frequency into 4 data bytes (frequency tuning word)
  freq2ftw(freq2, data2);
  write_bytes(FTW0, data, 4);
  
  // done! loop forever.
  while(FOREVER) // play a tone by rapidly switching the output frequency
  {
    LED_ON;
    write_bytes(FTW0, data, 4);
    delay(1); // 1 millisecond delay
    LED_OFF;
    write_bytes(FTW0, data2, 4);
    delay(1);
  }
  
}








// ************** set SYSFREQ *************************
// Sets SYSFREQ to 400MHz
void
set_sysfreq(void)
{
  unsigned char data[3];
  data[0]=0x18; data[1]=0; data[2]=0x24; // 100MHz external oscillator, multiplied by 4 for 400MHz SYSFREQ
  write_bytes(CFR2, data, 3);
}








// *********Set the amplitude register *****************
// Range is 0 (lowest) to 0x3fff (highest)
void
set_amplitude(unsigned int amp)
{
  unsigned char data[2];
  unsigned char* aptr;
  aptr=(unsigned char*)&
  if (amp>0x3fff)
  {
    // error
    exit(1);
  }
  data[1]=*aptr; // adjust these lines for endian'ness
  data[0]=*(aptr+1);
  write_bytes(ASF, data, 2);
}








// ******* convert freq into 4 data bytes that represent it *****
void
freq2ftw(double freq, unsigned char* data)
{
  unsigned char* tptr;
  unsigned int tword; // 32-bit tuning word
  
  tptr=(unsigned char*)&tword;
  tword=(unsigned int)((freq)*TWLEN/(SYSFREQ));
  // endian'ness: MKR ZERO: *tptr+0 is the least significant byte
  data[3]=*tptr; // adjust these lines for endian'ness
  data[2]=*(tptr+1);
  data[1]=*(tptr+2);
  data[0]=*(tptr+3);

}








// **** Write instruction and data to the AD9954 *****************
void
write_bytes(unsigned char instr, unsigned char* data, int len)
{
  int i, j;
  unsigned char dbyte, ibyte;
  
  ibyte=instr;
  CS_BAR_LOW;
  // transmit instruction byte
  for (i=0; i<8; i++)
  {
    if (ibyte & 0x80)
    {
      SDIO_HIGH;
    }
    else
    {
      SDIO_LOW;
    }
    ibyte=ibyte<<1;
    SCLK_HIGH;    
    SCLK_LOW;
  }
  
  // transmit data byte(s)
  for (j=0; j<len; j++)
  {
    dbyte=data[j];
    for (i=0; i<8; i++)
    {
      if (dbyte & 0x80)
      {
        SDIO_HIGH;
      }
      else
      {
        SDIO_LOW;
      }
      dbyte=dbyte<<1;
      SCLK_HIGH;
      SCLK_LOW;
    }
  }








  IO_UPD_HIGH; // toggle IO_UPD to transfer the data into the registers
  delay(1); // delay 1 millisec
  IO_UPD_LOW;
}

Interesting - you set /CS low in the write_bytes() function but you never set it high again.

I'm quite surprised that this works.

It has the downside that all your commands are effectively sent in one continuous splurge (until the next power cycle) so that a single error will knock it out.

MK

Hi Michael,

Ohhh.. that was unintentional, I copied my older code and made some tweaks but forgot about the CS line. That's not very robust  : (

I'll tidy up the code today, put the CS in there and retest. I'm not sure why that worked, in any case it makes sense to get it done correctly, and make the code look a bit nicer too.

Some ICs allow to work in CS_HOLD mode, where the CS is held low as long as the communication happens.

They do not need the CS->high to apply the traffic. As Michael indicates, it does not allow the IC to recover from a corrupt communication though. CS-> high allows it to reset its communication state machine.

Some ICs allow to work in CS_HOLD mode, where the CS is held low as long as the communication happens.

They do not need the CS->high to apply the traffic. As Michael indicates, it does not allow the IC to recover from a corrupt communication though. CS-> high allows it to reset its communication state machine.