File content as of revision 19:e205ab9142d8:

/**
* @file LDC1101.cpp
* @brief this C++ file contains all required
* functions to interface with Texas
* Instruments' LDC1101.
*
* @author Victor Sluiter
*
* @date 2015-12-09
*/

#include "LDC1101.h"

 
LDC1101::LDC1101(PinName mosi, PinName miso, PinName sck, PinName cs, float capacitor, float f_CLKIN, PinName clock_out) : _spiport(mosi,miso,sck, NC), _cs_pin(cs)//, _clock(clock_out,1)
{
    // settings
    _cap = capacitor;
    _spiport.format(8,3);
    _spiport.frequency(1E6);
    setFrequency(f_CLKIN);
    
    _cs_pin.write(1);
    wait_us(100);
    
    init();
}

void LDC1101::init()
{
    // Set LDC1101 in configuration modus
    func_mode(LDC_MODE_STANDBY);     // STANDBY = 0x01 naar 0x0B  
    wait(0.1);

    // - initialise LHR mode
    setLHRmode();

    // - set ResponseTime to 6144
    // (This setting MUST be applied, leaving it to default does not work)
    setResponseTime(LDC_RESPONSE_6144); // 6144 = 0x07 naar 0x04
    
    // - set Reference Count to 8192 (13 ENOB - 2^13)
    setReferenceCount(0x8192);   //0xffff
    
    // - disable RP_MAX
    // - set RP_MIN to 3 kOhm
    setRPsettings(1, RPMIN_12);

    //  - set Divider to 2
    setDivider(DIVIDER_2);  

    // Done configuring settings, set LDC1101 in measuring modus
    func_mode(LDC_MODE_ACTIVE);      // ACTIVE = 0x00 naar 0x0B
}

void LDC1101::setResponseTime(LDC_RESPONSE responsetime)
{
    uint16_t resps[] = {0, 0, 192, 384, 768, 1536, 3072, 6144};
    _responsetime = resps[responsetime];
    writeSPIregister(0x04, responsetime);
}

void LDC1101::setReferenceCount(uint16_t rcount)
{
    _Rcount = rcount;
    
    uint8_t LHR_RCOUNT_LSB = (rcount & 0x00ff);
    uint8_t LHR_RCOUNT_MSB = ((rcount & 0xff00) >> 8);
    
    writeSPIregister(0x30, LHR_RCOUNT_LSB);   //LSB
    writeSPIregister(0x31, LHR_RCOUNT_MSB);   //MSB
}

void LDC1101::setRPsettings(bool RP_MAX_DIS, RPMIN rpmin)
{
    float rpmins[] = {96, 48, 24, 12, 6, 3, 1.5, 0.75};
    _RPmin = rpmins[rpmin];
    writeSPIregister(0x01, ((RP_MAX_DIS & 0x80) << 7 | rpmin));
}

void LDC1101::setDivider(DIVIDER div)
{
    uint8_t divs[] = {1, 2, 4, 8};
    _divider = divs[div];    
    writeSPIregister(0x34, div);
}   


float LDC1101::get_Q(void)
{
    return _RPmin * sqrt(_cap/_inductance*1000000); 
}  


float LDC1101::get_fsensor(void)
{
    _L_data = get_LHR_Data();
    _fsensor = _fCLKIN * _divider * _L_data/16777216;       // (p.26)
    return _fsensor;
}   


float LDC1101::get_Inductance(void)
{  
    _fsensor = get_fsensor();
    
    //               1
    // L = ---------------------        --> p. 34
    //     C * (2*PI*f_sensor)^2
    _inductance = 1./(_cap * 4*PI*PI*_fsensor*_fsensor);
    return _inductance;
}


uint32_t LDC1101::get_LHR_Data(void)
{
    // LHR_DATA (p.26 & p.27)
    uint8_t LHR_DATA[3];
    readSPI(LHR_DATA, 0x38, 3);     // 0x38 + 0x39 + 0x3A
    uint32_t combinedbytes = (LHR_DATA[2]<<16) | (LHR_DATA[1]<<8) | LHR_DATA[0];
    return combinedbytes;
}

void LDC1101::readSPI(uint8_t *data, uint8_t address, uint8_t num_bytes)
{
    // CSB down
    _cs_pin.write(0);
    
    // makes sure the address starts with 1... Why?
    _spiport.write(address | 0x80); //read flag 
    for(int i=0; i < num_bytes ; i++)
    {
        data[i] = _spiport.write(0xFF);
    }
    // CSB up
    _cs_pin.write(1);
}

void LDC1101::writeSPI(uint8_t *data, uint8_t address, uint8_t num_bytes)
{
    // CSB down
    _cs_pin.write(0);
    
    _spiport.write(address); 
    for(int i=0; i < num_bytes ; i++)
    {
        _spiport.write(data[i]);
    }
    // CSB up
    _cs_pin.write(1);
}


// EXTRA test: Get&print values of all variables to verify (to calculate the induction)
// The data will be printed on the screen using RealTerm: baud 9600.
// Begin ***********************************************************
    float LDC1101::get_fCLKIN()             {return _fCLKIN;};    
    uint16_t LDC1101::get_responsetime()    {return _responsetime;};    
    uint16_t LDC1101::get_Rcount()          {return _Rcount;};
    uint8_t LDC1101::get_divider()          {return _divider;};
    float LDC1101::get_RPmin()              {return _RPmin;};
    float LDC1101::get_cap()                {return _cap;};
// END ***********************************************************