LED blinkt während Programmablauf

Daniel V. schrieb:
> Cuadrado schrieb:
>> Ist so etwas möglich? Ich habe in der Anleitung folgenden Quellcode
>> gefunden, hierbei blinkt zwar immer meine LED, aber das Hauptprogramm
>> lässt sich nicht mehr ausführen.
>
> Hast du das schon ausprobiert, oder ist das eine Vermutung?

Ja, wie wurde das getestet? Dein Hauptprogramm ist leer und somit 
passiert dort auch nicht viel

Also, während in der ISR eine LED immer blinkt, soll im Hauptprogramm 
einfach mal eine andere LED etwas schneller blinken. Dieses Programm 
habe ich ausprobiert. Die ISR LED hat funktioniert, an PD1 lagen aber 
immer +5V an.

#define F_CPU 1000000UL

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

int main(void)
{

  DDRD = 0xFF;

  // Timer 0 konfigurieren
  TCCR0 = (1<<CS01); // Prescaler 8
  // Overflow Interrupt erlauben
  TIMSK |= (1<<TOIE0);
  // Global Interrupts aktivieren
  sei();

  while(1)
  {

  PORTD |= (1<<PD1);
  _delay_ms(100);
  PORTD &= ~(1<<PD1);
  _delay_ms(100);

  }
}


ISR (TIMER0_OVF_vect)
{
PORTD |= (1<<PD0);
_delay_ms(500);
PORTD &= ~(1<<PD0);
_delay_ms(500);

}

Kann ich mir gut vorstellen, der ist ja in der ISR ausschließlich mit 
Warten beschäftigt und kommt gar nicht zum Hauptprogramm. Und nach dem 
Verlassen der ISR macht er einen Takt im Hauptprogramm und springt dann 
sofort wieder in die ISR. Ich vermute, wenn du lange genug wartest, wird 
sich auch im Hauptprogramm was tun. Das dauert aber lange (1 Takt pro 
Sekunde).

Lösung: Delay raus aus der ISR und das ganze mit Timern machen.

Weil die An/Aus-Zeit, in diesem Fall 1s länger ist als die Zeit bis die 
nächste ISR ausgelöst wird?

Ok, danke für die Tipps!

Also so funktioniert schonmal was, allerdings muss die LED in der ISR 
sehr schnell blinken und die andere auch. Naja, da muss ich mich wohl 
noch weiter einlesen, aber das Prinzip ist jetzt klarer geworden. :D

#define F_CPU 1000000UL

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

int main(void)
{

  DDRD = 0xFF;

  // Timer 0 konfigurieren
  TCCR0 = (1<<CS02); // Prescaler 256
  // Overflow Interrupt erlauben
  TIMSK |= (1<<TOIE0);
  // Global Interrupts aktivieren
  sei();

  while(1)
  {

  PORTD |= (1<<PD1);
  _delay_ms(200);
  PORTD &= ~(1<<PD1);
  _delay_ms(200);

  }
}


ISR (TIMER0_OVF_vect)
{

int zeit;

  for (zeit=0; zeit<1000; zeit++)
  {
    PORTD |= (1<<PD0);
  }

  PORTD &= ~(1<<PD0);

}

Cuadrado schrieb:
> ISR (TIMER0_OVF_vect)
> {
>
> int zeit;
>
>   for (zeit=0; zeit<1000; zeit++)
>   {
>     PORTD |= (1<<PD0);
>   }
>
>   PORTD &= ~(1<<PD0);
>
> }

Du wartest doch schon wieder in der ISR!
Mach die Zeit mit dem Timer. Und in der ISR wird dann nur noch der Port 
gesetzt und dann gehts wieder raus.

>ISR (TIMER0_OVF_vect)
>{
>
>int zeit;
>
>  for (zeit=0; zeit<1000; zeit++)
>  {
>    PORTD |= (1<<PD0);
>  }
>
>  PORTD &= ~(1<<PD0);
>
>}

Das ist doch der gleiche Käse wie mit dem delay!


ISR (TIMER0_OVF_vect)
{

zeit++;

  if (zeit >= 1000)
  {
    PORTD |= (1<<PD0);
    zeit = 0;
  }
  else
  {
  PORTD &= ~(1<<PD0);
  }

Sowas in der Art müsste gehen, da wird in der ISR nur eine Abfrage 
gemacht und keine Zeit verplempert.
}

Cuadrado schrieb:
>
>
> ISR (TIMER0_OVF_vect)
> {
> PORTD |= (1<<PD0);
> _delay_ms(500);
> PORTD &= ~(1<<PD0);
> _delay_ms(500);
>
> }

AUTSCH!!!


das warten übernimmt doch schon der timer für dich stelle ihn so ein, 
dass die isr alle 500ms aufgerufen wuird und toggle den pin... gut is

Die Variable "zeit" muss außerhalb von main stehen. Das volatile ist in 
diesem Fall nicht nötig, da sie ja nur in der ISR verwendet wird.

Hi
Wie immer sitzt ein Fehler vor dem µC. Merke: Ein Controller macht genau 
das, was du ihm sagst und nicht das, was du glaubst, ihm gesagt zu 
haben. Das ist der Unterschied zwischen Mensch und Maschine. Ich kann 
leider kein C und deshalb auch nicht mit Code weiterhelfen, aber merk 
dir eines: Eine ISR soll etwas ganz schnell zwischendurch erledigen, das 
keinen Aufschub erlaubt. Wenn ein Postbote an der Tür klingelt und du 
der Meinung bist, das es ja Zeit hat darauf zu reagieren, ist er wieder 
weg. Also, alles liegen lassen, die Post holen und dann weitermachen. 
Lesen kannst du dann in Ruhe. Ich glaub, die wenigsten Menschen lesen im 
Beisein des Postboten erst mal die Post, bevor sie wieder zurück in die 
Wohnung gehen. Es könnt sonst sein, das des Essen verkokelt oder das 
Bügeleisen ein neues Emblem auf das Hemd gezaubert hat.
MAch folgendes:
In deiner ISR, die alle 2mSek. aufgerufen wird, zählst du erst mal bis 
50. Das entspricht der Zeit von 0.1 Sek. In einem beliebigen Byte setzt 
du dann ein Bit. dann zählst du bei einem Überlauf bei 50 noch mal bis 
10. Das entspricht der Sekunde.
Etwas so:
ISR:
  INC Zähler1
  Zähler1<50 dann ende_ISR
  Set Bit_100mSek
  INC  Zähler2
  Zähler2<10 dann ende_ISR
  Set Bit_Sek
ende_ISR

Das ist eine überschaubare ISR. Im Hauptprogramm fragst du diese Bits 
ab:

 If Bit_100mSek dann
     .....
     Reset Bit100mSek
 endIf
 If Bit_Sek dann
     ...
     Reset Bit_Sek
 EndIF

Sorry, besser kann ich es nicht beschreiben, aber diesen Pseudocode 
sollte jeder in seine Sprache übersetzen können.
Gruß oldmax

Bastler schrieb:
>
>
> ISR (TIMER0_OVF_vect)
> {
>
> zeit++;
>
>   if (zeit >= 1000)
>   {
>     PORTD |= (1<<PD0);
>     zeit = 0;
>   }
>   else
>   {
>   PORTD &= ~(1<<PD0);
>   }
>
> }

um mit Deinen Worten zu antworten:

Das ist doch der gleiche Käse wie mit dem delay!

 Da kann man die ISR auch gleich weglassen.

> Sowas in der Art müsste gehen,
 nein, die blitzt höchstens ab und zu mal.

Cuadrado schrieb:

1

 ISR (TIMER0_OVF_vect)     // Led blinken lassen ... 

2

 {

3

    PORTD ^=  (1<<PD0);    // LED togeln

4

 }

Ich würde es mal mit "toggeln" (s.o.) versuchen; d.h. bei jedem Aufruf 
der ISR wird der aktuelle Zustand der LED invertiert.
Über den Timer stellst Du ein, in welchem Rhythmus das passiert und ob 
es passiert.