LAUNCHXL-F28379D: dual axis drive motor pwm sync issues

Adding Motor B oscilloscope images:

Channel C1 and C2 are probed across Phase U top(Inverted) and bottom MOSFET(Vds), C3 is the DC bus and C4 is Phase U Current.

You notice the suddent spikes comming in The sine wave

Here is a zoomed in image, notice the double pulse type event occuring.

Any other changes you made? Like PWM frequency? maxModIndex?

Switching frequency is 20 KHz, so the maxModIndex changes from 0.98(in SINGLE_SAMPLING) to 0.95.

We found some success in doing the below changes:

Instead of disabling phase shift load for PWM11, we have forced it to PWM1 

if (handle == &halMtr[MTR_1])
{
halfPeriod = M1_INV_PWM_TICKS / 2; // 100MHz EPWMCLK

//EPWM_disablePhaseShiftLoad(obj->pwmHandle[0]); //pwm11
EPWM_disablePhaseShiftLoad(EPWM1_BASE); -->Changed

// sync "down-stream"
//EPWM_setSyncOutPulseMode(obj->pwmHandle[0],EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
EPWM_setSyncOutPulseMode(EPWM1_BASE,EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);--?Changed

We had some success, But as the speed was increased this issue was again observed. Our requirment is to reach 10000 RPM running both the motors.

-Above 7000 RPM, 20 KHz switching frequency: we started observing this issue
-Then we reduced switching frequency to 15 KHz: we observed this issue at speeds above 9000 RPM
-Then we further reduced the switching frequency to 12 KHz, we were able to reach 10000 RPM without this event occuring., But if we ramp from 0 to 10000 RPM, because of a small overshoot in speed, at 10000 RPM we catch is issue again.
But we still don't know the root cause of this and how does changing switching frequecy effect the PWM sync between Motor A and Motor B PWMs.

One more point, looking at the other reference designs codes(Ex: F2838x, F28002x and F28004x) , we see that the phase shift values between the PWMs are different, so do we need to change the phase shifts values, if so what values do we use?

That depends on what EPWM modules for the motor. It's better to use the 3 PWM modules can be easily to synchronized for a motor according to the device, especially on F2838x and F28004x.

Or you may synchronize the EPWM modules by manual as below if you don't need to change the PWM frequency online.

// disable the ePWM module time base clock sync signal
// to synchronize all of the PWMs
SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

**Configure all of the PWM modules at here without using the phase shift.

// enable the ePWM module time base clock sync signal
SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

Yanming Luo said:

That depends on what EPWM modules for the motor. It's better to use the 3 PWM modules can be easily to synchronized for a motor according to the device, especially on F2838x and F28004x.

We are using PWM11,2,3 for Motor A , and PWM12,4,5 for Motor B. Unfortunately we cannot change the EPWM modules. SO that leaves us witth synchronizing the EPWMs manually..

Yanming Luo said:

Or you may synchronize the EPWM modules by manual as below if you don't need to change the PWM frequency online.

Yes, we are not changing the switching frequency online, 

I tried disabling the phase shift for all the PWMs, but at higher speeds again we see this issue...

This is what i had done, let me know if this is the correct way to disable the phaseshift loading.:

void HAL_setupMotorPWMs(HAL_MTR_Handle handle)
{
    HAL_MTR_Obj *obj = (HAL_MTR_Obj*) handle;

    uint16_t cnt;
    uint16_t halfPeriod = 0;

    SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

    // *****************************************
    // Inverter PWM configuration - PWM 1, 2, 3
    // *****************************************
    for (cnt = 0; cnt < 3; cnt++)
    {
        // Time Base SubModule Registers
        // set Immediate load
        EPWM_setPeriodLoadMode(obj->pwmHandle[cnt], EPWM_PERIOD_DIRECT_LOAD);
        EPWM_setTimeBasePeriod(obj->pwmHandle[cnt], 0);
        EPWM_setPhaseShift(obj->pwmHandle[cnt], 0);
        EPWM_setTimeBaseCounter(obj->pwmHandle[cnt], 0);
        EPWM_setTimeBaseCounterMode(obj->pwmHandle[cnt],
                                    EPWM_COUNTER_MODE_UP_DOWN);

        EPWM_setClockPrescaler(obj->pwmHandle[cnt], EPWM_CLOCK_DIVIDER_1,
                               EPWM_HSCLOCK_DIVIDER_1);

        // Counter Compare Submodule Registers
        // set duty 0% initially
        EPWM_setCounterCompareValue(obj->pwmHandle[cnt], EPWM_COUNTER_COMPARE_A,
                                    0);
        EPWM_setCounterCompareShadowLoadMode(obj->pwmHandle[cnt],
                                             EPWM_COUNTER_COMPARE_A,
                                             EPWM_COMP_LOAD_ON_CNTR_ZERO);

        // Action Qualifier SubModule Registers
        EPWM_setActionQualifierActionComplete(
                obj->pwmHandle[cnt],
                EPWM_AQ_OUTPUT_A,
                (EPWM_ActionQualifierEventAction) (EPWM_AQ_OUTPUT_LOW_UP_CMPA
                        | EPWM_AQ_OUTPUT_HIGH_DOWN_CMPA));

        // Active high complementary PWMs - Set up the deadband
        EPWM_setRisingEdgeDeadBandDelayInput(obj->pwmHandle[cnt],
        EPWM_DB_INPUT_EPWMA);
        EPWM_setFallingEdgeDeadBandDelayInput(obj->pwmHandle[cnt],
        EPWM_DB_INPUT_EPWMA);

        EPWM_setDeadBandDelayMode(obj->pwmHandle[cnt], EPWM_DB_RED, true);
        EPWM_setDeadBandDelayMode(obj->pwmHandle[cnt], EPWM_DB_FED, true);
        EPWM_setDeadBandDelayPolarity(obj->pwmHandle[cnt], EPWM_DB_RED,
                                      EPWM_DB_POLARITY_ACTIVE_HIGH);
        EPWM_setDeadBandDelayPolarity(obj->pwmHandle[cnt], EPWM_DB_FED,
                                      EPWM_DB_POLARITY_ACTIVE_LOW);
        /*
         * INFO: PWM Dead Time
         * Change this to change the pwm dead time.
         */
        EPWM_setRisingEdgeDelayCount(obj->pwmHandle[cnt], EPWM_DB_DELAY_RISE);
        EPWM_setFallingEdgeDelayCount(obj->pwmHandle[cnt], EPWM_DB_DELAY_FALL);

        EPWM_enablePhaseShiftLoad(obj->pwmHandle[cnt]);

        EPWM_setCountModeAfterSync(obj->pwmHandle[cnt],
                                   EPWM_COUNT_MODE_UP_AFTER_SYNC);
        //configure sync
        EPWM_setSyncOutPulseMode(obj->pwmHandle[cnt],
                                 EPWM_SYNC_OUT_PULSE_ON_EPWMxSYNCIN);
    }

//    //EPWM1->EWPM4
    SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM4,
                              SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
    //EPWM1->EWPM7
    SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM7,
                              SYSCTL_SYNC_IN_SRC_EPWM4SYNCOUT);
    //EPWM1->EWPM10
    SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM10,
                              SYSCTL_SYNC_IN_SRC_EPWM10SYNCOUT);

    EPWM_disablePhaseShiftLoad(EPWM1_BASE);
    EPWM_disablePhaseShiftLoad(EPWM2_BASE);
    EPWM_disablePhaseShiftLoad(EPWM3_BASE);
    EPWM_disablePhaseShiftLoad(EPWM4_BASE);
    EPWM_disablePhaseShiftLoad(EPWM5_BASE);
    EPWM_disablePhaseShiftLoad(EPWM6_BASE);
    EPWM_disablePhaseShiftLoad(EPWM7_BASE);
    EPWM_disablePhaseShiftLoad(EPWM8_BASE);
    EPWM_disablePhaseShiftLoad(EPWM9_BASE);
    EPWM_disablePhaseShiftLoad(EPWM10_BASE);
    EPWM_disablePhaseShiftLoad(EPWM11_BASE);
    EPWM_disablePhaseShiftLoad(EPWM12_BASE);

    if (handle == &halMtr[MTR_1])
    {
        halfPeriod = M1_INV_PWM_TICKS / 2;     // 100MHz EPWMCLK

        EPWM_disablePhaseShiftLoad(obj->pwmHandle[0]);
        //EPWM_disablePhaseShiftLoad(EPWM1_BASE);

        // sync "down-stream"
        EPWM_setSyncOutPulseMode(obj->pwmHandle[0],
                                 EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
//        EPWM_setSyncOutPulseMode(EPWM1_BASE,
//                                 EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);


        EPWM_setPhaseShift(obj->pwmHandle[0], 0);
        EPWM_setPhaseShift(obj->pwmHandle[1], 2);
        EPWM_setPhaseShift(obj->pwmHandle[2], 4);

        EPWM_setTimeBasePeriod(obj->pwmHandle[0], halfPeriod);
        EPWM_setTimeBasePeriod(obj->pwmHandle[1], halfPeriod);
        EPWM_setTimeBasePeriod(obj->pwmHandle[2], halfPeriod);
    }
    else if (handle == &halMtr[MTR_2])
    {
        halfPeriod = M2_INV_PWM_TICKS / 2;     // 100MHz EPWMCLK

        EPWM_setPhaseShift(obj->pwmHandle[0], ((halfPeriod >> 1) + 0));
        EPWM_setPhaseShift(obj->pwmHandle[1], ((halfPeriod >> 1) + 2));
        EPWM_setPhaseShift(obj->pwmHandle[2], ((halfPeriod >> 1) + 4));

        EPWM_setTimeBasePeriod(obj->pwmHandle[0], halfPeriod);
        EPWM_setTimeBasePeriod(obj->pwmHandle[1], halfPeriod);
        EPWM_setTimeBasePeriod(obj->pwmHandle[2], halfPeriod);
    }

    // Setting up link from EPWM to ADC
    // EPWM1/EPWM4 - Inverter currents at sampling frequency
    //               (@ PRD or @ (PRD&ZRO) )
#if(SAMPLING_METHOD == SINGLE_SAMPLING)
    // Select SOC from counter at ctr = prd
    EPWM_setADCTriggerSource(obj->pwmHandle[0], EPWM_SOC_A,
                             EPWM_SOC_TBCTR_ZERO);
#elif(SAMPLING_METHOD == DOUBLE_SAMPLING)
    // Select SOC from counter at ctr = 0 or ctr = prd
    EPWM_setADCTriggerSource(obj->pwmHandle[0], EPWM_SOC_A,
                             EPWM_SOC_TBCTR_ZERO_OR_PERIOD);
#endif

    // Generate pulse on 1st event
    EPWM_setADCTriggerEventPrescale(obj->pwmHandle[0], EPWM_SOC_A, 1);

    // Enable SOC on A group
    EPWM_enableADCTrigger(obj->pwmHandle[0], EPWM_SOC_A);

    return;
}

Did you call SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC) after the EPWMs are configured?

Yes , that is called in the main function , in dual_axis_servo_drive.c

Hi Yanming, even with the above sollution we get the double pulse issue at 20KHz switching frequency. Is there anything else that we can check?