LTC2453 - Ultra-Tiny, Differential, 16-Bit Delta Sigma ADC With I2C Interface

/*!
Linear Technology DC1491A Demonstration Board.
LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.

Linear Technology DC1493A Demonstration Board.
LTC2463: Differential, 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.

Linear Technology DC1266A Demonstration Board.
LTC2453: Differential, 16-Bit Delta Sigma ADC With I2C Interface

@verbatim

NOTES
  Setup:
   Set the terminal baud rate to 115200 and select the newline terminator. A voltage
   source (preferably low-noise) and a precision voltmeter are required. Ensure all
   jumpers on the demo board are installed in their default positions from the
   factory. Refer to Demo Manual DC1491A.
   * Run menu entry 4 if the voltage readings are not accurate. The DC1491A is not
     calibrated in the factory. Default values will be used until first customer
     calibration.
   If the voltage readings are in error, run menu entry 4 again. The previous
   calibration by the user may have been performed improperly.

  Menu Entry 1: Read ADC Voltage
   Ensure the applied voltage is within the analog input voltage range of 0V to
   +1.25V. Connect the voltage source between the DC1491A's IN terminal and GND
   terminal. This menu entry configures the LTC2461 to operate in 30 Hz mode.

  Menu Entry 2: Sleep Mode
   Enables sleep mode. Note that the REFOUT voltage will go to zero. Any
   subsequent read command will wake up the LTC2461.

  Menu Entry 3: 60 Hz Speed Mode
   Setup is the same as for Menu Entry 1, except the LTC2461 operates in 60 Hz mode,
   and continuous background offset calibration is not performed.

  Menu Entry 4: Calibration
   Follow the command cues to alternately enter voltages with VIN at GND and with
   VIN near full scale voltage, approximately 1.20V. Upon startup, the calibration
   values will be restored.

USER INPUT DATA FORMAT:
 decimal : 1024
 hex     : 0x400
 octal   : 02000  (leading 0 "zero")
 binary  : B10000000000
 float   : 1024.0

@endverbatim

http://www.linear.com/product/LTC2461
http://www.linear.com/product/LTC2463
http://www.linear.com/product/LTC2453

http://www.linear.com/product/LTC2461#demoboards
http://www.linear.com/product/LTC2463#demoboards
http://www.linear.com/product/LTC2453#demoboards

REVISION HISTORY
$Revision: 4779 $
$Date: 2016-03-14 11:47:47 -0700 (Mon, 14 Mar 2016) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
 */

/*! @file
    @ingroup LTC2461
*/

#include <Arduino.h>
#include <stdint.h>
#include "Linduino.h"
#include "LT_SPI.h" // Needs this library to connect to main I2C
#include "UserInterface.h"
#include "LT_I2C.h"
#include "QuikEval_EEPROM.h"
#include "LTC2461.h"
#include <SPI.h>
#include <Wire.h>

// Function Declaration
void print_title();
void print_prompt();
int8_t restore_calibration();
void store_calibration();
int8_t menu_1_read_30Hz_mode();
int8_t menu_2_sleep_mode();
int8_t menu_3_read_60Hz_mode();
int8_t menu_4_calibrate();

// Global variables
static uint8_t demo_board_connected;        //!< Set to 1 if the board is connected

// Calibration Variables
static float LTC2461_lsb = 1.907377E-05;    //!< Ideal LSB voltage for a perfect part (Vref/(2^16))
static int32_t LTC2461_offset_code = 0;     //!< Ideal offset for a perfect part

//! Initialize Linduino
void setup()
{
  char demo_name[]="DC1491";    // Demo Board Name stored in QuikEval EEPROM

  quikeval_I2C_init();          // Configure the EEPROM I2C port for 100kHz
  quikeval_I2C_connect();       // Connects to Main I2C
  Serial.begin(115200);         // Initialize the serial port to the PC
  print_title();

  demo_board_connected = discover_demo_board(demo_name);
  if (demo_board_connected)
  {
    restore_calibration();
    print_prompt();
  }
}

//! Repeats Linduino loop
void loop()  // ***** BEGIN MAIN CONTROL LOOP *****
{
  int8_t ack = 0;                   // Set I2C acknowledge bit to zero at start of every loop.
  if (demo_board_connected)
  {
    if (Serial.available())         // Check for user input
    {
      uint16_t user_command;
      user_command = read_int();    // Read the user command
      Serial.println(user_command);

      switch (user_command)
      {
          // 30 Hz Standard Read Mode
        case 1:
          ack |= menu_1_read_30Hz_mode();
          break;

        case 2:
          ack |= menu_2_sleep_mode();
          break;

        case 3:
          // 60 Hz Read Mode
          ack |= menu_3_read_60Hz_mode();
          break;

        case 4:
          // Calibration
          ack |= menu_4_calibrate();
          break;

        default:
          Serial.println("***** INCORRECT ENTRY *****");  // Input validation
      }
      Serial.println();
      if (ack != 0)
      {
        Serial.println("Error: No Acknowledge. Check I2C Address.");
        Serial.println("***** ACK ERROR *****");
      }

      Serial.println("\n*****************************************************************");
      print_prompt();
    }
  }
}

// Function Definitions

//! Prints the title block when program first starts.
void print_title()
{
  Serial.println("");
  Serial.println("*****************************************************************");
  Serial.println("* DC1491A Demonstration Program                                 *");
  Serial.println("*                                                               *");
  Serial.println("* This program demonstrates how to send data and receive data   *");
  Serial.println("* from the LTC2461 16-bit ADC.                                  *");
  Serial.println("*                                                               *");
  Serial.println("*                                                               *");
  Serial.println("* Set the baud rate to 115200 and select the newline terminator.*");
  Serial.println("*                                                               *");
  Serial.println("*****************************************************************");
}

//! Prints main menu.
void print_prompt()    // This function prints menu
{
  Serial.println("");
  Serial.println("1-Read ADC Voltage");
  Serial.println("2-Sleep Mode");
  Serial.println("3-60 Hz Speed Mode");
  Serial.println("4-Calibration");
  Serial.println();
  Serial.print("Enter a command:");
}

//! Store measured calibration parameters to nonvolatile EEPROM on demo board
void store_calibration()
// Store the ADC calibration to the EEPROM
{
  eeprom_write_int16(EEPROM_I2C_ADDRESS, EEPROM_CAL_KEY, EEPROM_CAL_STATUS_ADDRESS);         // Cal key
  eeprom_write_int32(EEPROM_I2C_ADDRESS, LTC2461_offset_code, EEPROM_CAL_STATUS_ADDRESS+2);  // Store Offset
  eeprom_write_float(EEPROM_I2C_ADDRESS, LTC2461_lsb, EEPROM_CAL_STATUS_ADDRESS+6);          // Store LSB
  Serial.println("Calibration Stored to EEPROM");
}

//! Read stored calibration parameters from nonvolatile EEPROM on demo board
//! @return Return 1 if successful, 0 if not
int8_t restore_calibration()
{
// Read the calibration from EEPROM
// Return 1 if successful, 0 if not

  int16_t cal_key;
  // Read the cal key from the EEPROM
  eeprom_read_int16(EEPROM_I2C_ADDRESS, &cal_key, EEPROM_CAL_STATUS_ADDRESS);
  if (cal_key == EEPROM_CAL_KEY)
  {
    // Calibration has been stored, read offset and lsb
    eeprom_read_int32(EEPROM_I2C_ADDRESS, &LTC2461_offset_code, EEPROM_CAL_STATUS_ADDRESS+2);  // Offset
    eeprom_read_float(EEPROM_I2C_ADDRESS, &LTC2461_lsb, EEPROM_CAL_STATUS_ADDRESS+6);          // LSB
    Serial.println("Calibration Restored");
    return(1);
  }
  else
  {
    Serial.println("Calibration not found");
    return(0);
  }
}

//! Read ADC in 30 Hz mode
//! @return ACK bit (0=acknowledge, 1=no acknowledge)
int8_t menu_1_read_30Hz_mode()
{
  uint16_t adc_code_30Hz;
  int8_t ack = 0;
  Serial.println();
  Serial.print("ADC Command: b");
  Serial.println(LTC2461_60HZ_SPEED_MODE, BIN);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &adc_code_30Hz);  // Throw out this reading
  delay(100);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &adc_code_30Hz);
  delay(100);
  Serial.print("Received Code: 0x");
  Serial.println(adc_code_30Hz, HEX);

  // Use the calibration values stored on the DC1491A EEPROM to convert the raw_adc_reading to a (float) voltage value which is stored in adc_voltage_30Hz.
  // Run menu entry 4 if the voltage readings are not accurate.  The DC1491A is not calibrated in the factory.  Default values will be used until first customer calibration.
  // If the voltage readings are in error, run menu 4 again.  The previous calibration by the user may have been performed improperly.

  float adc_voltage_30Hz;
  adc_voltage_30Hz = LTC2461_code_to_voltage(adc_code_30Hz, LTC2461_lsb, LTC2461_offset_code);
  Serial.println();
  Serial.print("Voltage Reading: ");
  Serial.print(adc_voltage_30Hz, 4);
  Serial.println("V");
  return(ack);
}

//! Sleep Mode
//! @return ACK bit (0=acknowledge, 1=no acknowledge)
int8_t menu_2_sleep_mode()
{
  int8_t ack = 0;
  ack |= LTC2461_command(LTC2461_I2C_ADDRESS, LTC2461_SLEEP_MODE);
  delay(100);
  Serial.println();
  Serial.print("ADC Command: b");
  Serial.println(LTC2461_SLEEP_MODE, BIN);
  ack |= LTC2461_command(LTC2461_I2C_ADDRESS, LTC2461_SLEEP_MODE);    // send sleep mode command
  delay(100);
  Serial.println();
  Serial.println("***** LTC2461 In Sleep Mode ******");
  return(ack);
}

//! Read ADC in 60 Hz mode
//! @return ACK bit (0=acknowledge, 1=no acknowledge)
int8_t menu_3_read_60Hz_mode()
{
  // 60 Hz Read Mode
  uint16_t adc_code_60Hz;
  int8_t ack = 0;
  Serial.println();
  Serial.print("ADC Command: b");
  Serial.println(LTC2461_30HZ_SPEED_MODE, BIN);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_60HZ_SPEED_MODE, &adc_code_60Hz);     // Throw out this reading
  delay(100);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_60HZ_SPEED_MODE, &adc_code_60Hz);
  delay(100);
  Serial.print("Received Code: 0x");
  Serial.println(adc_code_60Hz, HEX);

  // Use the calibration values stored on the DC1491A EEPROM to convert the raw_adc_reading to a (float) voltage value which is stored in adc_voltage_60Hz
  // Run menu entry 4 if the voltage readings are not accurate.  The DC1491A is not calibrated in the factory.  Default values will be used until first customer calibration.
  // If the voltage readings are in error, run menu 4 again.  The previous calibration by the user may have been performed improperly.

  float adc_voltage_60Hz;
  adc_voltage_60Hz = LTC2461_code_to_voltage(adc_code_60Hz, LTC2461_lsb, LTC2461_offset_code);
  Serial.println();
  Serial.print("Voltage Reading: ");
  Serial.print(adc_voltage_60Hz, 4);
  Serial.println("V");
  Serial.println("*** 60 Hz Speed Mode ***");
  return(ack);
}

//! Calibrate the LTC2461
//! @return ACK bit (0=acknowledge, 1=no acknowledge)
int8_t menu_4_calibrate()
{
  // Calibration
  uint16_t zero_code;   // Cal zero code
  float zero_voltage;
  int8_t ack = 0;

  Serial.println("Apply 100mV to the input.");
  Serial.println("or apply a voltage for the lower point in two point calibration");
  Serial.print("Enter the measured input voltage:");
  zero_voltage = read_float();
  Serial.println(zero_voltage, 6);

  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &zero_code);  // Throw out this reading
  delay(100);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &zero_code);  // Measure zero

  Serial.println("Apply ~1.20V input voltage to input.");
  Serial.println("Enter the measured input voltage:");
  float fs_voltage;               // Measured cal voltage
  fs_voltage = read_float();      // read function in UserInterface.h: reads float from serial input
  Serial.println(fs_voltage, 6);

  uint16_t fs_code;               // Cal full scale code
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &fs_code);     // Throw out this reading
  delay(100);
  ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_30HZ_SPEED_MODE, &fs_code);     // Measure full scale
  LTC2461_cal_voltage(zero_code, fs_code, zero_voltage, fs_voltage, &LTC2461_lsb, &LTC2461_offset_code);  // Modifies offset code and lsb size using linear interpolation

  Serial.print("ADC offset code: ");
  Serial.print(LTC2461_offset_code);
  Serial.println();
  Serial.print("ADC calibrated lsb size : ");
  Serial.print(LTC2461_lsb * 1.0e6, 4);
  Serial.println(" uV (16-bits)");
  store_calibration();             // Store cal factors in EEPROM
  return(ack);
}

/*!
LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.
LTC2463: Differential, 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.
LTC2453: Differential, 16-Bit Delta Sigma ADC With I2C Interface.

@verbatim

The LTC2461/LTC2463 are ultra tiny, 16-Bit analog-to-digital converters with an
integrated precision reference. They use a single 2.7V to 5.5V supply and
communicate through an I2C Interface. The LTC2461 is single-ended with a 0V to
1.25V input range and the LTC2463 is differential with a 1.25V input range. Both
ADCs include a 1.25V integrated reference with 2ppm/C drift performance and 0.1%
initial accuracy. The converters are available in a 12-pin 3mm x 3mm DFN package
or an MSOP-12 package. They include an integrated oscillator and perform
conversions with no latency for multiplexed applications. The LTC2461/LTC2463
include a proprietary input sampling scheme that reduces the average input
current several orders of magnitude when compared to conventional delta sigma
converters

@endverbatim

http://www.linear.com/product/LTC2461
http://www.linear.com/product/LTC2463
http://www.linear.com/product/LTC2453

http://www.linear.com/product/LTC2461#demoboards
http://www.linear.com/product/LTC2463#demoboards
http://www.linear.com/product/LTC2453#demoboards

REVISION HISTORY
$Revision: 4779 $
$Date: 2016-03-14 11:47:47 -0700 (Mon, 14 Mar 2016) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
*/

//! @defgroup LTC2461 LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference

/*! @file
    @ingroup LTC2461
    Library for LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference
*/

#include <Arduino.h>
#include <stdint.h>
#include "Linduino.h"
#include "LT_I2C.h"
#include "LTC2461.h"
#include <Wire.h>

int8_t LTC2461_read(uint8_t i2c_address, uint8_t adc_command, uint16_t *adc_code)
// Reads 16 bits.
{
  int32_t ack = 0;

  ack = i2c_read_word_data(i2c_address, adc_command, adc_code);

  return(ack);

}

int8_t LTC2461_command(uint8_t i2c_address, uint8_t adc_command)
// Write an 8-bit command to the ADC.
// The function returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge.
{
  int32_t ack = 0;

  ack = i2c_write_byte(i2c_address, adc_command);
  return(ack);
}

float LTC2461_code_to_voltage(uint16_t adc_code, float LTC2461_lsb, int32_t LTC2461_offset_code)
// Calculates the LTC2461 input unipolar voltage.
{
  float adc_voltage;
  adc_voltage = (adc_code + LTC2461_offset_code)*(LTC2461_lsb); //! 1) Calculate voltage from ADC code, lsb, offset.
  return(adc_voltage);
}

void LTC2461_cal_voltage(uint16_t zero_code, uint16_t fs_code, float zero_voltage, float fs_voltage, float *LTC2461_lsb, int32_t *LTC2461_offset_code)  // Function definition
// Calibrate the lsb
{
  float temp_offset;
  *LTC2461_lsb = (fs_voltage-zero_voltage)/((float)(fs_code - zero_code));                              //! 1) Calculate the LSB

  temp_offset = (zero_voltage/ *LTC2461_lsb) - zero_code;                                               //! 2) Calculate Unipolar offset
  temp_offset = (temp_offset > (floor(temp_offset) + 0.5)) ? ceil(temp_offset) : floor(temp_offset);    //! 3) Round
  *LTC2461_offset_code = (int32_t)temp_offset;                                                          //! 4) Cast as int32_t
}

/*!
LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.
LTC2463: Differential, 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference.
LTC2453: Differential, 16-Bit Delta Sigma ADC With I2C Interface.

@verbatim

The LTC2461/LTC2463 are ultra tiny, 16-Bit analog-todigital converters with an
integrated precision reference. They use a single 2.7V to 5.5V supply and
communicate through an I2C Interface. The LTC2461 is single-ended with a 0V to
1.25V input range and the LTC2463 is differential with a 1.25V input range. Both
ADCs include a 1.25V integrated reference with 2ppm/C drift performance and 0.1%
initial accuracy. The converters are available in a 12-pin 3mm x 3mm DFN package
or an MSOP-12 package. They include an integrated oscillator and perform
conversions with no latency for multiplexed applications. The LTC2461/LTC2463
include a proprietary input sampling scheme that reduces the average input
current several orders of magnitude when compared to conventional delta sigma
converters

I2C DATA FORMAT (MSB First):

       Byte #1                             Byte #2                              Byte #3

START  SA6 SA5 SA4 SA3 SA2 SA1 SA0 W SACK  EN1 EN2 SPD SLP X   X   X  X   SACK  STOP

START  SA6 SA5 SA4 SA3 SA2 SA1 SA0 R SACK  D15 D14 D13 D12 D11 D10 D9 D8  MACK  D7 D6  D5  D4  D3  D2  D1  D0 MNACK STOP

SACK  : Slave Acknowledge
MACK  : Master Acknowledge
MNACK : Master Not Acknowledge
Sx    : Address Select Bit
EN1   : Enable 1 : to program, EN1 = High, EN2 = Low
EN2   : Enable 2
SPD   : Speed Bit- 0 for 60Hz, 1 for 30Hz
SLP   : Sleep Mode Bit
X     : Don't care
Dx    : Data Bits


Example Code:

Read ADC in 60Hz Speed Mode

    ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_60HZ_SPEED_MODE, &adc_code_60Hz);  // Throws out last reading
    ack |= LTC2461_read(LTC2461_I2C_ADDRESS, LTC2461_60HZ_SPEED_MODE, &adc_code_60Hz);  // Obtains the current reading and
                                                                                        // stores to adc_code_60Hz variable

    // Convert adc_code_60Hz to voltage
    adc_voltage_60Hz = LTC2461_code_to_voltage(adc_code_60Hz, LTC2461_lsb, LTC2461_offset_code);

@endverbatim

http://www.linear.com/product/LTC2461
http://www.linear.com/product/LTC2463
http://www.linear.com/product/LTC2453

http://www.linear.com/product/LTC2461#demoboards
http://www.linear.com/product/LTC2463#demoboards
http://www.linear.com/product/LTC2453#demoboards

REVISION HISTORY
$Revision: 4779 $
$Date: 2016-03-14 11:47:47 -0700 (Mon, 14 Mar 2016) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
*/

/*! @file
    @ingroup LTC2461
    Header for LTC2461: 16-Bit I2C Delta Sigma ADCs with 10ppm/C Max Precision Reference
*/

#ifndef LTC2461_H
#define LTC2461_H

#include <Wire.h>

// Address Choices:
// To choose an address, comment out all options except the
// configuration on the demo board:

//! @name I2C addresses
//! @{
//! Un-comment the address corresponding to the LTC2309's address

// LTC2461 I2C Addresses
#define LTC2461_I2C_ADDRESS    0x14   //  A0 = LOW : this is demo board default
// #define LTC2461_I2C_ADDRESS    0x54   //  A0 = HIGH
//!@}

//! @name Modes
//! @{
// Command Constants
#define LTC2461_30HZ_SPEED_MODE    0xA0     // SPD=1
#define LTC2461_60HZ_SPEED_MODE    0x80     // SPD=0
#define LTC2461_SLEEP_MODE         0x90     // SLP=1 SPD=XX
//!@}

//! Reads the ADC  and returns 16-bit data
//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge.
int8_t LTC2461_read(uint8_t i2c_address,    //!< I2C address of the LTC2461.
                    uint8_t adc_command,    //!< ADC command to be written to the LTC2461.
                    uint16_t *adc_code      //!< Returns code read from ADC.
                   );


//! Write a 16-bit command to the ADC. Derived from 2655.
//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge.
int8_t LTC2461_command(uint8_t i2c_address, //!< I2C address of the LTC2461.
                       uint8_t adc_command  //!< ADC command to be written to the LTC2461.
                      );

//! Calculates the LTC2309 input unipolar voltage.
//! @return Floating point voltage
float LTC2461_code_to_voltage(uint16_t adc_code,            //!< Raw ADC code
                              float LTC2461_lsb,            //!< LSB value (volts)
                              int32_t LTC2461_offset_code   //!< Offset code
                             );

//! Calibrate the lsb
//! @return Void
void LTC2461_cal_voltage(uint16_t zero_code,            //!< Code from zero reading
                         uint16_t fs_code,              //!< Full-scale code
                         float zero_voltage,            //!< Measured zero voltage
                         float fs_voltage,              //!< Measured full-scale voltage
                         float *LTC2461_lsb,            //!< Return LSB value (volts)
                         int32_t *LTC2461_offset_code   //!< Return Offset code
                        );


#endif  // LTC2461_H