mehrer eingänge einlesen,speichern uart senden

[Peter (Gast)]

Mache mir grad Gedanken wie man folgendes am besten machen soll.
Hardware STK500 mit ATMEGA16. Es liegt ein Aktive-High auf den Tasten.
Nun wollte ich, wenn ich eine Taste drücke und dann vll noch noch paar 
andere, soll diese registriert werden und irgendwie abgespeichert.Wenn 
alle tasten los gelassen werden, soll er per uart senden.In einem array 
sollen verschiedene buchstaben und zahlen drin sein, die nach 
kombination der tasteneingaben aufgerufen und per uart an pc gesendet 
werden sollen.

Klingt eigentlich einfach, mir fehlt aber die Übung noch in diesem 
Bereich.
Idee von mir war.
eine endloscheife, die immer durchläuft und guckt was gedrückt wurde.
die endloschleife muss die überprüfung durchführen, sprich wenn was 
gedrückt wurde registrieren und weiter horchen was passiert.

Wäre eure hilfe dankbar

[Stefan B. (stefan)]

Peter schrieb:

> Idee von mir war.
> eine endloscheife, die immer durchläuft und guckt was gedrückt wurde.
> die endloschleife muss die überprüfung durchführen, sprich wenn was
> gedrückt wurde registrieren und weiter horchen was passiert.


Kann man so machen.

Diese Art des Programmablaufs nennt sich Sequentieller Programmablauf 
bzw. Polling-Verfahren und ist im AVR-GCC-Tutorial erklärt.

Wenn du mut AVRs und C bzw. sogar mit GCC arbeitest, kannst du von dem 
Titorial dort profitieren.

[Peter (Gast)]

Ja okay da komme ich weiter. Arbeite mit yC und C. Nun muss ich mir 
überlegen wie die Abfrage statt finden soll. Wenn ich es nicht schaffe, 
melde ich mich wieder

[Karl H. (kbuchegg)]

Du hast ja schon eine gewisse Vorstellung davon wie dein
Programm arbeiten soll. Das ist schon mal gut.

Mein Tip:
Wenn du zur Implementierung schreitest überleg dir einen
Stufenplan so dass du immer etwas hast, was du testen kannst.

In deinem Fall würde es sich anbieten mit der UART anzufangen.
Einfach nur ein Zeichen ausgeben. Mehr nicht.

Wenn das klappt, dann beziehst du einen (!) Taster mit ein.
Wird der Taster gedrückt, soll über die UART ein (fixes) Zeichen
gesendet werden. Da die UART Routinen bereits laufen, ist es
auch kein Problem zu verifizieren ob deine Tastenauswertung
funktioniert.

Du wirst schnell merken, dass da manchmal bei einem Tastendruck
auch mehrere Zeichen gesendet werden -> Tastenprellen.
Also musst du dir etwas gegen das Prellen einfallen lassen.
Da du aber Gott sei Dank die UART Routine bereits am laufen
hast, hast du eine einfache Testmöglichkeit um zu sehen, ob
deine Entprell-Idee auch funktioniert.

Hast du das Prellproblem gelöst, kommt das nächste:
Du willst ja eigentlich nicht beim Drücken einer Taste etwas
verschicken, sondern beim Loslassen. Also baust du dein Programm
mal so um, dass beim Loslassen der Taste das senden beginnt.

Klappt es bei einer Taste, dann veränderst du das Programm so,
dass mehrere Tasten unterstützt werden (sagen wir mal: 2)
....


Du siehst: In kleinen Schritten arbeiten. Die Schritte so anlegen,
dass du immer was zum Testen hast. Oft ist es gut, als erstes die
Ausgabe zu machen, weil man die Ausgabe dann gleich bei der Ent-
wicklung der restlichen Komponenten einsetzen kann um in
Erfahrung zu bringen, was im Programm passiert.

Das Dümmste was du machen kannst, ist dein Programm in einem
Rutsch von vorne bis hinten herunterzuschreiben und darauf
zu hoffen, dass du keine Fehler machen wirst. Du wirst Fehler
machen und dann stehst du mit einem grossen Haufen Code da und
hast keine Ahnung wo du mit der Fehlersuche anfangen sollst.
Arbeitest du dich aber in kleinen Schritten vor, dann ist meist
ziemlich klar, wo der Fehler liegt bzw. welche Programmkomponenten
als Fehlerkandidaten ausscheiden, da sie bereits getestet sind.

[Peter (Gast)]

So einzelne Schritte habe ich mal gemacht. Im Prinzip funktionieren alle 
einzel Schritte schon. Aber deine Idee zur Vorgehensweise werde ich mir 
sicherlich zu Herzen nehmen. Muss mir aber bischen mehr Grundlagen in C 
anlesen. Da mangelt es noch bischen. Ansonsten vielen Dank.