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.

query regarding phase shift

sir,

      i am not getting phase shift of pulses.can anybody rectify my mistake in the program

// Title: ADC based spwm
// Date:08/06/2014


#include "DSP28x_Project.h" // Device Headerfile

#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/pwm.h"
#include "f2802x_common/include/wdog.h"
#include<math.h>


// Prototype statements for functions found within this file.
interrupt void adc_isr(void);
void Adc_Config(void);

// Global variables used in this example:
uint32_t EPwm1TimerIntCount;
uint16_t j;
uint16_t a;
uint16_t x,x1,tbpd,n,i,j;
float32 I,I1,Fd,F1,Iold,Fold,Imin,Fmin,Imax,Fmax;
float32 Fmax=20000;
float32 Fmin=3600;
float32 Imax=5;
float32 Imin=1;
float32 Iold=2;
float32 Fold=10000;
uint16_t tbpd=3000;

ADC_Handle myAdc;
CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
PWM_Handle myPwm1;
PWM_Handle myPwm2;
PWM_Handle myPwm3;

void main(void)
{

CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;

// Initialize all the handles needed for this application
myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

// Perform basic system initialization
WDOG_disable(myWDog);
CLK_enableAdcClock(myClk);
(*Device_cal)();

//Select the internal oscillator 1 as the clock source
CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

// Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2
PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

// Disable the PIE and all interrupts
PIE_disable(myPie);
PIE_disableAllInts(myPie);
CPU_disableGlobalInts(myCpu);
CPU_clearIntFlags(myCpu);

// If running from flash copy RAM only functions to RAM
#ifdef _FLASH
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

// Initalize GPIO
GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, GPIO_Number_2, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, GPIO_Number_4, GPIO_PullUp_Disable);

GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);

GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_EPWM2A);

GPIO_setMode(myGpio, GPIO_Number_4, GPIO_4_Mode_EPWM3A);


// Setup a debug vector table and enable the PIE
// PIE_setDebugIntVectorTable(myPie);
PIE_enable(myPie);

// Register interrupt handlers in the PIE vector table
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_10, PIE_SubGroupNumber_1, (intVec_t)&adc_isr);

// Initialize the ADC
ADC_enableBandGap(myAdc);
ADC_enableRefBuffers(myAdc);
ADC_powerUp(myAdc);
ADC_enable(myAdc);
ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);

// Enable ADCINT1 in PIE
PIE_enableAdcInt(myPie, ADC_IntNumber_1);
// Enable CPU Interrupt 1
CPU_enableInt(myCpu, CPU_IntNumber_10);
// Enable Global interrupt INTM
CPU_enableGlobalInts(myCpu);
// Enable Global realtime interrupt DBGM
CPU_enableDebugInt(myCpu);
j=0;

ADC_setIntPulseGenMode(myAdc, ADC_IntPulseGenMode_Prior); //ADCINT1 trips after AdcResults latch
ADC_enableInt(myAdc, ADC_IntNumber_1); //Enabled ADCINT1
ADC_setIntMode(myAdc, ADC_IntNumber_1, ADC_IntMode_ClearFlag); //Disable ADCINT1 Continuous mode
ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC1); //setup EOC2 to trigger ADCINT1 to fire
ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4); //set SOC0 channel select to ADCINA4
ADC_setSocChanNumber (myAdc, ADC_SocNumber_1, ADC_SocChanNumber_A4); //set SOC1 channel select to ADCINA4

ADC_setSocTrigSrc(myAdc, ADC_SocNumber_0, ADC_SocTrigSrc_EPWM1_ADCSOCA); //set SOC0 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1
ADC_setSocTrigSrc(myAdc, ADC_SocNumber_1, ADC_SocTrigSrc_EPWM1_ADCSOCA); //set SOC1 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1

ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles); //set SOC0 S/H Window to 7 ADC Clock Cycles, (6 ACQPS plus 1)
ADC_setSocSampleWindow(myAdc, ADC_SocNumber_1, ADC_SocSampleWindow_7_cycles); //set SOC1 S/H Window to 7 ADC Clock Cycles, (6 ACQPS plus 1)

// Stop all the TB clocks
CLK_disableTbClockSync(myClk);

CLK_enablePwmClock(myClk, PWM_Number_1);
CLK_enablePwmClock(myClk, PWM_Number_2);
CLK_enablePwmClock(myClk, PWM_Number_3);

// Setup Sync
PWM_setSyncMode(myPwm1, PWM_SyncMode_EPWMxSYNC);
PWM_setSyncMode(myPwm2, PWM_SyncMode_EPWMxSYNC);
PWM_setSyncMode(myPwm3, PWM_SyncMode_EPWMxSYNC);

// Allow each timer to be sync'ed
PWM_enableCounterLoad(myPwm1);
PWM_enableCounterLoad(myPwm2);
PWM_enableCounterLoad(myPwm3);


// Setup PWM
PWM_enableSocAPulse(myPwm1); // Enable SOC on A group
PWM_setSocAPulseSrc(myPwm1, PWM_SocPulseSrc_CounterEqualZeroOrPeriod); // Select SOC from from CPMA on upcount
PWM_setSocAPeriod(myPwm1, PWM_SocPeriod_FirstEvent); // Generate pulse on 1st event

PWM_setPeriod(myPwm1, tbpd); //Load period register
EPwm1Regs.TBPHS.half.TBPHS = 0; // Set Phase register to zero
EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Symmetrical mode
EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Master module
EPwm1Regs.TBCTL.bit.SYNCOSEL = TB_CTR_ZERO; // Sync down-stream module
//PWM_setIntMode(myPwm1, PWM_IntMode_CounterEqualZero); // Select INT on Zero event

PWM_setPeriod(myPwm2, tbpd); //Load period register

EPwm2Regs.TBPHS.half.TBPHS = tbpd*2/3;
EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Symmetrical mode
EPwm2Regs.TBCTL.bit.PHSEN = TB_ENABLE; // Slave module
EPwm2Regs.TBCTL.bit.PHSDIR = TB_DOWN; // Count DOWN on sync (=120 deg)
EPwm2Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN; // sync flow-through

//PWM_setIntMode(myPwm2, PWM_IntMode_CounterEqualZero); // Select INT on Zero event

PWM_setPeriod(myPwm3, tbpd); //Load period register

EPwm3Regs.TBPHS.half.TBPHS = tbpd*2/3;
EPwm3Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Symmetrical mode
EPwm3Regs.TBCTL.bit.PHSEN = TB_ENABLE; // Slave module
EPwm2Regs.TBCTL.bit.PHSDIR = TB_UP; // Count UP on sync (=240 deg)
EPwm3Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN; // sync flow-through
//PWM_setIntMode(myPwm3, PWM_IntMode_CounterEqualZero); // Select INT on Zero event


PWM_setShadowMode_CmpA(myPwm1, PWM_ShadowMode_Shadow);
PWM_setLoadMode_CmpA(myPwm1, PWM_LoadMode_Zero);
PWM_setShadowMode_CmpA(myPwm2, PWM_ShadowMode_Shadow); //Activate Shadow mode for CMPA
PWM_setLoadMode_CmpA(myPwm2, PWM_LoadMode_Zero); //load CMPA either at compare equals zero
PWM_setShadowMode_CmpA(myPwm3, PWM_ShadowMode_Shadow); //Activate Shadow mode for CMPA
PWM_setLoadMode_CmpA(myPwm3, PWM_LoadMode_Zero); //load CMPA either at compare equals zero

PWM_setActionQual_CntDown_CmpA_PwmA(myPwm1, PWM_ActionQual_Clear); // Clear PWM1A on event A, up count
PWM_setActionQual_CntUp_CmpA_PwmA(myPwm1, PWM_ActionQual_Set); // Set PWM1A on Zero


PWM_setActionQual_CntUp_CmpA_PwmA(myPwm2, PWM_ActionQual_Clear);
PWM_setActionQual_CntDown_CmpA_PwmA(myPwm2, PWM_ActionQual_Set);

PWM_setActionQual_CntUp_CmpA_PwmA(myPwm3, PWM_ActionQual_Clear);
PWM_setActionQual_CntDown_CmpA_PwmA(myPwm3, PWM_ActionQual_Set);

PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_1); //High Speed Clock divide by 1
PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_1); //TB clock divide by 1

PWM_setHighSpeedClkDiv(myPwm2, PWM_HspClkDiv_by_1); //High Speed Clock divide by 1
PWM_setClkDiv(myPwm2, PWM_ClkDiv_by_1); //TB clock divide by 1

PWM_setHighSpeedClkDiv(myPwm3, PWM_HspClkDiv_by_1); //High Speed Clock divide by 1
PWM_setClkDiv(myPwm3, PWM_ClkDiv_by_1); //TB clock divide by 1

// Start all the timers synced
CLK_enableTbClockSync(myClk);
for(;;)
{

}
}


interrupt void adc_isr(void)
{

a = ADC_readResult(myAdc, ADC_ResultNumber_1);

x1=a;
I=(x1*3.3/4096-1.65)/0.255;
for(i=0;I>Iold && I<Imax;i++)
{
Fd=19394*(pow((Iold+0.1),(-1.045))-pow((Iold),(-1.045)));
I1=Iold+0.1;
F1=Fold+Fd;
tbpd=30*pow(10,6)/F1;
PWM_setPeriod(myPwm1, tbpd);// Set period for ePWM1

Iold=I1;
Fold=F1;
}

for(i=0;I<Iold&&I>Imin;i++)
{
Fd=19394*(pow((Iold-0.1),(-1.045))-pow((Iold),(-1.045)));
I1=Iold-0.1;
F1=Fold+Fd;
tbpd=30*pow(10,6)/F1;
PWM_setPeriod(myPwm1, tbpd);// Set period for ePWM1
Iold=I1;
Fold=F1;
}
if(I==Imax)
{
F1=Fmin;
tbpd=30*pow(10,6)/F1;
PWM_setPeriod(myPwm1, tbpd); // Set period for ePWM1
Iold=I;
Fold=F1;

}
if(I==Imin)
{
F1=Fmax;
tbpd=30*pow(10,6)/F1;
PWM_setPeriod(myPwm1, tbpd); // Set period for ePWM1

Iold=I;
Fold=F1;

}

PWM_setCmpA(myPwm1,tbpd/2);
PWM_setCmpA(myPwm2,tbpd/2);
PWM_setCmpA(myPwm3,tbpd/2);

// Clear ADCINT1 flag reinitialize for next SOC
ADC_clearIntFlag(myAdc, ADC_IntNumber_1);
// Acknowledge interrupt to PIE
PIE_clearInt(myPie, PIE_GroupNumber_10);

return;
}