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.

CCS/TMS320F2808: Problem with Timer0

Part Number: TMS320F2808
Other Parts Discussed in Thread: C2000WARE

Tool/software: Code Composer Studio

Hi,
I am trying to program the Timer 0 module in TMS320F2808. The Timer doesn't seem to be triggering at all. Could you guide me in the right direction? Thanks!

Regards,
Frederic


Here is the source code:

/*
 * TMS320F2808_GPIO_TIMER.c
 *
 *  Created on: 14.10.2019
 *      Author: Frederic Leo
 */
#include "DSP280x_Device.h"     // DSP280x Header file Include File
#include "DSP280x_GlobalPrototypes.h"
#include "DSP280x_Examples.h"   // DSP280x Examples Include File


void Init_Timer0(void);
__interrupt void cpu_timer0_isr(void);

void main()
{
    // WARNING: Always ensure you call memcpy before running any functions from RAM
    // InitSysCtrl includes a call to a RAM based function and without a call to
    // memcpy first, the processor will go "into the weeds"
       #ifdef _FLASH
            memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
       #endif

    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
       InitSysCtrl();

    // Step 2. Initialize GPIO:
       InitGpio(); 

    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts
       DINT;

    // Initialize PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
       InitPieCtrl();

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

    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
       InitPieVectTable();

    // Disable Protection
    EALLOW;  // This is needed to write to EALLOW protected registers
    PieVectTable.TINT0 = &cpu_timer0_isr;
    EDIS;    // This is needed to disable write to EALLOW protected registers

    EALLOW;  // This is needed to write to EALLOW protected registers
    GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 0;    // Set as GPIO
    GpioCtrlRegs.GPADIR.bit.GPIO14 = 1;     // GPIO14 is output
    GpioCtrlRegs.GPAPUD.bit.GPIO14 = 1;     // Disable pull-up on GPIO14
    EDIS;    // This is needed to disable write to EALLOW protected registers

    Init_Timer0();

    for(;;)
    {
		//Run Forever
	}
}

void Init_Timer0(void)
{
    InitCpuTimers();  						// Only initialize the Cpu Timers

    ConfigCpuTimer(&CpuTimer0, 60, 500000);

    CpuTimer0Regs.TCR.all = 0x4001; 		// Use write-only instruction to set TSS bit = 0

    IER |= M_INT1;

    PieCtrlRegs.PIEIER1.bit.INTx7 = 1;    	// Enable TINT0 in the PIE: Group 1 interrupt 7

    EINT;   								// Enable Global interrupt INTM
    ERTM;   								// Enable Global realtime interrupt DBGM
}

__interrupt void cpu_timer0_isr(void)
{
   CpuTimer0.InterruptCount++;

   GpioDataRegs.GPATOGGLE.bit.GPIO14 = 1;	// Toggle the state of GPIO14

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

  • Frederic,

    I pasted your code verbatim into a CCS project and it ran correctly.  I placed a break-point on the first line of the ISR and it triggers each time.  When you say it's not triggering, how are you checking that?  Also, are building for flash or RAM?

    Regards,

    Richard 

  • Hi Richard,
    I am building for flash memory. Could you share your clock and PLL settings with which you programmed? Thanks!

    Regards
    Frederic

  • Frederic,

    Sorry, I didn't know you were building for flash.  In that case I think you need to re-structure your code a little. 

    You'll need to set up the clocks first with InitSysCtrl(), then do the MemCopy(), then initialize the flash with InitFlash().  Attached is the main file from an older F2808 flash example.  I recommend following a similar initialization sequence.  The PLL settings used were:

    #define DSP28_CLKINDIV 0

    #define DSP28_PLLCR 10

    All I did was build and run your main file on an '069 (which I had to hand) to check whether the code was functionally OK.  It ran fine.

    Regards,

    Richard

    Example_280xFlash.c
    // TI File $Revision: /main/5 $
    // Checkin $Date: September 14, 2005   11:20:59 $
    //###########################################################################
    //
    // FILE:    Example_280xFlash.c
    //
    // TITLE:   DSP280x ePWM Timer Interrupt From Flash Example.
    //
    // ASSUMPTIONS:
    //
    //    This program requires the DSP280x header files.  
    //
    //    As supplied, this project is configured for "boot to FLASH" 
    //    operation.  The 280x Boot Mode table is shown below.  
    //    For information on configuring the boot mode of an eZdsp, 
    //    please refer to the documentation included with the eZdsp,  
    //
    //       Boot      GPIO18     GPIO29    GPIO34
    //       Mode      SPICLKA    SCITXDA
    //                  SCITXB
    //       -------------------------------------
    //       Flash       1          1        1  <- "boot to FLASH"
    //       SCI-A       1          1        0
    //       SPI-A       1          0        1
    //       I2C-A       1          0        0
    //       ECAN-A      0          1        1        
    //       SARAM       0          1        0  
    //       OTP         0          0        1
    //       I/0         0          0        0 
    //
    //    The program must first be compiled and then programmed into the
    //    flash. 
    //
    //
    // DESCRIPTION:
    //
    //    This example runs the ePWM interrupt example from flash. 
    //
    //    1) Build the project
    //    2) Flash the .out file into the device. 
    //    3) Set the hardware jumpers to boot to Flash 
    //    4) Use the included GEL file to load the project, symbols 
    //       defined within the project and the variables into the watch
    //       window.   
    //
    //    Steps that were taken to convert the ePWM example from RAM 
    //    to Flash execution:
    //
    //    - Change the linker cmd file to reflect the flash memory map.
    //    - Make sure any initialized sections are mapped to Flash.  
    //      In SDFlash utility this can be checked by the View->Coff/Hex
    //      status utility. Any section marked as "load" should be
    //      allocated to Flash.
    //    - Make sure there is a branch instruction from the entry to Flash
    //      at 0x3F7FF6 to the beginning of code execution. This example
    //      uses the DSP0x_CodeStartBranch.asm file to accomplish this.
    //    - Set boot mode Jumpers to "boot to Flash"
    //    - For best performance from the flash, modify the waitstates
    //      and enable the flash pipeline as shown in this example.
    //      Note: any code that manipulates the flash waitstate and pipeline
    //      control must be run from RAM. Thus these functions are located
    //      in their own memory section called ramfuncs.
    //
    //
    //    ePwm1 Interrupt will run from RAM and puts the flash into sleep mode
    //    ePwm2 Interrupt will run from RAM and puts the flash into standby mode
    //    ePWM3 Interrupt will run from FLASH
    //
    //    As supplied:
    //
    //    All timers have the same period
    //    The timers are started sync'ed
    //    An interrupt is taken on a zero event for each ePWM timer
    //
    //       ePWM1: takes an interrupt every event
    //       ePWM2: takes an interrupt every 2nd event
    //       ePWM3: takes an interrupt every 3rd event
    //      
    //    Thus the Interrupt count for ePWM1, ePWM4-ePWM6 should be equal
    //    The interrupt count for ePWM2 should be about half that of ePWM1
    //    and the interrupt count for ePWM3 should be about 1/3 that of ePWM1
    //
    //          Watch Variables:
    //                 EPwm1TimerIntCount
    //                 EPwm2TimerIntCount
    //                 EPwm3TimerIntCount
    //
    //                 Toggle GPIO34 while in the background loop. 
    //
    //###########################################################################
    // $TI Release: DSP280x C/C++ Header Files V1.70 $
    // $Release Date: July 27, 2009 $
    //###########################################################################
    
    
    #include "DSP280x_Device.h"     // DSP280x Headerfile Include File
    #include "DSP280x_Examples.h"   // DSP280x Examples Include File
    
    // Configure which ePWM timer interrupts are enabled at the PIE level:
    // 1 = enabled,  0 = disabled
    #define PWM1_INT_ENABLE  1
    #define PWM2_INT_ENABLE  1
    #define PWM3_INT_ENABLE  1
    
    // Configure the period for each timer
    #define PWM1_TIMER_TBPRD   0x1FFF
    #define PWM2_TIMER_TBPRD   0x1FFF
    #define PWM3_TIMER_TBPRD   0x1FFF
    
    // Make this long enough so that we can see an LED toggle
    #define DELAY 1000000L
    
    // Functions that will be run from RAM need to be assigned to 
    // a different section.  This section will then be mapped using
    // the linker cmd file.
    #pragma CODE_SECTION(epwm1_timer_isr, "ramfuncs");
    #pragma CODE_SECTION(epwm2_timer_isr, "ramfuncs");
    
    // Prototype statements for functions found within this file.
    interrupt void epwm1_timer_isr(void);
    interrupt void epwm2_timer_isr(void);
    interrupt void epwm3_timer_isr(void);
    void InitEPwmTimer(void);
    
    // Global variables used in this example
    Uint32  EPwm1TimerIntCount;
    Uint32  EPwm2TimerIntCount;
    Uint32  EPwm3TimerIntCount;
    Uint32  LoopCount;
    
    // These are defined by the linker (see F2808.cmd)
    extern Uint16 RamfuncsLoadStart;
    extern Uint16 RamfuncsLoadEnd;
    extern Uint16 RamfuncsRunStart;
    
    void main(void)
    {
    
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the DSP280x_SysCtrl.c file.
       InitSysCtrl();
    
    // Step 2. Initalize GPIO: 
    // This example function is found in the DSP280x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    // InitGpio();  // Skipped for this example  
    
    
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts 
       DINT;
    
    // Initialize the PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.  
    // This function is found in the DSP280x_PieCtrl.c file.
       InitPieCtrl();
       
    // Disable CPU interrupts and clear all CPU interrupt flags:
       IER = 0x0000;
       IFR = 0x0000;
    
    // Initialize the PIE vector table with pointers to the shell Interrupt 
    // Service Routines (ISR).  
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in DSP280x_DefaultIsr.c.
    // This function is found in DSP280x_PieVect.c.
       InitPieVectTable();
    
    // Interrupts that are used in this example are re-mapped to
    // ISR functions found within this file.  
       EALLOW;  // This is needed to write to EALLOW protected registers
       PieVectTable.EPWM1_INT = &epwm1_timer_isr;
       PieVectTable.EPWM2_INT = &epwm2_timer_isr;
       PieVectTable.EPWM3_INT = &epwm3_timer_isr;
       EDIS;    // This is needed to disable write to EALLOW protected registers
    
    // Step 4. Initialize all the Device Peripherals:
    // This function is found in DSP280x_InitPeripherals.c
    // InitPeripherals();  // Not required for this example
       InitEPwmTimer();    // For this example, only initialize the ePWM Timers
    
    // Step 5. User specific code, enable interrupts:
    
    // Copy time critical code and Flash setup code to RAM
    // This includes the following ISR functions: epwm1_timer_isr(), epwm2_timer_isr()
    // epwm3_timer_isr and and InitFlash();
    // The  RamfuncsLoadStart, RamfuncsLoadEnd, and RamfuncsRunStart
    // symbols are created by the linker. Refer to the F2808.cmd file. 
       MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd, &RamfuncsRunStart);
    
    // Call Flash Initialization to setup flash waitstates
    // This function must reside in RAM
       InitFlash();
    
    // Initalize counters:   
       EPwm1TimerIntCount = 0;
       EPwm2TimerIntCount = 0;
       EPwm3TimerIntCount = 0;
       LoopCount = 0;
       
    // 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 = PWM1_INT_ENABLE;
       PieCtrlRegs.PIEIER3.bit.INTx2 = PWM2_INT_ENABLE;
       PieCtrlRegs.PIEIER3.bit.INTx3 = PWM3_INT_ENABLE;
    
    // Enable global Interrupts and higher priority real-time debug events:
       EINT;   // Enable Global interrupt INTM
       ERTM;   // Enable Global realtime interrupt DBGM
    
    // Step 6. IDLE loop. Just sit and loop forever (optional):
       EALLOW;
       GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;
       GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1;
       EDIS;
       
       for(;;)
       {
           // This loop will be interrupted, so the overall
           // delay between pin toggles will be longer. 
           DELAY_US(DELAY);
    	   LoopCount++;
           GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1;
       }
    
    } 
    
    
    void InitEPwmTimer()
    {
    
       EALLOW;
       SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;      // Stop all the TB clocks
       EDIS;
    
       // Setup Sync
       EPwm1Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;  // Pass through 
       EPwm2Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;  // Pass through
       EPwm3Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;  // Pass through
    
       // Allow each timer to be sync'ed
    
       EPwm1Regs.TBCTL.bit.PHSEN = TB_ENABLE;
       EPwm2Regs.TBCTL.bit.PHSEN = TB_ENABLE;
       EPwm3Regs.TBCTL.bit.PHSEN = TB_ENABLE;
    
       EPwm1Regs.TBPHS.half.TBPHS = 100;
       EPwm2Regs.TBPHS.half.TBPHS = 200;    
       EPwm3Regs.TBPHS.half.TBPHS = 300;        
       
       EPwm1Regs.TBPRD = PWM1_TIMER_TBPRD;
       EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP;    // Count up
       EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;     // Select INT on Zero event
       EPwm1Regs.ETSEL.bit.INTEN = PWM1_INT_ENABLE;  // Enable INT
       EPwm1Regs.ETPS.bit.INTPRD = ET_1ST;           // Generate INT on 1st event
    
       
       EPwm2Regs.TBPRD = PWM2_TIMER_TBPRD;
       EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP;     // Count up
       EPwm2Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;      // Enable INT on Zero event
       EPwm2Regs.ETSEL.bit.INTEN = PWM2_INT_ENABLE;   // Enable INT
       EPwm2Regs.ETPS.bit.INTPRD = ET_2ND;            // Generate INT on 2nd event
    
       
       EPwm3Regs.TBPRD = PWM3_TIMER_TBPRD;
       EPwm3Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP;     // Count up
       EPwm3Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;      // Enable INT on Zero event
       EPwm3Regs.ETSEL.bit.INTEN = PWM3_INT_ENABLE;   // Enable INT
       EPwm3Regs.ETPS.bit.INTPRD = ET_3RD;            // Generate INT on 3rd event
    
       EALLOW;
       SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1;         // Start all the timers synced
       EDIS;
    
    
    }
    
    // This ISR MUST be executed from RAM as it will put the Flash into Sleep
    // Interrupt routines uses in this example:
    interrupt void epwm1_timer_isr(void)
    {
    
       // Put the Flash to sleep
       FlashRegs.FPWR.bit.PWR = FLASH_SLEEP; 
        
       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;
    }
    
    // This ISR MUST be executed from RAM as it will put the Flash into Standby
    interrupt void epwm2_timer_isr(void)
    {
       EPwm2TimerIntCount++;
    
        // Put the Flash into standby
        FlashRegs.FPWR.bit.PWR = FLASH_STANDBY; 
    
       // 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;
    }
    
    interrupt void epwm3_timer_isr(void)
    {
       Uint16 i;
       
       EPwm3TimerIntCount++;
    
        // Short Delay to simulate some ISR Code
        for(i = 1; i < 0x01FF; i++) {}
        
       // Clear INT flag for this timer
       EPwm3Regs.ETCLR.bit.INT = 1;
    
       // Acknowledge this interrupt to receive more interrupts from group 3
       PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
    }
    
    
    
    
    //===========================================================================
    // No more.
    //===========================================================================
    

  • Hi Richard,

    The program was actually configured to build for RAM and not for flash. Sorry for the misinformation. Could you share the project with which you ran the code so that I can also test on my board? Thanks!

    Regards
    Frederic

  • Frederic,

    All I did was replace the main.c file in an F28069 example project with your code. If you download the latest C2000Ware, you can open up the CPU timer example for F28069, replace the main file in that project with the attachment (which is just your code), and it will work on an F28069. 

    I don't think this is going to run on an F2808, though.  If you have a TI example project for that device you should be able to do something similar.  Unfortunately, I'm not able to run F2808 on my machine at the moment.

    Regards,

    Richard

    forum.c
    #include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
    
    
    
    void Init_Timer0(void);
    __interrupt void cpu_timer0_isr(void);
    
    void main()
    {
        // WARNING: Always ensure you call memcpy before running any functions from RAM
        // InitSysCtrl includes a call to a RAM based function and without a call to
        // memcpy first, the processor will go "into the weeds"
           #ifdef _FLASH
                memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
           #endif
    
        // Step 1. Initialize System Control:
        // PLL, WatchDog, enable Peripheral Clocks
           InitSysCtrl();
    
        // Step 2. Initialize GPIO:
    //       InitGpio();
    
        // Step 3. Clear all interrupts and initialize PIE vector table:
        // Disable CPU interrupts
           DINT;
    
        // Initialize PIE control registers to their default state.
        // The default state is all PIE interrupts disabled and flags
        // are cleared.
           InitPieCtrl();
    
        // Disable CPU interrupts and clear all CPU interrupt flags:
           IER = 0x0000;
           IFR = 0x0000;
    
        // Initialize the PIE vector table with pointers to the shell Interrupt
        // Service Routines (ISR).
        // This will populate the entire table, even if the interrupt
        // is not used in this example.  This is useful for debug purposes.
           InitPieVectTable();
    
        // Disable Protection
        EALLOW;  // This is needed to write to EALLOW protected registers
        PieVectTable.TINT0 = &cpu_timer0_isr;
        EDIS;    // This is needed to disable write to EALLOW protected registers
    
        EALLOW;  // This is needed to write to EALLOW protected registers
        GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 0;    // Set as GPIO
        GpioCtrlRegs.GPADIR.bit.GPIO14 = 1;     // GPIO14 is output
        GpioCtrlRegs.GPAPUD.bit.GPIO14 = 1;     // Disable pull-up on GPIO14
        EDIS;    // This is needed to disable write to EALLOW protected registers
    
        Init_Timer0();
    
        for(;;)
        {
            //Run Forever
        }
    }
    
    void Init_Timer0(void)
    {
        InitCpuTimers();                        // Only initialize the Cpu Timers
    
        ConfigCpuTimer(&CpuTimer0, 60, 500000);
    
        CpuTimer0Regs.TCR.all = 0x4001;         // Use write-only instruction to set TSS bit = 0
    
        IER |= M_INT1;
    
        PieCtrlRegs.PIEIER1.bit.INTx7 = 1;      // Enable TINT0 in the PIE: Group 1 interrupt 7
    
        EINT;                                   // Enable Global interrupt INTM
        ERTM;                                   // Enable Global realtime interrupt DBGM
    }
    
    __interrupt void cpu_timer0_isr(void)
    {
       CpuTimer0.InterruptCount++;
    
       GpioDataRegs.GPATOGGLE.bit.GPIO14 = 1;   // Toggle the state of GPIO14
    
       // Acknowledge this interrupt to receive more interrupts from group 1
       PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
    }
    

  • Hi Richard,

    I compared the timer example for F28069 and tested it on my board. The result was the same and the Timer0 did not trigger. I also tired Timer1 and it doesn't seem to function either. I don't know what the issue is now and how to proceed from here on.

    Regards,

    Frederic

  • Frederic,

    I'm not sure either.  How are you testing to know whether the timer is triggering?  All I did was place a break-point on the first line of the ISR (line 87 in your program) and run the code.

    As a sanity check, and since you have an F28069 target, it would be worth running the CPU timer example in C2000Ware.  If you have the most recent C200Ware version installed in the default location, the example is at:

    C:\ti\c2000\C2000Ware_2_00_00_03\device_support\f2806x\examples\c28\cpu_timer

    Could you try that please and let me know?

    Regards,

    Richard

  • Hi Richard,
    I am also testing using breakpoint exactly at the line you mentioned. BTW my target microcontroller is F2808 and not F28069. So, unfortunately, I don't have any C2000Ware examples to test.

    Regards
    Frederic

  • Hi Frederic,

    It's strange because I don't think the issue is in the code you posted. 

    Can you place a break-point at the first instruction after main() - line 26 above - and run the code?  Does it return there?  If so, I'm wondering if the watchdog it timing out before you get to enabling the interrupr.

    If not, run and then stop the code.  It should be in the while loop.  Open a Registers window and check that the timer0 registers have been configured correctly.  They are fine on my machine, I'm just looking for clues.

    Attached is the main file from an older F2808 CPU timer example which isn't being shipped any more.  If all else fails, you might like to try integrating this with your project to see if it works. 

    Regards,

    Richard

    Example_280xCpuTimer.c
    // TI File $Revision: /main/3 $
    // Checkin $Date: July 31, 2009   14:26:06 $
    //###########################################################################
    //
    // FILE:    Example_280xCpuTimer.c
    //
    // TITLE:   DSP280x Device Getting Started Program.
    //
    // ASSUMPTIONS:
    //
    //    This program requires the DSP280x header files.  
    //
    //    Other then boot mode configuration, no other hardware configuration
    //    is required.   
    //
    //
    //    As supplied, this project is configured for "boot to SARAM" 
    //    operation.  The 280x Boot Mode table is shown below.  
    //    For information on configuring the boot mode of an eZdsp, 
    //    please refer to the documentation included with the eZdsp,  
    //
    //       Boot      GPIO18     GPIO29    GPIO34
    //       Mode      SPICLKA    SCITXDA
    //                 SCITXB
    //       -------------------------------------
    //       Flash       1          1        1
    //       SCI-A       1          1        0
    //       SPI-A       1          0        1
    //       I2C-A       1          0        0
    //       ECAN-A      0          1        1        
    //       SARAM       0          1        0  <- "boot to SARAM"
    //       OTP         0          0        1
    //       I/0         0          0        0 
    //
    //
    // DESCRIPTION:
    //
    //    This example configures CPU Timer0 and increments
    //    a counter each time the timer asserts an interrupt.
    //      
    //       Watch Variables:
    //          CpuTimer0.InterruptCount
    //
    //###########################################################################
    // $TI Release: DSP280x C/C++ Header Files V1.70 $
    // $Release Date: July 27, 2009 $
    //###########################################################################
    
    
    #include "DSP280x_Device.h"     // DSP280x Headerfile Include File
    #include "DSP280x_Examples.h"   // DSP280x Examples Include File
    
    // Prototype statements for functions found within this file.
    interrupt void cpu_timer0_isr(void);
    
    void main(void)
    {
    
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the DSP280x_SysCtrl.c file.
       InitSysCtrl();
    
    // Step 2. Initalize GPIO: 
    // This example function is found in the DSP280x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    // InitGpio();  // Skipped for this example  
    
    
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts 
       DINT;
    
    // Initialize the PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.  
    // This function is found in the DSP280x_PieCtrl.c file.
       InitPieCtrl();
       
    // Disable CPU interrupts and clear all CPU interrupt flags:
       IER = 0x0000;
       IFR = 0x0000;
    
    // Initialize the PIE vector table with pointers to the shell Interrupt 
    // Service Routines (ISR).  
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in DSP280x_DefaultIsr.c.
    // This function is found in DSP280x_PieVect.c.
       InitPieVectTable();
    
    // Interrupts that are used in this example are re-mapped to
    // ISR functions found within this file.  
       EALLOW;  // This is needed to write to EALLOW protected registers
       PieVectTable.TINT0 = &cpu_timer0_isr;
       EDIS;    // This is needed to disable write to EALLOW protected registers
    
    // Step 4. Initialize all the Device Peripherals:
    // This function is found in DSP280x_InitPeripherals.c
    // InitPeripherals(); // Not required for this example
       InitCpuTimers();   // For this example, only initialize the Cpu Timers
    
    // Configure CPU-Timer 0 to interrupt every second:
    // 100MHz CPU Freq, 1 second Period (in uSeconds)
       ConfigCpuTimer(&CpuTimer0, 100, 1000000);
       StartCpuTimer0();
    
    // Step 5. User specific code, enable interrupts:
    
    
    // Enable CPU INT1 which is connected to CPU-Timer 0:
       IER |= M_INT1;
    
    // Enable TINT0 in the PIE: Group 1 interrupt 7
       PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
    
    // Enable global Interrupts and higher priority real-time debug events:
       EINT;   // Enable Global interrupt INTM
       ERTM;   // Enable Global realtime interrupt DBGM
    
    // Step 6. IDLE loop. Just sit and loop forever (optional):
       for(;;);
    
    } 
    
    
    interrupt void cpu_timer0_isr(void)
    {
       CpuTimer0.InterruptCount++;
    
       // Acknowledge this interrupt to receive more interrupts from group 1
       PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
    }
    
    //===========================================================================
    // No more.
    //===========================================================================
    

  • Frederic,

    Could you please let us know which target board (TI Experimenter Kit or Spectrum Digital eZdsp) you are using?  Also, please be sure that you are selecting the correct boot mode.  This may be related to your issue.

    I hope this helps. If this answers your question, please click the green "Verified Answer" button. Thanks.

    - Ken

  • Frederic,

    It's been a while since we have heard from you last. Therefore, we are assuming you were able to resolve your issue and this thread will be closed. If this isn’t the case, please reject this resolution or reply to this thread. If this thread locks, please make a new thread describing the current status of your issue. Thank you.

    - Ken