[aux_compa.h] AUX continous-time comparator COMPA

Functions
static void	AUXCOMPADisable (void)
	Disables COMPA. More...
static void	AUXCOMPAEnable (void)
	Enables COMPA. More...
static void	AUXCOMPASelectGpioInput (uint8_t auxio)
	Selects an AUXIO pin as analog input of COMPA. More...
static void	AUXCOMPASelectGpioRef (uint8_t auxio)
	Selects an AUXIO pin as analog reference of COMPA. More...
void	AUXCOMPASelectDacRef (void)
	Selects the DAC output as analog reference of COMPA. More...
void	AUXCOMPASelectInternalRef (uint8_t internalRef)
	Selects an internal voltage as analog reference of COMPA. More...
static void	AUXCOMPAIntSetPolarity (uint8_t polarity)
	Selects the edge polarity of COMPA output on which an interrupt is triggered. More...
static void	AUXCOMPAIntClear (void)
	Clears COMPA's interrupt flag. More...
static void	AUXCOMPAIntRegister (uint8_t polarity, void(*fnHandler)(void))
	Registers an interrupt handler on COMPA output trigger. More...
static void	AUXCOMPAIntUnregister (void)
	Disables and unregisters the interrupt handler on COMPA output trigger. More...

Detailed Description

Introduction

The COMPA module provides the low-level APIs to manage the high-performance continuous-time comparator located in the AUX domain.

The COMPA driverlib module supports the following features:

• Operating the COMPA peripheral in MCU active power mode
• Selecting the source connected to the positive and reference input of COMPA
• Registering/unregistering a callback on the interrupt triggered by COMPA's output, as well as clearing the interrupt flag
• Enabling and disabling the COMPA module

COMPA supports the following inputs:

• Positive input from:
  • Analog-capable I/O pins
• Reference input from:
  • Analog-capable I/O pins
  • Internal chip voltages
  • Reference DAC

The COMPA driverlib module has the following limitation:

• Cannot operate the COMPA peripheral in standby mode
• Cannot setup COMPA as a wakeup source from standby

COMPA output is routed to the event bus where it holds a dedicated interrupt line.

On devices equipped with sensor controller, a CPU application that uses COMPA must configure ownership of the module through AUX hardware semaphores. When using the DAC as reference, ownership of both DAC and COMPA modules is required. The table below shows the conventional matching between AUX semaphores IDs and AUX peripherals:

SMPH_ID	Resource Allocation
1	TDC
2	ADC + COMPB
3	COMPA + ISRC
4	Reference DAC
5	Timer2
6	Unassigned by TI
7	Unassigned by TI

COMPA operations are tightly integrated with the reference DAC present in the AUX domain, which can be connected to the reference input of COMPA. When using the DAC as reference for COMPA, it is discouraged to use the RTOS-based DAC driver. The RTOS-based DAC driver has been designed to support the specific use case of driving external loads, therefore it is not compatible with the COMPA driverlib module. When using the DAC as reference for COMPA, use the DAC driverlib module instead, which provides more flexibility and can adapt to this particular use case.

Code example

The following code example demonstrates how to set up COMPA with:

• an analog IO pin connected to its positive input
• the reference DAC connected to its reference input in order to trigger an interrupt on a rising edge of its output.

  #include "inc/hw_types.h"
  #include "inc/hw_ints.h"
  #include "inc/hw_memmap.h"
  #include "inc/hw_adi_4_aux.h"
  #include "inc/hw_aux_aiodio.h"
  #include "driverlib/aux_compa.h"
  #include "driverlib/aux_dac.h"
  #include "driverlib/aon_batmon.h"
  #include "driverlib/ioc.h"
  
  #define DAC_CLOCK_FREQ_24MHZ        0U
  #define MICROVOLTS_PER_MILLIVOLT    1000
  #define CALIBRATION_VDDS            3000
  #define REF_DAC_UVOLT               1500000
  
  static volatile uint32_t vdds = 0;
  
  void aux_compaISR(void)
  {
      // Handle interrupt here
  
      // Clear interrupt flag
      AUXCOMPAIntClear();
  }
  
  void test_compa_interrupt_with_dacref(uint32_t in_iothDacOutput)
  {
      uint32_t dacMax = 0;
      uint32_t dacMin = 0;
      uint32_t vdds = 0;
      uint32_t tempReg;
      bool auxSmphIsAcquired = false;
  
      //
      // DIO setup
      //
  
      // DIO 26 is setup to be used as a regular GPIO with output disabled, no pull and input buffer disabled
      // Internally DIO 26 is hardwired to AUXIO23
      IOCPortConfigureSet(IOID_26, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_NO_IOPULL | IOC_INPUT_DISABLE );
      GPIO_setOutputEnableDio(GPIO_DIO_26_MASK, GPIO_OUTPUT_DISABLE);
  
      //
      // AUX semaphores acquisition in case the device is equipped with sensor controller
      //
  
      // Try acquiring AUX semaphore 3 belonging to COMPA+ISRC
      auxSmphIsAcquired = AUXSMPHTryAcquire(AUX_SMPH_3);
  
      // Try acquiring AUX semaphore 4 belonging to the DAC
      auxSmphIsAcquired = AUXSMPHTryAcquire(AUX_SMPH_4);
  
      //
      // DAC setup
      //
  
      // Use BATMON (7 bits) to measure VDDS for DAC scaling (LaunchPads don't have exactly 3.3V on VDDS).
      // BatMon uses [3.8] format (8 fractional bits) which is converted to mV.
      AONBatMonEnable();
  
      //wait for a BATMON measurement to be ready
      while(!AONBatMonNewBatteryMeasureReady()) {}
      vdds = (1000 * AONBatMonBatteryVoltageGet()) >> 8;
  
      // Use VDDS as voltage reference for the DAC
      AUXDACSetVref(AUXDAC_VREF_SEL_VDDS);
  
      // Retrieve the Min and Max values relative to the set voltage ref
      dacMin = AUXDACCalcMin() * MICROVOLTS_PER_MILLIVOLT;
      dacMax = ((AUXDACCalcMax() * vdds) / CALIBRATION_VDDS) * MICROVOLTS_PER_MILLIVOLT;
  
      AUXDACSetSampleClock(DAC_CLOCK_FREQ_24MHZ);
  
      // Set code to 1.5V and then enable the DAC with "not connected" output pin
      uint8_t dacCode = (uint8_t) AUXDACCalcCode (REF_DAC_UVOLT, dacMin, dacMax);
      AUXDACSetCode(dacCode);
  
      AUXDACEnable(0x0);
  
      //
      // COMPA setup
      //
  
      AUXCOMPASelectGpioInput(AUXCOMPA_GPIO_IN_AUX23);
  
      AUXCOMPASelectDacRef();
  
      AUXCOMPAEnable();
  
      // wait for reference DAC and COMPA to stabilize their outputs before enabling COMPA interrupt
  
      AUXCOMPAIntRegister(AUXCOMPA_POL_RISE, aux_compaISR);
  
      // Wait for interrupt to trigger
  
      // When finished, release AUX semaphores, if sensor controller is present on the device
      AUXSMPHRelease(AUX_SMPH_3);
      AUXSMPHRelease(AUX_SMPH_4);
  }

Function Documentation

AUXCOMPADisable()

static void AUXCOMPADisable ( void  )

inlinestatic

Disables COMPA.

This function disables COMPA and it must be called before re-enabling the module using AUXCOMPAEnable().

{
    ADI8BitsClear(AUX_ADI4_BASE, ADI_4_AUX_O_COMP, ADI_4_AUX_COMP_COMPA_EN_M);
}

Here is the call graph for this function:

AUXCOMPAEnable()

static void AUXCOMPAEnable ( void  )

inlinestatic

Enables COMPA.

This function enables COMPA. This function must be called after having selected an input and reference for COMPA.

{
    ADI8BitsSet(AUX_ADI4_BASE, ADI_4_AUX_O_COMP, ADI_4_AUX_COMP_COMPA_EN_M);
}

Here is the call graph for this function:

AUXCOMPAIntClear()

static void AUXCOMPAIntClear ( void  )

inlinestatic

Clears COMPA's interrupt flag.

This function clears the interrupt flag related to the COMPA interrupt line. This function should be called inside the ISR registered with AUXCOMPAIntRegister().

Referenced by AUXCOMPAIntRegister().

{
    // Clear interrupt flag for AUX_COMPA
    HWREG(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUFLAGSCLR) = AUX_EVCTL_EVTOMCUFLAGSCLR_AUX_COMPA;
}

AUXCOMPAIntRegister()

static void AUXCOMPAIntRegister ( uint8_t  polarity, void(*)(void)  fnHandler  )

inlinestatic

Registers an interrupt handler on COMPA output trigger.

This function registers an interrupt handler and enables the AUX_COMPA interrupt line. Before enabling the interrupt line the function:

• sets whether the interrupt should trigger on a rising or falling edge of COMPA output
• clears the flag of the AUX_COMPA interrupt line After enabling COMPA using AUXCOMPAEnable() and before registering an interrupt using AUXCOMPAIntRegister(), a delay of at least 10us is required to let COMPA output stabilize. This allows to avoid incorrect interrupt triggers in the brief interval following the enablement of COMPA.

Parameters

polarity	Edge polarity of COMPA output on which the interrupt is triggered: AUXCOMPA_POL_RISE AUXCOMPA_POL_FALL
fnHandler	Interrupt handler invoked when COMPA output triggers with the specified edge polarity

{
    AUXCOMPAIntSetPolarity(polarity);

    // Register the interrupt handler for AUX_COMPA
    IntRegister(INT_AUX_COMPA, fnHandler);

    // Clear any pending interrupt
    AUXCOMPAIntClear();

    // Enable the AUX_COMPA interrupt.
    IntEnable(INT_AUX_COMPA);
}

Here is the call graph for this function:

AUXCOMPAIntSetPolarity()

static void AUXCOMPAIntSetPolarity ( uint8_t  polarity )

inlinestatic

Selects the edge polarity of COMPA output on which an interrupt is triggered.

This function selects whether a rising or falling edge of COMPA output will trigger an interrupt on the COMPA hw interrupt line. This function is called inside AUXCOMPAIntRegister() before registering the handler and enabling the interrupt line.

Parameters

polarity

Edge polarity of COMPA output on which the interrupt is triggered: AUXCOMPA_POL_RISE AUXCOMPA_POL_FALL

Referenced by AUXCOMPAIntRegister().

{
    if (polarity == AUXCOMPA_POL_RISE)
    {
        // Clear bit in case RISE edge is selected
        HWREGB(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUPOL) &= ~(1 << AUX_EVCTL_EVTOMCUPOL_AUX_COMPA_S);
    }
    else
    {
        // Set bit in case FALL edge is selected
        HWREGB(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUPOL) |= (1 << AUX_EVCTL_EVTOMCUPOL_AUX_COMPA_S);
    }
}

AUXCOMPAIntUnregister()

static void AUXCOMPAIntUnregister ( void  )

inlinestatic

Disables and unregisters the interrupt handler on COMPA output trigger.

This function disables interrupts on the AUX_COMPA line, and unregister a previously set interrupt handler. Note that this function does not clear COMPA's interrupt flag. The interrupt flag is either cleared implicitly when calling AUXCOMPAIntRegister() or explicitly with AUXCOMPAIntClear().

{
    // Disable the AUX_COMPA interrupt
    IntDisable(INT_AUX_COMPA);

    // Unregister the interrupt handler for AUX_COMPA
    IntUnregister(INT_AUX_COMPA);
}

Here is the call graph for this function:

AUXCOMPASelectDacRef()

void AUXCOMPASelectDacRef

(

void

)

Selects the DAC output as analog reference of COMPA.

This function selects the reference DAC output as analog reference for COMPA. The function makes sure that any previously connected reference is disconnected from the COMPA_REF line, before connecting the DAC reference. This function must be called before enabling COMPA using AUXCOMPAEnable().

Referenced by AUXCOMPASelectGpioRef().

                               {
    uint32_t dacCtl;

    // Use the "Not Connected" output as an intermediate step when changing DAC_VOUT_SEL
    HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL) &= ~AUX_ANAIF_DACCTL_DAC_VOUT_SEL_M;

    // Ensure that no internal voltages are connected to the reference voltage
    // of COMPA and that the DAC is not driving an external pin.
    ADI8BitsClear(AUX_ADI4_BASE, ADI_4_AUX_O_MUX0, ADI_4_AUX_MUX0_COMPA_REF_M);
    ADI8RegWrite(AUX_ADI4_BASE, ADI_4_AUX_O_MUX4, ADI_4_AUX_MUX4_COMPA_REF_NC);

    // Disable DAC buffer when driving an internal load
    HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL) &= ~AUX_ANAIF_DACCTL_DAC_BUFFER_EN_M;

    // Connect the DAC output to the reference voltage of COMPA
    dacCtl = HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL);
    HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL) = (dacCtl & ~AUX_ANAIF_DACCTL_DAC_VOUT_SEL_M) | \
                                                 AUX_ANAIF_DACCTL_DAC_VOUT_SEL_COMPA_REF;
}

Here is the call graph for this function:

AUXCOMPASelectGpioInput()

static void AUXCOMPASelectGpioInput ( uint8_t  auxio )

inlinestatic

Selects an AUXIO pin as analog input of COMPA.

This function selects one the available AUXIOs as analog input for COMPA. This function must be called before enabling COMPA using AUXCOMPAEnable().

Parameters

auxio

COMPA analog input: AUXCOMPA_GPIO_IN_AUX19 AUXCOMPA_GPIO_IN_AUX20 AUXCOMPA_GPIO_IN_AUX21 AUXCOMPA_GPIO_IN_AUX22 AUXCOMPA_GPIO_IN_AUX23 AUXCOMPA_GPIO_IN_AUX24 AUXCOMPA_GPIO_IN_AUX25 AUXCOMPA_GPIO_IN_AUX26 AUXCOMPA_GPIO_IN_NC

{
    ADI8RegWrite(AUX_ADI4_BASE, ADI_4_AUX_O_MUX1, auxio);
}

Here is the call graph for this function:

AUXCOMPASelectGpioRef()

static void AUXCOMPASelectGpioRef ( uint8_t  auxio )

inlinestatic

Selects an AUXIO pin as analog reference of COMPA.

This function selects one of the available AUXIOs as analog reference for COMPA. The function makes sure that any previously connected reference is disconnected from the COMPA_REF line, before connecting the AUXIO reference. This function must be called before enabling COMPA using AUXCOMPAEnable().

Parameters

auxio

COMPA external analog reference: AUXCOMPA_GPIO_REF_AUX19 AUXCOMPA_GPIO_REF_AUX20 AUXCOMPA_GPIO_REF_AUX21 AUXCOMPA_GPIO_REF_AUX22 AUXCOMPA_GPIO_REF_AUX23 AUXCOMPA_GPIO_REF_AUX24 AUXCOMPA_GPIO_REF_AUX25 AUXCOMPA_GPIO_REF_AUX26 AUXCOMPA_GPIO_REF_NC

{
    // Ensure that the DAC output is not connected to COMPA reference
    HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL) &= ~AUX_ANAIF_DACCTL_DAC_VOUT_SEL_M;

    // Ensure that no internal voltages are connected to the reference voltage of COMPA
    ADI8BitsClear(AUX_ADI4_BASE, ADI_4_AUX_O_MUX0, ADI_4_AUX_MUX0_COMPA_REF_M);

    // Select external reference voltage for COMPA
    ADI8RegWrite(AUX_ADI4_BASE, ADI_4_AUX_O_MUX4, auxio);
}

Here is the call graph for this function:

AUXCOMPASelectInternalRef()

void AUXCOMPASelectInternalRef

(

uint8_t

internalRef

)

Selects an internal voltage as analog reference of COMPA.

This function selects one of the available internal voltages as analog reference for COMPA. The function makes sure that any previously connected reference is disconnected from the COMPA_REF line, before connecting the internal voltage reference. This function must be called before enabling COMPA using AUXCOMPAEnable().

Parameters

internalRef

COMPA internal analog reference: AUXCOMPA_INT_REF_ADCVREFP AUXCOMPA_INT_REF_VDDS AUXCOMPA_INT_REF_VSS AUXCOMPA_INT_REF_DCOUPL AUXCOMPA_INT_REF_NC

Referenced by AUXCOMPASelectGpioRef().

{
    // Ensure that the DAC output is not connected to COMPA reference
    HWREG(AUX_ANAIF_BASE + AUX_ANAIF_O_DACCTL) &= ~AUX_ANAIF_DACCTL_DAC_VOUT_SEL_M;

    // Ensure that no AUXIO pins are connected to COMPA's reference voltage
    ADI8RegWrite(AUX_ADI4_BASE, ADI_4_AUX_O_MUX4, ADI_4_AUX_MUX4_COMPA_REF_NC);

    // Select Internal reference voltage for COMPA
    ADI8SetValBit(AUX_ADI4_BASE, ADI_4_AUX_O_MUX0, ADI_4_AUX_MUX0_COMPA_REF_M, internalRef);
}

Here is the call graph for this function:

Macro Definition Documentation

AUXCOMPA_GPIO_IN_AUX19

#define AUXCOMPA_GPIO_IN_AUX19   ADI_4_AUX_MUX1_COMPA_IN_AUXIO19

AUXCOMPA_GPIO_IN_AUX20

#define AUXCOMPA_GPIO_IN_AUX20   ADI_4_AUX_MUX1_COMPA_IN_AUXIO20

AUXCOMPA_GPIO_IN_AUX21

#define AUXCOMPA_GPIO_IN_AUX21   ADI_4_AUX_MUX1_COMPA_IN_AUXIO21

AUXCOMPA_GPIO_IN_AUX22

#define AUXCOMPA_GPIO_IN_AUX22   ADI_4_AUX_MUX1_COMPA_IN_AUXIO22

AUXCOMPA_GPIO_IN_AUX23

#define AUXCOMPA_GPIO_IN_AUX23   ADI_4_AUX_MUX1_COMPA_IN_AUXIO23

AUXCOMPA_GPIO_IN_AUX24

#define AUXCOMPA_GPIO_IN_AUX24   ADI_4_AUX_MUX1_COMPA_IN_AUXIO24

AUXCOMPA_GPIO_IN_AUX25

#define AUXCOMPA_GPIO_IN_AUX25   ADI_4_AUX_MUX1_COMPA_IN_AUXIO25

AUXCOMPA_GPIO_IN_AUX26

#define AUXCOMPA_GPIO_IN_AUX26   ADI_4_AUX_MUX1_COMPA_IN_AUXIO26

AUXCOMPA_GPIO_IN_NC

#define AUXCOMPA_GPIO_IN_NC   ADI_4_AUX_MUX1_COMPA_IN_NC

AUXCOMPA_GPIO_REF_AUX19

#define AUXCOMPA_GPIO_REF_AUX19   ADI_4_AUX_MUX4_COMPA_REF_AUXIO19

AUXCOMPA_GPIO_REF_AUX20

#define AUXCOMPA_GPIO_REF_AUX20   ADI_4_AUX_MUX4_COMPA_REF_AUXIO20

AUXCOMPA_GPIO_REF_AUX21

#define AUXCOMPA_GPIO_REF_AUX21   ADI_4_AUX_MUX4_COMPA_REF_AUXIO21

AUXCOMPA_GPIO_REF_AUX22

#define AUXCOMPA_GPIO_REF_AUX22   ADI_4_AUX_MUX4_COMPA_REF_AUXIO22

AUXCOMPA_GPIO_REF_AUX23

#define AUXCOMPA_GPIO_REF_AUX23   ADI_4_AUX_MUX4_COMPA_REF_AUXIO23

AUXCOMPA_GPIO_REF_AUX24

#define AUXCOMPA_GPIO_REF_AUX24   ADI_4_AUX_MUX4_COMPA_REF_AUXIO24

AUXCOMPA_GPIO_REF_AUX25

#define AUXCOMPA_GPIO_REF_AUX25   ADI_4_AUX_MUX4_COMPA_REF_AUXIO25

AUXCOMPA_GPIO_REF_AUX26

#define AUXCOMPA_GPIO_REF_AUX26   ADI_4_AUX_MUX4_COMPA_REF_AUXIO26

AUXCOMPA_GPIO_REF_NC

#define AUXCOMPA_GPIO_REF_NC   ADI_4_AUX_MUX4_COMPA_REF_NC

AUXCOMPA_INT_REF_ADCVREFP

#define AUXCOMPA_INT_REF_ADCVREFP   ADI_4_AUX_MUX0_COMPA_REF_ADCVREFP

AUXCOMPA_INT_REF_DCOUPL

#define AUXCOMPA_INT_REF_DCOUPL   ADI_4_AUX_MUX0_COMPA_REF_DCOUPL

AUXCOMPA_INT_REF_NC

#define AUXCOMPA_INT_REF_NC   ADI_4_AUX_MUX0_COMPA_REF_NC

AUXCOMPA_INT_REF_VDDS

#define AUXCOMPA_INT_REF_VDDS   ADI_4_AUX_MUX0_COMPA_REF_VDDS

AUXCOMPA_INT_REF_VSS

#define AUXCOMPA_INT_REF_VSS   ADI_4_AUX_MUX0_COMPA_REF_VSS

AUXCOMPA_POL_FALL

#define AUXCOMPA_POL_FALL   0x01

AUXCOMPA_POL_RISE

#define AUXCOMPA_POL_RISE   0x00

Referenced by AUXCOMPAIntSetPolarity().