[参考译文] LAUNCHXL-F28379D：将 GPIO 信号置于 Launchpad 的引脚中时、为什么 GPIO 信号会始终变为零？

// Included Files.
#include "driverlib.h"
#include "device.h"d

// Set PWM Frequency defines
#define EPWM_TIMER_TBPRD 600

// Set PWM Function Prototypes.
void initEPWM1(void);
void initEPWM2(void);

// Set PWM Interrupt Functions.
__interrupt void epwm1ISR(void);
__interrupt void epwm2ISR(void);

// Functions that set-up the GPIO signals.
void setupGPIO(void);

// Function that implements active-high complementary FED/RED.
void setupEPWMActiveHighComplementary(void);

// Define any and all ISR counters here.
uint32_t epwm1TZIntCount = 0;
uint32_t interruptCount1 = 0;
uint32_t epwm1ISRCount = 0;
uint32_t epwm2ISRCount = 0;

// Interrupt handler for trip-zone events.
__interrupt void epwm1TZISR(void);

int main(void)
{
// As per usual, do all of these initialisation functions.
// Initialise system control, device clock, and peripherals
Device_init();

// Initialise PIE and clear PIE registers. Disables CPU interrupts.
// and clear all CPU interrupt flags.
Interrupt_initModule();

// Initialise the PIE vector table with pointers to the shell interrupt
// Service Routines (ISR).
Interrupt_initVectorTable();

setupGPIO();

// Specify which function is called when an interrupt is triggered by assigning to register.
Interrupt_register(INT_EPWM1, &epwm1ISR);
Interrupt_register(INT_EPWM2, &epwm2ISR);
Interrupt_register(INT_EPWM1_TZ, &epwm1TZISR);

// Start EPWM Initialisation here, first disable peripheral.
SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

// Initialise PWM1 with zero phase shift, set as master. See function.
initEPWM1();

// Initialise PWM2 with variable phase-shift, set as slave. See function.
initEPWM2();

// Synchronised shadow load mode.
EPWM_selectPeriodLoadEvent(EPWM2_BASE, EPWM_SHADOW_LOAD_MODE_SYNC);

// Set initial phase-shift and time-base counter as zero for soft-start.
EPWM_setPhaseShift(EPWM2_BASE, 500);
EPWM_setTimeBaseCounter(EPWM2_BASE, 500);

// Set EPWM1 SYNCO to be generated when counter is zero.
EPWM_setSyncOutPulseMode(EPWM1_BASE, EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);

// EPWM2 will use the EPWM1 SYNCO signal as SYNCIN value
// Do not need to call setSyncInputConfig as EPWM2 uses this by default.
EPWM_setSyncOutPulseMode(EPWM2_BASE, EPWM_SYNC_OUT_PULSE_ON_EPWMxSYNCIN);

// Disable phase shift load for EPWM1, enable for PWM2.
EPWM_disablePhaseShiftLoad(EPWM1_BASE);
EPWM_enablePhaseShiftLoad(EPWM2_BASE);

// Setup rising and falling edge delays for both modules.
setupEPWMActiveHighComplementary();

// Enable the synch register and lock to the PWM.
SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

// Finally, enable the PWM interrupts.
Interrupt_enable(INT_EPWM1);
Interrupt_enable(INT_EPWM2);

// Trip zone itnerrupts. Only use one and allow it to handle both PWM modules.
Interrupt_enable(INT_EPWM1_TZ);

// Enables CPU interrupts
Interrupt_enableMaster();

// Enable Global Interrupt (INTM) and real time interrupt (DBGM)
EINT;
ERTM;

// Loop forever to allow debug.
for(;;)
{
// Charge enabled for maximum of 2 milliseconds
GPIO_writePin(67, 1);
DEVICE_DELAY_US(2000);
// Charging disabled for 500 microseconds
GPIO_writePin(67, 0);
DEVICE_DELAY_US(500);
}
}

void initEPWM1(void) {

// Set up time-base clock.
EPWM_setTimeBasePeriod(EPWM1_BASE, EPWM_TIMER_TBPRD);
EPWM_setPhaseShift(EPWM1_BASE, 0);
EPWM_setTimeBaseCounter(EPWM1_BASE, 0);

// Counter compare config for EPWM1. May just need CMPA if use FED/RED.
EPWM_setCounterCompareValue(EPWM1_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_TIMER_TBPRD/2);
EPWM_setCounterCompareValue(EPWM1_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_TIMER_TBPRD/2);

// Set up counter mode.
EPWM_setTimeBaseCounterMode(EPWM1_BASE, EPWM_COUNTER_MODE_UP);
EPWM_disablePhaseShiftLoad(EPWM1_BASE);
EPWM_setClockPrescaler(EPWM1_BASE,
EPWM_CLOCK_DIVIDER_1,
EPWM_HSCLOCK_DIVIDER_1);

// Set up PWM Shadowing. Load on CTR ZRO.
EPWM_setCounterCompareShadowLoadMode(EPWM1_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(EPWM1_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_COMP_LOAD_ON_CNTR_ZERO);

// Set up the action qualifier.
EPWM_setActionQualifierAction(EPWM1_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);

EPWM_setActionQualifierAction(EPWM1_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);

EPWM_setActionQualifierAction(EPWM1_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);

EPWM_setActionQualifierAction(EPWM1_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);

// Trip zones defined here.
EPWM_enableTripZoneSignals(EPWM1_BASE, EPWM_TZ_SIGNAL_OSHT1);

EPWM_setTripZoneAction(EPWM1_BASE, EPWM_TZ_ACTION_EVENT_TZA, EPWM_TZ_ACTION_LOW);

// Enable TZ interrupt
EPWM_enableTripZoneInterrupt(EPWM1_BASE, EPWM_TZ_INTERRUPT_OST);

// Interrupt where we will change execute control code.
// Select INT on time base counter zero event
// Enable INT, but generate on the 15th event
// Bandwidth is then FSW/15.
EPWM_setInterruptSource(EPWM1_BASE, EPWM_INT_TBCTR_ZERO);
EPWM_enableInterrupt(EPWM1_BASE);
EPWM_setInterruptEventCount(EPWM1_BASE, 15);
}

void initEPWM2(void) {

// Set up time-base clock.
EPWM_setTimeBasePeriod(EPWM2_BASE, EPWM_TIMER_TBPRD);

// Initially zero, but test with different TBPHS.
// Ensure Time base is set to same value as phase shift.
EPWM_setPhaseShift(EPWM2_BASE, 300);
EPWM_setTimeBaseCounter(EPWM2_BASE, 300);

// Counter compare config for EPWM2. May just need CMPA if use FED/RED.
EPWM_setCounterCompareValue(EPWM2_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_TIMER_TBPRD/2);
EPWM_setCounterCompareValue(EPWM2_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_TIMER_TBPRD/2);

// Set up counter mode.
EPWM_setTimeBaseCounterMode(EPWM2_BASE, EPWM_COUNTER_MODE_UP);
EPWM_disablePhaseShiftLoad(EPWM2_BASE);
EPWM_setClockPrescaler(EPWM2_BASE,
EPWM_CLOCK_DIVIDER_1,
EPWM_HSCLOCK_DIVIDER_1);

// Set up PWM Shadowing. Load on CTR ZRO.
EPWM_setCounterCompareShadowLoadMode(EPWM2_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(EPWM2_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_COMP_LOAD_ON_CNTR_ZERO);

// Set up the action qualifier.
// Scope these and check if right, most likely need to be different to EPWM1.
EPWM_setActionQualifierAction(EPWM2_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);

EPWM_setActionQualifierAction(EPWM2_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);

EPWM_setActionQualifierAction(EPWM2_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);

EPWM_setActionQualifierAction(EPWM2_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);

EPWM_enableTripZoneSignals(EPWM2_BASE, EPWM_TZ_SIGNAL_OSHT1);

EPWM_setTripZoneAction(EPWM2_BASE, EPWM_TZ_ACTION_EVENT_TZA, EPWM_TZ_ACTION_LOW);

EPWM_enableTripZoneInterrupt(EPWM2_BASE, EPWM_TZ_INTERRUPT_OST);

// Interrupt where we will change execute control code.
// Select INT on time base counter zero event
// Enable INT, but generate on the 15th event
// Bandwidth is then FSW/15.
EPWM_setInterruptSource(EPWM2_BASE, EPWM_INT_TBCTR_ZERO);
EPWM_enableInterrupt(EPWM2_BASE);
EPWM_setInterruptEventCount(EPWM2_BASE, 15);
}

void setupEPWMActiveHighComplementary() {

// As always, use EPWMA as the input for both RED and FED.
EPWM_setRisingEdgeDeadBandDelayInput(EPWM1_BASE, EPWM_DB_INPUT_EPWMA);
EPWM_setRisingEdgeDeadBandDelayInput(EPWM2_BASE, EPWM_DB_INPUT_EPWMA);
EPWM_setFallingEdgeDeadBandDelayInput(EPWM1_BASE, EPWM_DB_INPUT_EPWMA);
EPWM_setFallingEdgeDeadBandDelayInput(EPWM2_BASE, EPWM_DB_INPUT_EPWMA);

// Set the rising and falling edge delay values. One percent of switching period, for now.
EPWM_setFallingEdgeDelayCount(EPWM1_BASE, EPWM_TIMER_TBPRD/100);
EPWM_setFallingEdgeDelayCount(EPWM2_BASE, EPWM_TIMER_TBPRD/100);
EPWM_setRisingEdgeDelayCount(EPWM1_BASE, EPWM_TIMER_TBPRD/100);
EPWM_setRisingEdgeDelayCount(EPWM2_BASE, EPWM_TIMER_TBPRD/100);

// Invert only the falling edge delayed output for active-high complementary mode.
EPWM_setDeadBandDelayPolarity(EPWM1_BASE, EPWM_DB_RED, EPWM_DB_POLARITY_ACTIVE_HIGH);
EPWM_setDeadBandDelayPolarity(EPWM1_BASE, EPWM_DB_FED, EPWM_DB_POLARITY_ACTIVE_LOW);
EPWM_setDeadBandDelayPolarity(EPWM2_BASE, EPWM_DB_RED, EPWM_DB_POLARITY_ACTIVE_HIGH);
EPWM_setDeadBandDelayPolarity(EPWM2_BASE, EPWM_DB_FED, EPWM_DB_POLARITY_ACTIVE_LOW);

// Use the delayed signals instead of the original signals.
EPWM_setDeadBandDelayMode(EPWM1_BASE, EPWM_DB_RED, true);
EPWM_setDeadBandDelayMode(EPWM1_BASE, EPWM_DB_FED, true);
EPWM_setDeadBandDelayMode(EPWM2_BASE, EPWM_DB_RED, true);
EPWM_setDeadBandDelayMode(EPWM2_BASE, EPWM_DB_FED, true);

// Importantly, do not switch output A with output B.
EPWM_setDeadBandOutputSwapMode(EPWM1_BASE, EPWM_DB_OUTPUT_A, false);
EPWM_setDeadBandOutputSwapMode(EPWM1_BASE, EPWM_DB_OUTPUT_B, false);
EPWM_setDeadBandOutputSwapMode(EPWM2_BASE, EPWM_DB_OUTPUT_A, false);
EPWM_setDeadBandOutputSwapMode(EPWM2_BASE, EPWM_DB_OUTPUT_B, false);
}

// Call this function to set-up the pin-out of the GPIOs.
void setupGPIO(void)
{
// Enable PWM1A/B-2A/B on GPIO0-GPIO4
GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD); // Standard push-pull output on GPIO0
GPIO_setPadConfig(1, GPIO_PIN_TYPE_STD); // GPIO1
GPIO_setPadConfig(2, GPIO_PIN_TYPE_STD); // GPIO2
GPIO_setPadConfig(3, GPIO_PIN_TYPE_STD); // GPIO3
GPIO_setPinConfig(GPIO_0_EPWM1A); // GPIO0 = PWM1A
GPIO_setPinConfig(GPIO_1_EPWM1B); // GPIO1 = PWM1B
GPIO_setPinConfig(GPIO_2_EPWM2A); // GPIO2 = PWM2A
GPIO_setPinConfig(GPIO_3_EPWM2B); // GPIO3 = PWM2B

// Enable a GPIO67 output on GPIO67, set it high
GPIO_setPadConfig(67, GPIO_PIN_TYPE_PULLUP); // Enable pullup on GPIO67
GPIO_writePin(67, 1); // Load output latch
GPIO_setPinConfig(GPIO_67_GPIO67); // GPIO67 = GPIO67
GPIO_setDirectionMode(67, GPIO_DIR_MODE_OUT); // GPIO67 = output

// Enable a GPIO output on GPIO8, set it high
GPIO_setPadConfig(5, GPIO_PIN_TYPE_PULLUP); // Enable pullup on GPIO5
GPIO_writePin(5, 1); // Load output latch
GPIO_setPinConfig(GPIO_5_GPIO5); // GPIO5 = GPIO5 MUX SELECT
GPIO_setDirectionMode(5, GPIO_DIR_MODE_IN); // GPIO5 = input (output overvolts latch)

// Enable Trip Zone input on GPIO5
GPIO_setQualificationMode(5, GPIO_QUAL_ASYNC); // asynch input

// Input pins trigger XBAR TZs
XBAR_setInputPin(XBAR_INPUT1, 5); // GPIO5 = TZ1

}

__interrupt void epwm1ISR() {
epwm1ISRCount++;

// Clear INT flag for this timer
EPWM_clearEventTriggerInterruptFlag(EPWM1_BASE);

// Acknowledge interrupt group
Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP3);
}

__interrupt void epwm2ISR() {
epwm2ISRCount++;

// Clear INT flag for this timer
EPWM_clearEventTriggerInterruptFlag(EPWM2_BASE);

// Acknowledge interrupt group
Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP3);
}

__interrupt void epwm1TZISR() {
epwm1TZIntCount++;

// For one-shot trips, we must re-enable all of the trip-zone flags within both PWM modules.
EPWM_clearTripZoneFlag(EPWM1_BASE, (EPWM_TZ_INTERRUPT | EPWM_TZ_FLAG_OST));
EPWM_clearTripZoneFlag(EPWM2_BASE, (EPWM_TZ_INTERRUPT | EPWM_TZ_FLAG_OST));

// Acknowledge this interrupt to receive more interrupts from group 2
Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP2);
}