Arrays sollen taster aufnehmen

[Patrick R. (pat711)]

Guten Tag zusammen,

Hab ein kleines Problem:
Und zwar wollte ich die Reihenfolge von tastern in einem array 
abspeichern und nach 5 eingaben diese auf dem LCD wieder ausgeben. wenn 
ich nun das Programm starte wird zwar "Taste Nr. 0" angezeigt aber wenn 
ich auf den tastern rum drücke passiert gar nichts???
kann mir da vll jemand behilflich sein?

Hier mein Code:

#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <util/delay.h>

#define taster_a (!(PIND & (1<<PIND3)))
#define taster_b (!(PIND & (1<<PIND2)))
#define taster_c (!(PIND & (1<<PIND4)))
#define u_int unsigned int

volatile u_int taster[5], a = 0; 

void long_delay(uint16_t ms) 
{
    for(; ms>0; ms--) _delay_ms(1);
}

void kein_taster(void)
{
  a = 1;
  while(a == 1)
  {
    long_delay(20);
    if((!(taster_b)) && (!(taster_a)) && (!(taster_c)))
    {
      a = 0;
    }
  }
}

int main(void)
{
  taster[0] = 0;
  taster[1] = 0;
  taster[2] = 0;
  taster[3] = 0;
  taster[4] = 0;
  lcd_init();
  for (u_int counter = 0; counter < 5; counter ++)
  {
    lcd_clear();
    set_cursor(0,0);
    char Buffer[20];
    itoa( counter, Buffer, 10 ); 
    lcd_string("Taste Nr.");
    lcd_string( Buffer );
    while (taster[counter] == 0)
    {
      if (taster_b)
      {
        kein_taster();
        taster[counter] = 1;
      }
      else if (taster_a)
      {
        kein_taster();
        taster[counter] = 2;
      }
      else if (taster_c)
      {
        kein_taster();
        taster[counter] = 3;
      }
    }
  }
  lcd_clear();
  set_cursor(0,0);
  
  for (u_int counter = 0; counter < 5; counter ++)
  {
    if (taster[counter] == 1)
    {
      lcd_string("b");
    }
    else if (taster[counter] == 2)
    {
      lcd_string("a");
    }
    else if (taster[counter] == 3)
    {
      lcd_string("c");
    }
    else
    {
      lcd_string("err.");
    }
  }
  long_delay(5000);
}

[Chris H. (wuselwutz)]

Schau dir deinen Code doch selber noch einmal in Ruhe an. Möchtest Du 
die Taster ein einziges Mal auslesen oder immer wieder?

[Patrick R. (pat711)]

naja durch die for-schleife werden die Taster ja für jeden Teil des 
Arrays ein mal abgefragt, also insgesamt 5 mal...

Und das Ganze Programm soll erst einmal nur ein mal durchlaufen

[Stefan H. (stefanhennig)]

Blöde Frage: Wo werden die Ports initialisiert, also auf Input 
geschaltet, etc.?
Ich kenne Deine Hardware ja nicht, aber das würde ich irgendwo ganz am 
Anfang erwarten.

[Karl H. (kbuchegg)]

long_delay(20);


und du denkst du kannst innerhalb von 20 Millisekunden einen Taster 
drücken und wieder loslassen?

Denn: Wenn du einen Taster drückst, wird das zwar registriert, aber ~20 
Millisekunden später kommt die nächste Abfrage, ob eine Taste gedrückt 
ist.


    if((!(taster_b)) && (!(taster_a)) && (!(taster_c)))

Probier mal alle 3 Taster gleichzeitig drücken :-)

[Stefan H. (stefanhennig)]

Nö, entweder ich bin übermüdet, oder er prüft alle 20ms ob alle Taster 
losgelassen sind, bevor es weiter geht. Der Busy-Wait ist zwar sinnlos 
aber m.E. harmlos.
Korrektur: Der Busy-Wait will wohl entprellen, damit nicht sinnlos. Aber 
dann müsste eigentlich nochmal im "Alle-Tasten losgelassen 
erkannt"-Zweig gewartet werden.

[Karl H. (kbuchegg)]

Stefan Hennig schrieb:
> Nö, entweder ich bin übermüdet, oder er prüft alle 20ms ob alle Taster
> losgelassen sind, bevor es weiter geht.

Da könnte was drann sein.
Die vielen ! machen mich ganz konfus :-)

TO:
Was ist der genau Zweck der Funktion kein_Taster()?
Worauf soll die warten?
a) bis eine Taste gedrückt wird
b) bis alle Tasten losgelassen wurden

-> PeDa Entprellung zur Tastenabfrage benutzen. Da stellt sich dieses 
Problem gleich gar nicht :-)

[Patrick R. (pat711)]

die Funktion kein_taster(); habe ich als ganz unprofesionelle 
entprellung genutzt. ^^

In diesem prog wollte ich erst mal ausprobieren wie das mit den arrays 
so am besten funzt der eigentliche nutzen soll später sein, dass 
messwerte in arrays geschrieben werden. also in etwa so:

array1[counter] = messwert;
array2[counter] = zeitpunkt;
counter ++;

das ganze soll dann im eeprom abgepeichert werden:

for (u_int counter2 = 0; counter2 <= counter; counter ++)
{
     eeprom_write_byte(&eeFooByte, array1[counter2]);
     eeprom_write_byte(&eeFooByte, array2[counter2]);
}

und später dann eben wieder ausgelesen werden

array1[1] = eeprom_read_byte(&eeFooByte);
array2[1] = eeprom_read_byte(&eeFooByte);

[Stefan H. (stefanhennig)]

Wie gesagt: Ich sehe keinen Grund in der Software, warum es überhaupt 
nicht gehen sollte, vorausgesetzt:
- Du verwendest den richtigen Port
- Die Ports sind nach einem Reset korrekt initialisiert (ich sehe nicht, 
dass Du das in Deinem Code machen würdest)
- Die Taster schalten in die richtige Richtung. Ich denke, in Deinem 
Code bedeutet ein gedrückter Taster ein Portbit, das auf 0 gezogen wird.
- Das würde bedeuten, dass Du irgendwo einen Pullupwiderstand verbaut 
hast, oder den Port entsprechend konfiguriert hast (s.o.)

Prüfe das doch mal.

Grüße,
 Stefan

[Peter D. (peda)]

Karl heinz Buchegger schrieb:
> -> PeDa Entprellung zur Tastenabfrage benutzen. Da stellt sich dieses
> Problem gleich gar nicht :-)

Jawoll, so isses!!!

Sie erschlägt so nebenbei mindestens 10 andere häufige Probleme.

Vor allem gestattet sie einen einfachen Programmablauf ohne haufenweise 
Merkvariablen und Verzweigungen.


Peter

[Patrick R. (pat711)]

oh mann...
an sowas primitivem wie nem Widerstand gescheitert Kopf gegen Wand
thx Stefan Hennig.

und auch allen anderen.

noch ne frage:
wenn ich mehrere variablen in den EEprom schreibe und dann wieder lesen 
will. Stimmt das dann so:

eeprom_write_byte(&eeFooByte, variable1);
eeprom_write_byte(&eeFooByte, variable2);
eeprom_write_byte(&eeFooByte, variable3);

variable1 = eeprom_read_byte(&eeFooByte);
variable2 = eeprom_read_byte(&eeFooByte);
variable3 = eeprom_read_byte(&eeFooByte);

[Karl H. (kbuchegg)]

Patrick R. schrieb:

> wenn ich mehrere variablen in den EEprom schreibe und dann wieder lesen
> will. Stimmt das dann so:
>

> eeprom_write_byte(&eeFooByte, variable1);
> eeprom_write_byte(&eeFooByte, variable2);
> eeprom_write_byte(&eeFooByte, variable3);
> 
> variable1 = eeprom_read_byte(&eeFooByte);
> variable2 = eeprom_read_byte(&eeFooByte);
> variable3 = eeprom_read_byte(&eeFooByte);
>

Im Prinzip schon, wenn du für eeFooByte jedesmal eine andere Adresse 
nimmst. Sonst wird ja alles auf derselben EEPROM Adresse abgelegt.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM

[Patrick R. (pat711)]

Also muss in dieser Variablen ein Wert zwischen 1 und (je nach größedes 
EEproms) stehen?

wird die Adresse nicgt automatisch bestimmt? Muss ich mir nochmal 
anschaun ^^

[Patrick R. (pat711)]

OK thx @all jetzt funktionierts :)