ATTINY 13 Weihnachtskarte LED - Fehler im Code?

[Dan. R. (dan_r)]

Servus zusammen,

bei der Idee eine simple Weihnachtskarte mit einer fixen LED und 6 
weiteren LED´s (jeweils 2 in einem Schaltkreis) wollte ich einen Attiny 
13 als Steuerung benutzen. Die Idee war die Karte durch einen kleinen 
Schalter zu aktivieren und durch erneutes drücken wieder auszuschalten 
um den Attiny in den Sleepmode zu versetzen. Nach dem Test bekomme ich 
jetzt allerdings starr leuchtende LED´s ohne je etwas gedrückt zu haben, 
vielleicht kann mir ja jemand helfen den Fehler zu finden oder hat einen 
alternativen Vorschlag. Betrieben soll das ganze mit einer 3V Batterie 
ohne Vorwiderstände werden.

Danke euch schonmal.

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

#define F_CPU 1200000L  //1,2MHz

#define LED_DDR      DDRB
#define LED_PORT      PORTB

#define LED_PIN      PB4 //LED: Leuchtet immer
#define LED_GRP1_PIN      PB2 //LED-Gruppe 1: blinkt
#define LED_GRP2_PIN      PB1 //LED-Gruppe 2: blinkt
#define LED_GRP3_PIN      PB0 //LED-Gruppe 3: blinkt
#define BUTTON_INPUT_PIN    PB3 //Taster

void init_io() {
    //Set all pins of LED port as output
    LED_DDR |= (1 << LED_PIN);
    LED_DDR |= (1 << LED_GRP1_PIN );
    LED_DDR |= (1 << LED_GRP2_PIN );
    LED_DDR |= (1 << LED_GRP3_PIN );
    LED_DDR &= ~(1 << BUTTON_INPUT_PIN);
}

void init_interrupt() {
    MCUCR &= ~0x3;
    sei();
}

void free_external_interrupt() {
    //GICR |= (1 << INT0);
}

void lock_external_interrupt() {
    //GICR &= ~(1 << INT0);
}

void power_down() {
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_mode();
}

// Empty interrupt routine
ISR(INT0_vect) {
}

int main(void) {
    init_io();
    init_interrupt();

    //Turn on the single LED
    LED_PORT |= (1 << LED_PIN);

    //Turn on LED group and wait for one second
    while (1) {
      free_external_interrupt();
      power_down();
      lock_external_interrupt();


      LED_PORT |= (1 << LED_GRP1_PIN);
      _delay_ms(1000);
      LED_PORT &= ~(1 << LED_GRP1_PIN);

      LED_PORT |= (1 << LED_GRP2_PIN);
      _delay_ms(1000);
      LED_PORT &= ~(1 << LED_GRP2_PIN);

      LED_PORT |= (1 << LED_GRP3_PIN);
      _delay_ms(1000);
      LED_PORT &= ~(1 << LED_GRP3_PIN);
    }

    return 1;
}

[Georg G. (df2au)]

Dan. R. schrieb:
> ohne Vorwiderstände

Das ist schon mal eine extrem schlechte Voraussetzung. Irgendwer muss 
den Strom begrenzen, die Batterie, die LED oder der arme ATTiny (wenn 
dem die Ausgänge durchlegiert sind, bleibt aber wenigstens das Licht 
an).

[kopfkratzer (Gast)]

kopfkratz
Neben den Widerlingen solltest Du einen Timer statt delay nehmen und wie 
wird der Taster denn erkannt ?
Ein Taster prellt, d.h. wenn Du den nur am externen IRQ ohne 
Softwareentprellung hast gibt's viele IRQs hintereinander.
Und eine sinnvolle ISR sehe ich auch nicht ?
Du solltest in der ISR ein Flag setzen, IRQs deaktivieren, den Flag in 
einer Entprellroutine abfragen und wenn dann der Taster nochmal gedrückt 
wurde den Flag zurücksetzen und den Käfer schlafen legen.
Alles andere ist Murks !

[Dan. R. (dan_r)]

Ok habe jetzt das Blinken mit nem neuen Ansatz geschafft, jetzt müsste 
ich das ganze nur so hinbekommen dass es auf Knopfdruck an bzw. ausgeht. 
Hmm das mit der Entprellung klingt logisch, hat jmd ein Beispiel 
hierfür? Wegen den Widerständen sollte es ja mit den richtigen Led´s auf 
lange Zeit klappen.

#include <avr/io.h>

#define F_CPU 1200000L  //1,2MHz

void init_io() {
    DDRB |= (1 << PB0);
    DDRB |= (1 << PB1);
    DDRB |= (1 << PB2);
    DDRB |= (1 << PB4);
    DDRB &= ~(1 << PB3);
}

void switch_on(int port) {
  PORTB &= ~(1 << port);
}

void switch_off(int port) {
    PORTB |= (1 << port);
}

int main(void)
{
    int n;
  int Leuchtzeit = 20000;

    init_io();

    switch_on(PB4);

  while(1)
  {
      switch_on(PB0);
      for(n=0;n<Leuchtzeit+2000;n++);
      switch_off(PB0);

      switch_on(PB1);
      for(n=0;n<Leuchtzeit+2000;n++);
      switch_off(PB1);

      switch_on(PB2);
      for(n=0;n<Leuchtzeit+2000;n++);
      switch_off(PB2);
  }
}