• State
  • Replies 3 replies
  • Subscribers 83 subscribers
  • Views 61 views
  • Users 0 members are here
Support feedback
Options
Options
Related

TMS320F28379D: Unable to Generate Sine Signal using ePWM 10KHz Signal

SOumitri Kumar Suraparaju
Prodigy 110 points
Part Number: TMS320F28379D
Other Parts Discussed in Thread: C2000WARE

Hello Forms,


I tried to generate Variable Sine PWM Signals using ePWM Signals at 10kHz Frequency


Observations as Follows:
PWM Signals - 9.98KHz.
Dead Band (RED/FED) - 400ns
Vdc = 48V
Modulation Index = 0.01
Natural Frequecy (Set) = 25Hz
Natural Frequecy (Observation) = ~23.5Hz

ePWM Configuration used as Follows.

void EPWM_init(){
    EPWM_setClockPrescaler(EPWM_1_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);  
    EPWM_setTimeBasePeriod(EPWM_1_BASE, 2499);  
    EPWM_setTimeBaseCounter(EPWM_1_BASE, 0);    
    EPWM_setTimeBaseCounterMode(EPWM_1_BASE, EPWM_COUNTER_MODE_UP_DOWN);    
    EPWM_disablePhaseShiftLoad(EPWM_1_BASE);    
    EPWM_setPhaseShift(EPWM_1_BASE, 0);
    EPWM_forceSyncPulse(EPWM_1_BASE);  
    EPWM_setSyncOutPulseMode(EPWM_1_BASE, EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
    EPWM_setSyncPulseSource(EPWM_1_BASE, HRPWM_PWMSYNC_SOURCE_ZERO);    
    EPWM_setCounterCompareValue(EPWM_1_BASE, EPWM_COUNTER_COMPARE_A, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_1_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_setCounterCompareValue(EPWM_1_BASE, EPWM_COUNTER_COMPARE_B, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_1_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_1_BASE, EPWM_ACTION_QUALIFIER_A);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_1_BASE, EPWM_ACTION_QUALIFIER_A, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW);
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_1_BASE, EPWM_ACTION_QUALIFIER_B);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_1_BASE, EPWM_ACTION_QUALIFIER_B, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH);    
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_1_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);    
    EPWM_setDeadBandDelayPolarity(EPWM_1_BASE, EPWM_DB_RED, EPWM_DB_POLARITY_ACTIVE_LOW);  
    EPWM_setDeadBandDelayMode(EPWM_1_BASE, EPWM_DB_RED, true);  
    EPWM_setRisingEdgeDelayCountShadowLoadMode(EPWM_1_BASE, EPWM_RED_LOAD_ON_CNTR_ZERO);    
    EPWM_setRisingEdgeDelayCount(EPWM_1_BASE, 40);  
    EPWM_setDeadBandDelayMode(EPWM_1_BASE, EPWM_DB_FED, true);  
    EPWM_setFallingEdgeDelayCountShadowLoadMode(EPWM_1_BASE, EPWM_FED_LOAD_ON_CNTR_ZERO);  
    EPWM_setFallingEdgeDelayCount(EPWM_1_BASE, 40);
    EPWM_setDeadBandCounterClock(EPWM_1_BASE, EPWM_DB_COUNTER_CLOCK_HALF_CYCLE);    
    EPWM_enableInterrupt(EPWM_1_BASE);  
    EPWM_setInterruptSource(EPWM_1_BASE, EPWM_INT_TBCTR_PERIOD);    
    EPWM_setInterruptEventCount(EPWM_1_BASE, 1);    
    EPWM_enableADCTrigger(EPWM_1_BASE, EPWM_SOC_A);
    EPWM_setADCTriggerSource(EPWM_1_BASE, EPWM_SOC_A, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_1_BASE, EPWM_SOC_A, 1);    
    EPWM_enableADCTrigger(EPWM_1_BASE, EPWM_SOC_B);
    EPWM_setADCTriggerSource(EPWM_1_BASE, EPWM_SOC_B, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_1_BASE, EPWM_SOC_B, 1);    
    EPWM_setClockPrescaler(EPWM_2_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);  
    EPWM_setPeriodLoadMode(EPWM_2_BASE, EPWM_PERIOD_DIRECT_LOAD);  
    EPWM_setTimeBasePeriod(EPWM_2_BASE, 2499);  
    EPWM_setupEPWMLinks(EPWM_2_BASE, EPWM_LINK_WITH_EPWM_1, EPWM_LINK_TBPRD);  
    EPWM_setTimeBaseCounter(EPWM_2_BASE, 0);    
    EPWM_setTimeBaseCounterMode(EPWM_2_BASE, EPWM_COUNTER_MODE_UP_DOWN);    
    EPWM_enablePhaseShiftLoad(EPWM_2_BASE);
    EPWM_setPhaseShift(EPWM_2_BASE, 2);
    EPWM_setSyncOutPulseMode(EPWM_2_BASE, EPWM_SYNC_OUT_PULSE_DISABLED);    
    EPWM_setSyncPulseSource(EPWM_2_BASE, HRPWM_PWMSYNC_SOURCE_ZERO);    
    EPWM_setCounterCompareValue(EPWM_2_BASE, EPWM_COUNTER_COMPARE_A, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_2_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_setCounterCompareValue(EPWM_2_BASE, EPWM_COUNTER_COMPARE_B, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_2_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_2_BASE, EPWM_ACTION_QUALIFIER_A);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_2_BASE, EPWM_ACTION_QUALIFIER_A, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW);
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_2_BASE, EPWM_ACTION_QUALIFIER_B);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_2_BASE, EPWM_ACTION_QUALIFIER_B, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH);    
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_2_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);    
    EPWM_setDeadBandDelayPolarity(EPWM_2_BASE, EPWM_DB_RED, EPWM_DB_POLARITY_ACTIVE_LOW);  
    EPWM_setDeadBandDelayMode(EPWM_2_BASE, EPWM_DB_RED, true);  
    EPWM_setRisingEdgeDelayCountShadowLoadMode(EPWM_2_BASE, EPWM_RED_LOAD_ON_CNTR_ZERO);    
    EPWM_setRisingEdgeDelayCount(EPWM_2_BASE, 40);  
    EPWM_setDeadBandDelayMode(EPWM_2_BASE, EPWM_DB_FED, true);  
    EPWM_setFallingEdgeDelayCountShadowLoadMode(EPWM_2_BASE, EPWM_FED_LOAD_ON_CNTR_ZERO);  
    EPWM_setFallingEdgeDelayCount(EPWM_2_BASE, 40);
    EPWM_setDeadBandCounterClock(EPWM_2_BASE, EPWM_DB_COUNTER_CLOCK_HALF_CYCLE);    
    EPWM_enableADCTrigger(EPWM_2_BASE, EPWM_SOC_A);
    EPWM_setADCTriggerSource(EPWM_2_BASE, EPWM_SOC_A, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_2_BASE, EPWM_SOC_A, 1);    
    EPWM_enableADCTrigger(EPWM_2_BASE, EPWM_SOC_B);
    EPWM_setADCTriggerSource(EPWM_2_BASE, EPWM_SOC_B, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_2_BASE, EPWM_SOC_B, 1);    
    EPWM_setClockPrescaler(EPWM_3_BASE, EPWM_CLOCK_DIVIDER_1, EPWM_HSCLOCK_DIVIDER_1);  
    EPWM_setTimeBasePeriod(EPWM_3_BASE, 2499);  
    EPWM_setupEPWMLinks(EPWM_3_BASE, EPWM_LINK_WITH_EPWM_1, EPWM_LINK_TBPRD);  
    EPWM_setTimeBaseCounter(EPWM_3_BASE, 0);    
    EPWM_setTimeBaseCounterMode(EPWM_3_BASE, EPWM_COUNTER_MODE_UP_DOWN);    
    EPWM_enablePhaseShiftLoad(EPWM_3_BASE);
    EPWM_setPhaseShift(EPWM_3_BASE, 2);
    EPWM_setSyncOutPulseMode(EPWM_3_BASE, EPWM_SYNC_OUT_PULSE_DISABLED);    
    EPWM_setSyncPulseSource(EPWM_3_BASE, HRPWM_PWMSYNC_SOURCE_ZERO);    
    EPWM_setCounterCompareValue(EPWM_3_BASE, EPWM_COUNTER_COMPARE_A, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_3_BASE, EPWM_COUNTER_COMPARE_A, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_setCounterCompareValue(EPWM_3_BASE, EPWM_COUNTER_COMPARE_B, 1250);
    EPWM_setCounterCompareShadowLoadMode(EPWM_3_BASE, EPWM_COUNTER_COMPARE_B, EPWM_COMP_LOAD_ON_CNTR_ZERO);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_3_BASE, EPWM_ACTION_QUALIFIER_A);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_3_BASE, EPWM_ACTION_QUALIFIER_A, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW);
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);
    EPWM_disableActionQualifierShadowLoadMode(EPWM_3_BASE, EPWM_ACTION_QUALIFIER_B);    
    EPWM_setActionQualifierShadowLoadMode(EPWM_3_BASE, EPWM_ACTION_QUALIFIER_B, EPWM_AQ_LOAD_ON_CNTR_ZERO);
    EPWM_setActionQualifierSWAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH);    
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);    
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_LOW, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPA);  
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_NO_CHANGE, EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPB);
    EPWM_setActionQualifierAction(EPWM_3_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH, EPWM_AQ_OUTPUT_ON_TIMEBASE_DOWN_CMPB);    
    EPWM_setDeadBandDelayPolarity(EPWM_3_BASE, EPWM_DB_RED, EPWM_DB_POLARITY_ACTIVE_LOW);  
    EPWM_setDeadBandDelayMode(EPWM_3_BASE, EPWM_DB_RED, true);  
    EPWM_setRisingEdgeDelayCountShadowLoadMode(EPWM_3_BASE, EPWM_RED_LOAD_ON_CNTR_ZERO);    
    EPWM_setRisingEdgeDelayCount(EPWM_3_BASE, 40);  
    EPWM_setDeadBandDelayMode(EPWM_3_BASE, EPWM_DB_FED, true);  
    EPWM_setFallingEdgeDelayCountShadowLoadMode(EPWM_3_BASE, EPWM_FED_LOAD_ON_CNTR_ZERO);  
    EPWM_setFallingEdgeDelayCount(EPWM_3_BASE, 40);
    EPWM_setDeadBandCounterClock(EPWM_3_BASE, EPWM_DB_COUNTER_CLOCK_HALF_CYCLE);    
    EPWM_enableADCTrigger(EPWM_3_BASE, EPWM_SOC_A);
    EPWM_setADCTriggerSource(EPWM_3_BASE, EPWM_SOC_A, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_3_BASE, EPWM_SOC_A, 1);    
    EPWM_enableADCTrigger(EPWM_3_BASE, EPWM_SOC_B);
    EPWM_setADCTriggerSource(EPWM_3_BASE, EPWM_SOC_B, EPWM_SOC_TBCTR_PERIOD);  
    EPWM_setADCTriggerEventPrescale(EPWM_3_BASE, EPWM_SOC_B, 1);    
}

Compare Value Assignment as Follows.

static inline uint16_t limitCMP(epwmInformation *epwmInfo, uint16_t cmp)
{
    if(cmp < epwmInfo->epwmMinCompB) cmp = epwmInfo->epwmMinCompB;
    if(cmp > epwmInfo->epwmMaxCompB) cmp = epwmInfo->epwmMaxCompB;
    return cmp;
}


void updateCompareSoft(epwmInformation *epwmInfo, uint16_t targetCmpA, uint16_t targetCmpB)
{
    uint16_t currentCmpA = EPWM_getCounterCompareValue(epwmInfo->epwmModule,
                                                       EPWM_COUNTER_COMPARE_A);
    uint16_t currentCmpB = EPWM_getCounterCompareValue(epwmInfo->epwmModule,
                                                       EPWM_COUNTER_COMPARE_B);

 

    // Soft step size — controls how fast we approach the target
     uint16_t stepSize = epwmInfo->stepSize;


    // - Duty Compare Value
    /*if(targetCmpA>epwmInfo->epwmMaxCompA)
    {
        targetCmpA = epwmInfo->epwmMaxCompA;
    }
    if(targetCmpA<epwmInfo->epwmMinCompA)
    {
        targetCmpA = epwmInfo->epwmMinCompA;
    }*/
    //targetCmpA = LimitVerification(targetCmpA, epwmInfo->epwmMinCompA, epwmInfo->epwmMaxCompA);


    // Update CMPA smoothly
    if(currentCmpA < targetCmpA)
    {
        currentCmpA = (targetCmpA - currentCmpA > stepSize) ?
                (currentCmpA + stepSize) : targetCmpA;
    }
    else if(currentCmpA > targetCmpA)
    {
        currentCmpA = (currentCmpA - targetCmpA > stepSize) ?
                (currentCmpA - stepSize) : targetCmpA;
    }


    EPWM_setCounterCompareValue(epwmInfo->epwmModule,
                                EPWM_COUNTER_COMPARE_A,
                                targetCmpA);
    // + Duty Compare Value
    //targetCmpB = LimitVerification(targetCmpB, epwmInfo->epwmMinCompB, epwmInfo->epwmMaxCompB);
    if(targetCmpB>epwmInfo->epwmMaxCompB)
    {
        targetCmpB = epwmInfo->epwmMaxCompB;
    }
    if(targetCmpB<epwmInfo->epwmMinCompB)
    {
        targetCmpB = epwmInfo->epwmMinCompB;
    }


    // Update CMPB smoothly
    if(currentCmpB < targetCmpB)
    {
        currentCmpB = (targetCmpB - currentCmpB > stepSize) ?
                (currentCmpB + stepSize) : targetCmpB;
    }
    else if(currentCmpB > targetCmpB)
    {
        currentCmpB = (currentCmpB - targetCmpB > stepSize) ?
                (currentCmpB - stepSize) : targetCmpB;
    }


    EPWM_setCounterCompareValue(epwmInfo->epwmModule,
                                EPWM_COUNTER_COMPARE_B,
                                targetCmpB);
}

 


void UpdateAction(void)
{
    pVabc_pu.value[0] = limitCMP(&epwm1Info, pVabc_pu.value[0]);
    pVabc_pu.value[1] = limitCMP(&epwm2Info, pVabc_pu.value[1]);
    pVabc_pu.value[2] = limitCMP(&epwm3Info, pVabc_pu.value[2]);


    updateCompareSoft(&epwm1Info,(uint16_t) pVabc_pu.value[0],(uint16_t) pVabc_pu.value[0]);
    updateCompareSoft(&epwm2Info,(uint16_t) pVabc_pu.value[1],(uint16_t) pVabc_pu.value[1]);
    updateCompareSoft(&epwm3Info,(uint16_t) pVabc_pu.value[2],(uint16_t) pVabc_pu.value[2]);
}

Main Interrupt

__interrupt void INT_EPWM_1_ISR(void)
{

UpdateAction();

//... Protections


if (NOT_ON_FLAG != 0) {
              pastdelta =
                  (SineFrequency * 0.00005); // 2*TBPRD*Interrupt Frequency
              Currentdelta += pastdelta;


              Temp_Rad = Currentdelta * 12.56637061;
              // OverFlow Protection
              if (Temp_Rad >= TWO_PI) {
                //Currentdelta = 0;
                Temp_Rad -= TWO_PI;
              }
              Compa1 = modulation_index *
                       sinf(Temp_Rad); // Amplitude(10) * Sinef(rad) = I_sense1
              Compa2 = modulation_index *
                       sinf((Temp_Rad - 2.094395f)); // Amplitude * Sinef(rad
                                                     // - 2.094395f) =  I_sense2
              Compa3 = -Compa1 - Compa2; // Park() -<  theta +30  = rad


              pVabc_pu.value[0] = (uint16_t)((Compa1 * (amplitude_scale_1)) +
                                             (amplitude_scale_1));
              pVabc_pu.value[1] = (uint16_t)((Compa2 * (amplitude_scale_2)) +
                                             (amplitude_scale_2));
              pVabc_pu.value[2] = (uint16_t)((Compa3 * (amplitude_scale_3)) +
                                             (amplitude_scale_3));
            } else {
              Currentdelta = 0;
}

4d65e1e5-9d54-41e9-8f67-55c09b3df98e.jpg

Kindly Let me Know if any Issue in the above code.

Thanks in Advance,
Soumitri Kumar

  • 0
    TI__Expert 4200 points

    Soumitri,

    For Sinusoidal Waveform regeneration and its usage in PWM modulation with retaining accuracy, you can refer the Ti Digital Power Libraries or Reference examples.

    You can download and install the C2000WareDPSDK where you can find sine regeneration libraries  here: C:\ti\c2000\C2000Ware_DigitalPower_SDK_5_05_01_00\libraries\utilities\rampgen

    You can look at the TPPFC reference design code for PMP23338 or TIDA-010210 or or other AC/DC or DC/AC reference design that shows its usage to generate reference sinusoidal to modulate PWM waveform. These codes are located in the same installation location:C:\ti\c2000\C2000Ware_DigitalPower_SDK_5_04_00_00\solutions

    Regards,

    Sumit

  • 0
    Guru 56043 points
    SOumitri Kumar Suraparaju said:
    Dead Band (RED/FED) - 400ns

    Soumitri, in addition to Sumit why set dead band value so high? Check MOSFET Ton/Toff delay times + body diode Trr recovery time, add some safety margin but 400ns is excessive for most modern MOSFET's. Typical dead band time 100ns for Gan, IGBT, NexFET but longer delay may cause poor AC sine results. however your sinewave capture looks really clean.

    Regards,    

  • 0 in reply to Genatco
    Prodigy 110 points

    Hi Genatco,

    Thanks for the Response.

    ePWM signals are connected via a Gate driver(ST's - L6491D). We are Currently Using Infineon's - IPF016N10NF2S.

    Here is the schematic.


    Here is the Info Acc.to data sheet


    We previous tried to solve the above at 300ns but the sine distortion is Observed. I didn't tried to go Further in.

    After resolving the Angle errors sine Genration is Observed much Identical, but the Observed the Oscillations.

    Below are the Images, which are apart ~10sec and repeated after ~ 20sec




    Above Images are recorded at 0.01 MI with 100Hz NF.

    Thanks,
    Soumitri.