CAPT_HAL.h

Go to the documentation of this file.

//*****************************************************************************
// CAPT_HAL.h
//
//
//
//
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************

#ifndef CAPT_HAL_H_
#define CAPT_HAL_H_

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

#include <msp430.h>

#include "CAPT_Type.h"

//*****************************************************************************
//
// CapTIvate&tm; Timer Sources
//
//*****************************************************************************
#define CAPT_TIMER_SRC_ACLK                                              (0x00)
#define CAPT_TIMER_SRC_VLOCLK                                            (0x01)

//*****************************************************************************
//
// CapTIvate&tm; Timer Source Dividers
//
//*****************************************************************************
#define CAPT_TIMER_CLKDIV__1                                             (0x00)
#define CAPT_TIMER_CLKDIV__2                                             (0x01)
#define CAPT_TIMER_CLKDIV__4                                             (0x02)
#define CAPT_TIMER_CLKDIV__8                                             (0x03)
#define CAPT_TIMER_CLKDIV__16                                            (0x04)
#define CAPT_TIMER_CLKDIV__32                                            (0x05)
#define CAPT_TIMER_CLKDIV__64                                            (0x06)
#define CAPT_TIMER_CLKDIV__128                                           (0x07)

//*****************************************************************************
//
// CapTIvate&tm; Conversion Counter Interval Selections
//
//*****************************************************************************
#define CAPT_COUNTER__16                                                 (0x00)
#define CAPT_COUNTER__32                                                 (0x01)
#define CAPT_COUNTER__64                                                 (0x02)
#define CAPT_COUNTER__128                                                (0x03)
#define CAPT_COUNTER__256                                                (0x04)
#define CAPT_COUNTER__512                                                (0x05)
#define CAPT_COUNTER__1024                                               (0x06)
#define CAPT_COUNTER__2048                                               (0x07)
#define CAPT_COUNTER__DISABLED                                           (0x08)

//*****************************************************************************
//
// CapTIvate&tm; Conversion Clock Oscillator Frequencies
//
//*****************************************************************************
#define CAPT_OSC_FREQ_DEFAULT                                            (0x00)
#define CAPT_OSC_FREQ_16MHZ                                              (0x00)
#define CAPT_OSC_FREQ_14P7MHZ                                            (0x01)
#define CAPT_OSC_FREQ_13P1MHZ                                            (0x02)
#define CAPT_OSC_FREQ_11P2MHZ                                            (0x03)

//*****************************************************************************
//
// CapTIvate&tm; Reference Capacitor Sizes
//
//*****************************************************************************
#define CAPT_REFERENCE_CAP__SELF_1P0PF                                   (0x00)
#define CAPT_REFERENCE_CAP__SELF_1P1PF                                   (0x04)
#define CAPT_REFERENCE_CAP__SELF_1P5PF                                   (0x05)
#define CAPT_REFERENCE_CAP__SELF_5P0PF                                   (0x02)
#define CAPT_REFERENCE_CAP__SELF_5P1PF                                   (0x06)
#define CAPT_REFERENCE_CAP__SELF_5P5PF                                   (0x07)
#define CAPT_REFERENCE_CAP__MUTUAL_0P1PFM_1P0PF                          (0x00)
#define CAPT_REFERENCE_CAP__MUTUAL_0P5PFM_1P0PF                          (0x01)
#define CAPT_REFERENCE_CAP__MUTUAL_0P1PFM_5P0PF                          (0x02)
#define CAPT_REFERENCE_CAP__MUTUAL_0P5PFM_5P0PF                          (0x03)

//*****************************************************************************
//
// CapTIvate&tm; Coarse Gain Ratios
//
//*****************************************************************************
#define CAPT_COARSEGAIN_0                                                (0x00)
#define CAPT_COARSEGAIN_1                                                (0x01)
#define CAPT_COARSEGAIN_2                                                (0x02)
#define CAPT_COARSEGAIN_3                                                (0x03)
#define CAPT_COARSEGAIN_4                                                (0x04)
#define CAPT_COARSEGAIN_5                                                (0x05)
#define CAPT_COARSEGAIN_6                                                (0x06)
#define CAPT_COARSEGAIN_7                                                (0x07)
#define CAPT_COARSEGAIN_MIN                                 (CAPT_COARSEGAIN_0)
#define CAPT_COARSEGAIN_MAX                                 (CAPT_COARSEGAIN_7)

//*****************************************************************************
//
// CapTIvate&tm; Fine Gain Ratios
//
//*****************************************************************************
#define CAPT_FINEGAIN_0                                                  (0x00)
#define CAPT_FINEGAIN_1                                                  (0x01)
#define CAPT_FINEGAIN_2                                                  (0x02)
#define CAPT_FINEGAIN_3                                                  (0x03)
#define CAPT_FINEGAIN_4                                                  (0x04)
#define CAPT_FINEGAIN_5                                                  (0x05)
#define CAPT_FINEGAIN_6                                                  (0x06)
#define CAPT_FINEGAIN_7                                                  (0x07)
#define CAPT_FINEGAIN_8                                                  (0x08)
#define CAPT_FINEGAIN_9                                                  (0x09)
#define CAPT_FINEGAIN_10                                                 (0x0A)
#define CAPT_FINEGAIN_11                                                 (0x0B)
#define CAPT_FINEGAIN_12                                                 (0x0C)
#define CAPT_FINEGAIN_13                                                 (0x0D)
#define CAPT_FINEGAIN_14                                                 (0x0E)
#define CAPT_FINEGAIN_15                                                 (0x0F)
#define CAPT_FINEGAIN_16                                                 (0x10)
#define CAPT_FINEGAIN_17                                                 (0x11)
#define CAPT_FINEGAIN_18                                                 (0x12)
#define CAPT_FINEGAIN_19                                                 (0x13)
#define CAPT_FINEGAIN_MIN                                     (CAPT_FINEGAIN_0)
#define CAPT_FINEGAIN_MAX                                    (CAPT_FINEGAIN_19)

//*****************************************************************************
//
// CapTIvate&tm; Offset Tap Values
//
//*****************************************************************************
#define CAPT_OFFSETTAP_MIN                                               (0x00)
#define CAPT_OFFSETTAP_MAX                                               (0xFF)

//*****************************************************************************
//
// CapTIvate&tm; Offset Scale Values
//
//*****************************************************************************
#define CAPT_OFFSETSCALE__VERYSMALL                                    (0x0000)
#define CAPT_OFFSETSCALE__SMALL                                        (0x0100)
#define CAPT_OFFSETSCALE__LARGE                                        (0x0200)
#define CAPT_OFFSETSCALE__VERYLARGE                                    (0x0300)
#define CAPT_OFFSETSCALE_MIN                      (CAPT_OFFSETSCALE__VERYSMALL)
#define CAPT_OFFSETSCALE_MAX                      (CAPT_OFFSETSCALE__VERYLARGE)

//*****************************************************************************
//
// CapTIvate&tm; Interrupt Definitions
//
//*****************************************************************************
#define CAPT_END_OF_CONVERSION_INTERRUPT                               (0x0001)
#define CAPT_DETECTION_INTERRUPT                                       (0x0002)
#define CAPT_TIMER_INTERRUPT                                           (0x0004)
#define CAPT_CONVERSION_COUNTER_INTERRUPT                              (0x0008)
#define CAPT_MAX_COUNT_ERROR_INTERRUPT                                 (0x0100)

//*****************************************************************************
//
// CapTIvate&tm; Interrupt Vectors
//
//*****************************************************************************
#define CAPT_IV_NO_INTERRUPT                                           (0x0000)
#define CAPT_IV_END_OF_CONVERSION                                      (0x0002)
#define CAPT_IV_DETECTION                                              (0x0004)
#define CAPT_IV_TIMER                                                  (0x0006)
#define CAPT_IV_CONVERSION_COUNTER                                     (0x0008)
#define CAPT_IV_MAX_COUNT_ERROR                                        (0x000A)

//*****************************************************************************
//
//
//
//*****************************************************************************
extern void CAPT_init(void);


//*****************************************************************************
//
//
//*****************************************************************************
extern bool CAPT_pollResetStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool CAPT_pollCIPF(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_reset(void);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setStabilization(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_releaseStabilization(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableRefCap(tElement* pElement, uint8_t capSize);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableRefCap(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableSensorIO(tSensor *pSensor);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableSensorIO(tSensor *pSensor);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_initSensorIO(tSensor *pSensor);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_forceSensorIO(tSenseTechnology rxBarTx, tSensor *pSensor);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_applySensorParams(tSensor *pSensor);

//*****************************************************************************
//
//
 //*****************************************************************************
extern void CAPT_enableSensorSyncEvent(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableSensorSyncEvent(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_bypassFSM(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_engageFSM(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_applySensorFreq(uint8_t freqSelect, tSensor *pSensor);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setCycleIO(tSensor *pSensor,tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearCycleIO(tSensor *pSensor, tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_applyCycleComp(uint8_t freqOffset,tCycle * pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_applyAutoMultiFreqCycleComp(tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_applyCycleFSM(tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableISR(uint16_t interruptEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableISR(uint16_t interruptDisable);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setCAPSTART(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearCAPSTART(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_saveCycleRawResults(uint8_t indexFreq,tSensor *pSensor, tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_saveCycleResults(tSensor *pSensor ,tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_saveCycleResultsAutoMultiFreq(tSensor *pSensor, tCycle *pCycle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectCCounterInterval(uint8_t counterSel);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearCCounter(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_startCCounter(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_stopCCounter(void);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectTimerSourceDivider(uint8_t sourceDiv);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectTimerSource(uint8_t source);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableTimerTrigMeasurement(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableTimerTrigMeasurement(void);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearTimer(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_startTimer(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_stopTimer(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_readTimerRegister(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_readTimerCompRegister(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_writeTimerCompRegister(uint16_t compRegister);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_powerOff(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_powerOn(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setChannelActive(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setChannelEnable(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setChannelOffState(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setChannelOnState(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearChannelActive(uint8_t ui8Block, uint8_t ui8Pin);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearChannelEnable(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearChannelOffState(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearChannelOnState(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_writeCoarseGain(uint8_t ui8Block, uint8_t ui8Value);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint8_t CAPT_readCoarseGain(uint8_t ui8Block);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_writeFineGain(uint8_t ui8Block, uint8_t ui8Value);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint8_t CAPT_readFineGain(uint8_t ui8Block);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_writeOffsetTap(uint8_t ui8Block, uint16_t ui16Value);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_readOffsetTap(uint8_t ui8Block);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_readConversion(uint8_t ui8Block);


//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_setCAPLPMCFG(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearCAPLPMCFG(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_pollIFG(uint16_t ui16InterruptMask);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearIFG(uint16_t ui16InterruptMask);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t CAPT_getInterruptVector(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableShieldIO(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableShieldIO(uint8_t ui8Block, uint8_t ui8Pin);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectElectrodeChargeVoltageSource(tElectrodeChargeVoltageSourceSelectStyle electrodeChargeVoltageSourceSelectStyle);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectOversamplingCount(tOversamplingStyle oversamplingStyle);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool CAPT_isFrequencyHopping(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_enableFrequencyHopping(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_disableFrequencyHopping(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern tInputImpedanceBiasCurrent CAPT_getInputImpedanceBiasCurrent(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_clearInputImpedanceBiasCurrent(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectInputImpedanceBiasCurrent(
        tInputImpedanceBiasCurrent biasCurrent);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CAPT_selectInputImpedanceBiasCurrentTrim(uint8_t trim, tElement* pElement);

//*****************************************************************************
//
//
//*****************************************************************************
extern IQ16_t CAPT_readLTA(uint8_t ui8Block);

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