F2812-Illegal operation TRAP

Dear,

I'm facing the same problem you get. Do you have any solution for this? Can you give me some suggestion to nguyen.kirk.die@gmail.com

Best regards,

That's an illegal instruction trap.  The CPU tried to execute 0x0000 or 0xFFFF.  As part of the instruction trap the offending address was pushed to the stack.  You should be able to inspect the stack to figure out where the trap occurred.  That will hopefully give a clue as to what happened (e.g. code branched to a bad address and tried to execute from erased flash, perhaps code went bad and wiped out part of memory, etc.).

Dear,
I  have faced the same problem you get.

Finaily,

In external memory, we can excute a program

   1. Init XINTF
   2. Copy a flash memory to a external memory
   3. Call Function in external memory

  So easy

Have nioce day!

#pragma CODE_SECTION(Loop_main, "ramfuncs");  // ram -> flash changuage
#pragma CODE_SECTION(RTC_byte_read, "ramfuncs");
#pragma CODE_SECTION(RTC_read, "ramfuncs");
#pragma CODE_SECTION(cpu_timer0_isr, "ramfuncs");
#pragma CODE_SECTION(scia_rx_isr, "ramfuncs");
#pragma CODE_SECTION(scia_tx_isr, "ramfuncs");
#pragma CODE_SECTION(scib_rx_isr, "ramfuncs");
#pragma CODE_SECTION(scib_tx_isr, "ramfuncs");

.
.
.

void main(void)
{
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the DSP281x_SysCtrl.c file.
 //1.1 using Flash mode setting;
 Uint32 i;
 InitSysCtrl();

 //

// memcpy_a( &RamfuncsRunStart,&RamfuncsLoadStart,&RamfuncsLoadEnd);

 InitFlash();

// Step 2. Initalize GPIO:
// This example function is found in the DSP281x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
 Gpio_setup();

// 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 DSP281x_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 DSP281x_DefaultIsr.c.
// This function is found in DSP281x_PieVect.c.
 InitPieVectTable();

 EALLOW;  
 // Peripheral clock enables set for the selected peripherals.  
 SysCtrlRegs.PCLKCR.bit.EVAENCLK=0; // 1 = on, 0 = off
 SysCtrlRegs.PCLKCR.bit.EVBENCLK=0;
 SysCtrlRegs.PCLKCR.bit.SCIAENCLK=1;
 SysCtrlRegs.PCLKCR.bit.SCIBENCLK=1;
 SysCtrlRegs.PCLKCR.bit.MCBSPENCLK=0;
 SysCtrlRegs.PCLKCR.bit.SPIENCLK=1;
 SysCtrlRegs.PCLKCR.bit.ECANENCLK=0;
 SysCtrlRegs.PCLKCR.bit.ADCENCLK=0;
 EDIS;

// 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; // for TINT0
 PieVectTable.XINT1 = &xint1_isr;  // for XINT1
 PieVectTable.RXAINT = &scia_rx_isr;  // for RXA
 PieVectTable.TXAINT = &scia_tx_isr;  // for TXA
 PieVectTable.RXBINT = &scib_rx_isr;  // for RXB
 PieVectTable.TXBINT = &scib_tx_isr;  // for TXB
// PieVectTable.ECAN0INTA = &eCAN0INT_ISR;
// PieVectTable.ECAN1INTA = &eCAN1INT_ISR;
 
 EDIS;    // This is needed to disable write to EALLOW protected registers

// Step 4. Initialize all the Device Peripherals:
// This function is found in DSP281x_InitPeripherals.c
 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, 150, 100); // 100 us = 100, 1 ms = 1000 us = 1000
 StartCpuTimer0();
 if((Input_SW() & 0x80) == 0x80)
 {
  Initsci(BRRa_VAL,BRRb_VAL);
 }
 else
 {
  Initsci(BRRa_VAL,BRRb_VAL_Setup);
 }
 memcpy( &RamfuncsRunStart,
   &RamfuncsLoadStart,
   &RamfuncsLoadEnd - &RamfuncsLoadStart);

// Step 5. User specific code, enable interrupts:
// RTC_setting(); // subroutine for current date & time setting
 RTC_byte_write(0x000A, 0x0020);  // RTC ACTIVE
 RTC_byte_write(0x000B, 0x0002);  // RTC ACTIVE

// Enable CPU INT1 which is connected to CPU-Timer 0:
 IER |= M_INT1;  // for TINT0, XINT1, XINT2
 IER |= M_INT9;  // for SCI-A, SCI-B

// Enable TINT0 in the PIE: Group 1 interrupt 7
 PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
 PieCtrlRegs.PIEIER1.bit.INTx4 = 1;
 PieCtrlRegs.PIEIER9.bit.INTx1 = 1; // SCI-A rx int
 PieCtrlRegs.PIEIER9.bit.INTx2 = 1; // SCI-A tx int
 PieCtrlRegs.PIEIER9.bit.INTx3 = 1; // SCI-B rx int
 PieCtrlRegs.PIEIER9.bit.INTx4 = 1; // SCI-B tx int

 XIntruptRegs.XINT1CR.bit.POLARITY = 0; // 0 = falling, 1 = rising
 XIntruptRegs.XINT1CR.bit.ENABLE = 1; // 1 = 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):

 for(i=0;i<1000000;i++) asm("IDLE");

 Loop_main();

 
}

void Loop_main()
{
.
.
}

Lin,

It is possible that your stack is overwriting on the program memory during the execution of the code. The program memory is getting corrputed with 0x0000 (or) 0xFFFF. With some debug effort you should be able to check at which addresses the program memory is getting corrected and should be able to move around the stack from the program memory locations.

So, effectively you need to change the stack size and linker command file.

Regards,

Manoj

Dear,

I think that U don't modify the ILLEGAL_ISR.

Only  U need  to modify cmd file  and main function code

1. Modify cmd file :  Internal RAM and External RAM

// for external RAM  

ramfuncs            : LOAD = FLASH_ABCDEFGHIJ, PAGE = 0
                         RUN = ZONE6, PAGE = 0
                         LOAD_START(_RamfuncsLoadStart),
                         LOAD_END(_RamfuncsLoadEnd),
                         RUN_START(_RamfuncsRunStart)

// to excute a program setting  XINTF and internal Flash ROM  in internal RAM

InterRamfuncs         : LOAD = FLASH_ABCDEFGHIJ, PAGE = 0
                         RUN = H0SARAM, PAGE = 0
                         LOAD_START(_InterRamfuncssLoadStart),
                         LOAD_END(_InterRamfuncsLoadEnd),
                         RUN_START(_InterRamfuncsRunStart)

2. Modify main function

a) CODE_SECTION

#pragma CODE_SECTION(Loop_main, "ramfuncs");  // flash changuage==>  extrernal ram

#pragma CODE_SECTION(InitXintf, "InterRamfuncs"); // flash changuage==>  intrernal ram, Because this must be excuted in internal ram

#pragma CODE_SECTION(InitXintf, "InterRamfuncs");//flash changuage==>  intrernal ram, Because this must beexcuted in internal ram

b) InitSysCtrl();

c)   Gpio_setup();

d) Interrupt disable

e)         DINT;

        InitPieCtrl();

        IER = 0x0000;
        IFR = 0x0000;.
        InitPieVectTable();

f) Copy  InterRamfuncs to internal RAM

      MemCopy(&InterRamfuncssLoadStart,&InterRamfuncsLoadEnd,&InterRamfuncsRunStart);

g) Configurate flash and XTINF

         InitXintf();
        InitFlash();

h) Copy  ramfuncs  to external RAM

g) Setting interrupt

..

h) Call "Loop_main()"

Have a nice day! 

 If U want , I can send U my program

e-mail:dukhyung.um@doosan.com