Problem bei Tastendruck

[J. K. (jk-med)]

Hallo zusammen,

ich habe ein kleines Projekt gestartet, damit ich meine 
Eisenbahnbeleuchtung steuern kann.

Dazu habe ich insgesamt drei Taster (Schließer) vorgesehen, die 
folgendes machen sollen:

- Wird Taster-1 gedrückt, soll immer wiederkehrend ein Blinkmuster 
erfolgen (z.B. 3 sec. AN, 1 sec. AUS).

- Wird Taster-2 gedrückt, soll nur einmalig ein Muster ausgegeben werden 
(z.B. 1 sec. AN, 3 sec. AUS, 2 sec. AN).

- Wird Taster-3 gedrückt, soll das wiederkehrende Blinkmuster (von 
Taster-1) gelöscht werden und die LED ausgehen.


Hier der Code:

#define F_CPU      8000000

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



#define TASTER_1     PINC4
#define TASTER_2     PINC3
#define TASTER_RESET  PINC5

#define OUTPUT_PORT    PORTD              
#define OUTPUT_PIN    PD0                  // hier hängt die LED dran

volatile unsigned char Taster;


void init_timer_0(void)
{
  TCCR0 |= (1 << CS02) | (1 << CS00);              // Prescaler auf F_CPU / 1024
  TIMSK |= (1 << TOIE0);                  // overflow interrupt erlauben
}



ISR (TIMER0_OVF_vect)                    // Interrupt Service Routine (bei Timer-Overflow von Timer0)
{
  if (!(PINC & (1 << TASTER_1)))    { Taster = 1; }
  if (!(PINC & (1 << TASTER_2)))    { Taster = 2; }
  if (!(PINC & (1 << TASTER_RESET)))  { Taster = 0; }
  
}

void main (void)
{
  Taster = 0;
  
  DDRC = 0;                        // Port C als Eingang
  PORTC = 0xFF;                      // interne Pullups aktivieren
  
  DDRD |= (1 << DDD0);                  // Port D als Ausgang
  OUTPUT_PORT = 0;
  
  init_timer_0();
  sei();
  
  while(1)
  {
    switch(Taster)
    {
      case 1:
        while(1)
        {
          OUTPUT_PORT |= (1 << OUTPUT_PIN);      //wiederkehrendes Blinken
          _delay_ms(3000);
          OUTPUT_PORT &= ~(1 << OUTPUT_PIN);
          Taster=0;
        }
        break;
        
      
      case 2:                        // 1 sec. AN, 3 sec. AUS, 2 sec. AN
        OUTPUT_PORT |= (1 << OUTPUT_PIN);
        _delay_ms(1000);
        OUTPUT_PORT &= ~(1 << OUTPUT_PIN);
        _delay_ms(3000);
        OUTPUT_PORT |= (1 << OUTPUT_PIN);
        _delay_ms(2000);
        OUTPUT_PORT &= ~(1 << OUTPUT_PIN);
        Taster=0;
        break;
      
      
      
      case 0:
      OUTPUT_PORT &= ~(1 << OUTPUT_PIN);            //...ausschalten
      break;
    }
  }
}

Nun das Problem:
 1.) Warum wird nach Tastendruck auf Taster-1 kein weiterer Tastendruck 
mehr erkannt? Wie kann ich das machen, dass der Timer-Interrupt 
registriert, dass während case 1 abgearbeitet wird, was gedrückt wurde?

 2.) Ähnliches Problem: Warum löscht er mir das Blinken nicht, wenn ich 
auf Taster-3 drücke?

Ich bin mir bewusst, dass die _delay_ms()-Routine ein rotes Tuch für 
manche hier ist. Aber für den Zweck sollte das reichen! :-)

Vielen Dank euch!

Grüße

[Dietrich L. (dietrichl)]

J. K. schrieb:

 case 1:
         while(1)
         {
           OUTPUT_PORT |= (1 << OUTPUT_PIN);
           _delay_ms(3000);
           OUTPUT_PORT &= ~(1 << OUTPUT_PIN);
           Taster=0;
         }
         break;

Dies ist eine Endlosschleife ohne Ausgang! Der Timerinterrupt läuft 
schon weiter, Du fragst das Ergebnis 'Taster' in der Schleife aber nicht 
ab.

Gruß Dietrich

[J. K. (jk-med)]

Danke Dietrich!

Das heißt, es müsste so lauten?

case 1:
         while(Taster==1)
         {
           OUTPUT_PORT |= (1 << OUTPUT_PIN);
           _delay_ms(3000);
           OUTPUT_PORT &= ~(1 << OUTPUT_PIN);
         }
         Taster=0;
         break;

[J. K. (jk-med)]

Das klappt soweit. Aber: wie könnte ich einen längeren Blinkrhythmus mit 
der Taste-3 unterbrechen?

Dass quasi der Interrupt bei einem Tastendruck von Taster-3 sofort den 
laufenden Blinkrhythmus unterbricht?


Danke!

[holger (Gast)]

>Das klappt soweit. Aber: wie könnte ich einen längeren Blinkrhythmus mit
>der Taste-3 unterbrechen?

_delay_ms(3000); anders machen.

for(i = 0; i < 3000; i++)
{
  _delay_ms(1);
  if(Taster == 0) break;
}

Dann kannst du jede Millisekunde abbrechen.

[J. K. (jk-med)]

Oh weh...da ist dann schon das nächste Problem.

Ich habe mir eine Funktion geschrieben:

void wait_ms(int time)
{
   for(i = 0; i < time; i++)
   {
      _delay_ms(1);
      if(Taster == 0) break;
   }
   return;
}

Doch das "break" beendet ja nur die Schleife?!
Ich bräuchte etwas, was außerhalb der Funktion "breaked".

Habt ihr eine Idee?

[holger (Gast)]

>Ich habe mir eine Funktion geschrieben:

Sehr schön.
Dann eben:

uint8_t wait_ms(int time)
{
   for(i = 0; i < time; i++)
   {
      _delay_ms(1);
      if(Taster == 0) return 1;
   }
   return 0;
}

Wenn die Funktion mit 0 rauskommt weitermachen,
wenn sie mit >= 1 rauskommt abbrechen.

[Peter D. (peda)]

Hier findest Du einiges, was ganz nützlich ist:

Beitrag "AVR Sleep Mode / Knight Rider"

Eine Entprellroutine, die Dir viel Ärger bei der Tastenabfrage vom Hals 
schafft.

Und eine tabellengesteuerte Blinkroutine.
Man kann statt des Blinkmuster auch die Zeitabstände in die Tabelle 
schreiben. Oder auch beides.

Die Sleep-Funktionen läßt man einfach komplett raus.
Du benutzt ja bestimmt ein Netzteil und keine Batterie.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

J. K. schrieb:
> Habt ihr eine Idee?
Du musst dein Programmkonzept umstellen!

Weg von diesem "Schritt-für-Schritt"-Denken hin zu einer 
Zustandsautomaten-Denkweise. Dann sorgst du nur erst mal dafür, dass du 
eine einzige Hauptschleife hast, die mit maximaler Geschwindigkeit und 
ohne nennenswerte Unterbrechungen durchläuft. Und nur wenn nötig, wird 
in dieser Hauptschleife etwas ausgeführt (z.B. Leds umschalten). Und 
weil du ständig an der Tastenabfrage vorbeikommst, kannst du sofort auf 
eine Taste reagieren.

Als kleiner Denkanstoß hier mal mein Ansatz zu Verwaltung von Zeiten:
http://www.lothar-miller.de/s9y/categories/22-Zeiten

Du siehst: Zeiten werden dort nicht über die Verschwendung von 
Rechenkapazität mit "delay_ms()" gemacht, sondern über das 
Vorausberechnen eines Zeitpunktes, bei dem wieder eine Aktion ausgeführt 
werden soll (z.B. LED toggeln). So ein Programm kannst du einfach 
erweitern und unter Kontrolle halten: es muss nur die Durchlaufzeit der 
Hautschleife hinreichend gering bleiben, und du hast immmer eine 
"sofortige" Reaktion.