Probleme mit dem isr(int0_vect)

[Tuji de Assis M. (tujideassis_m)]

Hallo Leute,

ich steh hier leider vor einem Problem.

ISR (INT0_vect)
{

  setLedMode(15,true);

}

Ich wollte eigentlich das bei einem Interrupt eine Led immer 
eingeschaltet wird.

Mein Problem ist gerade, dass der Interrupt immer ausgelöst wird, sobald 
mein µC geflasht worden ist mit meinem neuen Programm.

Es liegt immer 5 V an und bei einem Interrupt fällt die Flanke auf 0 V.
(ich denke daran liegt der fehler).

Hier ist die Doku für die Lichtschranke:
http://www.produktinfo.conrad.com/datenblaetter/125000-149999/140268-da-01-en-IR_SENSOR_APDS_9102_L22.pdf

und es handelt sich um ein ATMEGA88.


Danke im Vorraus!

[Gerald G. (gerald_g)]

Zeige mal die Initialisierung deines Programms

[Tuji de Assis M. (tujideassis_m)]

//TIMSK0 |= (1 << TOIE0);
  //TCCR0B |= (1<<CS00 | 0<<CS01 | 0<<CS02);
  // Port B auf Ausgang setzen
  DDRB = 0xff;
  // Port C auf Ausgang setzen
  DDRC  = 0xff;
  // Port D auf Ausgang setzen
  DDRD = 0xff;
  // Lichtschranke PD2 auf Eingang
  DDRD = DDRD & ~(1<<PD2);

  // LEDs auf den Ports ausschalten
  PORTB = 0xff;
  PORTC = 0xff;
  PORTD = 0xff;
  
  EIMSK |= _BV(INT0);    // PD2 = INT0 enablen
  EICRA |= _BV(ISC01);  // Triggern auf fallende Flanke des INT0

  //Timer1 fuer die Umlaeufe konfigurieren
  TCCR1B = (1 << CS10) | (1 << CS21) ;  //kein Prescaler
  TIMSK1 = (1 << TOIE1) | (1 << OCIE1A) ;
  
  TIMSK2 |= (1 << TOIE2);
  TCCR2B |= (1<<CS20 | 0<<CS21 | 0<<CS22);

  // Timer0 fuer die Stundenanzahl konfigurieren
  // CompareMatchInterupt ausloesen
  // Timer0 fuer die Uhrzeiten-Logik und Overflow fuer Timer0
  TIMSK0 = _BV(OCIE0A) | _BV(TOIE0);  // Enable Interrupt TimerCounter0 Compare Match A (SIG_OUTPUT_COMPARE0A)
  TCCR0A = _BV(WGM01);        // Mode = CTC
  TCCR0B = _BV(CS02) | _BV(CS00);    // Clock/1024, 0.001024 seconds per tick
  OCR0A = 244;            // 0.001024*244 ~= .25 SIG_OUTPUT_COMPARE0A will be triggered 4 times per second.
  
  // Das Makro sei() schaltet alle Interrupts ein.
  sei();

[Thomas K. (thomas_k39)]

Tuji de Assis Moreira schrieb:
> // Port D auf Ausgang setzen
>   DDRD = 0xff;
>   // Lichtschranke PD2 auf Eingang
>   DDRD = DDRD & ~(1<<PD2);

Diese Initialisierung produziert einen kurzen Low-Impuls auf PD2 und 
triggert damit den INT0!

Wieso den Port D nicht gleich richtig initalisieren?

  DDRD = 0xff & ~(1<<PD2);

[Thorsten S. (thosch)]

Unabhängig von dem ISR-Problem: Mach mal Deine Schaltung heil!

AVCC muß an VCC angeschlossen werden (und mit 100nF gegen GND 
geblockt), auch dann, wenn der A/D-Wandler nicht benutzt wird.
Der Pin versorgt nämlich nicht nur den A/D-Wandler,
sondern auch PORT C (PC0..PC3).

(siehe Datenblatt, Seite 6)

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Es ist auch eine gute Idee, vor der Freigabe des Interruptes etwaige 
anstehende Anforderungen zu löschen:

EIFR = (1<<INTF0);

[Tuji de Assis M. (tujideassis_m)]

Port C wird für die RGB LED´s verwendet.(Charlie-Plexing)

Hat das was mit der Lichtschranke zu tun?

[Tuji de Assis M. (tujideassis_m)]

Matthias Sch. schrieb:
> Es ist auch eine gute Idee, vor der Freigabe des Interruptes
> etwaige
> anstehende Anforderungen zu löschen:EIFR = (1<<INTF0);


Habe es versucht und trotzdem, funktioniert es nicht.

[Tuji de Assis M. (tujideassis_m)]

Hat niemand eine Ahnung ?
oder überhaupt, an was es liegen könnte, warum der interrupt immer 
ausgelöst wird?

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:
> Hat niemand eine Ahnung ?
> oder überhaupt, an was es liegen könnte, warum der interrupt immer
> ausgelöst wird?

Weil die Erkennungslogik nicht riechen kann, ob die Bedingung zur 
Registreierung eines Interrupts jetzt deswegen eingetreten ist, weil 
sich am Eingang tatsächlich eine Flanke ereignet hat, oder ob diese 
Flanke 'pseudo-mässig' dadurch enstanden ist, dass du die 
Auswertebedingungen während der Intialisierungsphase des Programms 
geändert hast.

Nachdem alles fertig konfiguriert ist, lösche eventuell aufgelaufene 
'falsche und unerwünschte' Interrupt Anforderungen ehe du mit sei() 
alles für den tatsächlichen Betrieb freigibst und gut ists.
Das ist weder anrüchig noch schlechte Praxis.

Hinweis: derartige Interrupt-Registrierungsflags werden durch 
Einschreiben eines 1-Bits an der entsprechenden Bitposition ins 
entsprechende Register gelöscht.

[Tuji de Assis M. (tujideassis_m)]

Karl Heinz schrieb:
> Weil die Erkennungslogik nicht riechen kann, ob die Bedingung zur
> Registreierung eines Interrupts jetzt deswegen eingetreten ist, weil
> sich am Eingang tatsächlich eine Flanke ereignet hat, oder ob diese
> Flanke 'pseudo-mässig' dadurch enstanden ist, dass du die
> Auswertebedingungen während der Intialisierungsphase des Programms
> geändert hast.

Ich hab versucht es zurückzusetzen.
Iwie funktioniert es aber nicht, vllt habe ich es nur falsch gemacht:
GIFR = (1<<INF1);
EIFR = (1<<INTF0);


Habe ich das was falsches gemacht?
Wie heißt den der Code zum zurück setzen?

[spess53 (Gast)]

Hi

>und es handelt sich um ein ATMEGA88.

>GIFR = (1<<INF1);

Wo hat der ATMEga88 ein GIF-Register?

MfG Spess

[Stefan P. (form)]

Was macht denn setLedMode(15,true); ?

[Tuji de Assis M. (tujideassis_m)]

Stefan P. schrieb:
> Was macht denn setLedMode(15,true); ?

Ich hab auf meiner Platine 16 LED´s.
Wenn diese methode aufgerufen wird, wird die LED eingeschalten.
Das Problem bei der ganzen Sache ist, dass der immer anbleibt(ist ja 
auch richtig).

Aber wenn ich in meiner Main dann sage, schalte die LED wieder aus, 
leuchtet die LED auf und wieder zu, die ganze zeit.

Darum denke ich, dass diese ISR(INT0_vect) immer wieder aufgerufen wird, 
obwohl kein externer Interrupt geschieht.

[Tuji de Assis M. (tujideassis_m)]

spess53 schrieb:
> Wo hat der ATMEga88 ein GIF-Register?
>
> MfG Spess

Muss ehrlich zugeben, dass ich noch ein newbie bin.
Ich kenne mich halt nicht perfekt aus, suche mir gerade alles ausm 
Internet zusammen.
Versuche aber auf über den µController zu lernen.
Aber es tut sich einfach nicht.

[Tuji de Assis M. (tujideassis_m)]

Kann es vielleicht sein, dass ich diese Register setzen muss:

GICR|=0x40;
MCUCR=0x02;

Ich bin mir halt nicht sicher.

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:

> Darum denke ich, dass diese ISR(INT0_vect) immer wieder aufgerufen wird,
> obwohl kein externer Interrupt geschieht.

Zeig doch mal dein ganzes Programm.
Immer diese Ratespielchen von wegen: ich denke, das das und das 
passiert.


Unabhängig davon: wenn man den Verdacht hat, dass eine bestimmte 
Komponente ein Problem verursacht, dann ist es auch kein Beinbruch sich 
erst mal ein Testprogramm zu machen, welches nur und ausschliesslich 
diese Komponente testet.
In deinem Fall willst du wissen, ob der externe Interrupt korrekt 
funktioniert. Dazu braucht es keinen Timer oder sonstiges Zeugs. Einfach 
nur dir Lichtschranke und die LED um das Ansprechen der Lichtschranke 
anzuzeigen. Mehr braucht es dazu nicht. Dann läuft man auch nicht 
Gefahr, dass man sich mit all den anderen Zusatzteilen im Programm 
irgendwo einen Bock geschossen hat, den man selbst nicht mehr findet. 
Bei der Fehlersuche bzw. wenn man erst mal ratlos ist, ist die 
Konzentration aufs Wesentliche der erste wichtige Punkt. Alles was 
nichts mit diesem Wesentlichen zu tun hat, fliegt erst mal raus.

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:
> Kann es vielleicht sein, dass ich diese Register setzen muss:
>
> GICR|=0x40;
> MCUCR=0x02;
>
> Ich bin mir halt nicht sicher.


Das weiß ich nicht, weil ich eine Abneigung dagegen habe, einzelne BIts 
(die eine Bedeutung haben, die sich in ihrem Namen wiederspiegelt) per 
Hex-Zahl zu setzen.

Die Bits haben Namen. Atmel hat dir diese Namen zur Verfügung gestellt. 
Benutzte sie auch!
Immer dieses Hex-Zahl mit dem Datenblatt auseinanderpfriemeln. Da 
scrollt man sich doch regelmässig einen Tennisarm beim Nachverfolgen im 
PDF.

[Tuji de Assis M. (tujideassis_m)]

Am besten  wäre es wenn sie das komplette Projekt mit Atmel Studio 
öffnen.

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:

> Darum denke ich, dass diese ISR(INT0_vect) immer wieder aufgerufen wird,
> obwohl kein externer Interrupt geschieht.


IN deinem Eröffnungsposting klingt das alles aber nocht ganz anders

> Mein Problem ist gerade, dass der Interrupt immer ausgelöst wird,
> sobald mein µC geflasht worden ist mit meinem neuen Programm.

da ist vom Einspielen eines neuen Programms die Rede.

Was denn nun?

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:
> Am besten  wäre es wenn sie das komplette Projekt mit Atmel Studio
> öffnen.

Nö. Sorry. Aber das tu ich mir nicht an.

Entweder du reduzierst dein Programm auf einen einfachen Fall
* lichtschranke + 1 LED
oder du musst dir den Fehler selbst suchen

[Tuji de Assis M. (tujideassis_m)]

Das ist immer noch das alte Programm. Mit kleinen Veränderungen die mir 
hier vorgeschlagen worden ist.

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:
> Das ist immer noch das alte Programm. Mit kleinen Veränderungen die mir
> hier vorgeschlagen worden ist.

Ja. Aber ich analysiere jetzt nicht 30 Minuten lang, was da im Programm 
alles abgeht und welche Querverflechtungen für welchen Effekt 
verantwortlich sein könnten, wenn ein simples

#include <avr/io.>
#include <util/delay.h>

int main()
{
  DDRC = 0xFF;

  EIMSK |= _BV(INT0);    // PD2 = INT0 enablen
  EICRA |= _BV(ISC01);   // Triggern auf fallende Flanke des INT0
  PORTD |= _BV(PD2);

  while( 1 ) {
    PORTC |= _BV( PC0 );
    _delay_ms( 1000 );
  }
}

ISR (INT0_vect)
{
  PORTC &= ~ _BV( PC0 );
}

... auch ausreichend ist, um die Funktion des externen Interrupts für 
sich alleine zu testen.


Und bei sowas

ISR (INT0_vect)
{
  turnOffLeds();
  _delay_ms(5000);
....

fangen bei mir sowieso alle Alarmglocken zu klingeln an.

[Tuji de Assis M. (tujideassis_m)]

Karl Heinz schrieb:
> Nö. Sorry. Aber das tu ich mir nicht an.
>
> Entweder du reduzierst dein Programm auf einen einfachen Fall
> * lichtschranke + 1 LED
> oder du musst dir den Fehler selbst suchen

int main (void)
{
  init();
  
  
  
}

/************************************************************************/
/* Initialisierungsmethode                                              */
/************************************************************************/
void init() {
  board_init();
  resetRegisters();  
  // Port D auf Ausgang setzen
  DDRD = 0xff;
  // Lichtschranke PD2 auf Eingang
  DDRD = DDRD & ~(1<<PD2);

  // LEDs auf den Ports ausschalten

  PORTD = 0xff;
  
  EIMSK |= _BV(INT0);    // PD2 = INT0 enablen
  EICRA |= _BV(ISC01);  // Triggern auf fallende Flanke des INT0




  // Das Makro sei() schaltet die Interrupts ein.
  sei();
}

void resetRegisters() {
  // Port D auf Ausgang setzen
  DDRD = 0b11100111;
  // Lichtschranke PD2 auf Eingang
  DDRD = DDRD & ~(1<<PD2);
  
  DDRC = 0x00;
  PORTC = 0x00;
  PORTD = 0x00;
}
/************************************************************************/
/*  Lichtschranken-Interrupt                                            */
/*  Hier Timer starten für Counter der Umläufe und der Geschwindigkeit. */
/************************************************************************/
ISR (INT0_vect)
{
  turnOffLeds();
  _delay_ms(5000);
}

[spess53 (Gast)]

Hi

>Kann es vielleicht sein, dass ich diese Register setzen muss:
>GICR|=0x40;
>MCUCR=0x02;

>Ich bin mir halt nicht sicher.

Welchen Controller setzt du nun wirklich ein?

MCUCR/GICR/GIFR gehören zum ATMega8. Beim ATMega88 heißen die 
richtigen Register EICRA, EIMSK und EIFR.

Könnte es sein, das du dein Programm für einen ATMega8 compilierst?

MfG Spess

[Karl H. (kbuchegg)]

Tuji de Assis Moreira schrieb:

>

> int main (void)
> {
>   init();
> 
> 
> 
> }
>

schon besser.
Aber da fehlt die obligate Hauptschleife.
Ohne Hauptschleife läuft das Programm aus main() raus zurück in die 
C-Runtime. Und die hat als erstes nichts besseres zu tun, als alle 
Interrupts mittels eines cli() abzuschalten.
Daher braucht JEDES Programm eine Hauptschleife. Selbst wenn die leer 
ist. Du willst das Programm aus main() nie wieder rauslassen.

int main (void)
{
  init();

  while( 1 )
    ;
}

[Tuji de Assis M. (tujideassis_m)]

Ich verwende einen ATMEGA 88 und kompelieren tu ich das auch für einen 
ATMEGA 88.

[Tuji de Assis M. (tujideassis_m)]

Karl Heinz schrieb:
> #include <avr/io.>
> #include <util/delay.h>
>
> int main()
> {
>   DDRC = 0xFF;
>
>   EIMSK |= _BV(INT0);    // PD2 = INT0 enablen
>   EICRA |= _BV(ISC01);   // Triggern auf fallende Flanke des INT0
>   PORTD |= _BV(PD2);
>
>   while( 1 ) {
>     PORTC |= _BV( PC0 );
>     _delay_ms( 1000 );
>   }
> }
>
> ISR (INT0_vect)
> {
>   PORTC &= ~ _BV( PC0 );
> }


Was machen Sie da im Interrupt ?
Weil bei mir 2 Led´s aufleuchten.