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'm sorry, I didn't realise you were in the UK too. I'd be happy to take a look. I've sent you a message with my address details, if you click on the bell icon at the top-right, hopefully you'll be able to see it.

Regarding your other comments, I've never probed the SYNC_CLK pin, but I think you're right, there should be a signal there. The clock oscillator output seems ok, as I understand, it is AC coupled to the DDS, and any level between 0.1V and 1V peak-to-peak is fine.

Hi Shabaz and Derek,

I am glad you are going to have a look at this.  The board is reasonably priced and would be useful so I was considering ordering one to see if I could help and figure it out myself.

Hi Derek,

Good news, it finally works : )

I had a look at the board, it was not anything you were doing wrong, but basically the board didn't have some connections with defaults. On my board, I'd defaulted some pins using pull-down resistors etc.on the PCB itself, but on the ebay/aliexpress PCB, they are not defaulted.

There are a couple of pins, marked IOSY and PWR (the actual pin names are IOSYNC and PWRDWNCTL), and they both needed to be connected to GND. After that was done, it worked.

I'll get the board posted back to you on Friday or Saturday.

Hi Shabaz,

Joy o joy, cant believe it. Thank you soo much.

Cant wait to get it back and start experimenting.

Regards, Derek

Great work Shabaz!  I don’t think I would have ever thought to check if a pin marked PWR should be connected to GND :-). I looked at the photos of the board and did not see the offending pins.  Where are they located?

Frank

Edit:  never mind, found them.  They are on the data port.  Makes sense now.

Great work Shabaz!  I don’t think I would have ever thought to check if a pin marked PWR should be connected to GND :-). I looked at the photos of the board and did not see the offending pins.  Where are they located?

Frank

Edit:  never mind, found them.  They are on the data port.  Makes sense now.

Hi Frank,

Thanks! It did feel weird connecting the PWR pin to GND : )

I've summarized the connections below, from the AD9954 board to the MKR ZERO.

This works with the earlier code, with the code modification for the 20 MHz oscillator (my original board had a 100 MHz oscillator).

So, this code works with the ebay/aliexpress board:

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


// ************** definitions ******************** 
// input/output (I/O)
#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
// these are used for converting a frequency in Hz to the register format
// needed for the AD9954. If the system frequency is not 400 MHz this will need changing
#define SYSFREQ 400E6
#define TWLEN 4294967296
// other definitions
#define FOREVER 1
// This disables the comparator. Set this to zero if
// square wave output is required!
#define COMPDIS 1
// max amplitude is (2^14)-1 i.e. 16383
#define MAX_OUTPUT 16383


// ***************** structures *********************
typedef struct freq_info_s {
  double hz;
  unsigned char regdata[4];
} freq_info_t;


// ********** function prototypes *******************
void set_sysfreq(void); // sets up PLL to multiply the hardware crystal oscillator output
void set_ctrl_reg1(void); // sets up the CFR1 (control function register #1) to some defaults
void set_output_level(unsigned int amp); // set amplitude register 0-0x3fff (0x3fff is highest)
void freq2ftw(double freq, unsigned char* data); // convert freq (in Hz) 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 rapidly while we wait
  for (i=0; i<5; i++) {
    LED_ON;
    delay(50); // 50 msec delay
    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); // probably not needed but anyway..
}


// *************** main code ************************
// note: this function, despite being called loop, never
// gets to loop around, because I'm misusing it, by not
// allowing the execution of the function to ever complete,
// so that it cannot ever loop.
void loop() {
  unsigned int output_level; // 0-0x3fff, with 0x3fff being the highest
  
  freq_info_t freq; // this holds the desired frequency
  freq_info_t freq2; // alternate desired frequency, for test purposes
  output_level=MAX_OUTPUT;
  freq.hz=89000000; // 89 MHz signal
  freq2.hz=89100000; // this is 89.1 MHz, used as a test


  // set up the AD9954 suitable for generating single tones
  set_ctrl_reg1(); // sets up CFR1 register with some defaults
  set_sysfreq(); // sets up CFR2 register with PLL settings
  set_output_level(output_level);


  // perform the math manipulation from Hz to FTW0 register format
  freq2ftw(freq.hz, freq.regdata);
  freq2ftw(freq2.hz, freq2.regdata);
  
  // done! now loop just this following segment of code forever
  while(FOREVER) // play out two frequencies alternated
  {
    LED_ON;
    write_bytes(FTW0, freq.regdata, 4);
    delay(1); // 1 millisecond delay
    LED_OFF;
    write_bytes(FTW0, freq2.regdata, 4);
    delay(1);
  }
  
}


// ***** set control reg 1 (CFR1) to some defaults ****
void
set_ctrl_reg1(void)
{
  unsigned char data[4];
  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);
}


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


// *********Set the amplitude register *****************
// Range is 0 (lowest) to 0x3fff (highest)
void
set_output_level(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;
  CS_BAR_HIGH;
}

This test code above generates an FM-ish signal (not really, but it's enough for the test) at 89 MHz, so tuning an FM receiver to that frequency will result in a tone being heard.

I also tried generating just an unmodulated signal, to see the output from the SMA connector marked OUT1 on the board:

Board programmed for 12.7MHz output - the marker M1 indicates that the output was -9.2 dBm. RBW is set to 1 kHz. Span is 1 MHz for all of these screenshots:

Board programmed for 89 MHz, RBW set to 100 Hz:

Board programmed for 140.7 MHz:

The signal quality from the ebay/aliexpress board is great. The main chip alone costs £28+tax, so for generating RF (unmodulated, or FM or FSK) at sub-150 MHz, I think the board at £45GBP/$60USD is good value (plus the cost to attach to a MKR ZERO or whatever).

An SDR would be more versatile (and cover a wider range), but for a good reference signal for test purposes, then the AD9954 board is better.