TMS320F280049C: PWM generation for 3 phase inverter

Surendra P

Part Number: TMS320F280049C
Other Parts Discussed in Thread: C2000WARE,

Hi team,

Present we are working on TMS320F280049C, we are using the examples presented in “C:\ti\c2000\C2000Ware_MotorControl_SDK_3_00_01_00\c2000ware\driverlib\f28004x\examples”,

We initialize the ADC
And PWM modules individually, we generated the PWMs with 120-degree phase shift (for 3phase inverter application), as shown in below image. Yellow: PWM1A, Blue: PWM2A, Pink: PWM3A.

3. Now we are trying to change the Duty of the PWMs by using half of the ADC result, we integrated both ADC and PWMs code, (we have attached the code in below), the duty of the PWMs varies with respect to ADC values (we used POT for changing the result of ADC).but we are facing one problem, phase shift of the PWMs getting disturbed.

4. Phase_R PWM is 240-degree phase shift with Phase B, but Phase_R is not 120-degree phase shift with phase Y, can anyone help me to solve this problem? (Problem also shown in below image),

#include "driverlib.h"
#include "device.h"
uint16_t pwm_period_ticks = 2500;
uint16_t adcAResults;  //Store the ADC result
uint16_t  K;
__interrupt void adcA1ISR(void);
void main(void)
{
    VIENNA_HAL_setupDevice();
    initADC();
    VIENNA_HAL_disablePWMClkCounting();
    VIENNA_HAL_configurePWMUpDwnCnt1(EPWM1_BASE,2500);
    VIENNA_HAL_configurePWMUpDwnCnt2(EPWM2_BASE,2500);
    VIENNA_HAL_configurePWMUpDwnCnt3(EPWM3_BASE,2500);
    VIENNA_HAL_setupPWM1(EPWM1_BASE);
    VIENNA_HAL_setupPWM2(EPWM2_BASE);
    VIENNA_HAL_setupPWM3(EPWM3_BASE);
    VIENNA_HAL_enablePWMClkCounting();
    PWMduty();
    Interrupt_register(INT_ADCA1, &adcA1ISR);
    // Enable ADC interrupt
    Interrupt_enable(INT_ADCA1);
    // Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
    EINT;
    ERTM;
    // Loop indefinitely
     while(1)
     {
         // Start ePWM1, enabling SOCA and putting the counter in up_Down-count mode
         EPWM_enableADCTrigger(EPWM1_BASE, EPWM_SOC_A);
         EPWM_setTimeBaseCounterMode(EPWM1_BASE, EPWM_COUNTER_MODE_UP_DOWN);
         K= adcAResults/2;
         PWMduty(K);
         // Stop ePWM1, disabling SOCA and freezing the counter
         EPWM_disableADCTrigger(EPWM1_BASE, EPWM_SOC_A);
         EPWM_setTimeBaseCounterMode(EPWM1_BASE, EPWM_COUNTER_MODE_UP_DOWN);
     }
}
void VIENNA_HAL_setupDevice(void)
{
  //Device initialization
    Device_init();
  // Disable pin locks and enable internal pull ups
    Device_initGPIO();
  // 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();
  //This function sets the pin type for specified pin
    GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD);
 //This function sets the pin configuration for EPWM1A
    GPIO_setPinConfig(GPIO_0_EPWM1A);

    GPIO_setPadConfig(2, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_2_EPWM2A);

    GPIO_setPadConfig(4, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_4_EPWM3A);
}
void initADC(void)
{
    // Setup VREF as internal
    ADC_setVREF(ADCA_BASE, ADC_REFERENCE_INTERNAL, ADC_REFERENCE_3_3V);
    // Set ADCCLK divider to /4
    ADC_setPrescaler(ADCA_BASE, ADC_CLK_DIV_4_0);
    // Set pulse positions to late
    ADC_setInterruptPulseMode(ADCA_BASE, ADC_PULSE_END_OF_CONV);
    // Power up the ADC and then delay for 1 ms
    ADC_enableConverter(ADCA_BASE);
    DEVICE_DELAY_US(1000);
    // ADC start of conversion
    // Configure SOC0 of ADCA to convert pin A0 with a sample window of 10
    // SYSCLK cycles. The EPWM1SOCA signal will be the trigger.
    ADC_setupSOC(ADCA_BASE, ADC_SOC_NUMBER5, ADC_TRIGGER_EPWM1_SOCA,
                    ADC_CH_ADCIN5, 10);
    // Set SOC0 to set the interrupt 1 flag. Enable the interrupt and make
    // sure its flag is cleared.
    ADC_setInterruptSource(ADCA_BASE, ADC_INT_NUMBER1, ADC_SOC_NUMBER5);
    ADC_enableInterrupt(ADCA_BASE, ADC_INT_NUMBER1);
    ADC_clearInterruptStatus(ADCA_BASE, ADC_INT_NUMBER1);
}
void VIENNA_HAL_setupPWM1(uint32_t base1)
{
    EPWM_disablePhaseShiftLoad(EPWM1_BASE);
    EPWM_setSyncOutPulseMode(EPWM1_BASE, EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
}
void VIENNA_HAL_setupPWM2(uint32_t base1)
{
    EPWM_enablePhaseShiftLoad(EPWM2_BASE);
    EPWM_setSyncOutPulseMode(EPWM2_BASE, EPWM_SYNC_OUT_PULSE_ON_SOFTWARE);

    EPWM_setPhaseShift(EPWM2_BASE, 833);
    EPWM_setCountModeAfterSync(EPWM2_BASE, EPWM_COUNT_MODE_UP_AFTER_SYNC);
}
void VIENNA_HAL_setupPWM3(uint32_t base1)
{
    EPWM_enablePhaseShiftLoad(EPWM3_BASE);
    EPWM_setSyncOutPulseMode(EPWM3_BASE, EPWM_SYNC_OUT_PULSE_ON_SOFTWARE);

    EPWM_setPhaseShift(EPWM3_BASE, 1666);
    EPWM_setCountModeAfterSync(EPWM3_BASE, EPWM_COUNT_MODE_UP_AFTER_SYNC);
}
// configurePWM1chUpDwnCnt()
void VIENNA_HAL_configurePWMUpDwnCnt1(uint32_t base1, uint16_t pwm_period_ticks1)
{
    // Time Base SubModule Registers
    EPWM_setPeriodLoadMode(EPWM1_BASE, EPWM_PERIOD_SHADOW_LOAD);
    EPWM_setTimeBasePeriod(EPWM1_BASE, pwm_period_ticks);
    EPWM_setTimeBaseCounter(EPWM1_BASE, 0);
    EPWM_setPhaseShift(EPWM1_BASE, 0);
    EPWM_setTimeBaseCounterMode(EPWM1_BASE, EPWM_COUNTER_MODE_UP_DOWN);
    EPWM_setClockPrescaler(EPWM1_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);

    EPWM_setCounterCompareValue(EPWM1_BASE, EPWM_COUNTER_COMPARE_A,
                                pwm_period_ticks >> 1);
    EPWM_setCounterCompareShadowLoadMode(EPWM1_BASE, EPWM_COUNTER_COMPARE_A,
                                       EPWM_COMP_LOAD_ON_CNTR_ZERO);
    // Action Qualifier SubModule Registers
    // CTR = CMPA@UP , set to 1
    EPWM_setActionQualifierAction(EPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH,
                                    EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    // CTR = CMPA@Down , set to 0
    EPWM_setActionQualifierAction(EPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
                                        EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
    // CTR = 0 , set to 0
    EPWM_setActionQualifierAction(EPWM1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
                                        EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
    // Configure the SOC to occur on the first up_Down-count event
    EPWM_setADCTriggerSource(EPWM1_BASE, EPWM_SOC_A, EPWM_SOC_TBCTR_PERIOD);
    EPWM_setADCTriggerEventPrescale(EPWM1_BASE, EPWM_SOC_A, 1);
    EPWM_enableADCTrigger(EPWM1_BASE, EPWM_SOC_A);
}
void VIENNA_HAL_configurePWMUpDwnCnt2(uint32_t base1, uint16_t pwm_period_ticks2)
{
    // Time Base SubModule Registers
    EPWM_setPeriodLoadMode(EPWM2_BASE, EPWM_PERIOD_SHADOW_LOAD);
    EPWM_setTimeBasePeriod(EPWM2_BASE, pwm_period_ticks);
    EPWM_setTimeBaseCounter(EPWM2_BASE, 0);
    EPWM_setPhaseShift(EPWM2_BASE, 833);
    EPWM_setTimeBaseCounterMode(EPWM2_BASE, EPWM_COUNTER_MODE_UP_DOWN);
    EPWM_setClockPrescaler(EPWM2_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);

    EPWM_setCounterCompareValue(EPWM2_BASE, EPWM_COUNTER_COMPARE_A,
                                pwm_period_ticks >> 1);
    EPWM_setCounterCompareShadowLoadMode(EPWM2_BASE, EPWM_COUNTER_COMPARE_A,
                                       EPWM_COMP_LOAD_ON_CNTR_ZERO);
    // Action Qualifier SubModule Registers
    // CTR = CMPA@Down, set to 1
    EPWM_setActionQualifierAction(EPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
    //  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA
    // CTR = CMPA@UP , set to 0
    EPWM_setActionQualifierAction(EPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    // CTR = 0 , set to 1
    EPWM_setActionQualifierAction(EPWM2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH,
                                        EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
}
void VIENNA_HAL_configurePWMUpDwnCnt3(uint32_t base1, uint16_t pwm_period_ticks3)
{
    // Time Base SubModule Registers
    EPWM_setPeriodLoadMode(EPWM3_BASE, EPWM_PERIOD_SHADOW_LOAD);
    EPWM_setTimeBasePeriod(EPWM3_BASE, pwm_period_ticks);
    EPWM_setTimeBaseCounter(EPWM3_BASE, 0);
    EPWM_setPhaseShift(EPWM3_BASE, 1666);
    EPWM_setTimeBaseCounterMode(EPWM3_BASE, EPWM_COUNTER_MODE_UP_DOWN);
    EPWM_setClockPrescaler(EPWM3_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);

    EPWM_setCounterCompareValue(EPWM3_BASE, EPWM_COUNTER_COMPARE_A,
                                pwm_period_ticks >> 1);
    EPWM_setCounterCompareShadowLoadMode(EPWM3_BASE, EPWM_COUNTER_COMPARE_A,
                                       EPWM_COMP_LOAD_ON_CNTR_ZERO);
    // Action Qualifier SubModule Registers
    // CTR = CMPA@UP , set to 1
    EPWM_setActionQualifierAction(EPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    //  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA
    // CTR = CMPA@Down , set to 0
    EPWM_setActionQualifierAction(EPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);
    // CTR = 0 , set to 0
    EPWM_setActionQualifierAction(EPWM3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
                                        EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
}
// setPinAsPWM()
void VIENNA_HAL_disablePWMClkCounting(void)
{
    SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
}
void VIENNA_HAL_enablePWMClkCounting(void)
{
    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
}
void initEPWMGPIO(void)
{
    // Disable pull up on GPIO 0,GPIO 2 and GPIO 3 and configure them as PWM1A,
    // PWM2A,PWM3A output respectively.
    GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_0_EPWM1A);
    GPIO_setPadConfig(2, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_2_EPWM2A);
    GPIO_setPadConfig(4, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_4_EPWM3A);
}
__interrupt void adcA1ISR(void)
{
    // Add the latest result to the buffer
    adcAResults = ADC_readResult(ADCARESULT_BASE, ADC_SOC_NUMBER5);
    //Clear the interrupt flag
    ADC_clearInterruptStatus(ADCA_BASE, ADC_INT_NUMBER1);
    //Acknowledge the interrupt
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
}
void PWMduty(uint16_t duty)
{
    EPWM_setCounterCompareValue(EPWM1_BASE, EPWM_COUNTER_COMPARE_A,
                                      duty);
    EPWM_setCounterCompareValue(EPWM2_BASE, EPWM_COUNTER_COMPARE_A,
                                      duty);
    EPWM_setCounterCompareValue(EPWM3_BASE, EPWM_COUNTER_COMPARE_A,
                                duty);
}

over 2 years ago

0 Nima Eskandari over 2 years ago

TI__Guru 52000 points

To change the duties, you just change the CMPA/CMPB values? Do you change the PRD?

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

CMPA values are changed based on the ADC values

EPWM1A

EPWM2A

EPWM3A

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

Can you show me your TBPHS and TBPHSEN bits? for all three during runtime?

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

EPWM1A TBPHS

EPWM2A

EPWM3A

Hi, thanks for the reply,

above are the 3PWMS TBPHS values, we observed one thing,the TBPHS value of PWM3A is varying in run time( going to zero).

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

Surendra P said:
we observed one thing,the TBPHS value of PWM3A is varying in run time( going to zero).

That is exactly the issue. Where are you writing to this register in your code?

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

We are writing the register in PWM initialization. And in while loop we are changing the CMPA values.

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

Well you must at one point update the value to somehting other than 1666 if it is changing in the expressions window. Find that line of code as well.

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

EPWM3A TBPHS value " 0 "

This is the line of code for changing the TBPHS value for EPWM3A

While entering the above line in the code TBPHS Value is " 0 " but this is not done every time. We are unable to identify when it becomes to zero.

Please verify my code, and suggest any modifications in the code.

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

That line of code should not be causing your TBPHS value to get reset to zero.

Do you have optimizations enabled?

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

No optimizations is enabled.

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

That line cannot change the value of your TBPHS. The EPWM_setPhaseShift or HRWPM_setPhaseShift are the only ones that can do this.Do a search for all of your code to find the culprit.

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

Hi Nima Eskandari,Thanks for the reply,

1. we are unable to find when and where that TBHS value become zero, In the initialization we set that TBPHS value to set 120 degree phase shift between EPWM1,EPWM2.
2.Can you please help me to solve this problem?

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

So, this is a very interesting issue to me. Other than writing to the register there should not be another reason that the TBPHS value gets set to ZERO.

1. Do you have a DMA that could possibly be writing to that range of registers?

2. Can you search your whole code including any libraries for "phase"?

0 Surendra P over 2 years ago in reply to Nima Eskandari

Prodigy 10 points

Hi,Thnaks for the reply,

Actually my goal is to generate PWMs to 3-phase invertor, we are thinking that present phase shift problem will cause phase shorting issue,

1.Yes 280039 has DMA,but we didn't get what you are asking
2.we searched for "phase" in all including libraries, we couldn't found this

0 Nima Eskandari over 2 years ago in reply to Surendra P

TI__Guru 52000 points

1. Is the DMA writing to any EPWM registers?

2. I did a search and the only library function that writes to the phase other than the EPWM_setPhaseShift is:

Are you using EPWM_configureSignal?

0 Nima Eskandari over 2 years ago in reply to Nima Eskandari

TI__Guru 52000 points

Surendra, That is the only other function accessing the TBPHS value, are you using this function in your project?

C2000™︎ microcontrollers

C2000 microcontrollers forum

TMS320F280049C: PWM generation for 3 phase inverter