Diff: LDC1101.cpp

Revision:

25:ae111662ee03

Parent:

24:6bf98c909dfb

Child:

26:1ef9172cd355

--- a/LDC1101.cpp	Mon Jan 25 09:11:05 2016 +0000
+++ b/LDC1101.cpp	Tue Feb 16 15:54:59 2016 +0000
@@ -16,6 +16,9 @@
 {
     // settings
     _cap = capacitor;
+    _LHRoffset = 0;
+    _f_sensor_min = 6.4;    // MHz
+    _Rcount = 0xffff;       // max
        
     _spiport.format(8,3);
     _spiport.frequency(1E6);
@@ -45,17 +48,17 @@
 void LDC1101::init()
 {
     /********* SETTINGS *****************
-    ** C_sensor     =  120 pF
-    ** L_sensor     =    5 uH
-    ** Rp_min       = 1500 Ohm
+    ** C_sensor     =   120 pF
+    ** L_sensor     =     5 uH
+    ** Rp_min       =  1500 Ohm
     **
-    ** RCount       = 65535
+    ** RCount       = 65535     (max)
     ** Samplerate   =    15.3 Hz
     ** t_conv       =    65.5 ms
     **
-    ** f_sensor_min =   6.4 MHz (d = inf)
-    ** f_sensor_max =  10   MHz (d = 0)
-    ** divider      = (4*f_sensor_max)/f_CLKIN = 4*10/16 = 2,5 --> 2
+    ** f_sensor_min =     6.4 MHz (d = inf)
+    ** f_sensor_max =    10   MHz (d = 0)
+    ** divider      =     1
     ************************************/
     
     
@@ -63,23 +66,28 @@
     func_mode( LDC_MODE_STANDBY );     // STANDBY = 0x01 naar 0x0B  
 
     // - initialise LHR mode & enable SHUTDOWN mode
-    setLHRmode();
+    setLHRmode();   // LHR mode
+    // setRPmode(); // RP+L mode
 
     // - set ResponseTime to 6144
     setResponseTime( LDC_RESPONSE_6144 );
     
     // - set Reference Count to highest resolution
-    setReferenceCount( 0xffff );
+    setReferenceCount( _Rcount );
     
     // - set calibrated value for f_sensor_min (d = inf, no target)
-    setf_sensorMin( 6.4 ); // 6.4 MHz
+    set_fsensor_min( _f_sensor_min ); // 6.4 MHz
     
     // - disable RP_MAX
     // - set RP_MIN to 1,5 kOhm (RPMIN_1)
-    setRPsettings( 1, RPMIN_1 );
+    setRPsettings( 1, RPMAX_96, RPMIN_1 );   // LHR mode
+    // setRPsettings( 0, RPMAX_96, RPMIN_1 );   // RP+L mode
 
-    //  - set Divider to 2
-    setDivider( DIVIDER_2 );  
+    // - set Divider to 1 (for large range / ENOB / resolution)
+    setDivider( DIVIDER_1 );  
+
+    // - shift the signal down a bit
+    setLHRoffset( _LHRoffset );
 
     // Done configuring settings, set LDC1101 in measuring modus
     func_mode( LDC_MODE_ACTIVE );
@@ -90,11 +98,17 @@
     writeSPIregister( 0x0C, 0x01 ); // D_CONFIG:    Enables LHR modus, disables RP 
 }
 
-void LDC1101::setRPsettings(bool RP_MAX_DIS, RPMIN rpmin)
+void LDC1101::setRPmode( void ){
+    writeSPIregister( 0x05, 0x02 ); // ALT_CONFIG:  0000 0010 --> RP modus + Shutdown enabled
+    writeSPIregister( 0x0C, 0x00 ); // D_CONFIG:    Enables LHR modus, disables RP 
+}
+
+void LDC1101::setRPsettings(bool RP_MAX_DIS, RPMAX rpmax, 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));
+    float rps[] = {96, 48, 24, 12, 6, 3, 1.5, 0.75};
+    _RPmin = rps[rpmin];
+    _RPmax = rps[rpmax];
+    writeSPIregister(0x01, (RP_MAX_DIS << 7) | (rpmax << 4) | rpmin);
 }
 
 void LDC1101::setDivider(DIVIDER div)
@@ -104,13 +118,21 @@
     writeSPIregister(0x34, div);
 } 
 
+void LDC1101::setLHRoffset( uint32_t offset )
+{
+    _LHRoffset = offset;
+    uint16_t LHR_OFFSET = offset / 256;
+    writeSPIregister(0x32, (uint8_t) (LHR_OFFSET & 0x00ff) );           // LSB
+    writeSPIregister(0x33, (uint8_t) ((LHR_OFFSET & 0xff00) >> 8) );    // MSB
+}
+
 void LDC1101::setResponseTime(LDC_RESPONSE responsetime)
 {
     uint16_t resps[] = {0, 0, 192, 384, 768, 1536, 3072, 6144};
     _responsetime = resps[responsetime];
-    uint8_t buffer[1];    
-    readSPI(buffer, 0x04, 1);
-    writeSPIregister(0x04, (buffer[0] & 0xF8) + responsetime);
+    uint8_t DIG_CONF[1];    
+    readSPI(DIG_CONF, 0x04, 1);
+    writeSPIregister(0x04, (DIG_CONF[0] & 0xF8) + responsetime);
 }
 
 void LDC1101::setReferenceCount(uint16_t rcount)
@@ -125,62 +147,85 @@
 void LDC1101::setSampleRate(float samplerate){ setReferenceCount( ((_fCLKIN/samplerate)-55)/16 ); }
 
 
-void LDC1101::setf_sensorMin(float f_sensor_min)
+void LDC1101::set_fsensor_min(float f_sensor_min)
 {
-    uint8_t buffer[1];    
-    readSPI(buffer, 0x04, 1);
-    uint8_t MIN_FREQ = 16 - (8 / f_sensor_min);
-    writeSPIregister(0x04, ((buffer[0] & 0x0F) + (MIN_FREQ << 4)));
+    uint8_t DIG_CONF[1];    
+    readSPI(DIG_CONF, 0x04, 1);
+    uint8_t MIN_FREQ = 16.0f - (8.0f / f_sensor_min);
+    writeSPIregister(0x04, ((MIN_FREQ << 4) + (DIG_CONF[0] & 0x0f)));
 }
 
-bool LDC1101::is_New_LHR_data(void)
+float LDC1101::get_fsensor_min()
 {
-    return(!(get_LHR_status() & 0x01));
+    uint8_t DIG_CONF[1];
+    readSPI(DIG_CONF, 0x04, 1);   
+    return (float) 8.0f/(16.0f - (float) ((DIG_CONF[0] & 0xf0) >> 4));
 }
 
-bool LDC1101::is_Oscillation_Error(void)
-{
-    return(get_status() & 0x80);
-}
+bool LDC1101::is_New_LHR_data(void) { return(!(get_LHR_status() & 0x01)); }
+bool LDC1101::is_Oscillation_Error(void) { return(get_status() & 0x80); }
 
 uint8_t LDC1101::get_status(void)
 {
-    
-    uint8_t buffer[1];
-    readSPI(buffer, 0x20, 1);
-    
-    return buffer[0];
+    uint8_t status[1];
+    readSPI(status, 0x20, 1);   
+    return status[0];
 }
 
 uint8_t LDC1101::get_LHR_status(void)
 {
-    uint8_t buffer[1];
-    readSPI(buffer, 0x3B, 1);
-    return buffer[0];
+    uint8_t LHR_status[1];
+    readSPI( LHR_status, 0x3B, 1 );
+    
+    // ERR_ZC:   (LHR_status & 0x10) >> 4   //
+    // ERR_OR:   (LHR_status & 0x08) >> 3   // 
+    // ERR_UR:   (LHR_status & 0x04) >> 2   // 1 = LHR_DATA < 0 because LHR_OFFSET > LHR_DATA
+    // ERR_OF:   (LHR_status & 0x02) >> 1   // 
+    // LHR_DRDY: (LHR_status & 0x01)        // 1 = Data ready
+    
+    return LHR_status[0];
 }
 
+
+/* CALCULATE STUFF WITH SENSOR DATA */
+
 float LDC1101::get_Q(void){ return _RPmin * sqrt(_cap/_inductance*1000000); }  
 
 
-float LDC1101::get_fsensor(void)
+float LDC1101::get_fsensor( uint32_t Ldata )
 {
-    _L_data = get_LHR_Data();
-    _fsensor = _fCLKIN * _divider * _L_data/16777216;       // (p.26)
+    // LHR mode
+    if( Ldata == 0 ) { Ldata = get_LHR_Data(); }             
+    _fsensor = _fCLKIN * _divider * (Ldata + _LHRoffset)/16777216;       // (p.26)
+    
+    // RP+L mode
+    // if( Ldata == 0 ) { Ldata = get_L_Data(); }             
+    // _fsensor = (_fCLKIN * 6144) / (3 * Ldata);       // (p.31)
+    
     return _fsensor;
 }   
 
-
-float LDC1101::get_Inductance(void)
+float LDC1101::get_Inductance( uint32_t Ldata )
 {  
-    _fsensor = get_fsensor();
-    //               1
-    // L = ---------------------        --> p. 34
-    //     C * (2*PI*f_sensor)^2
-    _inductance = 1./(_cap * 4*PI*PI*_fsensor*_fsensor); // (p.34)
+    float fsensor = get_fsensor( Ldata );
+    _inductance = 1./(_cap * 4*PI*PI*fsensor*fsensor); // (p.34)
     return _inductance;
 }
 
 
+/* GETTING DATA FROM SENSOR */
+
+float LDC1101::get_RP( uint16_t RPdata )
+{
+    if( RPdata == 0 )
+    {
+        RPdata = get_RP_Data();
+    }
+        
+    return (_RPmax * _RPmin) / ( _RPmax * (1.0f - ((float) RPdata / 65535.0f)) + _RPmin * ((float) RPdata / 65535.0f));
+    // return _RPmax * (1.0f - ((float) RPdata / 65535.0f));
+}
+
 uint32_t LDC1101::get_LHR_Data(void)
 {
     uint8_t LHR_DATA[3];
@@ -188,6 +233,21 @@
     return (LHR_DATA[2]<<16) | (LHR_DATA[1]<<8) | LHR_DATA[0];
 }
 
+uint16_t LDC1101::get_RP_Data(void)
+{
+    uint8_t RP_DATA[2];
+    readSPI(RP_DATA, 0x21, 2);     // 021 + 0x22
+    return (RP_DATA[1]<<8) | RP_DATA[0];
+}
+
+uint16_t LDC1101::get_L_Data(void)
+{
+    uint8_t L_DATA[2];
+    readSPI(L_DATA, 0x23, 2);     // 023 + 0x24
+    return (L_DATA[1]<<8) | L_DATA[0];
+}
+
+
 void LDC1101::readSPI(uint8_t *data, uint8_t address, uint8_t num_bytes)
 {
     // CSB down
@@ -219,8 +279,10 @@
 // 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;};    
-    uint8_t LDC1101::get_divider()          {return _divider;};
-    float LDC1101::get_RPmin()              {return _RPmin;};
-    float LDC1101::get_cap()                {return _cap;};
+    float LDC1101::get_fCLKIN()             {return _fCLKIN;}    
+    uint8_t LDC1101::get_divider()          {return _divider;}
+    uint32_t LDC1101::get_LHRoffset()       {return _LHRoffset;}
+    float LDC1101::get_RPmin()              {return _RPmin;}
+    float LDC1101::get_RPmax()              {return _RPmax;}
+    float LDC1101::get_cap()                {return _cap;}
 // END ***********************************************************
\ No newline at end of file