Was genau passt hier nicht beim Auslesen der Pins?

[Pumba (Gast)]

Bekomme dauerhaft von der Funktion den Wert 1 zurückgeliefert bei allen 
Tastern.

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

#define BUTTON_MODE    PINB0
#define BUTTON_START  PINB1
#define BUTTON_STOP    PINB2

int8_t button_read(volatile uint8_t *port, uint8_t bit, uint8_t *last_state);

int main(void)
{
  DDRB &= ~((1<<BUTTON_MODE) | (1<<BUTTON_START) | (1<<BUTTON_STOP));
  PORTB |= (1<<BUTTON_MODE) | (1<<BUTTON_START) | (1<<BUTTON_STOP);

  while(1)
  {    
    static uint8_t last_state_start;
    if(button_read(&PINB, BUTTON_START, &last_state_start))
    {
      uart_puts("START\r\n");
    }
    
    static uint8_t last_state_stop;
    if(button_read(&PINB, BUTTON_STOP, &last_state_stop))
    {
      uart_puts("STOP\r\n");
    }
    
    static uint8_t mode;
    static uint8_t last_state_mode;
    if(button_read(&PINB, BUTTON_MODE, &last_state_mode))
    {
      if(++mode >= 10) mode = 0;
      uart_puts("MODE>");
      uart_putc(mode+'0');
      uart_puts("\r\n");
    }

  }
}

int8_t button_read(volatile uint8_t *port, uint8_t bit, uint8_t *last_state)
{
  uint8_t return_value;
  
  // Taster wird gedrueckt (steigende Flanke)
  if(*last_state == 0 && !(*port & (1<<bit)))
  {
    *last_state = 1;
    return_value = 1;
    _delay_ms(50);
  }
  
  // Taster wird gehalten
  else if(*last_state == 1 && !(*port & (1<<bit)))
  {
    *last_state = 2;
    return_value = 0;
  }
  
  // Taster wird losgelassen (fallende Flanke)
  else if(*last_state == 2 && (*port & (1<<bit)))
  {
    *last_state = 3;
    return_value = 0;
  }
  
  // Taster losgelassen
  else if(*last_state == 3 && (*port & (1<<bit)))
  {
    *last_state = 0;
    return_value = 0;
  }
  
  return return_value;
}

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

Die AVR unterscheiden strikt zwischen Programmspeicher, RAM Speicher und 
Ein/Ausgabe Adressraum. Du wirst mit deinem Konstrukt also auf die 
Adresse des RAM zugreifen, statt auf den I/O Adressraum und die RAM 
Zelle auslesen, die die gleiche Adresse hat (aber im RAM Adressraum) wie 
der Port B, weil der Kompiler bei Pointern davon ausgeht, das sie in den 
RAM zeigen.

[Stefan F. (Gast)]

Ich hatte das auch mal versucht (Port und Bit Nummer als Parameter 
übergeben) und scheiterte an der gleichen Stelle. Deswegen interessiert 
mich auch, wie man das elegant lösen kann.

Mein Programm enthält aktuelle eine große switch Anweisung, wo für jeden 
möglichen Port der gleiche Code wiederholt wird. Funktioniert, aber 
schön ist es nicht.

[Axel S. (a-za-z0-9)]

Das Lesen der Pins ist schon richtig so (siehe auch 
http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass).

Was nicht korrekt ist, ist die Funktion button_read() selber. Zum einen 
wird die Variable return_value nicht initialisiert. Es ist also durchaus 
möglich, daß die Funktion einen undefinierten Wert zurückliefert.

Viel schlimmer ist aber der logische Fehler. Anscheinend soll das eine 
Statemachine sein. Die funktioniert aber nur dann so wie erwartet, wenn 
der Taster entprellt ist und wenn die Funktion häufig genug aufgerufen 
wird. Sonst kann es passieren, daß die Statemachine in einem Zustand 
hängen bleibt.

Nehmen wir z.B. an, beim letzten Aufruf wäre die Statemachine in den 
Zustand last_state == 1 (Tastendruck erkannt) übergegangen. Nun ist der 
Taster zwischenzeitlich aber schon wieder losgelassen worden (bzw. hat 
geprellt). Beim nächsten Aufruf der Funktion ist das Portbit also 1. 
Dann wird keiner der if/else Zweige genommen. Denn von Zustand 1 ist 
nur der eine Weg nach Zustand 2 vorgesehen, wenn der Taster gedrückt 
bleibt (das Portbit beim Test gerade 0 ist). Und genau an dieser Stelle 
wird dann auch ein undefinierter Wert von return_value zurückgegeben.

Um das sauber zu machen, muß die Statemachine in jedem Zustand jeden 
möglichen Input bewerten. Man muß also auch die "unmöglichen" Übergänge 
berücksichtigen. Weil die eben doch möglich sind.