LTC2480 - 16-Bit ΔΣ ADC with Easy Drive Input Current Cancellation

/*!
Linear Technology DC798B Demonstration Board.
LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.

@verbatim

The LTC2480 is a 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.
It includes on-chip programmable gain and an oscillator. The LTC2480 can be
configured to provide a programmable gain from 1 to 256 in 8 steps, measure an
external signal or internal temperature sensor and reject line frequencies. 50Hz,
60Hz or simultaneous 50Hz/60Hz line frequency rejection can be selected as well
as a 2x speed-up mode.

The voltage on the input pins can have any value between GND – 0.3V and VCC + 0.3V.
Within these limits the converter bipolar input range (VIN = IN+ – IN–) extends
from –0.5 • VREF/GAIN to 0.5 • VREF/GAIN. Outside this input range the converter
produces unique overrange and underrange output codes.

@endverbatim

http://www.linear.com/product/LTC2480

http://www.linear.com/product/LTC2480#demoboards

REVISION HISTORY
$Revision: 5670 $
$Date: 2016-09-02 10:55:41 -0700 (Fri, 02 Sep 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 LTC2480
*/

#include <Arduino.h>
#include <stdint.h>
#include "Linduino.h"
#include "LT_SPI.h"
#include "UserInterface.h"
#include "LT_I2C.h"
#include "QuikEval_EEPROM.h"
#include "LTC24XX_general.h"
#include "LTC2480.h"
#include <SPI.h>

// Function Declaration
void print_title();                             // Print the title block
void print_prompt();                            // Prompt the user for an input command

void menu_1_read_input();
void menu_2_select_gain();
void menu_3_select_rejection();
void menu_4_reference_voltage();

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

// Global variables
float LTC2480_vref = 5;
float LTC2480_range = LTC2480_vref/2;
uint8_t LTC2480_gain_selection = LTC2480_GAIN_1;
uint8_t LTC2480_gain = 1;
uint8_t LTC2480_rejection_mode = 0;       // Simultaneous 50Hz/60Hz Rejection

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

  quikeval_I2C_init();          // Configure the EEPROM I2C port for 100kHz
  quikeval_SPI_init();          // Configure the spi port for 4MHz SCK
  quikeval_SPI_connect();       // Connect SPI to main data port

  Serial.begin(115200);         // Initialize the serial port to the PC
  print_title();
  demo_board_connected = discover_demo_board(demo_name);
  if (demo_board_connected)
  {
    print_prompt();
  }
  LTC2480_set_modes(LTC2480_CS, LTC2480_gain_selection, LTC2480_rejection_mode);
}

//! Repeats Linduino loop
void loop()
{
  uint16_t user_command;
  {
    if (Serial.available())
    {
      user_command = read_int();        // Read the user command
      if (user_command != 'm')
        Serial.println(user_command);   // Prints the user command to com port
      switch (user_command)
      {
        case 1:
          menu_1_read_input();
          break;
        case 2:
          menu_2_select_gain();
          break;
        case 3:
          menu_3_select_rejection();
          break;
        case 4:
          menu_4_reference_voltage();
          break;
        default:
          Serial.println(F("Invalid Option"));
          break;
      }
      Serial.println();
      print_prompt();
    }
  }
}

// Function Definitions
//! Read channel
//! @return void
void menu_1_read_input()
{
  uint8_t user_command;
  uint32_t adc_code;                           // The LTC2480 code
  int32_t display_code = 0;
  float adc_voltage;                               // The LTC2480 voltage

  // Read and display
  LTC2480_read(LTC2480_CS, &adc_code);      // discard the first reading
  delay(200);
  LTC2480_read(LTC2480_CS, &adc_code);

  display_code = adc_code >> 4;
  display_code = display_code & 0xFFFF;

  Serial.print(F("  Received Code: 0x"));
  Serial.println(display_code, HEX);

  // Convert the received code to voltage
  adc_voltage = LTC2480_code_to_voltage(display_code, LTC2480_range, LTC2480_gain);

  if (adc_code & 0x100000)    // Checking sign bit
  {
    adc_voltage = LTC2480_range - adc_voltage;
    adc_voltage = adc_voltage * (-1);
  }

  Serial.print(F("  Equivalent voltage: "));
  Serial.print(adc_voltage, 4);
  Serial.println(F(" V"));
}

//! Select number of bits
//! @return void
void menu_2_select_gain()
{
  uint16_t user_command;

  Serial.println();
  Serial.print(F("  Select a gain (1, 4, 8, 16, 32, 64, 128, 256): "));

  user_command = read_int();    // Read user input
  Serial.println(user_command);   // Prints the user command to com port
  switch (user_command)
  {
    case 1:
      LTC2480_gain_selection = LTC2480_GAIN_1;
      LTC2480_gain = 1;
      Serial.println(F("  Gain = 1"));
      break;
    case 4:
      LTC2480_gain_selection = LTC2480_GAIN_4;
      LTC2480_gain = 4;
      Serial.println(F("  Gain = 4"));
      break;
    case 8:
      LTC2480_gain_selection = LTC2480_GAIN_8;
      LTC2480_gain = 8;
      Serial.println(F("  Gain = 8"));
      break;
    case 16:
      LTC2480_gain_selection = LTC2480_GAIN_16;
      LTC2480_gain = 16;
      Serial.println(F("  Gain = 16"));
      break;
    case 32:
      LTC2480_gain_selection = LTC2480_GAIN_32;
      LTC2480_gain = 32;
      Serial.println(F("  Gain = 32"));
      break;
    case 64:
      LTC2480_gain_selection = LTC2480_GAIN_64;
      LTC2480_gain = 64;
      Serial.println(F("  Gain = 64"));
      break;
    case 128:
      LTC2480_gain_selection = LTC2480_GAIN_128;
      LTC2480_gain = 128;
      Serial.println(F("  Gain = 128"));
      break;
    case 256:
      LTC2480_gain_selection = LTC2480_GAIN_256;
      LTC2480_gain = 256;
      Serial.println(F("  Gain = 256"));
      break;
    default:
      {
        Serial.println(F("  Invalid Option"));
        return;
      }
      break;
  }
  LTC2480_set_modes(LTC2480_CS, LTC2480_gain_selection, LTC2480_rejection_mode);
}

//! Select frequency rejection
//! @return void
void menu_3_select_rejection()
{
  uint8_t user_command;

  Serial.println(F("  0: Simultaneous 50Hz/60Hz rejection"));
  Serial.println(F("  1: 50Hz Rejection"));
  Serial.println(F("  2: 60Hz Rejection"));
  Serial.print(F("  Enter the required rejection mode: "));

  user_command = read_int();    // Read user input
  Serial.println(user_command);   // Prints the user command to com port

  switch (user_command)
  {
    case 0:
      Serial.println(F("Selected simultaneous 50Hz/60Hz rejection"));
      LTC2480_rejection_mode = 0x00;
      break;
    case 1:
      Serial.println(F("Selected 50Hz Rejection"));
      LTC2480_rejection_mode = 0x02;
      break;
    case 2:
      Serial.println(F("Selected 60Hz rejection"));
      LTC2480_rejection_mode = 0x04;
      break;
    default:
      {
        Serial.println(F("  Invalid Option"));
        return;
      }
      break;
  }
  LTC2480_set_modes(LTC2480_CS, LTC2480_gain_selection, LTC2480_rejection_mode);
}

void menu_4_reference_voltage()
{
  Serial.print(F("\n  Enter the reference voltage: "));
  LTC2480_vref = read_float();
  Serial.print(LTC2480_vref);
  Serial.println(F(" V"));

  LTC2480_range = LTC2480_vref/2;
}

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

//! Prints main menu.
void print_prompt()
{
  Serial.print(F("\n1-Read Input\n"));
  Serial.print(F("2-Select Gain\n"));
  Serial.print(F("3-Select Rejection\n"));
  Serial.print(F("4-Change reference voltage\n"));
  Serial.print(F("\nEnter a Command: "));
}

/*!
LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.

@verbatim

The LTC2480 is a 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.
It includes on-chip programmable gain and an oscillator. The LTC2480 can be
configured to provide a programmable gain from 1 to 256 in 8 steps, measure an
external signal or internal temperature sensor and reject line frequencies. 50Hz,
60Hz or simultaneous 50Hz/60Hz line frequency rejection can be selected as well
as a 2x speed-up mode.

@endverbatim

http://www.linear.com/product/LTC2480

http://www.linear.com/product/LTC2480#demoboards

REVISION HISTORY
$Revision: 5670 $
$Date: 2016-09-02 10:55:41 -0700 (Fri, 02 Sep 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 LTC2480 LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.

/*! @file
    @ingroup LTC2480
    Library for LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.
*/

#include <stdint.h>
#include "Linduino.h"
#include "LT_SPI.h"

// Function to set the input voltage gain and frequency rejection mode
void LTC2480_set_modes(uint8_t cs, uint8_t gain_selection, uint8_t rejection_mode)
{
  uint8_t rx;
  uint8_t mode = gain_selection | rejection_mode;
  mode = mode | 0x80;  // Enable
  spi_transfer_byte(cs, mode, &rx);
}

// Reads the LTC2480 and returns 24-bit data
void LTC2480_read(uint8_t cs, uint32_t *ptr_adc_code)
{
  LT_union_int32_4bytes data, command;  // LTC24XX data and command
  command.LT_uint32 = 0;
  data.LT_uint32 = 0;

  spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3);

  *ptr_adc_code = data.LT_uint32;
}

// Calculates the LTC2480 input voltage given the binary data, reference voltage and input gain.
float LTC2480_code_to_voltage(uint32_t adc_code, float vref, uint8_t gain)
{
  float voltage;

  voltage = (float)adc_code;
  voltage = voltage / (pow(2,16)-1);    //! 2) This calculates the input as a fraction of the reference voltage (dimensionless)
  voltage = voltage * vref;             //! 3) Multiply fraction by Vref to get the actual voltage at the input (in volts)
  voltage = voltage / gain;       //! 4) Divide by input gain

  return(voltage);
}

/*!
LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.

@verbatim

The LTC2480 is a 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.
It includes on-chip programmable gain and an oscillator. The LTC2480 can be
configured to provide a programmable gain from 1 to 256 in 8 steps, measure an
external signal or internal temperature sensor and reject line frequencies. 50Hz,
60Hz or simultaneous 50Hz/60Hz line frequency rejection can be selected as well
as a 2x speed-up mode.

Example Code:

Read ADC input.

    LTC2480_read(LTC2480_CS, &adc_code);   // Throws out last reading
    LTC2480_read(LTC2480_CS, &adc_code);   // Obtains the current reading and stores to adc_code variable

  display_code = adc_code >> 4;
    display_code = display_code & 0xFFFF;

  // Convert adc_code to voltage
    adc_voltage = LTC2480_code_to_voltage(display_code, vref, gain);

@endverbatim

http://www.linear.com/product/LTC2480

http://www.linear.com/product/LTC2480#demoboards

REVISION HISTORY
$Revision: 5670 $
$Date: 2016-09-02 10:55:41 -0700 (Fri, 02 Sep 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 LTC2480
    Header for LTC2480: 16-Bit Delta-Sigma ADC with Easy Drive Input Current Cancellation.
*/

#ifndef LTC2480_H
#define LTC2480_H

//! Define the SPI CS pin
#ifndef LTC2480_CS
#define LTC2480_CS QUIKEVAL_CS
#endif

//! @name LTC480 Input Gain
//! @{
// Input Gain
#define LTC2480_GAIN_1 0x00
#define LTC2480_GAIN_4 0x10
#define LTC2480_GAIN_8 0x20
#define LTC2480_GAIN_16 0x30
#define LTC2480_GAIN_32 0x40
#define LTC2480_GAIN_64 0x50
#define LTC2480_GAIN_128 0x60
#define LTC2480_GAIN_256 0x70
//!@}

//! Function to set the input voltage gain and frequency rejection mode
//! @return void
void LTC2480_set_modes(uint8_t cs,        //!< Chip Select Pin
                       uint8_t gain,       //!< Input voltage gain
                       uint8_t rejection_mode);  //!< Frequency rejection mode

//! Reads the LTC2480 and returns 24-bit data
//! @return void
void LTC2480_read(uint8_t cs,         //!< Chip Select Pin
                  uint32_t *ptr_adc_code  //!< Returns code read from ADC (from previous conversion)
                 );

//! Calculates the LTC2480 input voltage given the binary data, reference voltage and input gain.
//! @return Floating point voltage
float LTC2480_code_to_voltage(uint32_t adc_code,      //!< Raw ADC code
                              float vref,           //!< Reference voltage
                              uint8_t gain          //!< Input voltage gain
                             );


#endif  //  LTC2480_H