Interrupt +ATMEGA32

Hallo

Ich arbeite gerade mit einem ATMEGA 32 und versuche über INT2 einen 
Hardware Interrupt auszulösen. Irgendwie wird aber nicht in die 
Interrupt Routine gesprungen. Sprich der Hardware Interrupt wird nicht 
ausgelöst. Hier mal mein Code.

#include <avr/io.h>

#include <compat/twi.h>

#include <util/delay.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>
#include <stdlib.h>
#include <avr/interrupt.h>


#include "USART.h"
#include "USART.c"

#include "i2cdevices.h"
#include "i2cdevices.c"

#include "i2cmaster.h"
#include "twimaster.c"

#include "BiT.h"
#include "BiT.c"

#include "Timer.h"
#include "Timer.c"

#include "PORT80.h"
#include "PORT80.c"

#include "Temperatur.h"
#include "Temperatur.c"



#define LED_RT_ON 0
#define LED_GN_ON 1
#define LED_RT_BLINK 2
#define LED_GN_BLINK 3

/* in PORT80.c definiert
unsigned char port_80_[100];
unsigned char port_80_read_pointer_ = 0;
unsigned char port_80_write_pointer_ = 0;
*/

//void pb_reset(void);


int main(void)
{
/******************************************************* I/O 
***********************************************************/
//LED BIT - HEAT Output

PORTC |= (1<<PORTC7) | (1<<PORTC6) | (1<<PORTC5) | (PORTC4);
  DDRC = 0x00;


//---------------------
//HEAT-FAN Output
PORTD |= (1<<DDD7) | (1<<DDD6);
DDRD |= (1<<PORTD7) | (1<<PORTD6);
//---------------------
//RESET-OUT

//---------------------------------------------------------------------- 
-------------------------------------------------


/*************************************************** Variabeln 
*********************************************************/
  unsigned char port_80_temp = 0;    //In diese Variable werden die 
Werte aus dem Array geschrieben
//  unsigned char led_merker_sc = ( 1<<LED_RT_BLINK); //4    // Bit 0 
rt, Bit 1 gn, Bit 2 rt-blink, , Bit 3 gn-blink
//  unsigned char led_merker_sp = 0x04;
//---------------------------------------------------------------------- 
-------------------------------------------------


//************************************************** Initialisierungs 
Routinen ******************************************
//DDRC |= 0x80;
//PORTC &= ~0x81;


  port80Init();
  initInterrupt2();    // PORT80
  initTimer1();
  SREG |= 0x80;
  i2c_init();        // I2C Bus initialisieren

  time_counter_[0] = 1;        // Timer benutzt LM92
  time_counter_[1] = 2;        // Timer benutzt für LED blinken
  time_counter_[2] = 301;        // Timer für PORT80 Time Out
  time_counter_[3] = 10;        // Timer für SC Reset beim Start für 
Delay
  time_counter_[5] = 8;
  time_counter_[6] = 21;        // Clr für NMEA EVT

  while(time_counter_[3] > 1){;}
  time_counter_[3] = 0;        // Timer für SC Reset
//---------------------------------------------------------------------- 
-----------------------------------------------------------------
//port_80_temp = 0xE7;
while(1)
{


// if port 80 dann rt-blink aus ELSE rt-blink on
    if(port_80_read_pointer_ != port_80_write_pointer_)
    {
      port_80_temp = port_80_[port_80_read_pointer_];
      port_80_read_pointer_++;
      if(port_80_read_pointer_ >= sizeof(port_80_)) 
port_80_read_pointer_ = 0;
      if (port_80_temp == 0xE7) //normal 0xC0
      {
        //PORTC &= ~(1<<PORTC7);
      }

    }
    if(port_80_temp == 0x80) time_counter_[2] = 301;
    if(time_counter_[2] <= 1)        // PORT 80 Test
    {
      if(port_80_temp != 0xC0)
      {
      //  led_merker_sc = (1<<LED_RT_ON);  // Rote LED vom sc teil 
schalten wenn wenn 0xc0 nicht kommt
      //  nmea_port_status_ = 0;


      }
      else
      {
      //  nmea_port_status_ = 1;
      }
    }
//      notloeschen();
    if(time_counter_[5] <= 1)
    {
      //sendNmea(NMEA_STA,NMEA_DUMMY,NMEA_DUMMY);
      time_counter_[5] = 100;
    }
//pb_reset();




}  //Endlosschleife

}  //Programmende

/*
void pb_reset(void)
{

  if(bit_is_clear(PIND, PIND3) )
  {

    PORTC &= ~(1<<PORTC6) ;


    PORTD |= (1<<PORTD1) ;
    PORTD &= ~(1<<PORTD1) ;
  }
  else{
      PORTC |= (1<<PORTC6) ;
      PORTD |= (1<<PORTD1);
    }
}//ende pb_reset */




SIGNAL  (INT2_vect)
{
  PORTC &= ~(1<<PORTC7) | (1<<PORTC6) | (1<<PORTC5) | (PORTC4);
  DDRC = 0xF0;
  PORTC &= ~(1<<PORTC7);



  PORTC &= ~(1<<PORTC7);
  port_80_temp_ = PINA;
  port_80_[port_80_write_pointer_] = port_80_temp_;
  port_80_write_pointer_++;
  if(port_80_write_pointer_ >= sizeof(port_80_)) port_80_write_pointer_ 
= 0;
  if(port_80_write_pointer_ == port_80_read_pointer_)
  {
    port_80_write_pointer_--;
    if(port_80_write_pointer_ >= 255) port_80_write_pointer_ = 
sizeof(port_80_)-1;
  }

}


meine Initialisierung Routine sieht so aus:

//Interrupt Routine for PORT80



unsigned char port_80_[100];
unsigned char port_80_read_pointer_ = 0;
unsigned char port_80_write_pointer_ = 0;


void port80Init(void)
{
    // Eingänge für PORT80
//  DDRA = 0x00;     /*Daten Richtungs Register für PORTA setzen*/
//  PORTA |= (1<<PORTA0) | (1<<PORTA1) | (1<<PORTA2) | (1<<PORTA3)
//  | (1<<PORTA4) | (1<<PORTA5) | (1<<PORTA6) | (1<<PORTA7);    /*Leds 
ausschalten*/
}



void initInterrupt2(void)    //Interrupt für PORT80 INT2 am ATMEGA32
{
  // port_80_write_pointer_ auf 0 setzen
  port_80_write_pointer_ = 0;

  // port_80_read_pointer_ auf 0 setzten
  port_80_read_pointer_ = 0;

  // MCUCSR muss nicht eingestellt werden da Bit6 (ISC2) schon auf 0 
steht. 0 fallende Flanke löst Interrupt aus.
  MCUCSR |= (1<<ISC10) | (1<<ISC11);

//  Externen Interrupt 2 aktivieren
  GICR |= (1<<INT2);


  MCUCSR |= (1 << ISC2);
   GICR  |= (1 << INT2);  //INT2 enable
}
Ich würde mich freuen wenn mir irgend jemand helfen könnte da ich 
absolut nicht weiter komme. Habe auch schon versucht, durch anlegen von 
5V auf der Interrupt leitung einen Interrupt auszölösen aber das bringt 
auch nichts.

Griß Gizmo