1.2.1 Entprellen von Tastern
Welche Möglichkeiten des Entprellens gibt es
Es gibt programmtechnisch mehrere Möglichkeiten das Prellen zu unterbinden. Generell würde dies so ablaufen, das nach dem Feststellen des Tastendrucks eine Weile (einige Millisekunden) gewartet wird und dann noch einmal überprüft wird, ob nach dieser Zeitspanne der Taster immer noch gedrückt ist. Wenn ja, dann wird das Ereignis im Programm als Tasterdruck gewertet. Die Zeitspannenmessung könnte dabei mit waitms oder mittels Timerinterrupt realisiert werden.
Beide Varianten erfordern viel Aufmerksamkeit beim Programmieren. BASCOM bringt hier aber schon einen vorgefertigten Befehl für uns:
Tasterauswertung mit Debounce
Der Befehl Debounce besteht aus zwei Teilen und arbeitet mit einer Subroutine, also einem Unterprogramm.
WIKI-Logo Merktext.jpg
Ein Unterprogramm ist ein in sich abgeschlossenes Programm innerhalb Eures Gesamtprogramms. Wenn keine Sonderform (wie hier bei Debounce) angewendet wird, springt man gewöhnlich mit dem Befehl Gosub (gehe zur (Sub) Unterroutine) zu einem solchen Teilprogramm. Hier werden beispielsweise Befehlsfolgen abgearbeitet, welche im Programm an unterschiedlichen Stellen immer in gleicher Form geschrieben werden müßten. Durch die Verwendung der Unterroutine braucht dieser Programmteil aber nur einmal geschrieben zu werden. Jedesmal wenn er ausgeführt werden soll wird mit dem Befehl Gosub in diesen Programmteil verzweigt. Das Hauptprogramm merkt sich die Stelle, an der es sozusagen "abgebogen" ist. Das Unterprogramm wird generell mit Return (Zurück) abgeschlossen. Das Programm weiß nun, dass die Unterroutine beendet ist und spring an die Stelle zurück, an der das Hauptprogramm mit Gosub verlassen wurde. Es kann auch in einer Unterroutine nochmals mit Gosub in eine weitere Unterroutine gesprungen werden. Man spricht in diesem Fall von "Verschachtelung"
Hinweis für Fortgeschrittene: Je mehr Unterroutinen verschachtelt werden, um so mehr Rücksprungadressen muss sich der Controller merken. Dies muss bei der Wertangabe der Stacks berücksichtigt werden! Mehr Informationen zu den Stack´s gibt es hier:Speicheraufbau
Wie im Merktext beschrieben handelt es sich bei Debounce in gewisser Weise um eine Sonderform. Wir erstellen zwar eine Unterroutine, springen aber nicht mit Gosub in diese sondern verwenden folgende Schreibweise, wobei zu beachten ist, dass der Befehl Debounce sich innerhalb der Do- Loop- Schleife befindet !:
Zuvor haben wir einen Pin unseres Controllers als Eingang definiert und ihm einen Alias zugewiesen, sowie den internen Pullupwiderstand aktiviert. Ihr wißt sicher noch wie es geht:
Config Portb.2 = Input
Taster Alias Pinb.2
Portb.2 = 1'Pullupwiderstand
Kommen wir also jetzt zur Befehlssyntax, die innerhalb der Do- Loop- Schleife steht:
Debounce Taster , 0 , Taster_gedrueckt , Sub
Dies Bedarf sicher noch einiger Erklärungen. Also:
WIKI-Logo Merktext.jpg
Unterprogramme (Subroutinen) beginnen in BASCOM mit einem eindeutigen Namen und einem nachfolgendem Doppelpunkt. Unterprogramme (Subroutinen) werden immer mit Return beendet (verlassen).
In unserem Fall sieht das dann folgendermaßen aus:
Zum Beispiel können wir eine Variable mit jedem Tasterdruck um 1 erhöhen:
Bei Verwendung von Debounce können wir uns jetzt ganz sicher sein, dass I immer nur um 1 erhöht wird.
Schauen wir uns mal ein komplettes Programm an
Im folgenden Beispielprogramm wird mittels Taster eine LED unseresExperimentierboards ein- und wieder ausgeschaltet. Die Jumper undKabelverbindungen bleiben wie beim vorangegangenen Experiment:
Erstes Tasterprogramm.png
So werden Brücken und Jumper für das folgende Programm gesteckt
Alles anzeigen
Was passiert nun in diesem Programm? Bei jedem Schleifendurchlauf wird geprüft, ob die entsprechende Taste gedrückt ist. Wenn das nicht der Fall ist, dann läuft das Programm einfach weiter zum nächsten Befehl (hier also zu Loop und anschließend zu Do und dann wieder zur Tasterabfrage). Wenn die entsprechende Taste gedrückt ist dann wartet das Programm, damit das Kontaktprellen sich beruhigen kann. Wenn dann die Taste immer noch gedrückt ist, springt das Programm in die entsprechende Routine. Vor einem nächsten Tastendruck muss die Taste losgelassen worden sein. Dadurch wird verhindert, dass SOFORT wieder in die Routine gesprungen wird, wenn die Taste gedrückt gehalten wird.
Ein Codeschloß mit 4 (5) Tastern- eine sinnvolle erste Anwendung
Viele Taster haben wir beispielsweise bei Codeschlössern. Meist mehr als vier, aber auch mit vier Tastern kann schon ein effektives Codeschloß aufgebaut werden.
Einige Vorüberlegungen sind hierzu aber notwendig. Zuerst ist es wichtig, dass wir zum Eingabestart immer die gleichen Ausgangsbedingungen haben. Hierzu könnten wir einen der vier Taster verwenden, um unsere Laufvariablen, die wir im Anschluß bestimmen werden zurückzusetzen. Dieser Taster wäre sozusagen ein RESET (Rücksetz) Taster. Spätestens jetzt kommt da aber eine Idee: Unsere Platine hat doch einen festen Resttaster, der das Programm neu startet, also vordefinierte Zustände erzeugt.
Wir integrieren also den Resettaster in unser Eingabefeld und haben nun fünf Taster zur Verfügung, wobei der Resettaster immer als erstes betätigt werden muss. An welche Position wir den Resettaster in einem Tastfeld setzten würden, bleibt uns somit selber überlassen.
Bevor wir beginnen kümmern wir uns erst einmal um das Grundgerüst des Programms. Wir haben eine LED an Portb.0 und vier Taster an Portb.1 bisPortb.4:
Alles anzeigen
Soweit die Grundkonfiguration in gewohnter Form.
Jetzt wollen wir aber zunächst einmal überlegen, was an Variablen notwendig ist:
Dim I as Byte
Dim Passwort as Byte
Laßt uns jetzt das Programm Stück für Stück vervollständigen. Zunächst muß bei jedem Tastendruck die Laufvariable I um eins erhöht werden, damit das Programm weiß, wie oft die Taster bereits gedrückt wurden. Die Programmzeile kennen wir bereits, sie lautet: I=I+1 Diese muß natürlich jetzt in jede Taster- Subroutine eingefügt werden, da sie ja für alle Taster gleichermaßen gilt.
WIKI-Logo Merktext.jpg
Um eine Variable um 1 zu erhöhen gibt es übrigens einen eigenen Befehl in BASCOM. Statt I=I+1 können wir auch folgendes schreiben: Incr I. Auch hier wird jetzt die Variable I um eins erhöht. Soll eine Variable um 1 verringert werden, so lautet der Befehl (für die Variable I): Decr I.
Vervollständigen wir also unseren Code:
Alles anzeigen
Jetzt müssen wir nur noch das eigentliche Passwort generieren. Wir wollen dies hier nicht unnötig schwer machen, sondern addieren bei jedem Tastendruck nur einen bestimmten Wert zu unserer Variablen:
Wenn wir jetzt beispielsweise als Code die Reihenfolge: (RESET) Taste1, Taste2, Taste3, Taste4 verlangen, ändert sich die Variable Passwort folgendermaßen: 1+2+3+4 = 10. Wenn nach dem 4 Tastendruck die Variable Passwort = 10 ist, wird das Schloß freigegeben.
Verlangen wir als Reihenfolge: (RESET) Taste4, Taste4, Taste4, Taste4, so ändert sich das Passwort folgendermaßen: 4+4+4+4 = 16. In diesem Fall erwartet das Programm nach dem vierten Tastendruck eine 16 in der Variable Passwort zur Freigabe.
Das addieren der Werte für die Variable Passwort geschieht wie bereits erwähnt in den Tastersub´s. Die Auswertung selber muß aber in der Do- Loop- Schleife erfolgen:
Als erstes muß abgefragt werden ob die Taste bereits 4 mal betätigt wurde: If I = 4 then.... Danach muß abgefragt werden ob das Ergebnis der Variable Passwort mit dem vorbestimmten Wert übereinstimmt: If Passwort = xx then... Nun schalten wir die LED stellvertretend für einen Türöffner für 3 Sekunden ein und danach wieder aus. Abschließend erhöhen wir I noch um eins, damit die Schleife nicht erneut angesprungen wird und "Unwissende" fleißig weiter tippen können. Fertig ist unser Codeschloß:
Alles anzeigen
Verkabeln wir noch unsere Experimentierplatine und probieren dann unser Zahlenschloß aus. Den von Dir gewünschten Code mußt Du in der Do- Loop-Schleife hinter der Auswertung If Passwort = einsetzen. Vergesst nicht bei Eurem Code die Resttaste als erstes zu betätigen
Codeschloss 4 Taster.gif
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Du kannst in den Tastersub´s auch andere Zahlen addieren oder auchmultiplizieren um andere Ergebnisse zu erhalten. Auch einen 5 oder 6stelligenCode können wir nun leicht abfragen. TIP: Beim Einbau in eineZehnertastatur, läßt Du nicht verwendete Taster einfach ohne Funktion. So ist es auch schon bei diesem einfachen Codeschloß sehr schwierig dieses zu umgehen. Außerdem kennt keiner die Technik dahinter und das macht das "Knacken" des Schlosses ohnehin schwierig.
Verbesserungsmöglichkeiten für das Codeschloß
Das Codeschloß ist sicherlich sehr einfach gestrickt. Es ist aber fürBASCOM- Anfänger bestimmt. Es ging hier nicht darum ein kryptisch ausgefeiltes System zu präsentieren, sondern darum eine praktische Anwendung mit den wenigen Portpins des Attiny13 zu zeigen.
Die gewählten "Zahlen" können im Beispiel in beliebiger Reihenfolge eingegeben werden, was die Möglichkeiten natürlich stark einschränkt.
Um die Reihenfolge der Zahleneingabe auszuwerten und damit die Kombinationsmöglichkeiten deutlich zu erhöhen, muß dies in die Do- Loop-Schleife eingearbeitet werden. Zu diesem Zeitpunkt des Mikrocontrollerkurses ist diese Umsetzung jedoch verfrüht. Hier beschäftigen wir uns zunächst vorrangig mit den Grundfunktionen der Mikrocontrollerprogrammierung.
In einem Erweiterungsbeitrag findest Du die Entwicklung für einen mehrstelligen Code, der auch die Tasterreihenfolge mit einbezieht:
1.2.1a Logische Programmentwicklung am Beispiel des Codeschlosses
So geht es weiter
Nach der Einführung in die Auswertung von Tastern kehren wir noch einmal zuden Leuchtdioden zurück. Diesmal zu den Würfel- LED´s, denn deren Ansteuerung
ist ohne Taster ziemlich sinnlos.
Hier geht es zum Thema1.2.2 ElektronischerWürfel mit Tasterbedienung
Welche Möglichkeiten des Entprellens gibt es
Es gibt programmtechnisch mehrere Möglichkeiten das Prellen zu unterbinden. Generell würde dies so ablaufen, das nach dem Feststellen des Tastendrucks eine Weile (einige Millisekunden) gewartet wird und dann noch einmal überprüft wird, ob nach dieser Zeitspanne der Taster immer noch gedrückt ist. Wenn ja, dann wird das Ereignis im Programm als Tasterdruck gewertet. Die Zeitspannenmessung könnte dabei mit waitms oder mittels Timerinterrupt realisiert werden.
Beide Varianten erfordern viel Aufmerksamkeit beim Programmieren. BASCOM bringt hier aber schon einen vorgefertigten Befehl für uns:
Tasterauswertung mit Debounce
Der Befehl Debounce besteht aus zwei Teilen und arbeitet mit einer Subroutine, also einem Unterprogramm.
WIKI-Logo Merktext.jpg
Ein Unterprogramm ist ein in sich abgeschlossenes Programm innerhalb Eures Gesamtprogramms. Wenn keine Sonderform (wie hier bei Debounce) angewendet wird, springt man gewöhnlich mit dem Befehl Gosub (gehe zur (Sub) Unterroutine) zu einem solchen Teilprogramm. Hier werden beispielsweise Befehlsfolgen abgearbeitet, welche im Programm an unterschiedlichen Stellen immer in gleicher Form geschrieben werden müßten. Durch die Verwendung der Unterroutine braucht dieser Programmteil aber nur einmal geschrieben zu werden. Jedesmal wenn er ausgeführt werden soll wird mit dem Befehl Gosub in diesen Programmteil verzweigt. Das Hauptprogramm merkt sich die Stelle, an der es sozusagen "abgebogen" ist. Das Unterprogramm wird generell mit Return (Zurück) abgeschlossen. Das Programm weiß nun, dass die Unterroutine beendet ist und spring an die Stelle zurück, an der das Hauptprogramm mit Gosub verlassen wurde. Es kann auch in einer Unterroutine nochmals mit Gosub in eine weitere Unterroutine gesprungen werden. Man spricht in diesem Fall von "Verschachtelung"
Hinweis für Fortgeschrittene: Je mehr Unterroutinen verschachtelt werden, um so mehr Rücksprungadressen muss sich der Controller merken. Dies muss bei der Wertangabe der Stacks berücksichtigt werden! Mehr Informationen zu den Stack´s gibt es hier:Speicheraufbau
Wie im Merktext beschrieben handelt es sich bei Debounce in gewisser Weise um eine Sonderform. Wir erstellen zwar eine Unterroutine, springen aber nicht mit Gosub in diese sondern verwenden folgende Schreibweise, wobei zu beachten ist, dass der Befehl Debounce sich innerhalb der Do- Loop- Schleife befindet !:
Zuvor haben wir einen Pin unseres Controllers als Eingang definiert und ihm einen Alias zugewiesen, sowie den internen Pullupwiderstand aktiviert. Ihr wißt sicher noch wie es geht:
Config Portb.2 = Input
Taster Alias Pinb.2
Portb.2 = 1'Pullupwiderstand
Kommen wir also jetzt zur Befehlssyntax, die innerhalb der Do- Loop- Schleife steht:
Debounce Taster , 0 , Taster_gedrueckt , Sub
Dies Bedarf sicher noch einiger Erklärungen. Also:
- Zuerst mal Debounce, klar, um den Befehl aufzurufen.
- Dann Taster. Dies ist in unserem Fall der Alias für Pinb.2 , Es könnte also auch Pinb.2 hier stehen, mit Alias ist es aber einfacher. Es wird also angegeben, für welchen Pin der Befehl gültig sein soll.
- Jetzt folgt (von einem Komma getrennt !!!) eine 0. Alternativ kann hier eine 1 stehen und besagt nur, ob unser Taster bei Betätigung nach Plus (VCC) oder Minus GND) gezogen wird, Ihr erinnert Euch, dies wurde auf der vorherigen Seite beschrieben. Wir haben unsere Taster auf der Original- Experimentierplatine gegen Minus (GND) geschaltet, daher hier im Debouncebefehl die "0"
- Nun folgt in unserem Beispiel, von einem weiteren Komma getrennt der Text: "Taster_gedrueckt". Ich habe erläutert, dass wir hier mit einem Unterprogramm arbeiten und da in einem Programm mehrere Unterprogramme Verwendung finden können, muß unser Unterprogramm einen Namen haben, damit das Programm weiß, zu welcher Subroutine es bei der Tasterbetätigung springen soll. Der Name ist mit Ausnahme der reservierten Worte (welche im Editor andersfarbig erscheinen) frei wählbar. Ich habe hier "Taster_gedrueckt" gewählt, weil damit die Funktion gut beschrieben wird.
- Nach einem weiteren Komma folgt noch Sub, dass nehmen wir als zum Befehl gehörend einfach so zur Kenntnis und wird nicht geändert.
WIKI-Logo Merktext.jpg
Unterprogramme (Subroutinen) beginnen in BASCOM mit einem eindeutigen Namen und einem nachfolgendem Doppelpunkt. Unterprogramme (Subroutinen) werden immer mit Return beendet (verlassen).
In unserem Fall sieht das dann folgendermaßen aus:
BASCOM-Quellcode
- '==============================================================================
- 'Sub- Routinen (ein Kommentartext kann nicht schaden!!!
- '------------------------------------------------------------------------------
- Taster_gedrueckt:
- 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
- Return
Zum Beispiel können wir eine Variable mit jedem Tasterdruck um 1 erhöhen:
Schauen wir uns mal ein komplettes Programm an
Im folgenden Beispielprogramm wird mittels Taster eine LED unseresExperimentierboards ein- und wieder ausgeschaltet. Die Jumper undKabelverbindungen bleiben wie beim vorangegangenen Experiment:
Erstes Tasterprogramm.png
So werden Brücken und Jumper für das folgende Programm gesteckt
BASCOM-Quellcode
- '************************************************************
- ' Kleiner Mikrocontroller Einsteigerkurs
- ' (c) 2013/2014 ceperiga
- '------------------------------------------------------------
- ' Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- ' Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- ' Name:
- ' Unit: 1.2.1
- '------------------------------------------------------------
- 'Beschreibung: Debounce Toggeln einer LED mittels Taster
- '************************************************************
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 6 'Stackwerte und Framesize weisen
- $swstack = 6
- $framesize = 28
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- '
- '==============================================================================
- Config Portb.0 = Output
- Led Alias Portb.0
- Config Portb.1 = Input
- Taster Alias Pinb.1
- Portb.1 = 1 'Pullupwiderstand
- '==============================================================================
- 'Hauptprogramm
- '------------------------------------------------------------------------------
- Do
- Debounce Taster , 0 , Taster_gedrueckt , Sub
- Loop
- '==============================================================================
- 'Sub- Routinen
- '------------------------------------------------------------------------------
- Taster_gedrueckt:
- Toggle Led
- Return
- '==============================================================================
- End 'end program
Was passiert nun in diesem Programm? Bei jedem Schleifendurchlauf wird geprüft, ob die entsprechende Taste gedrückt ist. Wenn das nicht der Fall ist, dann läuft das Programm einfach weiter zum nächsten Befehl (hier also zu Loop und anschließend zu Do und dann wieder zur Tasterabfrage). Wenn die entsprechende Taste gedrückt ist dann wartet das Programm, damit das Kontaktprellen sich beruhigen kann. Wenn dann die Taste immer noch gedrückt ist, springt das Programm in die entsprechende Routine. Vor einem nächsten Tastendruck muss die Taste losgelassen worden sein. Dadurch wird verhindert, dass SOFORT wieder in die Routine gesprungen wird, wenn die Taste gedrückt gehalten wird.
Ein Codeschloß mit 4 (5) Tastern- eine sinnvolle erste Anwendung
Viele Taster haben wir beispielsweise bei Codeschlössern. Meist mehr als vier, aber auch mit vier Tastern kann schon ein effektives Codeschloß aufgebaut werden.
Einige Vorüberlegungen sind hierzu aber notwendig. Zuerst ist es wichtig, dass wir zum Eingabestart immer die gleichen Ausgangsbedingungen haben. Hierzu könnten wir einen der vier Taster verwenden, um unsere Laufvariablen, die wir im Anschluß bestimmen werden zurückzusetzen. Dieser Taster wäre sozusagen ein RESET (Rücksetz) Taster. Spätestens jetzt kommt da aber eine Idee: Unsere Platine hat doch einen festen Resttaster, der das Programm neu startet, also vordefinierte Zustände erzeugt.
Wir integrieren also den Resettaster in unser Eingabefeld und haben nun fünf Taster zur Verfügung, wobei der Resettaster immer als erstes betätigt werden muss. An welche Position wir den Resettaster in einem Tastfeld setzten würden, bleibt uns somit selber überlassen.
Bevor wir beginnen kümmern wir uns erst einmal um das Grundgerüst des Programms. Wir haben eine LED an Portb.0 und vier Taster an Portb.1 bisPortb.4:
BASCOM-Quellcode
- '************************************************************
- ' Kleiner Mikrocontroller Einsteigerkurs
- ' (c) 2013/2014 ceperiga
- '------------------------------------------------------------
- ' Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- ' Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- ' Name:
- ' Unit: 1.2.1
- '------------------------------------------------------------
- 'Beschreibung: Codeschloß mit 4 (5) Tastern
- '************************************************************
- '==============================================================================
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 32 'Grundeinstellung
- $swstack = 4 'Grundeinstellung
- $framesize = 4 'Grundeinstellung
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- 'Ausgang configurieren
- Config Portb.0 = Output
- Led Alias Portb.0
- 'Eingänge configurieren
- Config Portb.1 = Input
- Taster_1 Alias Pinb.1
- Portb.1 = 1 'Pullupwiderstand
- Config Portb.2 = Input
- Taster_2 Alias Pinb.2
- Portb.2 = 1 'Pullupwiderstand
- Config Portb.3 = Input
- Taster_3 Alias Pinb.3
- Portb.3 = 1 'Pullupwiderstand
- Config Portb.4 = Input
- Taster_4 Alias Pinb.4
- Portb.4 = 1 'Pullupwiderstand
- 'Natürlich benötigen wir jetzt für jeden Taster eine Unterroutine ,
- 'Sowie jeweils einen Debouncebefehl in Der Do - Loop - Schleife:
- Do
- Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
- Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
- Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
- Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
- Loop
- End 'end program
- '-----------------------------------------------------------------------------
- 'Sub- Unterroutinen für Tasterauswertung:
- '-----------------------------------------------------------------------------
- Taster_1_gedrueckt:
- 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
- Return
- Taster_2_gedrueckt:
- 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
- Return
- Taster_3_gedrueckt:
- 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
- Return
- Taster_4_gedrueckt:
- 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
- Return
Soweit die Grundkonfiguration in gewohnter Form.
Jetzt wollen wir aber zunächst einmal überlegen, was an Variablen notwendig ist:
- Um einen mehrstelligen Code abzufragen benötigen wir zunächst eine Laufvariable, welche die eingegebene Stellenanzahl überwacht. Dies ist eine einfache Zählvariable die wir wieder mit I benennen können. Eine Bit- Variable wäre zu klein, aber eine Bytevariable reicht vollkommen aus.
- Darüber hinaus benötigen wir noch eine Variable, in welcher wir das aktuelle Passwort ablegen können. Wir benennen diese Passwort, um sie im Programm einfach zuordnen zu können. Für unser Beispiel reicht ebenfalls eine Bytevariable, weil wir bei der Passwortkonstruktion in unserem Beispielprogramm nicht über den Wert 16 hinauskommen. Möchtet Ihr das Programm später abwandeln, könnt Ihr den Variablentyp ja immer noch ändern.
Dim I as Byte
Dim Passwort as Byte
Laßt uns jetzt das Programm Stück für Stück vervollständigen. Zunächst muß bei jedem Tastendruck die Laufvariable I um eins erhöht werden, damit das Programm weiß, wie oft die Taster bereits gedrückt wurden. Die Programmzeile kennen wir bereits, sie lautet: I=I+1 Diese muß natürlich jetzt in jede Taster- Subroutine eingefügt werden, da sie ja für alle Taster gleichermaßen gilt.
WIKI-Logo Merktext.jpg
Um eine Variable um 1 zu erhöhen gibt es übrigens einen eigenen Befehl in BASCOM. Statt I=I+1 können wir auch folgendes schreiben: Incr I. Auch hier wird jetzt die Variable I um eins erhöht. Soll eine Variable um 1 verringert werden, so lautet der Befehl (für die Variable I): Decr I.
Vervollständigen wir also unseren Code:
BASCOM-Quellcode
- '************************************************************
- ' Kleiner Mikrocontroller Einsteigerkurs
- ' (c) 2013/2014 ceperiga
- '------------------------------------------------------------
- ' Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- ' Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- ' Name:
- ' Unit: 1.2.1
- '------------------------------------------------------------
- 'Beschreibung: Codeschloß mit 4 (5) Tastern
- '************************************************************
- '==============================================================================
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 32 'Grundeinstellung
- $swstack = 4 'Grundeinstellung
- $framesize = 4 'Grundeinstellung
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- 'Ausgang configurieren
- Config Portb.0 = Output
- Led Alias Portb.0
- 'Eingänge configurieren
- Config Portb.1 = Input
- Taster_1 Alias Pinb.1
- Portb.1 = 1 'Pullupwiderstand
- Config Portb.2 = Input
- Taster_2 Alias Pinb.2
- Portb.2 = 1 'Pullupwiderstand
- Config Portb.3 = Input
- Taster_3 Alias Pinb.3
- Portb.3 = 1 'Pullupwiderstand
- Config Portb.4 = Input
- Taster_4 Alias Pinb.4
- Portb.4 = 1 'Pullupwiderstand
- '---------------------------------------------------------------------------
- 'Variablen Dimensionieren
- '---------------------------------------------------------------------------
- Dim I as Byte
- Dim Passwort as Byte
- '---------------------------------------------------------------------------
- 'Hauptprogramm
- '---------------------------------------------------------------------------
- Do
- Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
- Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
- Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
- Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
- Loop
- End 'End program
- '---------------------------------------------------------------------------
- 'Sub-Routinen für Tasterauswertung
- '---------------------------------------------------------------------------
- Taster_1_gedrueckt:
- Incr I 'I im 1 erhöhen statt I=I+1
- Return
- Taster_2_gedrueckt:
- Incr I 'I im 1 erhöhen statt I=I+1
- Return
- Taster_3_gedrueckt:
- Incr I 'I im 1 erhöhen statt I=I+1
- Return
- Taster_4_gedrueckt:
- Incr I 'I im 1 erhöhen statt I=I+1
- Return
- Bei Taster 1 eine 1
- Bei Taster 2 eine 2
- Bei Taster 3 eine 3
- Bei Taster 4 eine 4
Wenn wir jetzt beispielsweise als Code die Reihenfolge: (RESET) Taste1, Taste2, Taste3, Taste4 verlangen, ändert sich die Variable Passwort folgendermaßen: 1+2+3+4 = 10. Wenn nach dem 4 Tastendruck die Variable Passwort = 10 ist, wird das Schloß freigegeben.
Verlangen wir als Reihenfolge: (RESET) Taste4, Taste4, Taste4, Taste4, so ändert sich das Passwort folgendermaßen: 4+4+4+4 = 16. In diesem Fall erwartet das Programm nach dem vierten Tastendruck eine 16 in der Variable Passwort zur Freigabe.
Das addieren der Werte für die Variable Passwort geschieht wie bereits erwähnt in den Tastersub´s. Die Auswertung selber muß aber in der Do- Loop- Schleife erfolgen:
Als erstes muß abgefragt werden ob die Taste bereits 4 mal betätigt wurde: If I = 4 then.... Danach muß abgefragt werden ob das Ergebnis der Variable Passwort mit dem vorbestimmten Wert übereinstimmt: If Passwort = xx then... Nun schalten wir die LED stellvertretend für einen Türöffner für 3 Sekunden ein und danach wieder aus. Abschließend erhöhen wir I noch um eins, damit die Schleife nicht erneut angesprungen wird und "Unwissende" fleißig weiter tippen können. Fertig ist unser Codeschloß:
BASCOM-Quellcode
- '************************************************************
- ' Kleiner Mikrocontroller Einsteigerkurs
- ' (c) 2013/2014 ceperiga
- '------------------------------------------------------------
- ' Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- ' Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- ' Name:
- ' Unit: 1.2.1
- '------------------------------------------------------------
- 'Beschreibung: Codeschloß mit 4 (5) Tastern
- '************************************************************
- '==============================================================================
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 32 'Grundeinstellung
- $swstack = 4 'Grundeinstellung
- $framesize = 4 'Grundeinstellung
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- 'Ausgang configurieren
- Config Portb.0 = Output
- Led Alias Portb.0
- 'Eingänge configurieren
- Config Portb.1 = Input
- Taster_1 Alias Pinb.1
- Portb.1 = 1 'Pullupwiderstand
- Config Portb.2 = Input
- Taster_2 Alias Pinb.2
- Portb.2 = 1 'Pullupwiderstand
- Config Portb.3 = Input
- Taster_3 Alias Pinb.3
- Portb.3 = 1 'Pullupwiderstand
- Config Portb.4 = Input
- Taster_4 Alias Pinb.4
- Portb.4 = 1 'Pullupwiderstand
- '---------------------------------------------------------------------------
- 'Variablen Dimensionieren
- '---------------------------------------------------------------------------
- Dim I as Byte
- Dim Passwort as Byte
- '---------------------------------------------------------------------------
- 'Hauptprogramm
- '---------------------------------------------------------------------------
- Do
- Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
- Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
- Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
- Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
- 'Auswertung
- '--------------------------------------------------------------------------
- If I = 4 then
- If Passwort = 16 then
- Led = 1 'Türöffner einschalten
- Wait 3
- Led =0 'Türöffner ausschalten
- End if
- Incr I 'Wir erhöhen I um 1, damit die Schleife nicht erneut angesprungen wird
- End if
- Loop
- '---------------------------------------------------------------------------
- 'Sub-Routinen für Tasterauswertung
- '---------------------------------------------------------------------------
- Taster_1_gedrueckt:
- Incr I 'I um 1 erhöhen statt I=I+1
- Passwort = Passwort + 1
- Return
- Taster_2_gedrueckt:
- Incr I 'I um 1 erhöhen statt I=I+1
- Passwort = Passwort + 2
- Return
- Taster_3_gedrueckt:
- Incr I 'I um 1 erhöhen statt I=I+1
- Passwort = Passwort + 3
- Return
- Taster_4_gedrueckt:
- Incr I 'I um 1 erhöhen statt I=I+1
- Passwort = Passwort + 4
- Return
Verkabeln wir noch unsere Experimentierplatine und probieren dann unser Zahlenschloß aus. Den von Dir gewünschten Code mußt Du in der Do- Loop-Schleife hinter der Auswertung If Passwort = einsetzen. Vergesst nicht bei Eurem Code die Resttaste als erstes zu betätigen
Codeschloss 4 Taster.gif
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Du kannst in den Tastersub´s auch andere Zahlen addieren oder auchmultiplizieren um andere Ergebnisse zu erhalten. Auch einen 5 oder 6stelligenCode können wir nun leicht abfragen. TIP: Beim Einbau in eineZehnertastatur, läßt Du nicht verwendete Taster einfach ohne Funktion. So ist es auch schon bei diesem einfachen Codeschloß sehr schwierig dieses zu umgehen. Außerdem kennt keiner die Technik dahinter und das macht das "Knacken" des Schlosses ohnehin schwierig.
Verbesserungsmöglichkeiten für das Codeschloß
Das Codeschloß ist sicherlich sehr einfach gestrickt. Es ist aber fürBASCOM- Anfänger bestimmt. Es ging hier nicht darum ein kryptisch ausgefeiltes System zu präsentieren, sondern darum eine praktische Anwendung mit den wenigen Portpins des Attiny13 zu zeigen.
Die gewählten "Zahlen" können im Beispiel in beliebiger Reihenfolge eingegeben werden, was die Möglichkeiten natürlich stark einschränkt.
Um die Reihenfolge der Zahleneingabe auszuwerten und damit die Kombinationsmöglichkeiten deutlich zu erhöhen, muß dies in die Do- Loop-Schleife eingearbeitet werden. Zu diesem Zeitpunkt des Mikrocontrollerkurses ist diese Umsetzung jedoch verfrüht. Hier beschäftigen wir uns zunächst vorrangig mit den Grundfunktionen der Mikrocontrollerprogrammierung.
In einem Erweiterungsbeitrag findest Du die Entwicklung für einen mehrstelligen Code, der auch die Tasterreihenfolge mit einbezieht:
1.2.1a Logische Programmentwicklung am Beispiel des Codeschlosses
So geht es weiter
Nach der Einführung in die Auswertung von Tastern kehren wir noch einmal zuden Leuchtdioden zurück. Diesmal zu den Würfel- LED´s, denn deren Ansteuerung
ist ohne Taster ziemlich sinnlos.
Hier geht es zum Thema1.2.2 ElektronischerWürfel mit Tasterbedienung
14.290 mal gelesen