TMS320F28377S: What does "cannot load from non-primitive location" mean when used digital control library?

//
// Included Files
//
#include "F28x_Project.h"
#include "DCLF32.h"

//
// Defines
//
//#define ONE (4095) // in 2^12 format
//
// Function Prototypes
//

void InitEPwm1(void);
void InitEPwm2(void);

__interrupt void epwm1_isr(void);
__interrupt void epwm2_isr(void);


interrupt void int_ext(void); //timetick associato al pin 42
//variables

//int i = 0;
int j = 0;
//int k = 0;
float PI_OUTPUT;
//float error;
//float V_array[600];

float adc_volt[10];
float adc_cur[10];
float sum_V=0;
float sum_I=0;
float Volt_final;
float Curr_final;

float offset_V = 200;
float offset_I = 128;
float DUTY_cycle = 0.5;

void adc_config();
void SetupADCSoftwareSync(void);

#define EPWM1_TIMER_TBPRD  1667  // Period register
//#define EPWM1_CMPA         5000
#define EPWM1_DB   20; // for 500 ns of deadband

#define PI_VALUES_V {0.06f, 0.1f, 0.1f, 1.0f, -1.0f, 0.1f} // Kp, Ki, i10, Sat_max, Sat_min, Sat_storage
float rk_V;    // Reference value
float yk_V;    // Measured ADC signal
float uk_V;    // PI output
DCL_PI pi1 = PI_VALUES_V;
float V_ref=100;
int enable=0;

// PI controller variables for current controller
#define PI_VALUES_I {0.06f, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f} // Kp, Ki, i10, Sat_max, Sat_min, Sat_storage
float rk_I;    // Reference value
float yk_I;    // Measured ADC signal
float uk_I;    // PI output
//float lk_I = 0.0f; // saturation
DCL_PI pi2 = PI_VALUES_I;

Uint32 EPwm2TimerIntCount =0;
Uint32 EPwm1TimerIntCount =0;
Uint32 count = 0;
void main(void)
{

     InitSysCtrl();
 //   InitGpio();
   //
   // enable PWM1, PWM2
   //
      CpuSysRegs.PCLKCR2.bit.EPWM1=1;
      CpuSysRegs.PCLKCR2.bit.EPWM2=1;
   // For this case just init GPIO pins for ePWM1, ePWM2, ePWM3
   // These functions are in the F2837xD_EPwm.c file
   //
      InitEPwm1Gpio();
      InitEPwm2Gpio();
   //Clear all interrupts and initialize PIE vector table:
   //Disable CPU interrupts
      DINT;

      InitPieCtrl();

   //Disable CPU interrupts and clear all CPU interrupt flags:
      IER = 0x0000;
      IFR = 0x0000;

      InitPieVectTable();

   //User specific code:
   //Interrupts are not used in this example.
   //
   // Map ISR functions
   //
      EALLOW;
      PieVectTable.EPWM1_INT = &epwm1_isr;
      PieVectTable.EPWM2_INT = &epwm2_isr;
      PieVectTable.XINT1_INT = &int_ext;
      EDIS;

   //  Initialize the Device Peripherals:
   //
      EALLOW;
      CpuSysRegs.PCLKCR0.bit.TBCLKSYNC =0;
      EDIS;

//
// Configure the ePWM
//
      InitEPwm1();
      InitEPwm2();

      EALLOW;
      CpuSysRegs.PCLKCR0.bit.TBCLKSYNC =1;
      EDIS;

//
// Enable CPU INT3 which is connected to EPWM1-3 INT:
//
      IER |= M_INT3;

//
// Enable EPWM INTn in the PIE: Group 3 interrupt 1-3
//
      PieCtrlRegs.PIEIER3.bit.INTx1 = 1;
      PieCtrlRegs.PIEIER3.bit.INTx2 = 1;

//
// Enable global Interrupts and higher priority real-time debug events:
//
      EINT;  // Enable Global interrupt INTM
      ERTM;  // Enable Global real time interrupt DBGM
//
// Enable XINT1 and XINT2 in the PIE: Group 1 interrupt 4 & 5
// Enable INT1 which is connected to WAKEINT:
//
      PieCtrlRegs.PIECTRL.bit.ENPIE = 1;          // Enable the PIE block
      PieCtrlRegs.PIEIER1.bit.INTx4 = 1;          // Enable PIE Group 1 INT4
      PieCtrlRegs.PIEIER1.bit.INTx5 = 1;          // Enable PIE Group 1 INT5

      IER |= M_INT1;                              // Enable CPU INT1
      EINT;                                       // Enable Global Interrupts

//
// GPIO0 is XINT1
//
      GPIO_SetupXINT1Gpio(42); //timetick 1

//
// Configure XINT1
//
      XintRegs.XINT1CR.bit.POLARITY = 1;          // Rising edge interrupt

//
// Enable XINT1
//
      XintRegs.XINT1CR.bit.ENABLE = 1;            // Enable XINT1

//
// Configure the ADC and power it up
      adc_config();
      SetupADCSoftwareSync();

         EALLOW;

         GpioCtrlRegs.GPBMUX1.bit.GPIO42 = 0;         // GPIO 42 TimeTick 1
         GpioCtrlRegs.GPBDIR.bit.GPIO42 = 0;          // input QUI DECIDI LA DIR DELL'INTERRUpt
         GpioCtrlRegs.GPBQSEL1.bit.GPIO42 = 0;        // XINT1 Synch to SYSCLKOUT only
         GpioCtrlRegs.GPCMUX1.bit.GPIO64 = 0;
         GpioCtrlRegs.GPCDIR.bit.GPIO64 = 1;      //PIN OUT
         GpioCtrlRegs.GPCQSEL1.bit.GPIO64 = 0;
         GpioCtrlRegs.GPCMUX1.bit.GPIO65 = 0;
         GpioCtrlRegs.GPCDIR.bit.GPIO65 = 1;      //PIN OUT
         GpioCtrlRegs.GPCQSEL1.bit.GPIO65 = 0;

         GpioDataRegs.GPCCLEAR.bit.GPIO64 = 1;
         GpioDataRegs.GPCCLEAR.bit.GPIO65 = 1;
         DELAY_US(1000000);
         GpioDataRegs.GPCSET.bit.GPIO64 = 1;
         GpioDataRegs.GPCSET.bit.GPIO65 = 1;
         DELAY_US(5000);

         EDIS;

  for(;;) {
             count++;
  }

}

__interrupt void epwm1_isr(void)
{

    j++;
 //    GpioDataRegs.GPCSET.bit.GPIO71 =1;
 //    GpioDataRegs.GPCSET.bit.GPIO70 =1;
//     AdcaRegs.ADCSOCFRC1.all = 0x000F;
//     AdcbRegs.ADCSOCFRC1.all = 0x000F;
       AdccRegs.ADCSOCFRC1.all = 0x000F;
       AdcdRegs.ADCSOCFRC1.all = 0x000F;

       adc_volt[j] = (AdccResultRegs.ADCRESULT0-offset_V)*650/4095 ; // read dc-link voltage
       adc_cur[j] =  (2048-(AdcdResultRegs.ADCRESULT0+offset_I))*35/2048; // read inductor current value

       sum_V = adc_volt[j]+sum_V;
       sum_I = adc_cur[j]+sum_I;

       if(j==10){
         Volt_final = sum_V/10;
         Curr_final = sum_I/10;
         sum_V=0;
         sum_I=0;
         j=0;
       }

       if(enable==1){

            yk_V = Volt_final/400 ;  // dc-link voltage should be within 400 V
            yk_I = Curr_final/20 ;  //  inductor current should be within 20 A
            rk_V = V_ref/400;
      //============================== voltage and current PI controller =====================//
            uk_V = DCL_runPI_C1(&pi1, rk_V, yk_V);
            rk_I = uk_V;
            uk_I = DCL_runPI_C1(&pi2, rk_I, yk_I);
     //========================================================================//
     //
     //     error = (rk_V-(float)(AdcaResultRegs.ADCRESULT0)) ;
            PI_OUTPUT = (uk_I*EPwm2Regs.TBPRD); // change to uk_I for BDC
            DUTY_cycle = ((int)PI_OUTPUT)/( EPwm2Regs.TBPRD);

           EPwm2Regs.CMPA.bit.CMPA = PI_OUTPUT;
       }

           EPwm1TimerIntCount++;
// Clear INT flag for this timer
//
           EPwm1Regs.ETCLR.bit.INT = 1;
//
//Acknowledge this interrupt to receive more interrupts from group 3
//
           PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;

//       GpioDataRegs.GPCCLEAR.bit.GPIO71 =1;
//       GpioDataRegs.GPCCLEAR.bit.GPIO70 =1;
}

void adc_config(){

    EALLOW;

//
//write configurations
//

        AdcaRegs.ADCCTL2.bit.PRESCALE = 6; //set ADCCLK divider to /4
        AdcbRegs.ADCCTL2.bit.PRESCALE = 6; //set ADCCLK divider to /4
        AdccRegs.ADCCTL2.bit.PRESCALE = 6; //set ADCCLK divider to /4
        AdcdRegs.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);
        AdcSetMode(ADC_ADCC, ADC_RESOLUTION_12BIT, ADC_SIGNALMODE_SINGLE);
        AdcSetMode(ADC_ADCD, ADC_RESOLUTION_12BIT, ADC_SIGNALMODE_SINGLE);
//
//     AdcaRegs.ADCCTL1.bit.INTPULSEPOS = 1;
//power up the ADCs
//
        AdcaRegs.ADCCTL1.bit.ADCPWDNZ = 1;
        AdcbRegs.ADCCTL1.bit.ADCPWDNZ = 1;
        AdccRegs.ADCCTL1.bit.ADCPWDNZ = 1;
        AdcdRegs.ADCCTL1.bit.ADCPWDNZ = 1;

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

        EDIS;

}

interrupt void int_ext(void)
{
         enable = 1;
 //        GpioDataRegs.GPBCLEAR.bit.GPIO42 =1;
         //
         // Acknowledge this interrupt to get more from group 1
         //
         PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}


void SetupADCSoftwareSync(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
         }

         if(ADC_RESOLUTION_12BIT == AdcbRegs.ADCCTL2.bit.RESOLUTION)
         {
             acqps = 14; //75ns
         }
         else //resolution is 16-bit
         {
             acqps = 63; //320ns
         }
    if(ADC_RESOLUTION_12BIT == AdccRegs.ADCCTL2.bit.RESOLUTION)
      {
          acqps = 14; //75ns
      }
      else //resolution is 16-bit
      {
          acqps = 63; //320ns
      }

      if(ADC_RESOLUTION_12BIT == AdcdRegs.ADCCTL2.bit.RESOLUTION)
      {
          acqps = 14; //75ns
      }
      else //resolution is 16-bit
      {
          acqps = 63; //320ns
      }
    //
    //Select the channels to convert and end of conversion flag
     //
    EALLOW;
         AdcaRegs.ADCSOC0CTL.bit.CHSEL = 2;  //SOC1 will convert pin B2 (Lac lato sx 2.632V= 35A)
         AdcaRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +

         AdcbRegs.ADCSOC0CTL.bit.CHSEL = 2;  //SOC1 will convert pin B2 (Lac lato sx 2.632V= 35A)
         AdcbRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +

         AdccRegs.ADCSOC0CTL.bit.CHSEL = 2;  //SOC1 will convert pin B2 (Lac lato sx 2.632V= 35A)
         AdccRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +

         AdcdRegs.ADCSOC0CTL.bit.CHSEL = 2;  //SOC1 will convert pin B2 (Lac lato sx 2.632V= 35A)
         AdcdRegs.ADCSOC0CTL.bit.ACQPS = acqps; //sample window is acqps +
                                                 //1 SYSCLK cycles
    EDIS;
     }


void InitEPwm1()
{
    //used for ISR
    EPwm1Regs.TBPRD = 500;                       // Set timer period for f=10 KHz
    EPwm1Regs.TBPHS.bit.TBPHS = 0x0000;           // Phase is 0
    EPwm1Regs.TBCTR = 0x0000;                     // Clear counter
    //
    // Setup TBCLK
    //
    EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up DOWN
    EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE;        // Disable phase loading
    EPwm1Regs.TBCTL.bit.HSPCLKDIV =TB_DIV1;       // Clock ratio to SYSCLKOUT
    EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV1;

    EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;    // Load registers every ZERO
    EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;
    EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;
    EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;

    //
    // Setup compare
    //
    EPwm1Regs.CMPA.bit.CMPA = 250;

    //
    // Set actions
    //
    //Uncomment "ZRO" when run on 28379D
//    EPwm1Regs.AQCTLA.bit.ZRO = AQ_SET;            // Set PWM1A on Zero
    EPwm1Regs.AQCTLA.bit.CAU = AQ_SET;            // Set PWM1A on Zero
    EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR;

    EPwm1Regs.AQCTLB.bit.CAU = AQ_CLEAR;          // Set PWM1A on Zero
    EPwm1Regs.AQCTLB.bit.CAD = AQ_SET;


    // Active High complementary PWMs - setup the deadband
    //
    EPwm1Regs.DBCTL.bit.OUT_MODE = DB_FULL_ENABLE;
    EPwm1Regs.DBCTL.bit.POLSEL = DB_ACTV_HIC;
    EPwm1Regs.DBCTL.bit.IN_MODE = DBA_ALL;
    EPwm1Regs.DBRED.bit.DBRED = EPWM1_DB;
    EPwm1Regs.DBFED.bit.DBFED = EPWM1_DB;
    //
    // Interrupt where we will change the Deadband
    //
    EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;    // Select INT on Zero event
    EPwm1Regs.ETSEL.bit.INTEN = 1;               // Enable INT
    EPwm1Regs.ETPS.bit.INTPRD = ET_1ST;          // Generate INT on 3rd event
}

void InitEPwm2()
{
    //used for PWM operation
    EPwm2Regs.TBPRD = 1667;                       // frequency of ISR at 100kHz
    EPwm2Regs.TBPHS.bit.TBPHS = 0x0000;           // Phase is 0
    EPwm2Regs.TBCTR = 0x0000;                     // Clear counter

    //
    // Setup TBCLK
    //
    EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up DOWN
    EPwm2Regs.TBCTL.bit.PHSEN = TB_DISABLE;        // Disable phase loading
    EPwm2Regs.TBCTL.bit.HSPCLKDIV =TB_DIV1;       // Clock ratio to SYSCLKOUT
    EPwm2Regs.TBCTL.bit.CLKDIV = TB_DIV1;
    //
    // Setup compare

    EPwm2Regs.CMPA.bit.CMPA = DUTY_cycle* 1667;
    //
    // Set actions
    //
    EPwm2Regs.AQCTLA.bit.CAU = AQ_SET;            // Set PWM1A on Zero
    EPwm2Regs.AQCTLA.bit.CAD = AQ_CLEAR;            // Set PWM1A on Zero
  //EPwm2Regs.AQCTLA.bit.CAD = AQ_CLEAR;

    EPwm2Regs.AQCTLB.bit.CAU = AQ_CLEAR;          // Set PWM1A on Zero
    EPwm2Regs.AQCTLB.bit.CAD = AQ_SET;

    // Active High complementary PWMs - setup the deadband
    //
    EPwm2Regs.DBCTL.bit.OUT_MODE = DB_FULL_ENABLE;
    EPwm2Regs.DBCTL.bit.POLSEL = DB_ACTV_HIC;
    EPwm2Regs.DBCTL.bit.IN_MODE = DBA_ALL;
    EPwm2Regs.DBRED.bit.DBRED = EPWM1_DB;
    EPwm2Regs.DBFED.bit.DBFED = EPWM1_DB;
    //
    // Interrupt where we will change the Deadband
    //
    EPwm2Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;    // Select INT on Zero event
    EPwm2Regs.ETSEL.bit.INTEN = 1;               // Enable INT
    EPwm2Regs.ETPS.bit.INTPRD = ET_1ST;          // Generate INT on 3rd event
}

__interrupt void epwm2_isr(void)
{
    EPwm2TimerIntCount++;
    //
    // Clear INT flag for this timer
    //
    EPwm2Regs.ETCLR.bit.INT = 1;

    //
    // Acknowledge this interrupt to receive more interrupts from group 3
    //
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}

#define PI_VALUES_V { 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, NULL_ADDR, NULL_ADDR}
//#define PI_VALUES_V {0.06f, 0.1f, 0.1f, 1.0f, -1.0f, 0.1f} // Kp, Ki, i10, Sat_max, Sat_min, Sat_storage
float rk_V;    // Reference value
float yk_V;    // Measured ADC signal
float uk_V;    // PI output
//float lk_V;

DCL_PI pi1 = PI_VALUES_V;
float V_ref=100;
int enable=0;

// PI controller variables for current controller
#define PI_VALUES_I { 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, NULL_ADDR, NULL_ADDR}