Other Parts Discussed in Thread: C2000WARE
我的板子型号是280049，我在用HRPWM实现高精度移相，并可以调整高精度周期，但是出来的波形没有实现，是不是我的寄存器配置有问题？
This thread has been locked.
If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.
Original question:
我的板子型号是280049，我在用HRPWM实现高精度移相，并可以调整高精度周期，但是出来的波形没有实现，是不是我的寄存器配置有问题？
#include "driverlib.h"
#include "device.h"
#include "board.h"
#include "SFO_V8.h"
#include <math.h>
//
// Defines
//
#define EPWM_TIMER_TBPRD 4545UL//5000UL
#define LAST_EPWM_INDEX_FOR_EXAMPLE 5
#define MIN_HRPWM_PRD_PERCENT (20.0003f)
#define myEPWM1_BASE EPWM1_BASE
#define myEPWM2_BASE EPWM2_BASE
#define myEPWM3_BASE EPWM3_BASE
//
// Globals
//
static float64_t periodFine = MIN_HRPWM_PRD_PERCENT;
uint16_t status;
//int MEP_ScaleFactor; // Global variable used by the SFO library
// Result can be used for all HRPWM channels
// This variable is also copied to HRMSTEP
// register by SFO() function.
//volatile uint32_t ePWM[] =
// {myEPWM1_BASE,myEPWM2_BASE, myEPWM3_BASE};
//
// Function Prototypes
//
void initHRPWM(uint32_t period);
void error(void);
void PinMuxEPWM1_init();
void PinMuxEPWM2_init();
void PinMuxEPWM3_init();
void EPWM1_init();
void EPWM2_init();
void EPWM3_init();
void initGPIO();
//
// Main
//
void changeHZ(double zTemp,double iAngle)
{
uint32_t compCount = 0UL;
double iTemp = 0.0f;
uint32_t aTemp = 100000UL;
uint32_t xTemp = 0UL;
double yTemp = 0.0f;
uint32_t iPhase=0;
iTemp = aTemp / zTemp;
xTemp = floor(iTemp); //取整数部分
yTemp = iTemp - xTemp; //减，以取小数部分
compCount= ((xTemp-1) << 8UL)+ (float32_t)(yTemp*256);
HRPWM_setTimeBasePeriod(myEPWM1_BASE, compCount);
HRPWM_setTimeBasePeriod(myEPWM3_BASE, compCount);
HRPWM_setTimeBasePeriod(myEPWM2_BASE, compCount);
//
// set duty 50% initially
//
HRPWM_setCounterCompareValue(myEPWM1_BASE, HRPWM_COUNTER_COMPARE_A, (xTemp/2 << 8));
//HRPWM_setCounterCompareValue(myEPWM1_BASE, HRPWM_COUNTER_COMPARE_B, (xTemp/2 << 8));
HRPWM_setCounterCompareValue(myEPWM3_BASE, HRPWM_COUNTER_COMPARE_A, (xTemp/2 << 8));
//HRPWM_setCounterCompareValue(myEPWM3_BASE, HRPWM_COUNTER_COMPARE_B, (xTemp/2 << 8));
HRPWM_setCounterCompareValue(myEPWM2_BASE, HRPWM_COUNTER_COMPARE_A, (xTemp/2 << 8));
//HRPWM_setCounterCompareValue(myEPWM2_BASE, HRPWM_COUNTER_COMPARE_B, (xTemp/2 << 8));
//iPhase/xTemp*360=iAngle;
//
iTemp=((iAngle*xTemp)/360.0f);
compCount=(uint32_t)iTemp;
iPhase=xTemp-compCount;
EPWM_setPhaseShift(myEPWM3_BASE, iPhase);
EPWM_setPhaseShift(myEPWM2_BASE, iPhase);
}
void main(void)
{
uint16_t abit = 0;
float32_t angle = 1.0;
//
//compCount= ((xTemp-1) << 8UL)+ (float32_t)(yTemp*256);
//HRPWM_setTimeBasePeriod(myEPWM1_BASE, compCount);
//HRPWM_setTimeBasePeriod(myEPWM3_BASE, compCount);
// Initialize device clock and peripherals
//
Device_init();
//
// Disable pin locks and enable internal pull ups.
//
Device_initGPIO();
CBSP_GIO_LED_Init();
//
// Initialize PIE and clear PIE registers. Disables CPU interrupts.
//
Interrupt_initModule();
//
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
//
Interrupt_initVectorTable();
//
// Initialize EPWM GPIOs
//
PinMuxEPWM1_init();
PinMuxEPWM2_init();
PinMuxEPWM3_init();
EPWM1_init();
EPWM2_init();
EPWM3_init();
//
// Calling SFO() updates the HRMSTEP register with calibrated MEP_ScaleFactor.
// HRMSTEP must be populated with a scale factor value prior to enabling
// high resolution period control.
//
while(status == SFO_INCOMPLETE)
{
status = SFO();
if(status == SFO_ERROR)
{
error(); // SFO function returns 2 if an error occurs & # of MEP
} // steps/coarse step exceeds maximum of 255.
}
//
// Disable sync(Freeze clock to PWM as well)
//
SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
initHRPWM(EPWM_TIMER_TBPRD);
//
// Enable sync and clock to PWM
//
SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
//
// Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
//
EINT;
ERTM;
periodFine=MIN_HRPWM_PRD_PERCENT;
changeHZ(periodFine,90);
status = SFO(); // in background, MEP calibration module
// continuously updates MEP_ScaleFactor
if (status == SFO_ERROR)
{
error(); // SFO function returns 2 if an error occurs & #
// of MEP steps/coarse step
}
for(;;)
{
//
// Sweep DutyFine
//
//for(periodFine = MIN_HRPWM_PRD_PERCENT; periodFine < (MIN_HRPWM_PRD_PERCENT+0.805); periodFine += 0.1001)
//for(periodFine = 1; periodFine < (180); periodFine++)
LED_TOGGLE();
if(abit>0)
{
if(angle<(180-1))
{
angle++;
periodFine+=0.001;
}
else
{
abit=0;
}
}
else
{
if(angle>1)
{
angle--;
periodFine-=0.001;
}
else
{
abit=1;
}
}
{
DEVICE_DELAY_US(10);
changeHZ(periodFine,angle);
//
// Call the scale factor optimizer lib function SFO()
// periodically to track for any change due to temp/voltage.
// This function generates MEP_ScaleFactor by running the
// MEP calibration module in the HRPWM logic. This scale
// factor can be used for all HRPWM channels. The SFO()
// function also updates the HRMSTEP register with the
// scale factor value.
//
status = SFO(); // in background, MEP calibration module
// continuously updates MEP_ScaleFactor
if (status == SFO_ERROR)
{
error(); // SFO function returns 2 if an error occurs & #
// of MEP steps/coarse step
} // exceeds maximum of 255.
}
}
}
void initHRPWM(uint32_t period)
{
EPWM_setEmulationMode(myEPWM1_BASE, EPWM_EMULATION_FREE_RUN);
EPWM_setEmulationMode(myEPWM2_BASE, EPWM_EMULATION_FREE_RUN);
EPWM_setEmulationMode(myEPWM3_BASE, EPWM_EMULATION_FREE_RUN);
//
// Set-up TBCLK
//
EPWM_setTimeBasePeriod(myEPWM1_BASE, period-1);
EPWM_setPhaseShift(myEPWM1_BASE, 0U);
EPWM_setTimeBaseCounter(myEPWM1_BASE, 0U);
EPWM_setTimeBasePeriod(myEPWM2_BASE, period-1);
EPWM_setTimeBaseCounter(myEPWM2_BASE, 0U);
EPWM_setTimeBasePeriod(myEPWM3_BASE, period-1);
EPWM_setTimeBaseCounter(myEPWM3_BASE, 0U);
//
// set duty 50% initially
//
HRPWM_setCounterCompareValue(myEPWM1_BASE, HRPWM_COUNTER_COMPARE_A, (period/2 << 8));
HRPWM_setCounterCompareValue(myEPWM1_BASE, HRPWM_COUNTER_COMPARE_B, (period/2 << 8));
HRPWM_setCounterCompareValue(myEPWM2_BASE, HRPWM_COUNTER_COMPARE_A, (period/2 << 8));
HRPWM_setCounterCompareValue(myEPWM2_BASE, HRPWM_COUNTER_COMPARE_B, (period/2 << 8));
HRPWM_setCounterCompareValue(myEPWM3_BASE, HRPWM_COUNTER_COMPARE_A, (period/2 << 8));
HRPWM_setCounterCompareValue(myEPWM3_BASE, HRPWM_COUNTER_COMPARE_B, (period/2 << 8));
//
// Set up counter mode
//
EPWM_setTimeBaseCounterMode(myEPWM1_BASE, EPWM_COUNTER_MODE_UP);
EPWM_disablePhaseShiftLoad(myEPWM1_BASE);
EPWM_setClockPrescaler(myEPWM1_BASE,
EPWM_CLOCK_DIVIDER_1,
EPWM_HSCLOCK_DIVIDER_1);
EPWM_setSyncOutPulseMode(myEPWM1_BASE, EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
EPWM_setTimeBaseCounterMode(myEPWM2_BASE, EPWM_COUNTER_MODE_UP);
EPWM_enablePhaseShiftLoad(myEPWM2_BASE);
EPWM_setTimeBaseCounterMode(myEPWM3_BASE, EPWM_COUNTER_MODE_UP);
EPWM_enablePhaseShiftLoad(myEPWM3_BASE);
uint32_t iPeriod=period/3;
iPeriod=period*0.03;
EPWM_setPhaseShift(myEPWM3_BASE, iPeriod);
EPWM_setClockPrescaler(myEPWM3_BASE,
EPWM_CLOCK_DIVIDER_1,
EPWM_HSCLOCK_DIVIDER_1);
EPWM_setSyncOutPulseMode(myEPWM3_BASE, EPWM_SYNC_OUT_PULSE_DISABLED);
EPWM_setPhaseShift(myEPWM2_BASE, iPeriod);
EPWM_setClockPrescaler(myEPWM2_BASE,
EPWM_CLOCK_DIVIDER_1,
EPWM_HSCLOCK_DIVIDER_1);
EPWM_setSyncOutPulseMode(myEPWM2_BASE, EPWM_SYNC_OUT_PULSE_DISABLED);
//
// Set up shadowing
//
EPWM_setCounterCompareShadowLoadMode(myEPWM1_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(myEPWM1_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(myEPWM3_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(myEPWM3_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(myEPWM2_BASE,
EPWM_COUNTER_COMPARE_A,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareShadowLoadMode(myEPWM2_BASE,
EPWM_COUNTER_COMPARE_B,
EPWM_COMP_LOAD_ON_CNTR_ZERO);
//
// Set actions
//
EPWM_setActionQualifierAction(myEPWM1_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM1_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM1_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM1_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM3_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM3_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM3_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM3_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM2_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM2_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_LOW,
EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM2_BASE,
EPWM_AQ_OUTPUT_A,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM2_BASE,
EPWM_AQ_OUTPUT_B,
EPWM_AQ_OUTPUT_HIGH,
EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
HRPWM_setMEPEdgeSelect(myEPWM1_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM1_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM1_BASE, HRPWM_CHANNEL_A, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_setMEPEdgeSelect(myEPWM3_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM3_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM3_BASE, HRPWM_CHANNEL_A, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_setMEPEdgeSelect(myEPWM2_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM2_BASE, HRPWM_CHANNEL_A, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM2_BASE, HRPWM_CHANNEL_A, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_setMEPEdgeSelect(myEPWM1_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM1_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM1_BASE, HRPWM_CHANNEL_B, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_setMEPEdgeSelect(myEPWM3_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM3_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM3_BASE, HRPWM_CHANNEL_B, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_setMEPEdgeSelect(myEPWM2_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_CTRL_RISING_EDGE);
HRPWM_setMEPControlMode(myEPWM2_BASE, HRPWM_CHANNEL_B, HRPWM_MEP_DUTY_PERIOD_CTRL);
HRPWM_setCounterCompareShadowLoadEvent(myEPWM2_BASE, HRPWM_CHANNEL_B, HRPWM_LOAD_ON_CNTR_ZERO);
HRPWM_enableAutoConversion(myEPWM1_BASE);
HRPWM_enableAutoConversion(myEPWM3_BASE);
HRPWM_enableAutoConversion(myEPWM2_BASE);
//
// Turn on high-resolution period control.
//
HRPWM_enablePeriodControl(myEPWM1_BASE);
HRPWM_enablePhaseShiftLoad(myEPWM1_BASE);
HRPWM_enablePeriodControl(myEPWM3_BASE);
HRPWM_enablePhaseShiftLoad(myEPWM3_BASE);
HRPWM_enablePeriodControl(myEPWM2_BASE);
HRPWM_enablePhaseShiftLoad(myEPWM2_BASE);
EPWM_forceSyncPulse(myEPWM1_BASE);
EPWM_forceSyncPulse(myEPWM3_BASE);
EPWM_forceSyncPulse(myEPWM2_BASE);
}
void EPWM3_init(){
EPWM_setClockPrescaler(myEPWM3_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_2);
EPWM_setTimeBasePeriod(myEPWM3_BASE, 0);
EPWM_setTimeBaseCounter(myEPWM3_BASE, 0);
EPWM_setTimeBaseCounterMode(myEPWM3_BASE, EPWM_COUNTER_MODE_STOP_FREEZE);
EPWM_enablePhaseShiftLoad(myEPWM3_BASE);
EPWM_setPhaseShift(myEPWM3_BASE, 100);
EPWM_setCounterCompareValue(myEPWM3_BASE, EPWM_COUNTER_COMPARE_A, 0);
EPWM_setCounterCompareShadowLoadMode(myEPWM3_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareValue(myEPWM3_BASE, EPWM_COUNTER_COMPARE_B, 0);
EPWM_setCounterCompareShadowLoadMode(myEPWM3_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setSyncOutPulseMode(myEPWM3_BASE, EPWM_SYNC_OUT_PULSE_ON_EPWMxSYNCIN);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setRisingEdgeDeadBandDelayInput(myEPWM3_BASE,EPWM_DB_INPUT_EPWMA);
EPWM_setFallingEdgeDeadBandDelayInput(myEPWM3_BASE,EPWM_DB_INPUT_EPWMA); //配置死区输入模式
EPWM_setDeadBandDelayPolarity(myEPWM3_BASE,EPWM_DB_RED,EPWM_DB_POLARITY_ACTIVE_HIGH);
EPWM_setDeadBandDelayPolarity(myEPWM3_BASE,EPWM_DB_FED,EPWM_DB_POLARITY_ACTIVE_LOW);//配置极性
EPWM_setDeadBandDelayMode(myEPWM3_BASE,EPWM_DB_RED,true);
EPWM_setDeadBandDelayMode(myEPWM3_BASE,EPWM_DB_FED,true); //配置输出模式
EPWM_setDeadBandOutputSwapMode(myEPWM3_BASE,EPWM_DB_OUTPUT_A,false);
EPWM_setDeadBandOutputSwapMode(myEPWM3_BASE,EPWM_DB_OUTPUT_B,false); //输出不交换
EPWM_setRisingEdgeDelayCount(myEPWM3_BASE,28); //上升沿延时0nS
EPWM_setFallingEdgeDelayCount(myEPWM3_BASE,28); //下降沿延时0nS
}
void EPWM2_init(){
EPWM_setClockPrescaler(myEPWM2_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_2);
EPWM_setTimeBasePeriod(myEPWM2_BASE, 0);
EPWM_setTimeBaseCounter(myEPWM2_BASE, 0);
EPWM_setTimeBaseCounterMode(myEPWM2_BASE, EPWM_COUNTER_MODE_STOP_FREEZE);
EPWM_enablePhaseShiftLoad(myEPWM2_BASE);
EPWM_setPhaseShift(myEPWM2_BASE, 100);
EPWM_setCounterCompareValue(myEPWM2_BASE, EPWM_COUNTER_COMPARE_A, 0);
EPWM_setCounterCompareShadowLoadMode(myEPWM2_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setCounterCompareValue(myEPWM2_BASE, EPWM_COUNTER_COMPARE_B, 0);
EPWM_setCounterCompareShadowLoadMode(myEPWM2_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);
EPWM_setSyncOutPulseMode(myEPWM2_BASE, EPWM_SYNC_OUT_PULSE_ON_EPWMxSYNCIN);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setRisingEdgeDeadBandDelayInput(myEPWM2_BASE,EPWM_DB_INPUT_EPWMA);
EPWM_setFallingEdgeDeadBandDelayInput(myEPWM2_BASE,EPWM_DB_INPUT_EPWMA); //配置死区输入模式
EPWM_setDeadBandDelayPolarity(myEPWM2_BASE,EPWM_DB_RED,EPWM_DB_POLARITY_ACTIVE_HIGH);
EPWM_setDeadBandDelayPolarity(myEPWM2_BASE,EPWM_DB_FED,EPWM_DB_POLARITY_ACTIVE_LOW);//配置极性
EPWM_setDeadBandDelayMode(myEPWM2_BASE,EPWM_DB_RED,true);
EPWM_setDeadBandDelayMode(myEPWM2_BASE,EPWM_DB_FED,true); //配置输出模式
EPWM_setDeadBandOutputSwapMode(myEPWM2_BASE,EPWM_DB_OUTPUT_A,false);
EPWM_setDeadBandOutputSwapMode(myEPWM2_BASE,EPWM_DB_OUTPUT_B,false); //输出不交换
EPWM_setRisingEdgeDelayCount(myEPWM2_BASE,28); //上升沿延时0nS
EPWM_setFallingEdgeDelayCount(myEPWM2_BASE,28); //下降沿延时0nS
}
void EPWM1_init(){
EPWM_setClockPrescaler(myEPWM1_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_2);//ePWM 时钟为100MHZ
EPWM_setTimeBasePeriod(myEPWM1_BASE, 0);//设置周期值 = 0
EPWM_setTimeBaseCounter(myEPWM1_BASE, 0);//设置初始值
EPWM_setTimeBaseCounterMode(myEPWM1_BASE, EPWM_COUNTER_MODE_STOP_FREEZE);//设置为 Stop 计数模式
EPWM_disablePhaseShiftLoad(myEPWM1_BASE);//不偏移
EPWM_setPhaseShift(myEPWM1_BASE, 0);//设置偏移值为0
EPWM_setCounterCompareValue(myEPWM1_BASE, EPWM_COUNTER_COMPARE_A, 0);//设置CMPA的值
EPWM_setCounterCompareShadowLoadMode(myEPWM1_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);//设置A比较值加载模式
EPWM_setCounterCompareValue(myEPWM1_BASE, EPWM_COUNTER_COMPARE_B, 0);//设置CMPB的值
EPWM_setCounterCompareShadowLoadMode(myEPWM1_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);//设置B比较值加载模式
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO); //ePWMA的
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
EPWM_setActionQualifierAction(myEPWM1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
EPWM_setRisingEdgeDeadBandDelayInput(myEPWM1_BASE,EPWM_DB_INPUT_EPWMA);
EPWM_setFallingEdgeDeadBandDelayInput(myEPWM1_BASE,EPWM_DB_INPUT_EPWMA); //配置死区输入模式
EPWM_setDeadBandDelayPolarity(myEPWM1_BASE,EPWM_DB_RED,EPWM_DB_POLARITY_ACTIVE_HIGH);
EPWM_setDeadBandDelayPolarity(myEPWM1_BASE,EPWM_DB_FED,EPWM_DB_POLARITY_ACTIVE_LOW);//配置极性
EPWM_setDeadBandDelayMode(myEPWM1_BASE,EPWM_DB_RED,true);
EPWM_setDeadBandDelayMode(myEPWM1_BASE,EPWM_DB_FED,true); //配置输出模式
EPWM_setDeadBandOutputSwapMode(myEPWM1_BASE,EPWM_DB_OUTPUT_A,false);
EPWM_setDeadBandOutputSwapMode(myEPWM1_BASE,EPWM_DB_OUTPUT_B,false); //输出不交换
EPWM_setRisingEdgeDelayCount(myEPWM1_BASE,28); //上升沿延时0nS
EPWM_setFallingEdgeDelayCount(myEPWM1_BASE,28); //下降沿延时0nS
}
void PinMuxEPWM3_init()
{
//
// EPWM1 -> myEPWM1 Pinmux
//
GPIO_setPinConfig(GPIO_4_EPWM3A);
GPIO_setPinConfig(GPIO_5_EPWM3B);
}
void PinMuxEPWM2_init()
{
//
// EPWM1 -> myEPWM1 Pinmux
//
GPIO_setPinConfig(GPIO_2_EPWM2A);
GPIO_setPinConfig(GPIO_3_EPWM2B);
}
void PinMuxEPWM1_init()
{
//
// EPWM1 -> myEPWM1 Pinmux
//
GPIO_setPinConfig(GPIO_0_EPWM1A);
GPIO_setPinConfig(GPIO_1_EPWM1B);
}
一、在本论坛找到了一个帖子，照着改了下，发现pwm2和pwm3无法同时移相，具体如下：
1，PWM1正常开启，当开启pwm2和pwm3的时候，并同时设置pwm2和pwm3的相位角，发现只有pwm2的相位正常改变，pwn3的相位不动,；
2，PWM1正常开启，当把pwm2关闭，开启pwm3的时候，并同时设置pwm3的相位角，发现pwn3的相位正常改变,；
3，请问这是什么原因？
二、我需要实现的功能是：
1、PWM1A和PWM1B，PWM2A和PWM2B，PWM3A和PWM3B带死区互补输出；
2、通实时改变PWM1,2,3三组六路的频率，精度是0.1HZ；
3，PWM2A/B和PWM3A/B 相对于PWM1移相输出；
Hi,
我们的技术支持基于TI的例程。
EPWM2、3要相对于EPWM1移相，您需要设置EPWM1的同步输出信号，比如在CTR=0或CTR=PRD时输出；还需要设置EPWM2的同步输入信号为EPWM1的同步输出信号，并将这个信号直通给EPWM3。这样便实现了同步，然后EPWM2、3便会根据您配置的移相值，在同步信号到来时装载移相值进行移相。
（EPWM同步信号链）
死区互补输出是通过配置DB来实现的：
详细的配置请您阅读sprui33f_TMS320F28004x Real-Time Microcontrollers Technical Reference Manual (Rev. F) Chapter 18 Enhanced Pulse Width Modulator (ePWM)
我们只能给您提供一个大概的思路，或者为您解释困扰您的某个点。具体的代码实现您需要靠自己。TI提供的例程全部都在SDK中了。
--
谢谢