The program below is what we currently have for interfacing the LDC1000 with the MSP430F5529 and a different coil. Below is the Main.c code under the LDC1000_F5529_DRDY folder found online. This code ran properly with the EVM coil, but when switching coils stopped working. We believe this may be due to the fact that the capacitor is not attached to the new coil, however, when reattaching the EVM coil, the program still was not showing the LDC1000 values. We are using CCS cloud to modify the program.

Main.c (4/11/16)

 /* --COPYRIGHT--,BSD_EX
 * Copyright (c) Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * * 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.
 *
 * * Neither the name of Texas Instruments Incorporated nor the names of
 * its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * 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.
 *
 * --/COPYRIGHT--*/
/** 
* @section project LDC1000 Application Code
* @version 01.00.02
* @author Charles Cheung
* @date 101513
*/
//******************************************************************************
// MSP430F5529LP Demo - LDC1000 with DRDY through USB-CDC.
//
// Summary: Using USB-CDC, DRDY data can be sent to a USB Host.
//
// Description: Program calibrates the EVM then waits for any user input on
// the virtual COM port to begin streaming data. During this time
// EVM_GRN_LED will be flashing every 1 second.
//
// Once user input is received, data will begin streaming out.
// Packet format is:
// 1) if TIMESTAMP is defined (default):
// Seconds | DRDY | Proximity Data | Freq Counter Data
// 16-bits | 16-bits | 16-bits | 16-bits (LSB, Mid-Byte)
// 2) if TIMESTAMP is NOT defined:
// Proximity Data | Freq Counter Data
// 16-bits | 16-bits (LSB, Mid-Byte)
//
// 4MHz FLL to 24MHz DCOCLK, MCLK = ACLK = DCOCLK
// SMCLK = REF0 = 32.768kHz, used to drive 1 second timer
// EVM_LDCLK = ACLK Pin = ACLK / 4 = 6MHz
// EVM_SCLK = ACLK / 6 = 4MHz
//
// The CDC driver is located at:
// USB_config/MSP430_CDC.inf
//
// Alternatively it can be found in supporting files for
// the MSP430F5529LP.
//
// Note: Throughput can be increased by 2x by commenting out TIMESTAMP.
//
// Note2: The EVM library files
// - LDC1000_evm.c
// - spi_1p1.c
// have been modified to support SPI interrupt functionality
// without timeout. To adopt this library, we suggest modifying
// these files to use a timer interrupt to timeout SPI calls.
//
// Note3: For maximum USB host serial console throughput, we recommend
// using an OS like Linux or OSX.
//
// MSP430F552x
// -----------------
// /|\| X2IN|---__
// | | | |__| XTAL (4MHz)
// --|RST X2OUT|----
// /|\ | |
// EVM_INT-->| P1.2 X1IN|---__
// \|/ | | |__| XTAL (32.768kHz)
// | X1OUT|----
// | |
// | P4.7|-->EVM_GRN_LED
// | P7.0|-->EVM_RED_LED
// | 
// | P1.0/ACLK|-->EVM_LDCLK (TBCLK)
// | |
// | P4.0|-->EVM_CSB
// | P4.3/USCIB1CLK|-->EVM_SCLK
// | P4.2/USCIB1SOMI|<--EVM_SDO
// | P4.1/USCIB1SIMO|-->EVM_SDI
// | |
//
// Built with CCS Version 5.5.0
//******************************************************************************

// LDC1000 #includes
#include "LDC1000_evm.h"
#include "LDC1000_cmd.h"
#include "spi_1p1.h"

// Basic MSP430 and driverLib #includes
#include <intrinsics.h>
#include <string.h>
#include "msp430.h"
#include "driverlib/MSP430F5xx_6xx/wdt_a.h"
#include "driverlib/MSP430F5xx_6xx/ucs.h"
#include "driverlib/MSP430F5xx_6xx/pmm.h"
#include "driverlib/MSP430F5xx_6xx/sfr.h"
#include "driverlib/MSP430F5xx_6xx/inc/hw_memmap.h"

// USB API #includes
#include "USB_config/descriptors.h"
#include "USB_API/USB_Common/device.h"
#include "USB_API/USB_Common/types.h"
#include "USB_API/USB_Common/usb.h"
#include "USB_API/USB_CDC_API/UsbCdc.h"
#include "USB_app/usbConstructs.h"

// Application #includes
#include "hal.h" // Modify hal.h to select your hardware

/* With CDC, the USB device presents a COM port on the host;
 * you interact with it with a terminal application, like Hyperterminal or
 * Docklight.
 *
 * For deeper information on CDC Datapipe, see the USB API Programmer's
 * Guide in the USB Developers Package.
 */

// buffer size for LDC1000 data
#define BUFFER_SIZE 2048
// comment out for data without TIMESTAMP
#define TIMESTAMP

// Global variables
uint8_t bufferData[BUFFER_SIZE*2]; // buffer to send out
uint16_t bufferOffset; // sets the offset to write data to
uint8_t * bufferPtr; // pointer to current location in buffer
uint16_t bufferIdx; // buffer index counter
uint8_t led = 0; // LED toggle state
uint8_t dataReady = 0; // data ready flag
uint16_t drdyCounter = 0; // data ready counter
uint16_t secCounter = 0; // seconds counter

VOID main(VOID)
{
 uint8_t dummyByte; // dummy byte
 uint16_t dummyWord; // dummy word
 WDTCTL = WDTPW + WDTHOLD; // Stop Watchdog Tim 

 // MSP430 USB requires a Vcore setting of at least 2. 3 is the highest setting
 // for 24MHz MCLK, below.
 PMM_setVCore(PMM_BASE, PMM_CORE_LEVEL_3);

 initPorts(); // Config all the GPIOS for low-power (output low)
 initClocks(24000000); // Config clocks.

 // initialize LDC1000 (default threshold function on EVM_INT)
 __enable_interrupt(); // enable interrupts (for SPI)
 evm_init(); // Output selected clock to LDCLK, Inits LDC1000
 evm_test(); // Tests and Calibrates LDC1000
 __disable_interrupt(); // disable interrupts

 USB_setup(TRUE,TRUE); // Init USB; if a USB host (PC) is present, connect

 // setup watchdog as 1 second timer
 WDT_A_intervalTimerInit(WDT_A_BASE,WDT_A_CLOCKSOURCE_SMCLK,WDT_A_CLOCKDIVIDER_32K);
 WDT_A_start(WDT_A_BASE);
 SFRIE1 |= WDTIE;

 __enable_interrupt(); // enable interrupts

 // wait for keypress over USB (will timeout after 65535 seconds)
 secCounter = 1;
 while (secCounter != 0) {
 
 if (led)
 EVM_GRN_LED_OFF(); // Turn LED OFF
 else
 EVM_GRN_LED_ON(); // Turn LED ON
 dummyWord = secCounter;
 while (dummyWord == secCounter) {
 if (cdcReceiveDataInBuffer((BYTE*)&dummyByte, 1, CDC0_INTFNUM) > 0) {
secCounter = 0;
 break;
 }
 }
 }

 // un-comment to set fastest response time
// while(!spi_writeByte(NULL,LDC1000_CMD_PWRCONFIG,0x00));
// while(!spi_writeByte(NULL,LDC1000_CMD_LDCCONFIG,0x12)); // amplitude = 4V, response time = 192
// while(!spi_writeByte(NULL,LDC1000_CMD_PWRCONFIG,0x01));

 // set EVM_INT pin to DRDY function
 while(!spi_writeByte(NULL,LDC1000_CMD_INTCONFIG,0x04));

 // setup DRDY pin interrupt
 P1DIR &= ~BIT2; // INPUT
 P1IE |= BIT2; // interrupt enabled
 P1IES |= BIT2; // Hi->Lo Edge
 P1IFG &= ~BIT2; // Clear IFG

 // prep buffer
 bufferOffset = 0;
 bufferIdx = 0;
 bufferPtr = &bufferData[bufferOffset];

 // reset timers
 WDT_A_resetTimer(WDT_A_BASE);
 secCounter = 0;
 drdyCounter = 0;
 // handle USB
 while (1)
 {
 switch (USB_connectionState())
 {
 case ST_USB_DISCONNECTED:
 __bis_SR_register(LPM3_bits + GIE); //Enter LPM3 w/interrupt
 _NOP();
 break;

 case ST_USB_CONNECTED_NO_ENUM:
 break;

 case ST_ENUM_ACTIVE:
 // if DRDY triggered, read data
 if (dataReady) {
 if (bufferIdx > (BUFFER_SIZE-8)) {
 if (cdcSendDataInBackground((BYTE*)&bufferData[bufferOffset],
 BUFFER_SIZE,CDC0_INTFNUM,0)) { //Send it
 USBCDC_abortSend((WORD*)&dummyWord,CDC0_INTFNUM); //Operation probably still open; cancel it
 }
 bufferOffset = (bufferOffset == 0) ? BUFFER_SIZE : 0;
 bufferPtr = &bufferData[bufferOffset];
 bufferIdx = 0;
 }
#ifdef TIMESTAMP
 bufferPtr[0] = secCounter;
 bufferPtr[1] = secCounter >> 8;
 bufferPtr[2] = drdyCounter;
 bufferPtr[3] = drdyCounter >> 8;
 // read data
 if (spi_readBytes(NULL, LDC1000_CMD_PROXLSB, &bufferPtr[4], 4) == TRUE) {
 bufferPtr += 8;
 bufferIdx += 8;
 dataReady = 0;
 }
#else
 // read data
 if (spi_readBytes(NULL, LDC1000_CMD_PROXLSB, &bufferPtr[0], 4) == TRUE) {
 bufferPtr += 4;
 bufferIdx += 4;
 dataReady = 0;
 }
#endif
 }
 else {
 __bis_SR_register(LPM3_bits + GIE);
 }
 break;

 case ST_ENUM_SUSPENDED:
 __bis_SR_register(LPM3_bits + GIE); //Enter LPM0 until a resume or VBUS-off event
 break;

 case ST_ENUM_IN_PROGRESS:
 break;

 case ST_NOENUM_SUSPENDED:
 __bis_SR_register(LPM3_bits + GIE);
 break;

 case ST_ERROR:
 _NOP();
 break;

 default:;
 }
 } //while(1)
}

// Port 1 interrupt service routine, DRDY
#pragma vector=PORT1_VECTOR
__interrupt VOID Port_1(VOID)
{
 
 dataReady = 1;
 drdyCounter++;
 if (!(P1IN & BIT2)) {
 led ^= 1;
 if (led)
 EVM_GRN_LED_OFF(); // Turn LED OFF
 else
 EVM_GRN_LED_ON(); // Turn LED ON
 dataReady = 1;
 drdyCounter++;
 __bic_SR_register_on_exit(LPM3_bits); // wakeup from sleep
 }
 P1IFG &= ~BIT2; // IFG cleared
}

// Watchdog 1 second interval timer
#pragma vector = WDT_VECTOR
__interrupt VOID WDT_ISR(VOID)
{
 secCounter++;
 drdyCounter = 0;
 __bic_SR_register_on_exit(LPM3_bits); // Clear LPM3 bits from 0(SR)
}

// UNMI ISR
#pragma vector = UNMI_VECTOR
__interrupt VOID UNMI_ISR (VOID)
{
 switch (__even_in_range(SYSUNIV, SYSUNIV_BUSIFG ))
 {
 case SYSUNIV_NONE:
 __no_operation();
 break;
 case SYSUNIV_NMIIFG:
 __no_operation();
 break;
 case SYSUNIV_OFIFG:
 UCSCTL7 &= ~(DCOFFG + XT1LFOFFG + XT2OFFG); //Clear OSC fault Flags
 SFRIFG1 &= ~OFIFG; //Clear OFIFG fault flag
 break;
 case SYSUNIV_ACCVIFG:
 __no_operation();
 break;
 case SYSUNIV_BUSIFG:
 SYSBERRIV = 0; //clear bus error flag
 USB_disable(); //Disable
 }
}