TMS320f2833x External Interrupt

[Julian D. (juliandc)]

Hallo Leute.
Ich versuche zurzeit mithilfe des TI Standartbeispieles "CPUTimer" für 
den 2833x Mikrocontroller einen externen Interrupt zum Laufen zu 
bringen, wobei ich, sobald der Pin 25 eine Pulsflanke sieht, möchte dass 
die variable interruptcounter um einen hoch gezählt wird.
Dafür habe ich zunächst alle möglichen initialisierungen vorgenommen die 
ich mir anhand der drei CPU interrupts und des internets vorstellen 
konnte und am ende eine eigene interrupt funktion implementiert. Jedoch 
funktioniert dies nicht wirklich wenn ich am Evaluationboard den Pin 25 
Mit high oder LOW verbinde (vlt werde ich als nächstes auch noch einen 
schalter mit pullup widerstand einbauen um richtige pulsflanken zu 
erzeugen)
kann mir jemand von euch bei dem Problem helfen, bzw mir sagen was in 
meinem code fehlt?
Grüße,
Julian

Dies ist der code meiner main datei:

//###################################################################### 
#####
// Description
//! \addtogroup f2833x_example_list
//! <h1>Cpu Timer (cpu_timer)</h1>
//!
//! This example configures CPU Timer0, 1, and 2 and increments
//! a counter each time the timers asserts an interrupt.
//!
//! \b Watch \b Variables \n
//! - CputTimer0.InterruptCount
//! - CpuTimer1.InterruptCount
//! - CpuTimer2.InterruptCount
//
//###################################################################### 
#####
// $TI Release: F2833x/F2823x Header Files and Peripheral Examples V140 
$
// $Release Date: March  4, 2015 $
// $Copyright: Copyright (C) 2007-2015 Texas Instruments Incorporated -
//             http://www.ti.com/ ALL RIGHTS RESERVED $
//###################################################################### 
#####

#include "DSP28x_Project.h"     // Device Headerfile and Examples 
Include File

// Prototype statements for functions found within this file.
__interrupt void cpu_timer0_isr(void);
__interrupt void cpu_timer1_isr(void);
__interrupt void cpu_timer2_isr(void);
__interrupt void Pie1_isr(void);

volatile Uint16 interruptcounter = 0;

void main(void)
{
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the DSP2833x_SysCtrl.c file.
   InitSysCtrl();

// Step 2. Initialize GPIO:
// This example function is found in the DSP2833x_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 DSP2833x_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 DSP2833x_DefaultIsr.c.
// This function is found in DSP2833x_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;
   PieVectTable.XINT13 = &cpu_timer1_isr;
   PieVectTable.TINT2 = &cpu_timer2_isr;
   PieVectTable.XINT3 = &Pie1_isr;

   EDIS;    // This is needed to disable write to EALLOW protected 
registers

// Step 4. Initialize the Device Peripheral. This function can be
//         found in DSP2833x_CpuTimers.c
   InitCpuTimers();   // For this example, only initialize the Cpu 
Timers

#if (CPU_FRQ_150MHZ)
// Configure CPU-Timer 0, 1, and 2 to interrupt every second:
// 150MHz CPU Freq, 1 second Period (in uSeconds)

   ConfigCpuTimer(&CpuTimer0, 150, 1000000);
   ConfigCpuTimer(&CpuTimer1, 150, 1000000);
   ConfigCpuTimer(&CpuTimer2, 150, 1000000);
#endif

#if (CPU_FRQ_100MHZ)
// Configure CPU-Timer 0, 1, and 2 to interrupt every second:
// 100MHz CPU Freq, 1 second Period (in uSeconds)

   ConfigCpuTimer(&CpuTimer0, 100, 1000000);
   ConfigCpuTimer(&CpuTimer1, 100, 1000000);
   ConfigCpuTimer(&CpuTimer2, 100, 1000000);
#endif
// To ensure precise timing, use write-only instructions to write to the 
entire register. Therefore, if any
// of the configuration bits are changed in ConfigCpuTimer and 
InitCpuTimers (in DSP2833x_CpuTimers.h), the
// below settings must also be updated.

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

// Step 5. User specific code, enable interrupts:

   GpioCtrlRegs.GPAMUX2.bit.GPIO25 = 0;  // GPIO25 = GPIO25
   GpioCtrlRegs.GPADIR.bit.GPIO25 = 0;   // GPIO25 = input
   GpioIntRegs.GPIOXINT3SEL.all = 25;    // Xint3 connected to GPIO25

// Enable CPU int1 which is connected to CPU-Timer 0, CPU int13
// which is connected to CPU-Timer 1, and CPU int 14, which is connected
// to CPU-Timer 2:
   IER |= M_INT1;
   IER |= M_INT12; //von mir für XINT3 eingefügt da sich dieser in der 
interrupt group 12 befindet
   IER |= M_INT13;
   IER |= M_INT14;

// Enable TINT0 in the PIE: Group 1 interrupt 7
   PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
   PieCtrlRegs.PIEIER12.bit.INTx1 = 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;
}

__interrupt void cpu_timer1_isr(void)
{
   CpuTimer1.InterruptCount++;
   // The CPU acknowledges the interrupt.
   EDIS;
}

__interrupt void cpu_timer2_isr(void)
{  EALLOW;
   CpuTimer2.InterruptCount++;
   // The CPU acknowledges the interrupt.
   EDIS;
}

__interrupt void Pie1_isr(void){
  interruptcounter++;
  PieCtrlRegs.PIEACK.all = PIEACK_GROUP12;
}

//====================================================================== 
=====
// No more.
//====================================================================== 
=====

[Julian D. (juliandc)]

Ich habe noch ein weiteres, kürzeres Codebeispiel versucht, welches ich 
zu interrupts gefunden habe, welches jedoch ebenfalls nicht 
funktioniert:

/*===================================================================
* Description: Initial configuration for
* external interrupt 1 (from GPIO30)
* Parameters: NONE
* Return: NONE
*/
#include "DSP28x_Project.h"

__interrupt void xint1_isr(void);

volatile Uint16 interruptcounter = 0;

void main(void)
{
  InitSysCtrl();
  DINT;
  InitPieCtrl();
  IER = 0x0000;
  IFR = 0x0000;
  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.XINT1 = &xint1_isr;
  EDIS; // This is needed to disable write to EALLOW protected registers
  // Enable Xint1 in the PIE: Group 1 interrupt 4
  // 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
  IER |= M_INT1; // Enable CPU int1

  // GPIO30 is inputs
  EALLOW;
  GpioCtrlRegs.GPAMUX2.bit.GPIO30 = 0; // GPIO
  GpioCtrlRegs.GPADIR.bit.GPIO30 = 0; // Input
  GpioCtrlRegs.GPACTRL.bit.QUALPRD3 = 8; // Qual period = SYSCLKOUT/16
  GpioCtrlRegs.GPAQSEL2.bit.GPIO30 = 1; // Xint1 with 3 samples
  EDIS;

  // GPIO30 is XINT1
  EALLOW;
  GpioIntRegs.GPIOXINT1SEL.bit.GPIOSEL = 30;
  EDIS;

  // Configure XINT1
  XIntruptRegs.XINT1CR.bit.POLARITY = 0; // Falling edge interrupt

  // Enable XINT1
  XIntruptRegs.XINT1CR.bit.ENABLE = 1; // Enable Xint1

  for(;;){

  }
}


__interrupt void xint1_isr(void){
  interruptcounter++;
  PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}

//====================================================================== 
=====
// No more.
//====================================================================== 
=====

[Julian D. (juliandc)]

Edit: Durch ein einfügen von "EINT" nach der Zeile "IER |= M_INT1; // 
Enable CPU int1" habe ich das problem gelöst und der interrupt 
funktioniert