CAPT_Type.h

Go to the documentation of this file.

//*****************************************************************************
// CAPT_Type.h
//
//
//
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
#ifndef __CAPT_TYPE__
#define __CAPT_TYPE__

#ifndef S_SPLINT_S
#include <stdint.h>
#include <stdbool.h>
#endif

#ifndef NULL
#define NULL    (0)
#endif

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
    //
        //
        eButtonGroup = 0x00,
        
        //
        //
    eSlider = 0x01,
        
        //
        //
    eWheel = 0x02,
        
        //
        //
    eTrackpad = 0x03,
        
        //
        //
    eProx = 0x04
};
typedef uint8_t tSensorType;

//*****************************************************************************
//
//
//*****************************************************************************
enum
{
        //
        //
        eSelf = 0x00,
        
        //
        //
        eProjected = 0x01
};
typedef uint8_t tSenseTechnology;

//*****************************************************************************
//
//
//*****************************************************************************
enum
{
        //
        //
        eDOIDown = 0x00,

        //
        //
        eDOIUp = 0x01
};
typedef uint8_t tDirectionOfInterest;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        eVectors = 0x00,
        
        //
        //
        eOtherPositionAlg
};
typedef uint8_t tPositionAlgorithm;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        eCount = 0x00,

        //
        //
        eLTA = 0x01
};
typedef uint8_t tFilterOption;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        eStandard = 0x00,

        //
        //
        eMultiFrequency = 0x01,

        //
        //
        eMultiFrequencyWithOutlierRemoval = 0x02,
        
        //
        //
        eMultiFrequencyWithOutlierRemovalAndErrCorrection = 0x03,
        
        //
        //
        eNrOfConversionStyles
};
typedef uint8_t tRawConversionStyle;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        eNoOversampling = 0x00,

        //
        //
        e2xOversampling = 0x01,

        //
        //
        e4xOversampling = 0x02,

        //
        //
        e8xOversampling = 0x03,
#ifndef DEPRECATED
        //
        //
        e16xOversampling = 0x04,
        
        //
        //
        e32xOversampling = 0x05,
#endif
        //
        //
        eNrOfOversamplingStyles
};
typedef uint8_t tOversamplingStyle;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
    //
    //
    eVRegSupply = 0x0000,
    //
    //
    eDVCCSupply = 0x0100
};
typedef uint16_t tElectrodeChargeVoltageSourceSelectStyle;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
    //
    //
    eZeroIbias = 0x00,
    //
    //
    eIbiasSelf25Mutual10 = 0x10,
    //
    //
    eIbiasSelf50Mutual10 = 0x20,
    //
    //
    eIbiasSelf100Mutual10 = 0x30
};
typedef uint8_t tInputImpedanceBiasCurrent;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        eTouchStatus = 0x00,
        
        //
        //
        eProxStatus,
        
        //
        //
        eNegativeTouchStatus,

        //
        //
        eDetectStatus,
        
        //
        //
        eBISTStatus,
        
        //
        //
        eNoiseStatus
};
typedef uint8_t tElementStatusType;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum
{
        //
        //
        e80pFCsCap = 0x00,
        //
        //
        e40pFCsCap = 0x02,
        //
        //
        e20pFCsCap = 0x03
};
typedef uint8_t tCsCapSize;

//*****************************************************************************
//
//@typedef tXYFilterType
//
//*****************************************************************************
typedef enum
{
        eStatic,
        eDynamic
}
tXYFilterType;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
        eSingle,
        eMulti
}
tXYAlgorithm;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef union
{
        struct
    {
        //
                //
                uint16_t ui16Decimal;
                
                //
                //
        uint16_t ui16Natural;
    };
        
        //
        //
    uint32_t ui32Full;
} IQ16_t;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef int32_t IQ31_t;

//*****************************************************************************
//
//
//
//*****************************************************************************
#define _IQ31(x)                     (((IQ31_t)((x) * ((IQ31_t)1 << 30))) << 1)

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{
    //
        //
        uint8_t DbIn : 4;
        
    //
        //
    uint8_t DbOut : 4;
}
tDeBounceSettings;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{
    //
    //
    uint16_t ui16OffsetTap;
        
        //
    //
    uint8_t ui8CoarseGainRatio;

    //
    //
    uint8_t ui8FineGainRatio;
} tCaptivateElementTuning;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{
        //
        //
    IQ16_t  filterCount;
        
        //
        //
    IQ16_t  LTA;
        
        //
        //
    tCaptivateElementTuning* pTuning;

        //
        //
    uint16_t* pRawCount;
        
        //
        //
    uint8_t ui8TouchThreshold;
        
        //
        //
    tDeBounceSettings ProxDbCounter;
        
        //
        //
    tDeBounceSettings TouchDbCounter;
        
        //
        //
    uint8_t ui8RxPin : 4;
        
        //
        //
    uint8_t ui8RxBlock : 4;
        
        //
        //
    uint8_t ui8TxPin : 4;
        
        //
        //
    uint8_t ui8TxBlock : 4;

        //
        //
    bool bNoiseDetected : 1;

        //
        //
    bool bBISTFail : 1;
        
        //
        //
    bool bDetect : 1;
        
        //
        //
    bool bProx : 1;
        
        //
        //
    bool bNegativeTouch : 1;
        
        //
        //
    bool bTouch : 1;
        
        //
        //
    bool bElementHalt : 1;
        
        //
        //
    bool bReseed : 1;
        
        //*************************************************************************
        // NOTE: AT THIS POINT, THE LIBRARY DEVIATES FROM THE ELEMENT STRUCTURE
        // USED FOR THE ROM BUILD.  ALL ITEMS BELOW THIS POINT IN THE ELEMENT
        // STRUCTURE DID NOT EXIST FOR THE ROM BUILD, AND ARE NOT REFERENCED
        // BY ROM FXNS.
        //*************************************************************************

    //
    //
    uint16_t ui16PrevCompositeRawCount;

    //
    //
    uint16_t ui16CompositeRawCount;

    //
    //
    uint16_t ui16NoiseCount;

    //
    //
    tCsCapSize SamplingCapSize : 2;
    //
    //
    uint8_t ui8InputBiasExtractTrim : 4;
}
tElement;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    //
        //
        tElement** pElements;
        
        //
        //      
        uint8_t ui8NrOfElements;
}
tCycle;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    //
        //
        uint16_t ui16Value;
        
        //
        //
    uint16_t ui16Parameter;
}
tGenericSensorParams;

//*****************************************************************************
//
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
#if (defined(__TI_COMPILER_VERSION__) && defined(__LARGE_CODE_MODEL__)) || \
    (defined(__IAR_SYSTEMS_ICC__) && (__CODE_MODEL__==__CODE_MODEL_LARGE__))
typedef uint32_t pvCallbackAddress;
#endif
typedef struct tSensor
{
    //
    //
#if (defined(__TI_COMPILER_VERSION__) && defined(__LARGE_CODE_MODEL__)) || \
    (defined(__IAR_SYSTEMS_ICC__) && (__CODE_MODEL__==__CODE_MODEL_LARGE__))
    pvCallbackAddress pvCallback;
#else
    void (* pvCallback)(struct tSensor *);
#endif
        
        //
        //
    const tCycle** pCycle;
        
        //
        //
    tGenericSensorParams* pSensorParams;
        
        //
        //
    uint16_t ui16ConversionGain;
        
        //
        //
    uint16_t ui16ConversionCount;
        
        //
        //
    uint16_t ui16ErrorThreshold;
        
        //
        //
    uint16_t ui16ProxThreshold;
        
        //
        //
    uint16_t ui16NegativeTouchThreshold;
                
        //
        //
    uint16_t ui16TimeoutThreshold;
        
        //
        //
    uint16_t ui16Timeout;
        
        //
        //
    tDeBounceSettings ProxDbThreshold;
        
        //
        //
    tDeBounceSettings TouchDbThreshold; 
        
        //
        //
    uint8_t ui8NrOfCycles : 5;
        
        //
        //
    uint8_t ui8FreqDiv : 3;
        
        //
        //
    uint8_t ui8ChargeLength : 4;
        
        //
        //
    uint8_t ui8TransferLength : 4;
        
    //
        //
        tSensorType TypeOfSensor : 4;
                
    //
        //
    bool bCountFilterEnable : 1;
                
        //
        //
    uint8_t ui8CntBeta : 3;
        
        //
        //
    uint8_t ui8LTABeta : 3;
        
        //
        //
    uint8_t ui8BiasControl : 2;

    //
    //
        
        //
        //
    uint8_t ui8InputSyncControl : 2;    
        
        //
        //
    tSenseTechnology SensingMethod : 1;

    //
    //
    tDirectionOfInterest DirectionOfInterest : 1;
        
        //
        //
    bool bSensorUpdating : 1;
        
        //
        //
    bool bCsDischarge : 1;
                
        //
        //
    bool bModEnable : 1;
        
        //
        //
    bool bLpmControl : 1;
        
        //
        //
    bool bTimerSyncControl : 1;
        
        //
        //
    bool bReCalibrateEnable : 1;
        
        //
        //
    bool bIdleState : 1;        

        //
        //
    bool bSensorHalt : 1;
        
        //
        //
    bool bPTSensorHalt : 1;
        
        //
        //
    bool bPTElementHalt : 1;
        
        //
        //
    bool bSensorDetect : 1;     
        
        //
        //
    bool bSensorProx : 1;
        
        //
        //
    bool bSensorTouch : 1;
        
        //
        //      
    bool bSensorPrevTouch : 1;
        
        //
        //
    bool bSensorNegativeTouch : 1;      
        
        //
        //              
    bool bMaxCountError : 1;
        
        //
        //              
    bool bCalibrationError : 1;
        
        //
        //
    bool bCounterOVF : 1;
        
        //
        //
    bool bSensorNoiseState : 1;

} tSensor;


//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{

        //
        //
    tSensor** pSensor;
        
        //
        //
        uint8_t ui8NumberOfSensors;

    //
        //
        uint16_t ui16DominantElement;
        
        //
        //
    uint16_t ui16PrevDominantElement;
}
tButtonSensorParams;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{       
        //
        //
        IQ16_t SliderPosition;
        
        //
        //
        uint16_t ui16Resolution;
        
        //
        //
        uint16_t SliderLower;
        
        //
        //      
        uint16_t SliderUpper;
        
        //
        //
        uint8_t SliderBeta;
        
        //
        //
        uint8_t ui8TotalElements;
        
        //
        //
        tPositionAlgorithm SliderAlgorithm : 4;
        
        //
        //
        bool SliderFilterEnable : 1;
        
        //
        //
        bool Reseed : 1;
}
tSliderSensorParams;


/*
 * Trackpad sensor parameters
 */
//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{

//
//
IQ16_t          Position_X;
IQ16_t          Position_Y;

//
//
void (* pvProcessSensor)(tSensor *);

//
//
void (* pvProcessGesture)(tSensor *);

//
//
tElement** pMatrix;

//
uint16_t* pSumX;
uint16_t* pSumY;

//
//
uint16_t        ui16Raw_X;
uint16_t        ui16Raw_Y;

//
//
uint16_t        ui16PrevRaw_X;
uint16_t        ui16PrevRaw_Y;

//
//
uint16_t        ui16DynamicFilterHighSpeed;

//
//
uint16_t        ui16DynamicFilterLowSpeed;

//
//
uint16_t    ui16RejectionThreshold;

//
//
uint16_t    ui16Resolution_X;

//
//
uint16_t    ui16Resolution_Y;

//
//
uint16_t    ui16UpperTrim_X;

//
//
uint16_t    ui16LowerTrim_X;

//
//
uint16_t    ui16UpperTrim_Y;

//
//
uint16_t    ui16LowerTrim_Y;

//
uint16_t    ui16TapTime_Min;


//
uint16_t    ui16TapTime_Max;


//
uint16_t    ui16SwipeTime_Max;


//
uint16_t    ui16DoubleTapTime_Max;


//
uint16_t    ui16TapHoldTime_Min;


//
uint16_t    ui16SwipeDistance_Min;

//
//
uint8_t     ui8DynamicFilterLowSpeedBeta;

//
//
uint8_t     ui8Gesture;

//
//
uint8_t     ui8TotalColumns;
uint8_t     ui8TotalRows;

//
//
uint8_t     ui8StaticFilterBeta;

//
//
bool        bFilterEnable : 1;

//
//
bool        bFilterType : 1;

//
//
bool        bPresentTouch : 1;

//
//
bool        bReseed : 1;

}tTrackPadSensorParams;

//*****************************************************************************
//
//
//*****************************************************************************
typedef tSliderSensorParams tWheelSensorParams;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
        //
        //
    tSensor** pSensor;
        
        //
        //
        uint8_t ui8NumberOfSensors;
}
tProxSensorParams;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{
        //
        //
        IQ31_t coeffA;

        //
        //
        IQ31_t coeffB;

        //
        //
        uint16_t ui16CalibrationNoiseLimit;

        //
        //
        uint16_t ui8CalibrationTestSampleSize;

        //
        //
        uint8_t ui8NoiseThreshold;
        
        //
        //
        uint8_t ui8MaxRelThreshAdj;
        
        //
        //
        uint8_t ui8NoiseLevelFilterEntryThresh;
        
        //
        //
        uint8_t ui8NoiseLevelFilterExitThresh;

        //
        //
        uint8_t ui8NoiseLevelFilterUp : 4;

        //
        //
        uint8_t ui8NoiseLevelFilterDown : 4;
        
        //
        //
        tOversamplingStyle selfModeOversamplingStyle : 4;
        
        //
        //
        tOversamplingStyle projModeOversamplingStyle : 4;

        //
        //
        tRawConversionStyle selfModeConversionStyle : 3;

        //
        //
        tRawConversionStyle projModeConversionStyle : 3;

        //
        //
        bool bJitterFilterEnable : 1;

        //
        //
        bool bEnableDynamicThresholdAdjustment : 1;

} tEMCConfig;

//*****************************************************************************
//
//
//
//*****************************************************************************
enum 
{ 
        //
        //
        eUIActive,
        
        //
        //
        eUIWakeOnProx
};
typedef uint8_t tAppState;

//*****************************************************************************
//
//
//
//*****************************************************************************
typedef struct
{
        //
        //
        tSensor** pSensorList;
        
        //
        //
        uint16_t ui16ActiveModeScanPeriod;
        
        //
        //
        uint16_t ui16WakeOnProxModeScanPeriod;
        
        //
        //
        uint16_t ui16InactivityTimeout;
        
        //
        //
        uint8_t ui8WakeupInterval;
        
        //
        //
        uint8_t ui8NrOfSensors;

        //
        //
        uint8_t ui8AppLPM;
        
        //
        //
        tAppState state;
        
        //
        //
        bool bElementDataTxEnable : 1;

        //
        //
        bool bSensorDataTxEnable : 1;
}
tCaptivateApplication;

#endif
//*****************************************************************************
//*****************************************************************************