TMS320F28379D: TMS320F28379D- CLA

Hi Rani,

The C2000Ware SDK has examples that show how to use CLA with C28. Please download the SDK from the following link and navigate to driverlib\f2837xd\examples\cpu1\cla for the necessary examples for your device:

https://www.ti.com/tool/download/C2000WARE

Thanks,

Ashwini

Ashwini,

     when i am running example code also getting "Estop " error .

Thanks & Regards ,

Rani

Hi Rani,

Please comment the ESTOP0 assembly line. The assembly ESTOP statement is only there for proof to show that CLA1 is being triggered. If you want your application to run without stopping you dont need that line.

Thanks,

Ashwini

Ashwini,

    I would like to take pulse count through ecap module running on CLA. Count value will be calculate on Main CPU function like RPM. For that i have done Code  but it doesnt work . Can you help me where i missed the configuration process to run my application as per my idea.

1. Created variable in sharedcla. h and main file -Ecap_count

 
#include "driverlib.h"
#include "device.h"
#include "cla_ex1_asin_shared.h"
#include "Ecap_3.h"

#ifdef __cplusplus

#pragma DATA_SECTION("Cla1ToCpuMsgRAM");
uint8_t Ecap_count;
#else

#pragma DATA_SECTION(Ecap_count,"Cla1ToCpuMsgRAM");
int Ecap_count;

#endif //__cplusplus


//
// Function Prototypes
//
void CLA_runTest(void);
void CLA_configClaMemory(void);
void CLA_initCpu1Cla1(void);
__interrupt void cla1Isr1();
__interrupt void cla1Isr2();
__interrupt void cla1Isr3();
__interrupt void cla1Isr4();
__interrupt void cla1Isr5();
__interrupt void cla1Isr6();
__interrupt void cla1Isr7();
__interrupt void cla1Isr8();


float RPM ;
//
// Main
//
void main(void)
{

    //
    // Intialize device clock and peripherals
    //
    Device_init();

    //
    // Disable pin locks and enable internal pullups.
    //
    //Device_initGPIO(); //skipped for this example

    //
    // Initialize PIE and clear PIE registers. Disables CPU interrupts
    //
    Interrupt_initModule();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();

    //
    // Configure the CLA memory spaces first followed by
    // the CLA task vectors
    //
    CLA_configClaMemory();
    CLA_initCpu1Cla1();

    //
    // Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
    //
    EINT;
    ERTM;

    //
    // Run the test
    //


    for(;;)
    {
        CLA_runTest();
    }
}

//
// CLA_runTest - Execute CLA task tests for specified vectors
//
void CLA_runTest(void)
{


RPM=Ecap_count*60;

}



//
// CLA_configClaMemory - Configure CLA memory sections
//
void CLA_configClaMemory(void)
{
    extern uint32_t Cla1funcsRunStart, Cla1funcsLoadStart, Cla1funcsLoadSize;
    EALLOW;

#ifdef _FLASH
    //
    // Copy over code from FLASH to RAM
    //
    memcpy((uint32_t *)&Cla1funcsRunStart, (uint32_t *)&Cla1funcsLoadStart,
           (uint32_t)&Cla1funcsLoadSize);
#endif //_FLASH

    //
    // Initialize and wait for CLA1ToCPUMsgRAM
    //
    MemCfg_initSections(MEMCFG_SECT_MSGCLA1TOCPU);
    while (!MemCfg_getInitStatus(MEMCFG_SECT_MSGCLA1TOCPU)){};

    //
    // Initialize and wait for CPUToCLA1MsgRAM
    //
    MemCfg_initSections(MEMCFG_SECT_MSGCPUTOCLA1);
    while (!MemCfg_getInitStatus(MEMCFG_SECT_MSGCPUTOCLA1)){};

    //
    // Select LS4RAM and LS5RAM to be the programming space for the CLA
    // First configure the CLA to be the master for LS4 and LS5 and then
    // set the space to be a program block
    //
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS4,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS4,MEMCFG_CLA_MEM_PROGRAM);
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS5,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS5,MEMCFG_CLA_MEM_PROGRAM);

    //
    // Next configure LS0RAM and LS1RAM as data spaces for the CLA
    // First configure the CLA to be the master for LS0(1) and then
    // set the spaces to be code blocks
    //
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS0,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS0, MEMCFG_CLA_MEM_DATA);

    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS1,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS1, MEMCFG_CLA_MEM_DATA);

    EDIS;
}

//
// CLA_initCpu1Cla1 - Initialize CLA1 task vectors and end-of-task interrupts
//
void CLA_initCpu1Cla1(void)
{
    //
    // Compute all CLA task vectors
    // On Type-1 CLAs the MVECT registers accept full 16-bit task addresses as
    // opposed to offsets used on older Type-0 CLAs
    //
    EALLOW;
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_1,(uint16_t)&Cla1Task1);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_2,(uint16_t)&Cla1Task2);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_3,(uint16_t)&Cla1Task3);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_4,(uint16_t)&Cla1Task4);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_5,(uint16_t)&Cla1Task5);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_6,(uint16_t)&Cla1Task6);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_7,(uint16_t)&Cla1Task7);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_8,(uint16_t)&Cla1Task8);

    //
    // Enable the IACK instruction to start a task on CLA in software
    // for all  8 CLA tasks. Also, globally enable all 8 tasks (or a
    // subset of tasks) by writing to their respective bits in the
    // MIER register
    //
    CLA_enableIACK(CLA1_BASE);
    CLA_enableTasks(CLA1_BASE, CLA_TASKFLAG_ALL);

    //
    // Configure the vectors for the end-of-task interrupt for all
    // 8 tasks
    //
    Interrupt_register(INT_CLA1_1, &cla1Isr1);
    Interrupt_register(INT_CLA1_2, &cla1Isr2);
    Interrupt_register(INT_CLA1_3, &cla1Isr3);
    Interrupt_register(INT_CLA1_4, &cla1Isr4);
    Interrupt_register(INT_CLA1_5, &cla1Isr5);
    Interrupt_register(INT_CLA1_6, &cla1Isr6);
    Interrupt_register(INT_CLA1_7, &cla1Isr7);
    Interrupt_register(INT_CLA1_8, &cla1Isr8);

    //
    // Enable CLA interrupts at the group and subgroup levels
    //
    Interrupt_enable(INT_CLA1_1);
    Interrupt_enable(INT_CLA1_2);
    Interrupt_enable(INT_CLA1_3);
    Interrupt_enable(INT_CLA1_4);
    Interrupt_enable(INT_CLA1_5);
    Interrupt_enable(INT_CLA1_6);
    Interrupt_enable(INT_CLA1_7);
    Interrupt_enable(INT_CLA1_8);
}

//
// cla1Isr1 - CLA1 ISR 1
//

__interrupt void cla1Isr1 ()
{
    //
    // Acknowledge the end-of-task interrupt for task 1
    //


       Ecap_count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_1);

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP11);

    //
    // Uncomment to halt debugger and stop here
    //
   // asm(" ESTOP0");
}

//
// cla1Isr2 - CLA1 ISR 2
//
__interrupt void cla1Isr2 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr3 - CLA1 ISR 3
//
__interrupt void cla1Isr3 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr4 - CLA1 ISR 4
//
__interrupt void cla1Isr4 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr5 - CLA1 ISR 5
//
__interrupt void cla1Isr5 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr6 - CLA1 ISR 6
//
__interrupt void cla1Isr6 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr7 - CLA1 ISR 7
//
__interrupt void cla1Isr7 ()
{
    asm(" ESTOP0");
}

//
// cla1Isr8 - CLA1 ISR 8
//
__interrupt void cla1Isr8 ()
{
    //
    // Acknowledge the end-of-task interrupt for task 8
    //
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP11);
    //
    // Uncomment to halt debugger and stop here
    //
//    asm(" ESTOP0");
}

//
// End of file
//

3. ECAP Peripheral is initialized as it is normal

// Included Files
//
#include "driverlib.h"
#include "device.h"
#include "Ecap_3.h"

//
// Globals
//
uint32_t  Roller_Pulse_Count;
uint32_t ecap1PassCount;
uint32_t epwm3TimerDirection;
volatile uint16_t cap1Count;
volatile uint16_t cap2Count;
volatile uint16_t epwm3PeriodCount;


void Ecap_Int()
{
       XBAR_setInputPin(XBAR_INPUT7, 16);
       GPIO_setPinConfig(GPIO_16_GPIO16);
       GPIO_setPadConfig(16, GPIO_PIN_TYPE_PULLUP);
       GPIO_setDirectionMode(16, GPIO_DIR_MODE_IN);
       GPIO_setQualificationMode(16, GPIO_QUAL_ASYNC);
}

void initECAP()
{
    //
    // Disable ,clear all capture flags and interrupts
    //
    ECAP_disableInterrupt(ECAP1_BASE,
                          (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                           ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                           ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                           ECAP_ISR_SOURCE_COUNTER_COMPARE));
    ECAP_clearInterrupt(ECAP1_BASE,
                        (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                         ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                         ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                         ECAP_ISR_SOURCE_COUNTER_COMPARE));

    //
    // Disable CAP1-CAP4 register loads
    //
    ECAP_disableTimeStampCapture(ECAP1_BASE);

    //
    // Configure eCAP
    //    Enable capture mode.
    //    One shot mode, stop capture at event 4.
    //    Set polarity of the events to rising, falling, rising, falling edge.
    //    Set capture in time difference mode.
    //    Select input from XBAR7.
    //    Enable eCAP module.
    //    Enable interrupt.
    //
    ECAP_stopCounter(ECAP1_BASE);
    ECAP_enableCaptureMode(ECAP1_BASE);

    ECAP_setCaptureMode(ECAP1_BASE, ECAP_ONE_SHOT_CAPTURE_MODE, ECAP_EVENT_4);

    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_1, ECAP_EVNT_FALLING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_2, ECAP_EVNT_RISING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_3, ECAP_EVNT_FALLING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_4, ECAP_EVNT_RISING_EDGE);

    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_1);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_2);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_3);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_4);

    XBAR_setInputPin(XBAR_INPUT7, 16);

    ECAP_enableLoadCounter(ECAP1_BASE);
    ECAP_setSyncOutMode(ECAP1_BASE, ECAP_SYNC_OUT_SYNCI);
    ECAP_startCounter(ECAP1_BASE);
    ECAP_enableTimeStampCapture(ECAP1_BASE);
    ECAP_reArm(ECAP1_BASE);

    ECAP_enableInterrupt(ECAP1_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
}

4. In CLA file write the code to Read Pulse count

//#############################################################################
// \file f2837x/F2837x_internal_testcases/CLA/asin/asin.cla
//
// \brief  Arc Sine Example
// \author Vishal Coelho
// \date   Apr 8, 2013
//
//
//  Group:             C2000
//  Target Family:    F2837xS
//
//#############################################################################
// $TI Release: F2837xS Support Library v3.11.00.00 $
// $Release Date: Sun Oct  4 15:58:38 IST 2020 $
// $Copyright:
// Copyright (C) 2014-2020 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without 
// modification, are permitted provided that the following conditions 
// are met:
// 
//   Redistributions of source code must retain the above copyright 
//   notice, this list of conditions and the following disclaimer.
// 
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the 
//   documentation and/or other materials provided with the   
//   distribution.
// 
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################

//
// Included Files
//
#include "cla_ex1_asin_shared.h"
#include "Ecap_3.h"
//
// Defines
//

//
// Globals
//
// Note that the globals defined in the .cla source are global to the cla source
// file.  i.e. they may be shared across tasks. All of the data shared between
// the CLA and the C28x CPU must be defined in the C (or C++) code, and not the
// CLA code.  
//

//
// Function Definitions
//
//Task 1 : Calculate asin(X)
// Description:
//             Step(1): Calculate absolute of the input X
//
//             Step(2):   Use the upper 6-bits of input "X" value as an
//                          index into the table to obtain the coefficients
//                          for a second order equation:
//
//                        _FPUasinTable:
//                             CoeffA0[0]
//                             CoeffA1[0]
//                             CoeffA2[0]
//                                .
//                                .
//                             CoeffA0[63]
//                             CoeffA1[63]
//                             CoeffA2[63]
//
//             Step(3):   Calculate the angle using the following equation:
//
//                        arctan(Ratio) = A0 + A1*Ratio + A2*Ratio*Ratio
//                        arctan(Ratio) = A0 + Ratio(A1 + A2*Ratio)
//
//             Step(4):   The final angle is determined as follows:
//
//                        if( X < 0 )
//                            Angle = -Angle
__interrupt void Cla1Task1 ( void )
{


    Ecap_count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_1);
}

interrupt void Cla1Task2 ( void )
{

}

interrupt void Cla1Task3 ( void )
{

}

interrupt void Cla1Task4 ( void )
{

}

interrupt void Cla1Task5 ( void )
{

}

interrupt void Cla1Task6 ( void )
{

}

interrupt void Cla1Task7 ( void )
{

}

interrupt void Cla1Task8 ( void )
{

}

//
// End of file
//

My doubt is

1. There are two place ISR function will be there , where i have to write code for count pulse ?

2. when i am using C28x + CLA which   .cmd file  is used  cla or C28x  file (2837xD_FLASH_CLA_lnk_cpu1.cmd , 2837xS_Generic_FLASH_lnk.cmd.

Thanks & Regards,

Rani

Hi Rani,

In the snapshot you have posted, the file names have a * next to them indicating that the files have not been saved. Could you check if this is causing the issue. Also, please could you provide more details on what is not working?

Thanks,

Ashwini

Ashwini,

   ISR functions in two places where we have to write functions for CLA application.

Thanks & Regards,

Rani

Hi Rani,

The CLA task ISR only needs to be defined and implemented in the .cla file for CLA. You do not need any of the definitions you have in the .C file which will run on the C28.

Make sure your code is setup to trigger the CLA task. It will help to read the TRM and this guide:

https://software-dl.ti.com/C2000/docs/cla_software_dev_guide/intro.html

You can check if the CLA task is being triggered by using the mdebugstop instruction.

https://software-dl.ti.com/C2000/docs/cla_software_dev_guide/debugging.html

Thanks,

Ashwini

Ashwini,

 while uploading code getting an error as " Unknown properties :FlashcoreSelection " . But code is uploading i can debug the code.

when i am add my peripheral initialization in ,cla file getting an error after adding Header files too.

i am using "C:\ti\C2000Ware_3_03_00_00_Software\driverlib\f2837xd\examples\cpu1\cla "  Example sin program just added ECAP initialization.

Thanks & Regards,

Rani

Hi Rani,

Can you check this post to see if the error you are getting is because while the target is the F2837xD i.e dual core the example you are using is for an F2837xS i.e. a single core.

https://e2e.ti.com/support/tools/code-composer-studio-group/ccs/f/code-composer-studio-forum/479683/c2000-unknown-property-flashcoreselection

Please could you post the code and the error you are getting regarding ECAP initialization? One suggestion is to have the C28 code do the initialization and have the CLA only use the ECAP module.

Thanks,

Ashwini

Ashwini,

Ashwini Athalye said:

Can you check this post to see if the error you are getting is because while the target is the F2837xD i.e dual core the example you are using is for an F2837xS i.e. a single core.

         Yes, You are correct .Ok I will change it .

Ashwini Athalye said:

Please could you post the code and the error you are getting regarding ECAP initialization? One suggestion is to have the C28 code do the initialization and have the CLA only use the ECAP module.

         In ECAP initialization there is no problem . But No action in code when i am given Pulse to ECAP Pin

       .When I am trying to write CLA1ISR to count Pulse of ECAP getting an error .

        Bellow i have attached my codes , Please look up any mistake i have done in  either configuration or Procedure to set up the CLA .

.CLA file

//
// Included Files
//
#include "cla_ex1_asin_shared.h"
#include "Ecap_3.h"


__interrupt void Cla1Task1 ( void )
{
    //
    Ecap_count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_1);

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP11);

    __mdebugstop();

}

interrupt void Cla1Task2 ( void )
{

}

interrupt void Cla1Task3 ( void )
{

}

interrupt void Cla1Task4 ( void )
{

}

interrupt void Cla1Task5 ( void )
{

}

interrupt void Cla1Task6 ( void )
{

}

interrupt void Cla1Task7 ( void )
{

}

interrupt void Cla1Task8 ( void )
{

}

//
// End of file
//

Shared .h file

#ifndef _CLA_ASIN_SHARED_H_
#define _CLA_ASIN_SHARED_H_

//
// Included Files
//
#include <stdint.h>
#include "Ecap_3.h"

#ifdef __cplusplus
extern "C" {
#endif

//
//Task 1 (C) Variables
//
extern int Ecap_count;            //Result vector

// function defintion
__interrupt void Cla1Task1();
__interrupt void Cla1Task2();
__interrupt void Cla1Task3();
__interrupt void Cla1Task4();
__interrupt void Cla1Task5();
__interrupt void Cla1Task6();
__interrupt void Cla1Task7();
__interrupt void Cla1Task8();

#ifdef __cplusplus
}
#endif // extern "C"

#endif //end of _CLA_ASIN_SHARED_H_ definition

//
// End of file
//

Main File

//
// Included Files
//
#include "driverlib.h"
#include "device.h"
#include "cla_ex1_asin_shared.h"
#include "Ecap_3.h"


//
// Defines
//
#define WAITSTEP     asm(" RPT #255 || NOP")

//
// Globals
//

//
//Task 1 (C) Variables
// NOTE: Do not initialize the Message RAM variables globally, they will be
// reset during the message ram initialization phase in the CLA memory
// configuration routine
//
#ifdef __cplusplus

#pragma DATA_SECTION("Cla1ToCpuMsgRAM");
uint8_t Ecap_count;
#else

#pragma DATA_SECTION(Ecap_count,"Cla1ToCpuMsgRAM");
int Ecap_count;
#endif //__cplusplus


//
// Function Prototypes
//
void CLA_runTest(void);
void CLA_configClaMemory(void);
void CLA_initCpu1Cla1(void);
__interrupt void cla1Isr1();
__interrupt void cla1Isr2();
__interrupt void cla1Isr3();
__interrupt void cla1Isr4();
__interrupt void cla1Isr5();
__interrupt void cla1Isr6();
__interrupt void cla1Isr7();
__interrupt void cla1Isr8();


float RPM ;
//
// Main
//
void main(void)
{

    //
    // Intialize device clock and peripherals
    //
    Device_init();

    //
    // Disable pin locks and enable internal pullups.
    //
    Device_initGPIO(); //skipped for this example

    //
    // Initialize PIE and clear PIE registers. Disables CPU interrupts
    //
    Interrupt_initModule();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();




    GPIO_setPadConfig(DEVICE_GPIO_PIN_LED2, GPIO_PIN_TYPE_STD);
    GPIO_setDirectionMode(DEVICE_GPIO_PIN_LED2, GPIO_DIR_MODE_OUT);



    //
    // Configure the CLA memory spaces first followed by
    // the CLA task vectors
    //
    CLA_configClaMemory();
    CLA_initCpu1Cla1();
    Ecap_Int();
    initECAP();
    //
    // Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
    //
    EINT;
    ERTM;

    //
    // Run the test
    //


    for(;;)
    {

                             GPIO_writePin(27, 0);

                              //
                              // Delay for a bit.
                              //
                              DEVICE_DELAY_US(50000);

                              //
                              // Turn off LED
                              //
                              GPIO_writePin(27, 1);

                              //
                              // Delay for a bit.
                              //
                              DEVICE_DELAY_US(50000);
                              CLA_runTest();
    }
}

//
// CLA_runTest - Execute CLA task tests for specified vectors
//
void CLA_runTest(void)
{


RPM=Ecap_count*60;

}



//
// CLA_configClaMemory - Configure CLA memory sections
//
void CLA_configClaMemory(void)
{
    extern uint32_t Cla1funcsRunStart, Cla1funcsLoadStart, Cla1funcsLoadSize;
    EALLOW;

#ifdef _FLASH
    //
    // Copy over code from FLASH to RAM
    //
    memcpy((uint32_t *)&Cla1funcsRunStart, (uint32_t *)&Cla1funcsLoadStart,
           (uint32_t)&Cla1funcsLoadSize);
#endif //_FLASH

    //
    // Initialize and wait for CLA1ToCPUMsgRAM
    //
    MemCfg_initSections(MEMCFG_SECT_MSGCLA1TOCPU);
    while (!MemCfg_getInitStatus(MEMCFG_SECT_MSGCLA1TOCPU)){};

    //
    // Initialize and wait for CPUToCLA1MsgRAM
    //
    MemCfg_initSections(MEMCFG_SECT_MSGCPUTOCLA1);
    while (!MemCfg_getInitStatus(MEMCFG_SECT_MSGCPUTOCLA1)){};

    //
    // Select LS4RAM and LS5RAM to be the programming space for the CLA
    // First configure the CLA to be the master for LS4 and LS5 and then
    // set the space to be a program block
    //
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS4,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS4,MEMCFG_CLA_MEM_PROGRAM);
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS5,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS5,MEMCFG_CLA_MEM_PROGRAM);

    //
    // Next configure LS0RAM and LS1RAM as data spaces for the CLA
    // First configure the CLA to be the master for LS0(1) and then
    // set the spaces to be code blocks
    //
    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS0,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS0, MEMCFG_CLA_MEM_DATA);

    MemCfg_setLSRAMMasterSel(MEMCFG_SECT_LS1,MEMCFG_LSRAMMASTER_CPU_CLA1);
    MemCfg_setCLAMemType(MEMCFG_SECT_LS1, MEMCFG_CLA_MEM_DATA);

    EDIS;
}

//
// CLA_initCpu1Cla1 - Initialize CLA1 task vectors and end-of-task interrupts
//
void CLA_initCpu1Cla1(void)
{
    //
    // Compute all CLA task vectors
    // On Type-1 CLAs the MVECT registers accept full 16-bit task addresses as
    // opposed to offsets used on older Type-0 CLAs
    //
    EALLOW;
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_1,(uint16_t)&Cla1Task1);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_2,(uint16_t)&Cla1Task2);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_3,(uint16_t)&Cla1Task3);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_4,(uint16_t)&Cla1Task4);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_5,(uint16_t)&Cla1Task5);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_6,(uint16_t)&Cla1Task6);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_7,(uint16_t)&Cla1Task7);
    CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_8,(uint16_t)&Cla1Task8);

    //
    // Enable the IACK instruction to start a task on CLA in software
    // for all  8 CLA tasks. Also, globally enable all 8 tasks (or a
    // subset of tasks) by writing to their respective bits in the
    // MIER register
    //
    CLA_enableIACK(CLA1_BASE);
    CLA_enableTasks(CLA1_BASE, CLA_TASKFLAG_ALL);

    //
    // Configure the vectors for the end-of-task interrupt for all
    // 8 tasks
    //
    Interrupt_register(INT_CLA1_1, &cla1Isr1);
    Interrupt_register(INT_CLA1_2, &cla1Isr2);
    Interrupt_register(INT_CLA1_3, &cla1Isr3);
    Interrupt_register(INT_CLA1_4, &cla1Isr4);
    Interrupt_register(INT_CLA1_5, &cla1Isr5);
    Interrupt_register(INT_CLA1_6, &cla1Isr6);
    Interrupt_register(INT_CLA1_7, &cla1Isr7);
    Interrupt_register(INT_CLA1_8, &cla1Isr8);

    //
    // Enable CLA interrupts at the group and subgroup levels
    //
    Interrupt_enable(INT_CLA1_1);
    Interrupt_enable(INT_CLA1_2);
    Interrupt_enable(INT_CLA1_3);
    Interrupt_enable(INT_CLA1_4);
    Interrupt_enable(INT_CLA1_5);
    Interrupt_enable(INT_CLA1_6);
    Interrupt_enable(INT_CLA1_7);
    Interrupt_enable(INT_CLA1_8);
}


//
// cla1Isr2 - CLA1 ISR 2
//

ECap.C file

// Included Files
//

#include "Ecap_3.h"

//
// Globals
//
uint32_t  Roller_Pulse_Count;
uint32_t ecap1PassCount;
uint32_t epwm3TimerDirection;
volatile uint16_t cap1Count;
volatile uint16_t cap2Count;
volatile uint16_t epwm3PeriodCount;


void Ecap_Int()
{
       XBAR_setInputPin(XBAR_INPUT7, 16);
       GPIO_setPinConfig(GPIO_16_GPIO16);
       GPIO_setPadConfig(16, GPIO_PIN_TYPE_PULLUP);
       GPIO_setDirectionMode(16, GPIO_DIR_MODE_IN);
       GPIO_setQualificationMode(16, GPIO_QUAL_ASYNC);
}

void initECAP()
{
    //
    // Disable ,clear all capture flags and interrupts
    //
    ECAP_disableInterrupt(ECAP1_BASE,
                          (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                           ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                           ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                           ECAP_ISR_SOURCE_COUNTER_COMPARE));
    ECAP_clearInterrupt(ECAP1_BASE,
                        (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                         ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                         ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                         ECAP_ISR_SOURCE_COUNTER_COMPARE));

    //
    // Disable CAP1-CAP4 register loads
    //
    ECAP_disableTimeStampCapture(ECAP1_BASE);

    //
    // Configure eCAP
    //    Enable capture mode.
    //    One shot mode, stop capture at event 4.
    //    Set polarity of the events to rising, falling, rising, falling edge.
    //    Set capture in time difference mode.
    //    Select input from XBAR7.
    //    Enable eCAP module.
    //    Enable interrupt.
    //
    ECAP_stopCounter(ECAP1_BASE);
    ECAP_enableCaptureMode(ECAP1_BASE);

    ECAP_setCaptureMode(ECAP1_BASE, ECAP_ONE_SHOT_CAPTURE_MODE, ECAP_EVENT_4);

    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_1, ECAP_EVNT_FALLING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_2, ECAP_EVNT_RISING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_3, ECAP_EVNT_FALLING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_4, ECAP_EVNT_RISING_EDGE);

    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_1);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_2);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_3);
    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_4);

    XBAR_setInputPin(XBAR_INPUT7, 16);

    ECAP_enableLoadCounter(ECAP1_BASE);
    ECAP_setSyncOutMode(ECAP1_BASE, ECAP_SYNC_OUT_SYNCI);
    ECAP_startCounter(ECAP1_BASE);
    ECAP_enableTimeStampCapture(ECAP1_BASE);
    ECAP_reArm(ECAP1_BASE);

    ECAP_enableInterrupt(ECAP1_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
}

/*
_interrupt void ecap1ISR(void)
{
    //
    // Get the capture counts. Each capture should be 4x the ePWM count
    // because of the ePWM clock dividers.
    //
    //cap1Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_1);
    //cap2Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_2);
    //cap3Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_3);
    //cap4Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_4);

    //
    // Compare the period value with the captured count
    //
   // epwm3PeriodCount = EPWM_getTimeBasePeriod(EPWM3_BASE);



    //Roller_Pulse_Count++;



    //
    ECAP_clearInterrupt(ECAP1_BASE,ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
    ECAP_clearGlobalInterrupt(ECAP1_BASE);

    //
    // Start eCAP
    //
    ECAP_reArm(ECAP1_BASE);

    //
    // Acknowledge the group interrupt for more interrupts.
    //
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP4);

}

*/

Ecap.h file

/*
 * Ecap_3.h
 *
 *  Created on: Jun 8, 2020
 *      Author: Administrator
 */

#ifndef ECAP_3_H_
#define ECAP_3_H_

#include "driverlib.h"
#include "device.h"
// Globals
//
extern uint32_t  Roller_Pulse_Count;
extern uint32_t ecap1PassCount;
extern uint32_t epwm3TimerDirection;
extern volatile uint16_t cap1Count;
extern volatile uint16_t cap2Count;
extern volatile uint16_t epwm3PeriodCount;

//
// Function Prototypes
//
extern void error(void);
extern void initECAP(void);
extern void initEPWM(void);
extern __interrupt void ecap1ISR(void);
extern void Ecap_Int();



#endif /* ECAP_3_H_ */

While compiling getting an error as below

One more doubt In example CLA program used two claISR function . One is used in  Main C file other one is .cla File .

Interrupt is occured process will be taken care of .cla File iSR function , Main . c file ISR function will be cleared this interrupt

Am I correct ?

Thanks & Regards,

Rani

Hello Rani,

I apologize for the long delay. I was out of office and hence could not reply sooner.

1. Regarding the undefined CLA_O_SOFTINTEN message, this is a known issue with the C2000Ware 3.03 release. Please use the latest C2000Ware 3.04 from the ti.com/C2000Ware website to resolve this issue. 

2. In the example CLA program, this is the flow:

The C28 side in the CLA_initCpu1Cla1()

• sets up the system for the CLA to execute Cla1Task1.  See source line "CLA_mapTaskVector(CLA1_BASE,CLA_MVECT_1,(uint16_t)&Cla1Task1);"
• Along with this, the C28 side is also setting up the C28 side to generate an interrupt when the CLA finishes executing Cla1Task1. The C28 side interrupt service routine in cla1Isr1. See the source line "Interrupt_register(INT_CLA1_1, &cla1Isr1);"

The C28 side in the CLA_runTest()

• The C28 side code triggers the CLA task 1. See source line "CLA_forceTasks(CLA1_BASE,CLA_TASKFLAG_1);"

The CLA side in  Cla1Task1()

The C28 side cla1Isr1 ISR:

• The ISR is generated when the CLA Task 1 completes. Hence this ISR then clears the C28 interrupt . See source line  "Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP11);".  This code only belongs on the C28 side and is not relevant on CLA side as this is a C28 side interrupt.

In this example, the C28 side interrupt is enabled for when CLA Task 1 completes as a demonstration to show that the CLA task completed as well as to show how handshaking can be done between CLA and C28. If this handshaking is not needed in your system you do not need to enable the C28 side interrupt for INT_CLA1_1 and hence don't  need the cla1Isr1.

Hope this helps.

Thanks.

Ashwini

Thank you for the reply . I will check  it .

Thanks ,

Rani

Hi,

Here are some additional resources to help with writing code for CLA:

For hands-on training/workshop:

https://training.ti.com/control-law-accelerator-cla-hands-workshop

For FAQs related to the CLA:

• CLA Software Development Guide at https://software-dl.ti.com/C2000/docs/cla_software_dev_guide/index.html

In addition, you may also find these resources helpful:

• C2000 Software Guide at https://software-dl.ti.com/C2000/docs/software_guide/intro.html

• C2000 Optimization Guide at http://software-dl.ti.com/C2000/docs/optimization_guide/index.html

Thanks,

Ashwini

Thanks Ashwini.

?

Ashwini,

1.  If task can be requested by a peripheral interrupt which means have to  use this line   .DmaClaSrcSelRegs.CLA1TASKSRCSEL1.bit.TASK1     = CLA_TRIG_ECAP1INT;

Am i Correct?

2. What is difference between __attribute__((interrupt))  void Cla1Task1() & __interrupt void Cla1Task1().

3. In hands on solution project file  doesn't  have .Cla file  i think so .cla file is mandatory or not?

4. In Hands on Example project how adcintr is linked with CLA1ISR functions.

__attribute__((interrupt))  void adca1intIsr( void );

5. Corresponding API for this instruction is?

DmaClaSrcSelRegs.CLA1TASKSRCSEL1.bit.TASK1  = CLA_TRIG_ECAP1INT;

Thanks

Rani

Hi Rani,

1. Please look at the compiler optimization guide for details on the usage of interrupt keyword.

Compiler Guide

https://www.ti.com/lit/ug/spru514w/spru514w.pdf

2. There is a .cla file in the solution project. In the project snapshot posted above, the build configuration is set to C28_CODE, hence cla file is excluded from build, Change the build configuration for the CLA and you will see the .cla file included in the project.

3. Please see the device datasheet and TRM documentation to confirm if the CLA task can be triggered by ECAP peripheral and the programming of the TASK1 bit.

Thanks,

Ashwini