ATmega328: INT0 geht nur, wenn zu Beginn HIGH

[Roman S. (kadege)]

Hallo,
unten ein Programm, das eine Variable von einem SPI-Slave zu einem 
SPI-Master überträgt, beides ATmega328. Auf INT0 liegt ein mittels 
NAND-Gatter gebauter entprellter Schalter, der den Interrupt erfolgreich 
auslöst.
Mein Problem: Das Programm läuft nur, wenn beim Start (Anlegen der Vcc) 
der beiden Controller der Schalter auf HIGH liegt. Liegt er auf LOW, 
kann ich so viel schalten, wie ich will, nichts passiert.
Hat jemand eine Idee?

Vielen Dank im Voraus!
RS

/*
MASTER
INT0 (PD2) Interrupt (beide Flanken) löst die Anforderung einer SPI-Botschaft vom Slave aus
Die jeweils empfangene Zahl wird an LEDS (C1...C4) ausgegeben.
*/

#ifndef F_CPU
  #define F_CPU 16000000                          // Der IC ist mit 16 Mhz getaktet
#endif
#include <avr/io.h>          
#include <avr/interrupt.h> 

int volatile Anz_LEDs_an = 0;
int SS_Pin = PB2;

int main (void) 
  { 
  // LED-Port
  DDRC |= (1 << DDC1) | (1 << DDC2) | (1 << DDC3) | (1 << DDC4);  // C1...C4 auf "Ausgang", LEDs, Rest auf Eingang, wichtig für INT0 (PD2)
  DDRC |= (1 << PC5);                          // PC5 wird nicht gebraucht, kann als Debugpin benutzt werden
  PORTC |= (1 << PC5);                        // Init
  
  sei();                                // Global Interrupts aktivieren  
  EIMSK |= (1 << INT0);                        // Enable INT0
  EICRA |= (1 << ISC00);                        // Any logical change on INT0 generates an interrupt request.
  
  // SPI Init
  // Port B ist immer SPI-Port; PB3 = MOSI, PB5 = SCK, PB2 = SS
  DDRB = (1 << DDB3)|(1 << DDB5)|(1 << DDB2);            // Set MOSI, SS and SCK output, all others input
  SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0);            // Enable SPI, Master, set clock rate fck/16 = 1 MHz, enable SPI Interrupt  

  PORTB |= (1 << SS_Pin);                        // SS auf HIGH, Slave wird nicht angesprochen
  while(1) 
     {
     }                      
  /* wird nie erreicht */
  return 0;   
  }              
  
#ifndef INT0_vect
#endif

ISR (INT0_vect)
  {
  PORTC ^= (1 << PC5);                        // Invertieren für Debuggen
  PORTB &= ~(1 << SS_Pin);                      // SS auf LOW, Slave ansprechen
  SPDR = 0x0F;                            // irgendwas schreiben, um Übertragung zu starten
  while(!(SPSR & (1 << SPIF)))                    // warten, bis Übertragung fertig
  ;
  Anz_LEDs_an = SPDR;                         // Übertragene Daten auslesen
  
  PORTC &= ~(1 << PC1);
  PORTC &= ~(1 << PC2);
  PORTC &= ~(1 << PC3);
  PORTC &= ~(1 << PC4);
  PORTC |= ((Anz_LEDs_an & 0x01)<< 1) | ((Anz_LEDs_an & 0x02)<< 1) | ((Anz_LEDs_an & 0x04)<< 1) | ((Anz_LEDs_an & 0x08)<< 1);
  
  PORTB |= (1 << SS_Pin);                        // SS auf HIGH, Slave wird nicht angesprochen
  }

[Karl H. (kbuchegg)]

  sei();                                // Global Interrupts aktivieren  
  EIMSK |= (1 << INT0);                        // Enable INT0
  EICRA |= (1 << ISC00);                        // Any logical change on INT0 generates an interrupt request.

es ist keine so gute Idee, die Interrupts generell frei zu geben, noch 
ehe alles fertig konfiguriert ist.

Das sei() kommt ganz zum SChluss, wenn alles fertig eingestellt ist, 
unmittelbar vor der Hauptschleife in main().

Denn ansonsten kann es dir passieren, dass mit dem sei() schon die 
ersten Interrupts zu feuern beginnen. Was bei dir natürlich ganz 
besonders schlecht ist, wenn der µC gleich mal in die INT0-ISR geht, in 
der du über SPI etwas auszugeben versuchst, wobei das SPI zu diesem 
Zeitpunkt noch gar nicht konfiguriert ist.

Da kann dann deine Warteschleife auf das SPIF lange warten, ehe sich da 
mal was tut.

[Roman S. (kadege)]

Hallo Karl-Heinz,

> Das sei() kommt ganz zum SChluss, wenn alles fertig eingestellt ist,
> unmittelbar vor der Hauptschleife in main().

Mit

  PORTB |= (1 << SS_Pin);                        // SS auf HIGH, Slave wird nicht angesprochen
  sei();

(Rest unverändert) geht es. Vielen Dank für die schnelle Antwort!