Hallo zusammen, bei einer kleinen Bastelei möchte ich einem Eingabetaster an meinem PIC an verschiedenen Stellen im Programm je eine andere Funktion zuweisen. Sprich, wenn ich den Taster an Stelle X drücke soll A ausgeführt werden, wenn ich den Taster an Stelle Y drücke, soll B ausgeführt werden. Wie löse ich das Problem am einfachsten (C/Assembler)? Ich habe probiert, Variablen zu setzen bzw. zu löschen an den entsprechenden Stellen, aber dann werden bei Tastendruck immer A und B ausgeführt, egal ob ich bei X oder Y drücke (also genau, was ich nicht will). Die Taster werden jeweils im Programm per Polling abgefragt. Ich hoffe ihr könnt mir helfen und kommt mit meiner groben Darstellung halbwegs zurecht, habe versucht das ganze recht einfach zu erklären :)
Gast
#4132916
Wie ist denn die Stelle definiert ?
Gast
#4132924
Das wird so nix, es sei denn du hast im Programm genug Zeit zu verplempern, um zu warten. Du müsstest an der jeweiligen Stelle des Programms die Debounce-Rotine starten und abwarten bis sie ein gültiges Ergebnis liefert. Man macht das eher so: Für die beiden verschiedenen Funktionen einen kurzen und einen langen Tastendruck (oder einen normalen und einen Doppelclick) unterscheiden und das zur Separation der beiden Funktionen verwenden.
Gast
#4132943
Ich mach das so: Für die Eingabegeräte gibts eine Type, z.B. sowas:
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
Die eigentliche Variable wird als "static" in main deklariert (oder in eine andere Struktur eingewurstelt), alle Funktionen die mit Tastern zu tun haben bekommen einen Pointer drauf, unter anderem jene, die die Buttons einliest. Die Funktion, welche die Bits da einträgt, wird einmal alle 10ms oder so aufgerufen - die schaut nach, ob sich der Taster geänder hat und setzt fallweise das passende Bit. Entprellt ist das dann auch gleich, wenn der Taster nicht länger als 10ms prellt. Funktionen, die Benutzereingaben verarbeiten, bekommen einen Pointer da drauf. Die verarbeiten dann das jeweilige Ereignis und setzen das dann zurück. z.B. so:
1 | |
2 | |
3 | |
4 | |
Damit wird jedes Ereignis genau einmal verwurstet. Den Pointer kann man soweit herumreichen, wie man lustig ist. Man kann solange mit der Reaktion auf den Button warten, bis der Controller alles andere wichtige abgewurstelt hat. Damit kann man Button-gesteuerte Menüs beliebig verzweigen. Im Anhang ist ein Beispiel.
Du scheinst, eine noch etwas falsch Vorstellung von Programmabläufen, zu haben. Zeig doch mal Deine Code. Simpel schrieb: > Das wird so nix, es sei denn du hast im Programm genug Zeit zu > verplempern, um zu warten. Du müsstest an der jeweiligen Stelle des > Programms die Debounce-Rotine starten und abwarten bis sie ein gültiges > Ergebnis liefert. Sorry, aber das ist Quatsch. Man muss nur, in der jeweiligen Situation, unterscheiden ob Aktion A o. B ausgeführt werden soll.
Gast
#4132954
Dieter L. schrieb: > Sprich, wenn ich den Taster an Stelle X drücke soll A ausgeführt werden, > wenn ich den Taster an Stelle Y drücke, soll B ausgeführt werden. > > Wie löse ich das Problem am einfachsten (C/Assembler)? Das fällt in die Kategorie state machine. Status A = DiesUndDas Status B = WennWasAnderes Beim Ereignis Taste gedrückt fragst du den Status ab und machst dann entsprechend weiter.
Stefan schrieb: > Wie ist denn die Stelle definiert ? Ah, er meint 'im Zustand X' und 'im Zustand Y' usw., nicht 'Stelle'. @X4U: Guut! :-) Siehe Statemachine.
Gast
#4132962
Das Ganze macht eh nur bei einer (partiellen) State-Machine Sinn, bei der der Nutzer signalisiert bekommt, wie der aktuelle Stand ist, und auch Zeit hat zu reagieren, oder nicht... aber wenn die Eingabe eh von einem signalisierten Status (mit oder ohne Timeout) abhängt, ist es auch wurscht an welcher Stelle im Code die dazugehörige Tasteneingabe gemacht wird. Der Sinn des vom TO beschriebenen Vorgangs erschliesst sich mir irgendwie nicht...
Gast
#4132963
...oops... da hätt ich mir meinen letzten Text sparen können... schon erledigt :|
Dieter L. schrieb: > Wie löse ich das Problem am einfachsten (C/Assembler)? Beim Programmieren gilt auch "Teile und (be)herrsche", d.h. man erstellt kleine übersichtliche Teilaufgaben. Zuerst braucht man eine Entprell-Lib, die fertige Ereignisse liefert und vorzugsweise im Timerinterrupt läuft, damit keine Drücke verloren gehen. Und die Ereignisse holt man sich dann in den verschiedenen Kontexten (State-Maschinen) ab und reagiert darauf in der eine Statemaschine so und in der anderen eben anders. Um zu vermeiden, daß ein Druck aus einem vorherigen Kontext was falsches macht, wird bei Kontextwechsel das Ereignis gelöscht (Dummy-Abfrage). Man kann auch in verschiedenen Kontexten verschiedene Tastenfunktionen benutzen (z.B. lang/kurz Druck, Repeatfunktion).
Also der für mich einfachste Ablauf war damals...
Ich habe einen Timer oder eine Hauptschleife, in einem Intervall, dass
größer als die Prellzeit meines Tasters ist, oder es gibt eine TMIN die
mind. erreicht sein muss, damit der Tastendruck als gegeben hin genommen
wird.
Tastenverlauf:
TMIN TKURZ TLANG
____|~~~~|+++++|###########|____|~~~~|+++++|###########|
Dann habe ich eine Funktion, die zählt einen Zähler hoch, so lange der
Taster gedrückt ist. Wird der Taster los gelassen, wird geschaut, wie
lang der Taster gedrückt war:
- Zähler < TKURZ ist, dann wird die Funktion kurzer_druck() aufgerufen
- Zähler > TKURZ ist, dann wird die Funktion langer_druck() aufgerufen
Man kann das auch noch erweitern, in dem man noch eine TLANG hinzufügt.
Wird diese überschritten, wird die Funktion taster_halten() aufgerufen
und der Zähler zurück gesetzt, so dass er gleich wieder los rennt. Auf
die Art kann man seinen MP3 Player mit nur einer Taste steuern:
Kurzer Druck: PLAY/PAUSE
Mittellanger Druck: Nächster Titel
Halten: Springe im Titel
Damit die aufgerufenen Funktionen nicht den Ablauf durcheinander
bringen, setzen diese einfach nur Flags, die dann irgendwo geordnet
abgearbeitet werden.
Natürlich kann man das auch in Timer-Interrupts verankern und Callback
Functions definieren, aber ich denke, das heben wir uns für den 2. Teil
auf :)
Gruß
Ulrich