Arduino DUe - AD7714 interface

Hi,
I have a problem with the communication between the ARduino DUE and the ADC AD7714.
I read old post about this argument but I did not find areally solution or good suggestions for my case.
I don not undestand how to read 3 bytes (24 bit) in series.
I attach my code for clarity.

I hope that someone help me.
Thank you :wink:

Ale

AD7714.ino (2.99 KB)

aledio:
Hi,
I have a problem with the communication between the ARduino DUE and the ADC AD7714.
I read old post about this argument but I did not find areally solution or good suggestions for my case.
I don not undestand how to read 3 bytes (24 bit) in series.
I attach my code for clarity.

I hope that someone help me.
Thank you :wink:

Ale

I looked at your code, it won’t work.

When you talk to a SPI device, you are always ‚Äėwriting‚Äô, and you are always ‚Äėreading‚Äô at the same time.

the SPI.transfer() function is actually used like this.

readbyte = SPI.transfer(wrotebyte);

Calling SPI.transfer() returns the value received when you sent out the byte in transfer().

For this ADC AD7714, The first byte in every transaction is called the COMMUNICATIONS register. It defines the meaning of any subsequent bytes in the transfer.

Example.
to set the ADC for 24bit data you need to set bit 6 in register 2 (high filter register).

to do this you need to first create the COMMUNICATIONS register value for this operations.

// global storage
uint8_t ain=0;  // analog input mux setting CH2..CH0 bits of COMM register
bool bits24=false; // is dataregister configured for 24bits?


uint8_t writeByteRegister( uint8_t reg, uint8_t value){ // only valid for 8 bit registers 0..4

uint8_t result = 0;
if (reg<5) { // byte registers
 uint8_t cmd = 0; // a place to build the correct comm reg value.

 cmd = (reg<< 4); // set the correct RS2..RS0 bits of COMM register

 if(reg==0) // update global ain Value
   ain = value &7;

 cmd = cmd | ain; // keep the analog mux what it was previously configured as.

 digitalWrite(CS,LOW); // select the ADC

 uint8_t stat = SPI.transfer(cmd); // actually send the cmd and read the current status

 if(reg!=0){ // actually send the value to reg

   uint8_t unk = SPI.transfer(value);
   if(reg==2) bits24=(value &0x40)==0x40; // if configured for 24bit data register

   }
 digitalWrite(CS,HIGH); // all done with device
 result = stat; // return value received, drdy is bit 7.
 }
return result;
}

uint8_t writeBigRegister( uint8_t reg, uint32_t value){ // only valid for 16,24 bit registers 5..7

uint8_t result = 0;
if ((reg>4)&&(reg<8) { // big registers
 uint8_t cmd = 0; // a place to build the correct comm reg value.

 cmd = (reg << 4); // set the correct RS2..RS0 bits of COMM register

 cmd = cmd | ain; // keep the analog mux what it was previously configured as.

 digitalWrite(CS,LOW); // select the ADC

 uint8_t stat = SPI.transfer(cmd); // actually send the cmd and read the current status
// I am assuming little Endian transfer order

   uint8_t b = lowByte(value); // pick
   uint8_t unk = SPI.transfer(b);  //unk is unknown, possibly the previous register state value
   b = lowByte(value >>8); // middle byte
   unk = SPI.transfer(b); // send middle byte;
   if(bits24||(reg>5)){ // a 24bit register
     b = lowByte(value >>16); // high byte;
     unk = SPI.transfer(b); // send high byte
     }
   digitalWrite(CS,HIGH); // deSelect ADC
  result = stat; // drdy is bit 7
}
return result;
}

uint8_t readByteRegister( uint8_t reg){ // only valid for 8 bit registers 0..4

uint8_t result = 0;
if (reg<5) { // byte registers
 uint8_t cmd = 0; // a place to build the correct comm reg value.

 cmd = (reg<< 4); // set the correct RS2..RS0 bits of COMM register

 cmd = cmd | ain; // keep the analog mux what it was previously configured as.

 cmd = cmd | 0x08; // read mode

 digitalWrite(CS,LOW); // select the ADC

 result = SPI.transfer(cmd); // actually send the cmd and read the current status

 if(reg!=0){ // actually read the value of reg

   result = SPI.transfer(0); // 0 is just a place holder, the ADC ignores it. because of read mode
   }
 digitalWrite(CS,HIGH); // all done with device
 }
return result;
}


uint32_t readbigRegister( uint8_t reg){ // only valid for 16,24 bit registers 5..7

uint32_t result = 0;
if ((reg>4)&&(reg<8)) { // big registers
 uint8_t cmd = 0; // a place to build the correct comm reg value.

 cmd = (reg<< 4); // set the correct RS2..RS0 bits of COMM register

 cmd = cmd | ain; // keep the analog mux what it was previously configured as.

 cmd = cmd | 0x08; // read mode

 digitalWrite(CS,LOW); // select the ADC

 uint8_t stat = SPI.transfer(cmd); // actually send the cmd and read the current status
 uint8_t b = SPI.transfer(0); // send out placeholder get back byte
 result = b;
 b = SPI.transfer(0); // send out placeholder get back bigger byte
 result = (result << 8)+b; // build up 16 bit value from bytes
 if(bits24||(reg>5)){ //do a 24bit transfer
   b = SPI.transfer(0); // send out placeholder get back bigger byte
   result = (result << 8)+ b; // build up 24 bit value from bytes.
   }
 digitalWrite(CS,HIGH); // all done with device
 }
return result;
}

Does this give you some idea?

Chuck.

Hi Chuck,
thank you for your answer.
The difference with your function is the use of SPI.tansfer(0) when read a byte.
My problem is that the ADC does not reply. The value is 0 always.
I do not know why.
Have you got other suggestions?

Ale

#include <SPI.h>

// pins used for the connection with the sensor
// the other you need are controlled by the SPI library):
const int dataReady = 53;
const int chipSelect = 52;
unsigned long value;

void setup() {
  Serial.begin(9600);

  // -------- SPI initialization
  pinMode(chipSelect, OUTPUT);  // Set the SS pin as an output
  digitalWrite(chipSelect, HIGH);  // Set the SS pin HIGH
  SPI.begin();  // Begin SPI hardware
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(chipSelect, 128);  // Slow down SPI clock
  SPI.setDataMode(chipSelect, SPI_MODE3);

  // initalize the  data ready and chip select pins:
  pinMode(dataReady, INPUT);

  // configure AD7714
  writeRegister(0x20, 0xCF); // set the channel AIN1/AIN6 and set the next operation as write to the filter high register
  // set unipolar mode, 24 bits, boots off, all 4 MSBs of filterword to 1
  writeRegister(0x30, 0xFF); // set the next opearation as a write to the filter low register
  // max filter word allowed for low part of the filterword
  writeRegister(0x10, 0x20); // set the operation as a write to the mode register
  // set gain to 1, bornout current off, no filter sync, and do a self calibration

  // give the sensor time to set up:
  delay(100);
}

void loop() {
  if (digitalRead(dataReady) == 0)
  {
    value = readRegister(0x58, 3);

    Serial.print(value, HEX);
    Serial.println(" = " + String((float(value) / 16777216.0) * 3.3) + " V");
    delay(1000);
  }
}

//Read from or write to register from the AD7714:
byte readRegister(byte thisRegister, int bytesToRead ) {
  byte temp = 0;
  byte inByte = 0;           // incoming byte from the SPI
  unsigned long result = 0;   // result to return

  // take the chip select low to select the device:
  digitalWrite(chipSelect, LOW);

  // send the device the register you want to read:
  temp = SPI.transfer(thisRegister);
  // send a value of 0 to read the first byte returned:
  result = SPI.transfer(0);
  // decrement the number of bytes left to read:
  bytesToRead--;

  // if you still have another byte to read:
  while (bytesToRead > 0) {
    // shift the first byte left, then get the second byte:
    result = result << 8;
    inByte = SPI.transfer(0);
    // combine the byte you just got with the previous one:
    result = result | inByte;
    // decrement the number of bytes left to read:
    bytesToRead--;
  }

  // take the chip select high to de-select:
  digitalWrite(chipSelect, HIGH);
  // return the result:
  return result;
}

//Sends a write command to ad7714
byte writeRegister(byte thisRegister, byte thisValue) {
  byte stat = 0;
  byte unk = 0;

  // take the chip select low to select the device:
  digitalWrite(chipSelect, LOW);

  stat = SPI.transfer(thisRegister); //Send register location
  unk = SPI.transfer(thisValue);  //Send value to record into register

  // take the chip select high to de-select:
  digitalWrite(chipSelect, HIGH);
}

aledio:
Hi Chuck,
thank you for your answer.
The difference with your function is the use of SPI.tansfer(0) when read a byte.
My problem is that the ADC does not reply. The value is 0 always.
I do not know why.
Have you got other suggestions?

Ale

//Read from or write to register from the AD7714:

byte readRegister(byte thisRegister, int bytesToRead ) {

Change the definition of readRegister() to unsigned long

Chuck.

I have changed the data type definition.

Now, I read on the channel AIN6-AIN6 the value ABB0D5 but on the others channels 0.

I don't understand if the problem is the SPI configuration or the communication protocol.

I have observed that my program does not read correctly register values. I try to write this code:

void setup() {
  Serial.begin(9600);

  // -------- SPI initialization
  pinMode(chipSelect, OUTPUT);  // Set the SS pin as an output
  digitalWrite(chipSelect, HIGH);  // Set the SS pin HIGH
  SPI.begin();  // Begin SPI hardware
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(210);  // SPI clock sets to 400 kHz
  SPI.setDataMode(SPI_MODE0);

  // initalize the  data ready and chip select pins:
  pinMode(dataReady, INPUT);

  // configure AD7714
  writeRegister(0x20 | channel); /* set the channel AIN6/AIN6 and set the next operation as write to the filter high
register */
  writeRegister(0x4f); /* set Bipolar mode, 24 bits, boost off, all 4 MSBs of filterword to 1 */
  writeRegister(0x28 | channel);
  digitalWrite(chipSelect, LOW);
  conf = SPI.transfer(0);
  digitalWrite(chipSelect, HIGH);
  Serial.println(conf, HEX);
  
  writeRegister(0x30 | channel); /* set the next operation as a write to the filter low register */
  writeRegister(0xA0); /* max filter word allowed for low part of the filterword */
  writeRegister(0x38 | channel);
  digitalWrite(chipSelect, LOW);
  conf = SPI.transfer(0);
  digitalWrite(chipSelect, HIGH);
  Serial.println(conf, HEX);
  
  writeRegister(0x10 | channel); /* set the operation as a write to the mode register */
  writeRegister(0x20); /* set gain to 1, burnout current off, no filter sync, and do a self calibration */
  writeRegister(0x18 | channel);
  digitalWrite(chipSelect, LOW);
  conf = SPI.transfer(0);
  digitalWrite(chipSelect, HIGH);
  Serial.println(conf, HEX);

  // give the sensor time to set up:
  delay(100);
}

The value of "conf" variable should be equal to the written value, but it is not so.

aledio:
I have changed the data type definition.

Now, I read on the channel AIN6-AIN6 the value ABB0D5 but on the others channels 0.

I don't understand if the problem is the SPI configuration or the communication protocol.

I have observed that my program does not read correctly register values. I try to write this code:

void setup() {

// configure AD7714
 writeRegister(0x20 | channel); /* set the channel AIN6/AIN6 and set the next operation as write to the filter high
register /
 writeRegister(0x4f); /
set Bipolar mode, 24 bits, boost off, all 4 MSBs of filterword to 1 /
 writeRegister(0x28 | channel);
 digitalWrite(chipSelect, LOW);
 conf = SPI.transfer(0);
 digitalWrite(chipSelect, HIGH);
 Serial.println(conf, HEX);
 
 writeRegister(0x30 | channel); /
set the next operation as a write to the filter low register /
 writeRegister(0xA0); /
max filter word allowed for low part of the filterword /
 writeRegister(0x38 | channel);
 digitalWrite(chipSelect, LOW);
 conf = SPI.transfer(0);
 digitalWrite(chipSelect, HIGH);
 Serial.println(conf, HEX);
 
 writeRegister(0x10 | channel); /
set the operation as a write to the mode register /
 writeRegister(0x20); /
set gain to 1, burnout current off, no filter sync, and do a self calibration */
 writeRegister(0x18 | channel);
 digitalWrite(chipSelect, LOW);
 conf = SPI.transfer(0);
 digitalWrite(chipSelect, HIGH);
 Serial.println(conf, HEX);

// give the sensor time to set up:
 delay(100);
}




The value of "conf" variable should be equal to the written value, but it is not so.

What is the code for writeRegister()?

Everytime the chipSelect is driven Low, it starts a NEW transaction, the ADC expects the COMM register read/write mode plus any other register.

your code:

    writeRegister(0x30 | channel); /* set the next operation as a write to the filter low register */
  writeRegister(0xA0); /* max filter word allowed for low part of the filterword */
  writeRegister(0x38 | channel);
  digitalWrite(chipSelect, LOW);   // *****  this starts a NEW transaction
  conf = SPI.transfer(0);             // *****   writes 0 to the COMM register, Selects Ain1,Ain6
  digitalWrite(chipSelect, HIGH); //  *****   ends transaction
  Serial.println(conf, HEX);

I assume that each writeRegister()

  • takes CS low
  • creates a COMM value
  • SPI.transfer(); the COMM value
  • SPI.transfer(); any other register value, 8bit or 16bit or 24bit (multiple calls)
  • takes CS HIGH

So, in this code snippet the:

  digitalWrite(chipSelect, LOW);
  conf = SPI.transfer(0);
  digitalWrite(chipSelect, HIGH);

sends 0 as the current COMM value, (register 0 write, Ain1,Ain6). I don't think that was what you wanted.

Have you tried the code I wrote?

Also, do you have a pullup on the Data_ready Line?

Chuck.

Hi Chuck,
my completed code is that:

/*
 AD7714 <--> Arduino
 created 30 June 2015
 by A. Dionisi
 */

// the sensor communicates using SPI, so include the library:
#include <SPI.h>

#define CH0 0x00;
#define CH1 0x01;
#define CH2 0x02;
#define CH3 0x03;
#define CH4 0x04;
#define CH5 0x05;
#define CH6 0x06;
#define CH7 0x07;

// pins used for the connection with the sensor
// the other you need are controlled by the SPI library):
const int dataReady = 53;
const int chipSelect = 52;

byte channel;

unsigned long value;
unsigned long conf;

void setup() {
  Serial.begin(9600);

  // -------- SPI initialization
  pinMode(chipSelect, OUTPUT);  // Set the SS pin as an output
  digitalWrite(chipSelect, HIGH);  // Set the SS pin HIGH
  SPI.begin();  // Begin SPI hardware
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(210);  // Slow down SPI clock
  SPI.setDataMode(SPI_MODE2);

  // initalize the  data ready and chip select pins:
  pinMode(dataReady, INPUT);
  //digitalWrite(dataReady, HIGH);  // Pull-up DRDY pin
  
  channel = CH1;
  Serial.println(channel, HEX);

  // configure AD7714
  writeRegister(0x20 | channel, 0x4F); //  filter high register
  // set unipolar mode, 16 bits, boots off, all 4 MSBs of filterword to 1
  conf = readRegister(0x28 | channel, 1);
  Serial.println(conf, HEX);
  
  writeRegister(0x30 | channel, 0xA0); // filter low register
  // max filter word allowed for low part of the filterword
  conf = readRegister(0x38 | channel, 1);
  Serial.println(conf, HEX);
  
  writeRegister(0x10 | channel, 0x20); // mode register
  // set gain to 1, bornout current off, no filter sync, and do a self calibration
  conf = readRegister(0x18 | channel, 1);
  Serial.println(conf, HEX);

  // give the sensor time to set up:
  delay(100);
}

void loop() {
  if (digitalRead(dataReady) == 0)
  {
    value = readRegister(0x58 | channel, 3);

    Serial.print(value, HEX);
    Serial.println(" = " + String((float(value) / 16777216.0) * 3.3) + " V");
    delay(1000);
  }
}

//Read from or write to register from the AD7714:
unsigned long readRegister(byte thisRegister, int bytesToRead ) {
  byte temp = 0;
  byte inByte = 0;           // incoming byte from the SPI
  unsigned long result = 0;   // result to return

  // take the chip select low to select the device:
  digitalWrite(chipSelect, LOW);

  // send the device the register you want to read:
  temp = SPI.transfer(thisRegister);
  // send a value of 0 to read the first byte returned:
  result = SPI.transfer(0);
  // decrement the number of bytes left to read:
  bytesToRead--;

  // if you still have another byte to read:
  while (bytesToRead > 0) {
    // shift the first byte left, then get the second byte:
    result = result << 8;
    inByte = SPI.transfer(0);
    // combine the byte you just got with the previous one:
    result = result | inByte;
    // decrement the number of bytes left to read:
    bytesToRead--;
  }

  // take the chip select high to de-select:
  digitalWrite(chipSelect, HIGH);
  // return the result:
  return result;
}

//Sends a write command to ad7714
byte writeRegister(byte thisRegister, byte thisValue) {
  byte stat = 0;
  byte unk = 0;

  // take the chip select low to select the device:
  digitalWrite(chipSelect, LOW);

  stat = SPI.transfer(thisRegister); //Send register location
  unk = SPI.transfer(thisValue);  //Send value to record into register
  
  // take the chip select high to de-select:
  digitalWrite(chipSelect, HIGH);
}

I can read the filter and mode register in correct way (4F - A0 - 20) in the setup function.

Then, when I read the data register, the read value is always 800000 (24 bit).

I tried also your functions but give the same result.

Therefore, I don’t know if the problem is in the values that I passed to the setup register, as high filter and mode register.

Have you got any ideas?

aledio:
Hi Chuck,

I can read the filter and mode register in correct way (4F - A0 - 20) in the setup function.

Then, when I read the data register, the read value is always 800000 (24 bit).

I tried also your functions but give the same result.

Therefore, I don't know if the problem is in the values that I passed to the setup register, as high filter and mode register.

Have you got any ideas?

What is your circuit?

This statement in your Setup() does not do what the Comment says.

writeRegister(0x20 | channel, 0x4F); // filter high register
// set unipolar mode, 16 bits, boots off, all 4 MSBs of filterword to 1

This command actually sets BIpolar mode. b7=0, for unipolar with 24bit 0xCF,

Now on the Filter selections, the Spec Sheet says the FS0..FS11 must be in 19 to 4000 decimal

you are right at 4000.

With the BiPolar mode selected 0x800000 is zero, what is your actual circuit?

If you have just completed a calibration with the inputs shorted, and in BiPolar mode I would expect 0x800000 to be the value returned.

What were you expecting?

Chuck.

I have solved the problems of the SPI communication.

I use the writing/reading functions that you wrote.

Now I can read correctly the registers.

I post my correct code:

/* Hardware Connections Arduino <--> AD7714
PIN 1 -> SCLK : external clock SPI Arduino
PIN 2 -> MCLK IN : 2.4576 MHz by crystal (input)
PIN 3 -> MCLK OUT : 2.4576 MHz (output)
PIN 4 -> POL = 0: first transition of the serial clock in a data transfer operation is from a low to a high
PIN 5 -> (SYNC) = 1 : synchronization of the digital filters and analog modulators
PIN 6 -> (RESET) : Reset (PIN 30) Arduino
PIN 7/8/9/10 -> AIN1/AIN2/AIN3/AIN4 : Analog Input Channel
PIN 11 -> (STANDBY) = 1 : disable Standby
PIN 12 -> AVdd = 3.3 V
PIN 13 -> BUFFER = 0 : analog input is shorted out
PIN 14 -> REF IN(-) = AGND : negative input of the differential reference input
PIN 15 -> REF IN(+) = AVdd/2 : positive input of the differential reference input
PIN 16/17 -> AIN5/AIN6 : Analog Input Channel
PIN 18 -> AGND = GND
PIN 19 -> (CS) : chip select SPI (PIN 52) Arduino
PIN 20 -> (DRDY) : logic input of the AD7714
PIN 21 -> DOUT : serial data output, MISO SPI Arduino
PIN 22 -> DIN : serial data input, MOSI SPI Arduino
PIN 23 -> DVdd = 3.3 V
PIN 24 -> DGND = GND
*/

// SPI library
#include <SPI.h>

// define channels AD7714
#define CH0 0x00 // Pseudo Differential AIN1 - AIN6
#define CH1 0x01 // Pseudo Differential AIN2 - AIN6
#define CH2 0x02 // Pseudo Differential AIN3 - AIN6
#define CH3 0x03 // Pseudo Differential AIN4 - AIN6
#define CH4 0x04 // Fully Differential AIN1 - AIN2
#define CH5 0x05 // Fully Differential AIN3 - AIN4
#define CH6 0x06 // Fully Differential AIN5 - AIN6
#define CH7 0x07 // Test Mode AIN6 - AIN6

// constants and variables:
const int dataReady = 53;
const int CS = 52;
const int RESET = 30;

uint8_t ain;
uint8_t conf;
uint8_t channel[8] = {CH0, CH1, CH2, CH3, CH4, CH5, CH6, CH7};

uint32_t measur;
uint32_t conf3;
uint32_t temp;

bool bits24 = false; // is dataregister configured for 24bits?

char i;
int a = 0;

void setup() {
  Serial.begin(9600);

  // -------- SPI initialization
  pinMode(CS, OUTPUT);  // Set the SS pin as an output
  digitalWrite(CS, HIGH);  // Set the SS pin HIGH
  SPI.begin();  // Begin SPI hardware
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(210);  // Slow down SPI clock
  SPI.setDataMode(SPI_MODE2);

  // initalize the  data ready and chip select pins:
  pinMode(dataReady, INPUT);
  pinMode(RESET, OUTPUT);

  digitalWrite(RESET, LOW);
  delay(100);
  digitalWrite(RESET, HIGH);


  // configure filter high and low register AD7714
  for (i = 0; i < 7; i++) {

    if (i == 4 || i == 5) continue;

    ain = channel[i];
    Serial.println("Init channel: CH" + String(ain));

    //  delay(50);

    writeByteRegister(2, 0x81); // filter high register

    writeByteRegister(3, 0x80); // filter low register
  }

  // channels calibration AD7714
  for (i = 0; i < 3; i++) {
    ain = i;
    writeByteRegister(1, 0x20);
    while (digitalRead(dataReady));
    while (!(digitalRead(dataReady)));
  }

  Serial.println("Calibration register");
  conf3 = readbigRegister(6);
  Serial.println(conf3, HEX);
  conf3 = readbigRegister(7);
  Serial.println(conf3, HEX);
}

void loop() {

  delay(1000);
  
  Serial.println("Acquisition " + String(a));

  for (i = 0; i < 7; i++) {
    if (i == 4 || i == 5) continue;

    ain = channel[i];
    measur = readbigRegister(5);
    while (!(digitalRead(dataReady)));
    while (digitalRead(dataReady));
    while (!(digitalRead(dataReady)));
    while (digitalRead(dataReady));

    Serial.print("Channel CH" + String(ain) + " : ");
    Serial.print(measur, HEX);
    Serial.println(" = " + String((float(measur) / 65536.0) * 3.3) + " V");
//    Serial.println(" = " + String((float(measur) / 16777216.0) * 3.3) + " V");
  }

  a = a + 1;
}

I have some measuring problem of the input value:
for example when the input voltage changes to the channel AIN1 (with AIN6 to ground), changes the value to the AIN2-AIN6 channel. It is very strange!

Furthermore, I can read a voltage variation if the ADC is not powered with the 3.3 V. When I attach 3.3 V as supply the read value are fixed to 3.3/0/1.65/2.47 while when do not attach the supply (and the power is 2.47 V… I don’t now why) I can measure the voltage value of the channels but (as explained before) in different channels.

Have you got any idea why this behaviour?

aledio:
I have solved the problems of the SPI communication.

I have some measuring problem of the input value:
for example when the input voltage changes to the channel AIN1 (with AIN6 to ground), changes the value to the AIN2-AIN6 channel. It is very strange!

How much variation is bleeding thru?

How stable is your AVdd?

if you are expecting 24bits of resolution (1.96E-7 Volts per bit value) your AVdd needs to be very stable. Any variation in the AVdd voltage will be reflected in the digital output value.
Capacitor, Shielding (RF interference), Static influences.

aledio:
Furthermore, I can read a voltage variation if the ADC is not powered with the 3.3 V. When I attach 3.3 V as supply the read value are fixed to 3.3/0/1.65/2.47 while when do not attach the supply (and the power is 2.47 V... I don't now why) I can measure the voltage value of the channels but (as explained before) in different channels.

Have you got any idea why this behaviour?

The device is specified for +3 to +3.6V AD7714-3 or 4.75 to 5.25V AD7714-5. I am surprised that it will run correctly at 2.47v.

What is the actual part number for you chip?

Chuck.