Mutual Capacitance Calculation of a CapSense Sensor Through Firmware - KBA222425

Version: **

 

Question:

How do you calculate the mutual capacitance of a CapSense sensor, through firmware in CapSense Component version 3.0 or above?

 

Answer:

Raw counts are a direct measure of the mutual capacitance (Cm). The raw counts obtained can be used to calculate the mutual capacitance of sensor, by following these steps:

 

1. Start the CapSense Component; scan and process all the CapSense widgets

 

2. Calculate the maximum counts using the frequency of the modulator clock, number of sub conversions, and frequency of the transmitter clock.

 

Max_count =

( Modulator_clock_frequency * Number_of_sub_conversions )

Transmitter_clock_frequency

 

3. Calculate the hardware raw counts using the max counts (obtained in step 1) and raw counts processed by the CapSense Component.

 

Raw_count_hardware = Max_count – Raw_count

 

4. Calculate the mutual capacitance using the max counts (from step 1), hardware raw counts (from step 2), IDAC current, frequency, and amplitude of the transmitter clock signal.

 

Raw_count_hardware =

( 2 * Max_count * Mutual_capacitance * Transmitter_voltage * Transmitter_clock_frequency )

IDAC_current

 

include "project.h"

 

#define TRANSMITTER_VOLTAGE (5u) /* unit - voltage */

#define IDAC_GAIN (300u) /* unit – nano Amperes/bit */

 

int main(void)

{

     

    CyGlobalIntEnable; /* Enable global interrupts. */

 

    uint32 raw_count, modulator_clock_divider, sense_clock_divider, sub_conversions, IDAC_code, hardware_raw_count, max_count, mutual_capacitance;

 

    /* Start the CapSense component */

    CapSense_Start();

    /* Scan all the CapSense widgets */

    CapSense_ScanAllWidgets();

     

      for(;;)

      {

        /* Check if CapSense scan is completed*/

        if (!CapSense_IsBusy())

        {

            /* Process all the CapSense widgets */

CapSense_ProcessAllWidgets();

           

            /* Calculation of max counts for button 0*/

           

            /* API to get the value of modulator clock divider = HF_CLK_FREQ / MOD_CLK_FREQ */

CapSense_GetParam (CapSense_MOD_CSX_CLK_PARAM_ID , &modulator_clock_divider);

           

            /* API to get the value of sense clock divider = MOD_CLK_FREQ / SNS_CLK_FREQ */

CapSense_GetParam (CapSense_BUTTON0_SNS_CLK_PARAM_ID, &sense_clock_divider);

 

            /* API to get the number of sub conversions */

            CapSense_GetParam (CapSense_BUTTON0_RESOLUTION_PARAM_ID , &sub_conversions);

            max_count = sense_clock_divider * sub_conversions ;

 

            /* Calculation of hardware raw counts for button 0 */

 

            /* API to get the value of raw counts */

            CapSense_GetParam (CapSense_BUTTON0_RX0_RAW0_PARAM_ID , &raw_count);

hardware_raw_count = max_count-raw_count ;

 

            /* Calculation of mutual capacitance for button 0 */

 

            /* API to get the IDAC code */

CapSense_GetParam (CapSense_BUTTON0_RX0_IDAC_COMP0_PARAM_ID , &IDAC_code);

mutual_capacitance = (hardware_raw_count * IDAC_code * IDAC_GAIN * sense_clock_divider * modulator_clock_divider) / (2 * max_count * TRANSMITTER_VOLTAGE * CYDEV_BCLK__HFCLK__MHZ);

                       

            /* Scan all the CapSense widgets*/                   

CapSense_ScanAllWidgets();

        }

      }

}

 

 

The mutual capacitance is expected to be in the range of thousands of femto farads under the following conditions:

 

    HF_clock_fequency = 48 MHz

    Modulator_clock_frequency = 48 MHz

    Sense_clock_frequency = 300 kHz

    Transmitter_voltage = 5 V

    IDAC_gain = 300 nA/ bit

    IDAC code= 32

    Number_of_sub_conversions = 100

 

    Modulator_clock_divider = 1

    Sense clock divider = 160

 

     Max_count =

(48 * 100* 160 )

1 * 48

= 16000

 

As an example, if the raw counts obtained are 6200, then

 

    Raw_count_hardware = 16000 – 6200= 9800

 

     Mutual_capacitance =

(9800*300*20*160)

( 2*16000*5*48 )

= 1225 fF