user51060: I am having trouble configuring Arduino Due SPI to an AD7490 ADC. 
Here is how I have the pins connected:

+3.3V > 7490 pin 22 Vin 
+3.3V > 7490 Vref 
DUE CS (8) > 7490 pin 20 SS - slave select)
DUE SCK > 7490 pin 16 (SCK - clock)
DUE MOSI > 7490 pin 19 (MOSI - data out)
Ground > 7490 pin 24 (all ground lines are tied together)
DUE MISO > 7490 pin 15 

Below is my code, I feel like I am writing the correct bits into the register. The problem I think I'm having is getting the timing write. The code is a simple attempt to read a single channel. 
#include <SPI.h>

// Set Constants
const int adcChipSelectPin = 8;      // set pin 8 as the chip select for the 
ADC:

// Start setup function:
void setup() {

pinMode (adcChipSelectPin, OUTPUT);
// set the ChipSelectPins high initially:
digitalWrite(adcChipSelectPin, HIGH);
// initialise SPI:
SPI.begin();
SPI.setBitOrder(MSBFIRST);         // Not strictly needed but just to be 
sure.
SPI.setDataMode(SPI_MODE0);        // Not strictly needed but just to be 
sure.
Serial.begin(9600);
//Clock Speed: Master clock/divider
//84Mhz/64 =  1.3 MHz
SPI.setClockDivider(SPI_CLOCK_DIV64);

} // End setup function.

// Start loop function:
void loop() {
float voltage[2];
for (int i = 0; i < 3; i++) {
voltage[i] = readAdc(0, 0);
}


}// End of loop function.

//Function to read the ADC, accepts the channel to be read.
float readAdc(int channel, int slave) {

float value;
if (slave == 0) {
noInterrupts(); // disable interupts to prepare to send address data to the 
ADC.
digitalWrite(adcChipSelectPin, LOW); // take the Chip Select pin low to 
select the ADC.


byte FirstByte = 0b10000011;    
byte SecondByte = 0b00110000;      

SPI.transfer(FirstByte);

byte response1 = SPI.transfer(SecondByte);
byte response2 = SPI.transfer(0x00);

digitalWrite(adcChipSelectPin, HIGH); // take the Chip Select pin high to 
de-select the ADC.
interrupts(); // Enable interupts.
Serial.println(response1);
Serial.println(response2);

}

The serial.prints output 255 consistently. In my experience this means the SPI is configured incorrectly.
Any pointers are appreciated. 

user51060: For anyone else who comes across the same problem, this worked for me: 
// include the library code:
#include <SPI.h>

// Set Constants
const int adcChipSelectPin = 8;      // set pin 8 as the chip select for the ADC:

// Start setup function:
void setup() {
    pinMode (adcChipSelectPin, OUTPUT);

    // set the ChipSelectPins high initially:
    digitalWrite(adcChipSelectPin, HIGH);

    // initialise SPI:
    SPI.begin();
    SPI.setBitOrder(MSBFIRST);         // Not strictly needed but just to be sure.
    SPI.setDataMode(SPI_MODE0);        // Not strictly needed but just to be sure.
    Serial.begin(9600);

    //Clock Speed: Master clock/divider
    //84Mhz/64 =  1.3 MHz
    SPI.setClockDivider(SPI_CLOCK_DIV64);

    //Send dummy values over when ADC is turned on 
    //Hold Din High for 16 clock cycles twice 
    digitalWrite(adcChipSelectPin, LOW);
    SPI.transfer(0xFF);
    SPI.transfer(0xFF);
    digitalWrite(adcChipSelectPin, HIGH);

    digitalWrite(adcChipSelectPin, LOW);
    SPI.transfer(0xFF);
    SPI.transfer(0xFF);
    digitalWrite(adcChipSelectPin, HIGH);
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    //Send dummy values, next read should have correct values

    digitalWrite(adcChipSelectPin, LOW);
    byte FirstByte = 0x83;
    byte SecondByte = 0x50;
    byte response1 = SPI.transfer(FirstByte); 
    byte response2 = SPI.transfer(SecondByte); 

    digitalWrite(adcChipSelectPin, HIGH);

    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    ///////////////////////////////////////////////////////////////////////////////////

    //50ns quiet time?
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
} // End setup function.

// Start loop function:
void loop() {
    float voltage[2];
    for (int i = 1; i < 17; i++) {
        voltage[i] = readAdc(0, 1);
        //50ns quiet time? 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
    }
} // End of loop function.

//Function to read the ADC, accepts the channel to be read.
float readAdc(int channel, int slave) {
    float value;
    if (slave == 0) { 
        byte FirstByte = 0x83;
        byte SecondByte = 0x50;
        FirstByte |= channel << 2;

        noInterrupts(); // disable interupts to prepare to send address data to the ADC.

        digitalWrite(adcChipSelectPin, LOW); // take the Chip Select pin low to select the ADC.
        //Write = 1
        //SEQ = 0
        // ADD3-ADD0 = 0000
        //PM1 = PM0 = 1
        //Shadow = 0
        //WEAK/Tri = 1
        //Range = 0
        //Coding = 1
        //0b10000010 1010 0000
        //extra 4 zeros to fill

        //May need to wait 16 * (1/freq)
        //16 * (1/1.3MHz) 
        byte response1 = SPI.transfer(FirstByte); 
        byte response2 = SPI.transfer(SecondByte); 
        digitalWrite(adcChipSelectPin, HIGH);     

        interrupts(); // Enable interupts.

        //Serial.println(response1);
        Serial.println(response2);
        byte channel = (response1 >> 4);
        //byte value = (response1 << 4);
        //byte digitalValue = (response1 << 4) | response2; 
        //Serial.println(digitalValue);
        //Serial.println(channel);

        byte digitalValue = 0x00;
        float value = (float(digitalValue) * 3.3) / 4096.000; // The digital value is 
        converted to an analogue voltage using a VREF of 2.048V.
        //Serial.print(channel);
        //Serial.print("\t");
        //Serial.println(value);
    }
}


51060: <p>I am having trouble configuring Arduino Due SPI to an <a href="https://www.analog.com/media/en/technical-documentation/data-sheets/AD7490.pdf" rel="nofollow noreferrer">AD7490</a> ADC. </p>

<p>Here is how I have the pins connected:</p>

<ul>
<li>+3.3V > 7490 pin 22 Vin </li>
<li>+3.3V > 7490 Vref </li>
<li>DUE CS (8) > 7490 pin 20 SS - slave select)</li>
<li>DUE SCK > 7490 pin 16 (SCK - clock)</li>
<li>DUE MOSI > 7490 pin 19 (MOSI - data out)</li>
<li>Ground > 7490 pin 24 (all ground lines are tied together)</li>
<li>DUE MISO > 7490 pin 15 </li>
</ul>

<p>Below is my code, I feel like I am writing the correct bits into the register. The problem I think I'm having is getting the timing write. The code is a simple attempt to read a single channel. </p>

<pre><code>#include &lt;SPI.h&gt;

// Set Constants
const int adcChipSelectPin = 8;      // set pin 8 as the chip select for the 
ADC:

// Start setup function:
void setup() {

pinMode (adcChipSelectPin, OUTPUT);
// set the ChipSelectPins high initially:
digitalWrite(adcChipSelectPin, HIGH);
// initialise SPI:
SPI.begin();
SPI.setBitOrder(MSBFIRST);         // Not strictly needed but just to be 
sure.
SPI.setDataMode(SPI_MODE0);        // Not strictly needed but just to be 
sure.
Serial.begin(9600);
//Clock Speed: Master clock/divider
//84Mhz/64 =  1.3 MHz
SPI.setClockDivider(SPI_CLOCK_DIV64);

} // End setup function.

// Start loop function:
void loop() {
float voltage[2];
for (int i = 0; i &lt; 3; i++) {
voltage[i] = readAdc(0, 0);
}


}// End of loop function.

//Function to read the ADC, accepts the channel to be read.
float readAdc(int channel, int slave) {

float value;
if (slave == 0) {
noInterrupts(); // disable interupts to prepare to send address data to the 
ADC.
digitalWrite(adcChipSelectPin, LOW); // take the Chip Select pin low to 
select the ADC.


byte FirstByte = 0b10000011;    
byte SecondByte = 0b00110000;      

SPI.transfer(FirstByte);

byte response1 = SPI.transfer(SecondByte);
byte response2 = SPI.transfer(0x00);

digitalWrite(adcChipSelectPin, HIGH); // take the Chip Select pin high to 
de-select the ADC.
interrupts(); // Enable interupts.
Serial.println(response1);
Serial.println(response2);

}
</code></pre>

<p>The serial.prints output 255 consistently. In my experience this means the SPI is configured incorrectly.</p>

<p>Any pointers are appreciated. </p>
 51060: <p>For anyone else who comes across the same problem, this worked for me: </p>

<pre><code>// include the library code:
#include &lt;SPI.h&gt;

// Set Constants
const int adcChipSelectPin = 8;      // set pin 8 as the chip select for the ADC:

// Start setup function:
void setup() {
    pinMode (adcChipSelectPin, OUTPUT);

    // set the ChipSelectPins high initially:
    digitalWrite(adcChipSelectPin, HIGH);

    // initialise SPI:
    SPI.begin();
    SPI.setBitOrder(MSBFIRST);         // Not strictly needed but just to be sure.
    SPI.setDataMode(SPI_MODE0);        // Not strictly needed but just to be sure.
    Serial.begin(9600);

    //Clock Speed: Master clock/divider
    //84Mhz/64 =  1.3 MHz
    SPI.setClockDivider(SPI_CLOCK_DIV64);

    //Send dummy values over when ADC is turned on 
    //Hold Din High for 16 clock cycles twice 
    digitalWrite(adcChipSelectPin, LOW);
    SPI.transfer(0xFF);
    SPI.transfer(0xFF);
    digitalWrite(adcChipSelectPin, HIGH);

    digitalWrite(adcChipSelectPin, LOW);
    SPI.transfer(0xFF);
    SPI.transfer(0xFF);
    digitalWrite(adcChipSelectPin, HIGH);
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    //Send dummy values, next read should have correct values

    digitalWrite(adcChipSelectPin, LOW);
    byte FirstByte = 0x83;
    byte SecondByte = 0x50;
    byte response1 = SPI.transfer(FirstByte); 
    byte response2 = SPI.transfer(SecondByte); 

    digitalWrite(adcChipSelectPin, HIGH);

    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    ///////////////////////////////////////////////////////////////////////////////////

    //50ns quiet time?
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
    asm volatile("nop"); 
} // End setup function.

// Start loop function:
void loop() {
    float voltage[2];
    for (int i = 1; i &lt; 17; i++) {
        voltage[i] = readAdc(0, 1);
        //50ns quiet time? 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
        asm volatile("nop"); 
    }
} // End of loop function.

//Function to read the ADC, accepts the channel to be read.
float readAdc(int channel, int slave) {
    float value;
    if (slave == 0) { 
        byte FirstByte = 0x83;
        byte SecondByte = 0x50;
        FirstByte |= channel &lt;&lt; 2;

        noInterrupts(); // disable interupts to prepare to send address data to the ADC.

        digitalWrite(adcChipSelectPin, LOW); // take the Chip Select pin low to select the ADC.
        //Write = 1
        //SEQ = 0
        // ADD3-ADD0 = 0000
        //PM1 = PM0 = 1
        //Shadow = 0
        //WEAK/Tri = 1
        //Range = 0
        //Coding = 1
        //0b10000010 1010 0000
        //extra 4 zeros to fill

        //May need to wait 16 * (1/freq)
        //16 * (1/1.3MHz) 
        byte response1 = SPI.transfer(FirstByte); 
        byte response2 = SPI.transfer(SecondByte); 
        digitalWrite(adcChipSelectPin, HIGH);     

        interrupts(); // Enable interupts.

        //Serial.println(response1);
        Serial.println(response2);
        byte channel = (response1 &gt;&gt; 4);
        //byte value = (response1 &lt;&lt; 4);
        //byte digitalValue = (response1 &lt;&lt; 4) | response2; 
        //Serial.println(digitalValue);
        //Serial.println(channel);

        byte digitalValue = 0x00;
        float value = (float(digitalValue) * 3.3) / 4096.000; // The digital value is 
        converted to an analogue voltage using a VREF of 2.048V.
        //Serial.print(channel);
        //Serial.print("\t");
        //Serial.println(value);
    }
}
</code></pre>
