[参考译文] MSP430FR2532：在定制电路板上优化功耗时出现的问题

void main(void)
{
    //
    // Initialize the MCU
    // BSP_configureMCU() sets up the device IO and clocking
    // The global interrupt enable is set to allow peripherals
    // to wake the MCU.
    //
    WDTCTL = WDTPW | WDTHOLD;
    BSP_configureMCU();
    __bis_SR_register(GIE);

    //
    // Start the CapTIvate application
    //
    CAPT_appStart();

    //
    // Background Loop
    //
    while(1)
    {
        //
        // Run the captivate application handler.
        // Set LED1 while the app handler is running,
        // and set LED2 if proximity is detected
        // on any sensor.
        //
        LED1_TOGGLE;
        if(CAPT_appHandler() == true)
        {
            LED2_ON;

            // Add delay for 5 seconds
            __delay_cycles(100000000); // Assuming 1 MHz clock frequency

            LED2_OFF;
        }
        else
        {
            LED2_OFF;
        }
        LED1_OFF;

        //
        // This is a great place to add in any
        // background application code.
        //
        __no_operation();

        //
        // End of background loop iteration
        // Go to sleep if there is nothing left to do
        //
        CAPT_appSleep();

    } // End background loop
} // End main()

#ifndef CAPT_BSP_H_
#define CAPT_BSP_H_

#include <msp430.h>
#include "driverlib.h"

//*****************************************************************************
//
//! \def XT1_OSC_FREQ defines the frequency of the crystal oscillator on
//! XIN/XOUT.
//
//*****************************************************************************
#define XT1_OSC_FREQ                                                    (32768)
#define XT1_OSC_TIMEOUT                                                 (65000)

//*****************************************************************************
//
//! \def MCLK_FREQ defines the main clock frequency in Hz.
//! \def SMCLK_FREQ defines the sub-main clock frequency in Hz.
//! \def ACLK_FREQ defines the auxiliary clock frequency in Hz.
//! \def FLLREF_FREQ defines the FLL reference clock frequency in Hz.
//
//*****************************************************************************
#define MCLK_FREQ                                                    (16000000)
#define SMCLK_FREQ                                                    (2000000)
#define ACLK_FREQ                                                       (32768)
#define FLLREF_FREQ                                                     (32768)

//*****************************************************************************
//
//! \def FLL_RATIO defines ratio of MCLK to the FLL reference clock.
//
//*****************************************************************************
#define FLL_RATIO                                     (MCLK_FREQ / FLLREF_FREQ)

//*****************************************************************************
//
//! \def OSC_TIMEOUT defines the failure timeout for all oscillators.
//
//*****************************************************************************
#define OSC_TIMEOUT                                                      (1000)

//*****************************************************************************
//
//! \def LED1_POUT defines the port-out register LED1 is attached to.
//! \def LED1_PDIR defines the port-direction register LED1 is attached to.
//! \def LED1_PIN defines the port pin that LED1 is attached to.
//! \def LED1_ON defines macro to turn on LED1.
//! \def LED1_OFF defines a macro to turn off LED1.
//! \def LED1_TOGGLE defines a macro to toggle LED1.
//
//*****************************************************************************
#define LED1_POUT                                                       (P1OUT)
#define LED1_PDIR                                                       (P1DIR)
#define LED1_PIN                                                         (BIT0)
#define LED1_ON                                         (LED1_POUT |= LED1_PIN)
#define LED1_OFF                                       (LED1_POUT &= ~LED1_PIN)
#define LED1_TOGGLE                                     (LED1_POUT ^= LED1_PIN)

//*****************************************************************************
//
//! \def LED2_POUT defines the port-out register LED2 is attached to.
//! \def LED2_PDIR defines the port-direction register LED2 is attached to.
//! \def LED2_PIN defines the port pin that LED2 is attached to.
//! \def LED2_ON defines macro to turn on LED2.
//! \def LED2_OFF defines a macro to turn off LED2.
//! \def LED2_TOGGLE defines a macro to toggle LED2.
//
//*****************************************************************************
#define LED2_POUT                                                       (P2OUT)
#define LED2_PDIR                                                       (P2DIR)
#define LED2_PIN                                                         (BIT7)
#define LED2_ON                                         (LED2_POUT |= LED2_PIN)
#define LED2_OFF                                       (LED2_POUT &= ~LED2_PIN)
#define LED2_TOGGLE                                     (LED2_POUT ^= LED2_PIN)

//*****************************************************************************
//
//! This function is configures the MCU for operation.
//! This involves setting up the digital IO muxes and configuring the clock
//! system (CS).
//
//! \param none
//! \return none
//
//*****************************************************************************
extern void BSP_configureMCU(void);

#endif /* CAPT_BSP_H_ */

#include "captivate.h"

//*****************************************************************************
//
//! \def Define CAPT_WOP_VLO_LPM4 in order to use the very low power oscillator
//! (VLO) as the conversion timer in wake-on-proximity mode.  If this option
//! is defined, LPM4 will be selected as the power mode, disabling ACLK and
//! along with it XT1 or the REFO, whichever was sourcing ACLK previously,
//! while the system is in WOP mode.  When WOP mode is exited and active
//! mode is entered, ACLK will again be utilized to source the conversion timer
//! and the application-selected low power mode (g_uiApp.ui8AppLPM) will be
//! used until WOP mode is again entered.
//!
//! This option may be used to reduce the average current in wake-on-proximity
//! mode for designs that do not have a crystal oscillator.
//! If CAPT_WOP_VLO_LPM4 should be defined only if no CapTIvate COMM interface
//! is selected (CAPT_INTERFACE == __CAPT_NO_INTERFACE__).
//!
//! Note that if this mode is selected and the VLO is used, the tolerance
//! on the measured scan period will be poor.  For example, if 10 Hz (100ms)
//! is the selected WOP scan rate, this value may vary by as much as +/- 5 Hz
//! across temperature and voltage.  If this variance is too great for the
//! application requirements, a 32kHz crystal or the REFO should be
//! used instead.
//
//*****************************************************************************

#ifdef CAPT_WOP_VLO_LPM4
//*****************************************************************************
//! \var g_ui8SavedAppLPM
//! This variable is used as a context saving byte to recall the desired
//! app low power mode in active operation.  When in wake on proximity mode,
//! LPM4 will be used and the VLO will source the CapTIvate conversion
//! timer directly.  This variable is only included in the build when
//! CAPT_WOP_VLO_LPM4 is defined.
//
//*****************************************************************************
static uint8_t g_ui8SavedAppLPM;
#endif  // CAPT_WOP_VLO_LPM4

void CAPT_appStart(void)
{
    //
    // Initialize the user interface.
    // This function call enables the CapTIvate peripheral,
    // initializes and enables the capacitive touch IO.
    //
    MAP_CAPT_initUI(&g_uiApp);

    //
    // Load the EMC configuration, if this design has
    // noise immunity features enabled.  This function call
    // associates an EMC configuration with the EMC module.
    //
#if (CAPT_CONDUCTED_NOISE_IMMUNITY_ENABLE==true)
    MAP_CAPT_loadEMCConfig(&g_EMCConfig);
#endif  // CAPT_CONDUCTED_NOISE_IMMUNITY_ENABLE

    //
    // Calibrate the user interface.  This function establishes
    // coarse gain, fine gain, and offset tap tuning settings for
    // each element in the user interface.
    //
    MAP_CAPT_calibrateUI(&g_uiApp);

    //
    // Setup Captivate timer
    // This timer sets the g_bConvTimerFlag in the Captivate
    // library at the interval specified by CAPT_SCAN_INTERVAL.
    // This is used to trigger the app handler to update
    // the capacitive user interface.
    //
    MAP_CAPT_stopTimer();
    MAP_CAPT_clearTimer();
    MAP_CAPT_selectTimerSource(CAPT_TIMER_SRC_ACLK);
    MAP_CAPT_selectTimerSourceDivider(CAPT_TIMER_CLKDIV__1);
    MAP_CAPT_writeTimerCompRegister(CAPT_MS_TO_CYCLES(g_uiApp.ui16ActiveModeScanPeriod));
    MAP_CAPT_startTimer();
    MAP_CAPT_enableISR(CAPT_TIMER_INTERRUPT);

#ifdef CAPT_WOP_VLO_LPM4
    g_ui8SavedAppLPM  = g_uiApp.ui8AppLPM;
#endif  // CAPT_WOP_VLO_LPM4
}

bool CAPT_appHandler(void)
{
#if (CAPT_WAKEONPROX_ENABLE==true)
    static uint16_t g_ui16UISessionTimeoutCtr = 1;
#endif  // CAPT_WAKEONPROX_ENABLE
    static bool bActivity = false;

    switch (g_uiApp.state)
    {
        case eUIActive:
            if (g_bConvTimerFlag == true)
            {
                //
                // Clear the conversion timer flag,
                // and update the UI
                //
                g_bConvTimerFlag = false;
                MAP_CAPT_updateUI(&g_uiApp);
                bActivity = MAP_CAPT_getGlobalUIProximityStatus(&g_uiApp);

                //
                // If autonomous mode is enabled, check to
                // see if autonomous mode should be entered.
                //
#if (CAPT_WAKEONPROX_ENABLE==true)
                if (bActivity == true)
                {
                    //
                    // If there is still a prox detection,
                    // reset the session timeout counter.
                    //
                    g_ui16UISessionTimeoutCtr = g_uiApp.ui16InactivityTimeout;
                }
                else if (--g_ui16UISessionTimeoutCtr == 0)
                {
                    //
                    // If the session has timed out,
                    // enter autonomous mode
                    //
                    g_uiApp.state = eUIWakeOnProx;
                    bActivity = false;

                    //
                    // Set the timer period for wake on touch interval
                    //
                    MAP_CAPT_disableISR(CAPT_TIMER_INTERRUPT);
                    MAP_CAPT_stopTimer();
                    MAP_CAPT_clearTimer();
#ifndef CAPT_WOP_VLO_LPM4
                    MAP_CAPT_writeTimerCompRegister(CAPT_MS_TO_CYCLES(g_uiApp.ui16WakeOnProxModeScanPeriod));
#else
                    MAP_CAPT_selectTimerSource(CAPT_TIMER_SRC_VLOCLK);
                    MAP_CAPT_writeTimerCompRegister(CAPT_MS_TO_CYCLES_VLO(g_uiApp.ui16WakeOnProxModeScanPeriod));
                    g_uiApp.ui8AppLPM = LPM4_bits;
#endif  // CAPT_WOP_VLO_LPM4
                    MAP_CAPT_startTimer();
                    g_bConvTimerFlag = false;
                    MAP_CAPT_startWakeOnProxMode(
                            &CAPT_WAKEONPROX_SENSOR,
                            0,
                            g_uiApp.ui8WakeupInterval
                            );
                }
#endif  // CAPT_WAKEONPROX_ENABLE
            }
            break;

        case eUIWakeOnProx:
#if (CAPT_WAKEONPROX_ENABLE==true)
            if (g_bDetectionFlag || g_bConvCounterFlag || g_bMaxCountErrorFlag)
            {
                //
                // If a detection, conversion counter, or max count error flag was set,
                // stop autonomous mode and reload an active session
                //
                MAP_CAPT_stopWakeOnProxMode(&CAPT_WAKEONPROX_SENSOR, 0);
                g_bDetectionFlag = false;
                g_bConvCounterFlag = false;
                g_bMaxCountErrorFlag = false;
                g_uiApp.state = eUIActive;
                g_ui16UISessionTimeoutCtr = g_uiApp.ui16InactivityTimeout;

                //
                // Set the timer period for normal scan interval
                //
                MAP_CAPT_disableISR(CAPT_TIMER_INTERRUPT);
                MAP_CAPT_stopTimer();
                MAP_CAPT_clearTimer();
#ifdef CAPT_WOP_VLO_LPM4
                MAP_CAPT_selectTimerSource(CAPT_TIMER_SRC_ACLK);
                g_uiApp.ui8AppLPM = g_ui8SavedAppLPM;
#endif  // CAPT_WOP_VLO_LPM4
                MAP_CAPT_writeTimerCompRegister(CAPT_MS_TO_CYCLES(g_uiApp.ui16ActiveModeScanPeriod));

                MAP_CAPT_startTimer();
                MAP_CAPT_clearIFG(CAPT_TIMER_INTERRUPT);
                MAP_CAPT_enableISR(CAPT_TIMER_INTERRUPT);
            }
#endif  // CAPT_WAKEONPROX_ENABLE
            break;
    }

#if ((CAPT_INTERFACE==__CAPT_UART_INTERFACE__) ||\
    (CAPT_INTERFACE==__CAPT_BULKI2C_INTERFACE__) ||\
    (CAPT_INTERFACE==__CAPT_REGISTERI2C_INTERFACE__))
    //
    // If communications are enabled, check for any incoming packets.
    //
    CAPT_checkForInboundPacket();

    //
    // Check to see if the packet requested a re-calibration.
    // If wake-on-prox is enabled and the current application state
    // is wake-on-prox, disable the wake-on-prox feature during the calibration
    // and re-enable it after the calibration.
    //
    if (CAPT_checkForRecalibrationRequest() == true)
    {
#if (CAPT_WAKEONPROX_ENABLE==true)
        if (g_uiApp.state == eUIWakeOnProx)
        {
            MAP_CAPT_stopWakeOnProxMode(
                    &CAPT_WAKEONPROX_SENSOR,
                    0
                    );
            MAP_CAPT_calibrateUI(&g_uiApp);
            MAP_CAPT_startWakeOnProxMode(
                    &CAPT_WAKEONPROX_SENSOR,
                    0,
                    g_uiApp.ui8WakeupInterval
                    );
        }
        else
        {
            MAP_CAPT_calibrateUI(&g_uiApp);
        }
#else
        MAP_CAPT_calibrateUI(&g_uiApp);
#endif  // CAPT_WAKEONPROX_ENABLE
    }
#endif  // CAPT_INTERFACE

    return bActivity;
}

void CAPT_appSleep(void)
{
    //
    // If no captivate flags are set, enter the application's low power
    // mode.  Otherwise, re-enter the background loop immediately.
    //
    __bic_SR_register(GIE);
    if (!(g_bConvTimerFlag ||g_bDetectionFlag || g_bConvCounterFlag || g_bMaxCountErrorFlag))
    {
        __bis_SR_register(g_uiApp.ui8AppLPM | GIE);
    }
    else
    {
        __bis_SR_register(GIE);
    }
}