CCS/TMS320F28379D: ISR interrupt / murger programs

Hi  Vasudha,

think you for you answer.

My code is :

/* Cpu1.c - Created on: 1 févr. 2018 - Author: Haris */

//INCLUDE
#include "F28x_Project.h"
#include "driverlib.h"
#include "math.h"

void PWM1(float duty1,int resolution);
void HRPWM(float duty2);
//__interrupt void epwm1_isr(void);
//__interrupt void epwm2_isr(void);
//void APWM1(void);

// variable jj
int resolution = 700;
float i = 0;
float Val_max_duty =700 ;
float Val_min_duty = 0;
float val=0;
void ConfigureADC(void);
void SetupADCSoftware(void);
Uint16 AdcaResult0;
Uint16 AdcaResult1;
Uint16 AdcbResult0;
Uint16 AdcbResult1;

int main(void)
{
    /****INITIALISATION DU SYSTEME ET DES PERIPHERIQUES*****/

    InitSysCtrl();
    InitGpio();

    InitPeripheralClocks();//Initialisation des clocks
    InitFlash();//Initialise la RAM.
    FlashOff(); //Desactive la RAM.
    ServiceDog(); //Initialisation des WDog.
    InitEPwm1Gpio(); //Initialise les GPIOs pour generer un PWM sur la sortie 1.
    InitEPwm2Gpio(); //Initialise les GPIOs pour generer un PWM sur la sortie 2.
    InitAPwm1Gpio(); //Initialise les GP IOs pour generer un PWM sur la sortie 5.
    DINT; // ajout pour adc
    InitPieCtrl();
    //ajout pour adc
    //
    // Disable CPU interrupts and clear all CPU interrupt flags:
    //
        IER = 0x0000;
        IFR = 0x0000;
     //fin ajout
    InitPieVectTable();


    InitSysPll(INT_OSC2, IMULT_35, FMULT_0, PLLCLK_BY_1);
    // Modificateur de frequence de la clock source (dans notre cas INT_OSC1 = 2.5Mhz). Regarder doc pour choisir clock.
    //INT_OSC2 =>10Mhz (= fOSCCLK)
    //fPLLSYSCLK = fOSCCLK * (SYSPLLMULT.IMULT + SYSPLLMULT.FMULT) / SYSCLKDIVSEL.PLLSYSCLKDIV
    //IMULT_X: multiplier de fréquence (reglage de base 35)
    //FMULT_X : multiplieur fractionneur (*0/*0.25/*0.5/*0.75)
    //PLLCLK_BY_X : PLLSYSCLKDIV: diviseur de fréquence (min 1)


    //IER = 0x0000;
    //IFR = 0x0000;

    EALLOW;
    ClkCfgRegs.PERCLKDIVSEL.bit.EPWMCLKDIV = 0;//CLKDIV divise la frequence
//    PieVectTable.EPWM1_INT = &epwm1_isr;
//    PieVectTable.EPWM2_INT = &epwm2_isr;
    EDIS;

    //config ADC
        //
        // Enable global Interrupts and higher priority real-time debug events:
        //
            EINT;   // Enable Global interrupt INTM
            ERTM;   // Enable Global realtime interrupt DBGM

        //
        //Configure the ADCs and power them up
        //
            ConfigureADC();

        //
        //Setup the ADCs for software conversions
        //
            SetupADCSoftware();

    //Fin config ADC




    while(1){//i = 0;
        /*
        //convert, wait for completion, and store results
        //start conversions immediately via software, ADCA
        //
        AdcaRegs.ADCSOCFRC1.all = 0x0003; //SOC0 and SOC1

        //
        //start conversions immediately via software, ADCB
        //
        AdcbRegs.ADCSOCFRC1.all = 0x0003; //SOC0 and SOC1

        //
        //wait for ADCA to complete, then acknowledge flag
        //
        while(AdcaRegs.ADCINTFLG.bit.ADCINT1 == 0);
        AdcaRegs.ADCINTFLGCLR.bit.ADCINT1 = 1;

        //
        //wait for ADCB to complete, then acknowledge flag
        //
        while(AdcbRegs.ADCINTFLG.bit.ADCINT1 == 0);
        AdcbRegs.ADCINTFLGCLR.bit.ADCINT1 = 1;

        //
        //store results
        //
        AdcaResult0 = AdcaResultRegs.ADCRESULT0;
        AdcaResult1 = AdcaResultRegs.ADCRESULT1;
        AdcbResult0 = AdcbResultRegs.ADCRESULT0;
        AdcbResult1 = AdcbResultRegs.ADCRESULT1;

        //
        //at this point, conversion results are stored in
        //AdcaResult0, AdcaResult1, AdcbResult0, and AdcbResult1
        //
         * */

        val= ((float)Val_max_duty/3000);

        for (i=Val_min_duty;i<Val_max_duty;i++){
                PWM1(i,resolution);
                DELAY_US(10000);
        }

}



  //  PWM1(5); // réglage haris
  //  HRPWM(2500);//reglage Haris
//    APWM1();
   // HRPWM(200);
   // PWM1(1400);

    return 0;
}

//__interrupt void epwm1_isr(void)
//{

//}

//__interrupt void epwm2_isr(void)
//{

//}

void PWM1(float duty1, int resolution)
{
    float Rapport;
   // Rapport = 1750 - duty1; // Reglage Haris
    Rapport = resolution - duty1;

    /****DEFINITION DES GPIOs A UTILISER****/

    GPIO_SetupPinOptions(0, 1, GPIO_PULLUP);

    /****CARACTERISTIQUE DE LA PWM*****/
//EPWM_BASE  selectionne quelle PWM on veut, ici le 1
 //   EPWM_setTimeBasePeriod(EPWM1_BASE, 1749); //<---- Resolution
    EPWM_setTimeBasePeriod(EPWM1_BASE,(resolution-1)); // resolution -1 comprendre pourquoi le -1 est (vraiment utile?) (prog Haris)
    EPWM_setPhaseShift(EPWM1_BASE, 0U);
    EPWM_setTimeBaseCounter(EPWM1_BASE, 0U); //Initialisation du Counter.

    EPWM_setCounterCompareValue(EPWM1_BASE,
                                EPWM_COUNTER_COMPARE_A,
                                Rapport); //<-----Valeur du RAPPORT CYCLIQUE pour EPWM1A

    EPWM_setTimeBaseCounterMode(EPWM1_BASE,
                                EPWM_COUNTER_MODE_UP);
    EPWM_disablePhaseShiftLoad(EPWM1_BASE);
    EPWM_setClockPrescaler(EPWM1_BASE,
                           EPWM_CLOCK_DIVIDER_1,
                           EPWM_HSCLOCK_DIVIDER_1);

    EPWM_setCounterCompareShadowLoadMode(EPWM1_BASE,
                                         EPWM_COUNTER_COMPARE_A,
                                         EPWM_COMP_LOAD_ON_CNTR_ZERO);

    EPWM_setActionQualifierAction(EPWM1_BASE,
                                  EPWM_AQ_OUTPUT_A,
                                  EPWM_AQ_OUTPUT_HIGH,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    EPWM_setActionQualifierAction(EPWM1_BASE,
                                  EPWM_AQ_OUTPUT_A,
                                  EPWM_AQ_OUTPUT_LOW,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_PERIOD);

}

void HRPWM(float duty2)
{
    float Rapport;
    Rapport = 3500 - duty2;

    /****DEFINITION DES GPIOs A UTILISER****/

    GPIO_SetupPinOptions(2, 1, GPIO_PULLUP);

    /****CARACTERISTIQUE DE LA PWM*****/

    HRPWM_setTimeBasePeriod(EPWM2_BASE, 3499); //<---- Resolution
    HRPWM_setPhaseShift(EPWM2_BASE, 0U);
    HRPWM_setTimeBaseCounter(EPWM2_BASE, 0U); //Initialisation du Counter.

    HRPWM_setCounterCompareValue(EPWM2_BASE,
                                HRPWM_COUNTER_COMPARE_A,
                                Rapport); //<-----Valeur du RAPPORT CYCLIQUE pour EPWM1A

    HRPWM_setTimeBaseCounterMode(EPWM2_BASE,
                                EPWM_COUNTER_MODE_UP);
    HRPWM_disablePhaseShiftLoad(EPWM2_BASE);
    HRPWM_setClockPrescaler(EPWM2_BASE,
                           EPWM_CLOCK_DIVIDER_1,
                           EPWM_HSCLOCK_DIVIDER_1); //Modificateur de frequence de la clock PLL (Pas recommander de changer d'apres experience).

    HRPWM_setCounterCompareShadowLoadMode(EPWM2_BASE,
                                         EPWM_COUNTER_COMPARE_A,
                                         EPWM_COMP_LOAD_ON_CNTR_ZERO);

    HRPWM_setActionQualifierAction(EPWM2_BASE, EPWM_AQ_OUTPUT_A,
                                              EPWM_AQ_OUTPUT_HIGH,
                                              EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA); //Front montant du PWM.
    HRPWM_setActionQualifierAction(EPWM2_BASE, EPWM_AQ_OUTPUT_A,
                                              EPWM_AQ_OUTPUT_LOW,
                                              EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO); // Front descendant du PWM.
}
void ConfigureADC(void)
{
    EALLOW;

    //
    //write configurations
    //
    AdcaRegs.ADCCTL2.bit.PRESCALE = 6; //set ADCCLK divider to /4
    AdcbRegs.ADCCTL2.bit.PRESCALE = 6; //set ADCCLK divider to /4
    AdcSetMode(ADC_ADCA, ADC_RESOLUTION_12BIT, ADC_SIGNALMODE_SINGLE);
    AdcSetMode(ADC_ADCB, ADC_RESOLUTION_12BIT, ADC_SIGNALMODE_SINGLE);

    //
    //Set pulse positions to late
    //
    AdcaRegs.ADCCTL1.bit.INTPULSEPOS = 1;
    AdcbRegs.ADCCTL1.bit.INTPULSEPOS = 1;

    //
    //power up the ADCs
    //
    AdcaRegs.ADCCTL1.bit.ADCPWDNZ = 1;
    AdcbRegs.ADCCTL1.bit.ADCPWDNZ = 1;

    //
    //delay for 1ms to allow ADC time to power up
    //
    DELAY_US(1000);

    EDIS;
}

//
// SetupADCSoftware - Setup ADC channels and acquisition window
//
void SetupADCSoftware(void)
{
    Uint16 acqps;

    //
    //determine minimum acquisition window (in SYSCLKS) based on resolution
    //
    if(ADC_RESOLUTION_12BIT == AdcaRegs.ADCCTL2.bit.RESOLUTION)
    {
        acqps = 14; //75ns
    }
    else //resolution is 16-bit
    {
        acqps = 63; //320ns
    }

    //
    //Select the channels to convert and end of conversion flag
    //ADCA
    //
    EALLOW;
    AdcaRegs.ADCSOC0CTL.bit.CHSEL = 0;  //SOC0 will convert pin A0
    AdcaRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +
                                           //1 SYSCLK cycles
    AdcaRegs.ADCSOC1CTL.bit.CHSEL = 1;  //SOC1 will convert pin A1
    AdcaRegs.ADCSOC1CTL.bit.ACQPS = acqps; //sample window is acqps +
                                           //1 SYSCLK cycles
    AdcaRegs.ADCINTSEL1N2.bit.INT1SEL = 1; //end of SOC1 will set INT1 flag
    AdcaRegs.ADCINTSEL1N2.bit.INT1E = 1;   //enable INT1 flag
    AdcaRegs.ADCINTFLGCLR.bit.ADCINT1 = 1; //make sure INT1 flag is cleared
    //ADCB
    AdcbRegs.ADCSOC0CTL.bit.CHSEL = 0;  //SOC0 will convert pin B0
    AdcbRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +
                                           //1 SYSCLK cycles
    AdcbRegs.ADCSOC1CTL.bit.CHSEL = 1;  //SOC1 will convert pin B1
    AdcbRegs.ADCSOC1CTL.bit.ACQPS = acqps; //sample window is acqps +
                                           //1 SYSCLK cycles
    AdcbRegs.ADCINTSEL1N2.bit.INT1SEL = 1; //end of SOC1 will set INT1 flag
    AdcbRegs.ADCINTSEL1N2.bit.INT1E = 1;   //enable INT1 flag
    AdcbRegs.ADCINTFLGCLR.bit.ADCINT1 = 1; //make sure INT1 flag is cleared
    EDIS;
}
//void APWM1(void)
//{
//    ECAP_enableAPWMMode(ECAP1_BASE);
//    ECAP_setAPWMPeriod(ECAP1_BASE, 100);
//    ECAP_setAPWMPolarity(ECAP1_BASE, ECAP_APWM_ACTIVE_LOW);
//    ECAP_setPhaseShiftCount(ECAP1_BASE, 50);
//    ECAP_enableLoadCounter(ECAP1_BASE);
//    ECAP_loadCounter(ECAP1_BASE);
//    ECAP_stopCounter(ECAP1_BASE);
//    ECAP_startCounter(ECAP1_BASE);
//    ECAP_setAPWMCompare(ECAP1_BASE, 25);
//    ECAP_setAPWMShadowCompare(ECAP1_BASE, 15);
//}

Think in advance,

JJ

Hi JJ,

The max SYSCLK frequency can be 200MHz  and max EPWMCLK frequency can be 100MHz for this device. Also for SYSCLK above 100 MHz, the EPWMCLK must be half of SYSCLK.
So the below snippet will set the SYSCLK to 200MHz & EPWM
InitSysPll(INT_OSC2, IMULT_20, FMULT_0, PLLCLK_BY_1); // sets the sysclk to 200MHz
ClkCfgRegs.PERCLKDIVSEL.bit.EPWMCLKDIV = 0;  // this would set the EPWMCLK = SYSCLK = 200MHz (which is not correct)

Similarily
InitSysPll(INT_OSC2, IMULT_35, FMULT_0, PLLCLK_BY_1); // sets the sysclk to 350MHz (which is not correct)
ClkCfgRegs.PERCLKDIVSEL.bit.EPWMCLKDIV = 1; // sets EPWMCLK = SYSCLK/2 = 175MHz(not correct)

One of the possible configuration can be:
InitSysPll(INT_OSC2, IMULT_20, FMULT_0, PLLCLK_BY_1); // sets the sysclk to 200MHz
ClkCfgRegs.PERCLKDIVSEL.bit.EPWMCLKDIV = 1;   // this would set the EPWMCLK = SYSCLK/2 = 100MHz

Thanks
Vasudha