LED x-mal blinken lassen mit Timer

[Paul (Gast)]

Hallo,

ich mache gerade meine ersten Gehversuche mit dem AtMega8. Leider 
schaffe ich es (aus eigener Blödheit) nicht eine LED eine bestimmte 
Anzahl mal blinken zu lassen. Bisher sieht mein Code so aus:

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


volatile uint8_t count=0;

ISR(TIMER0_OVF_vect)
{
    count++;
}
void schalte_led()
{
  if(count>=5)
    PORTB |= (1<<PB3);
  if(count>=10)
  {
    PORTB &= ~(1<<PB3);    // LED aus
    count=0;
  }
}
int main(void)
{
   TCCR0 = (1<<CS02);     // Overflow-Modus, prescaler /256
   DDRB |= 0xFF;           // LED an einem Ausgang
   PORTB = 0xFF;    // LED aus
   TIMSK |= (1<<TOIE0);
   sei();

  while(1)
  {
    schalte_led();
  }

}

Nun würde ich der Funktion schalte_led gerne noch einen Parameter 
mitgeben, der bestimmt, wie oft geblinkt werden soll. Kann mir jemand 
einen Tipp geben? Meine bisherigen Versuche sind leider fehlgeschlagen.
Lieber Gruß
Paul

[Paul (Gast)]

P.S: Das "#include <util/delay.h>" ist ein Überbleibsel diverser Tests.

[Michael D. (Gast)]

if count >= 10 wahr
dann
if count >= 5  auch wahr

[Paul (Gast)]

if count >= 10 wahr
dann
if count >= 5  auch wahr

Ja, das ist natürlich Quatsch, Danke.

[Michael D. (etzen_michi)]

Nun auch angemeldet

Ich würde das über einen SwitchCase machen, der bei 5 und 10 schaltet 
(Die kurze aktion kann man noch in der ISR machen würde ich sagen.

Bei jedem Ausschalten der LED eine volatile +1
und vor dem SwitchCase eine for


for(;i<wieoft;) {
    switch(++count) {

        case 5:
            PORTB |= (1<<PB3);
            break;

        case 10:
            PORTB &= ~(1<<PB3);
            count=0;
            wieoft++;
            break;

        default:
            break;
    }
}

[Krapao (Gast)]

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

volatile uint8_t count = 0;

ISR(TIMER0_OVF_vect)
{
  count++;
}

void schalte_led(int blink_zyklen)
{
  static int erledigte_blink_zyklen = 0;

  if ( blink_zyklen == -1 )
    erledigte_blink_zyklen = 0; // Möglichkeit zum Zurücksetzen

  if ( erledigte_blink_zyklen < blink_zyklen )
  {
    if( count >= 5 )
    {
      PORTB |= (1<<PB3); // LED an
    }

    if( count >= 10 )
    {
      PORTB &= ~(1<<PB3); // LED aus
      count = 0;
      erledigte_blink_zyklen++;
    }
  }
}

int main(void)
{
  DDRB |= (1<<PB3);    // PORTB.3 Ausgang
  PORTB &= ~(1<<PB3);  // LED aus

  /*
   8-Bit Timer0 Overflow-Modus, Prescaler /256
   Aufruf der ISR alle 1 / F_CPU / Prescaler / 2^8 s
   Z.B. 65,536 ms bei 1 MHz
   Softwarezähler 5 => ~300ms AN/AUS Phasen
   */
  TCCR0 = (1<<CS02);
  TIMSK |= (1<<TOIE0);
  sei();

  while(1)
  {
    schalte_led(3);
  }
}

[Paul (Gast)]

Ihr seid ganz, ganz Toll! Vielen Dank!
Hab vorher nie mit Interrupts programmiert, da fällt mir das ein wenig 
schwer.
Schönes WE
Paul

[Michael D. (etzen_michi)]

static int erledigte_blink_zyklen = 0;


Verstehe ich nicht ganz ... die willst du doch hochzählen wenn ichd as 
richtig verstehe. Ich dachte das geht bei static nicht.

Bitte info wenn ich mich irre.

[Krapao (Gast)]

Das Schlüsselwort static bedeutet, dass der Wert von 
erledigte_blink_zyklen zwischen den Aufrufen von schalte_led 
erhalten bleibt. Nicht Verwechseln mit dem Schlüsselwort const!