Noch nicht formatierte Fassung und noch ohne Grafiken (Übertrag gesicherter Daten aus dem zerstörten WIKI, in Bearbeitung)
1.2.1a Logische Programmentwicklung am Beispiel des Codeschlosses
Wie bereits beschrieben, ist das bisher vorgestellte Codeschloßprogramm recht einfacher Natur. Es sollte lediglich an einem praxisnahen Beispiel die Verwendung von mehreren Tastern verdeutlichen.
Zwar wird eine vierstellige Tastenbetätigung abgefragt, die Reihenfolge ist aber beliebig und auch verschiedene Tastenkombinationen sind nicht ausgeschlossen.
Das es auch anders geht, soll nun an einem neuen Programm demonstriert werden. Dies soll jetzt aber nicht einfach so präsentiert werden, sondern ich möchte die Änderungen schrittweise durchführen und jeweils vorher erläutern,was verändert werden soll und welche logischen Schlussfolgerungen zu diesen Änderungen geführt haben. Damit soll Euch näher gebracht werden, wie sich ein Programm von der Grundidee bis zum Endprodukt entwickelt, denn die wenigsten Programme werden ohne Änderungen einfach niedergeschrieben.
Ausschlaggebend für diese Erweiterung war der Kontakt mit businski im bascomforum. Mit Ihm habe ich wechselweise das Programm immer weiter eingekürzt, sodass immer mehr Speicherplatz des doch recht kleinen Attiny 13 eingespart werden konnte. An dieser Stelle also ein Dank an businski für die freundliche Unterstützung.
Unser Ausgangsprogramm zur Erinnerung
Alles anzeigen
Unsere Jumper und Kabelverbindungen sehen wie gehabt folgendermaßen aus:
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Unser Ziel in diesem Kapitel
Wir wollen jetzt erreichen, dass unser Codeschloss auch die richtige Reihenfolge der Tasterbetätigung mit auswertet. Dafür müssen wir uns erst einmal bewusst werden, was die Tastereingabe eigentlich bewirkt. Wir haben den Tastern die folgenden Funktionen zugewiesen:
Wenn wir die Zahlen jetzt nicht addieren sondern nebeneinander betrachten so erhalten wir bei viermaliger Betätigung der Taste 1 also folgendes:
1111 (also eintausendeinhundertundelf)
und bei viermaligem Betätigen der Taste 4 entsprechend folgendes:
4444 (also viertausendvierhundertvierundvierzig)
Was soll das ganze jetzt?
Ganz einfach:
Bei Eingabe von 1,2,3,4 erhalten wir:
1234 (also eintausendzweihundertvierunddreißig)
aber bei Eingabe von 4, 3, 2, 1:
4321 (also viertausenddreihunderteinundzwanzig)
Bei den letzten beiden Auswertungen haben wir die gleichen Tasten betätigt, wir konnten die Reihenfolge jedoch eindeutig unterscheiden.
Dies wollen wir jetzt auch in unserem Programm erreichen.
Da wir nur vier Taster zur Verfügung haben können wir hier nur Zahlen von 1111 bis 4444 eingeben. Die Funktion, welche wir im folgenden erstellen kann jedoch jede mehrstellige Zahl erzeugen die in unsere Zielvariable passt.
Zielvariable ist das richtige Stichwort: Bisher kennen wir die Bit- Variable, welche nur 0 oder 1 sein kann, sowie die Byte- Variable die, wie wir wissen eine 8 Bit- Variable ist und folglich Werte zwischen 0 und 255 annehmen kann.
Unsere jetzt geforderte höchste Eingabemöglichkeit (4444) passt folglich nicht in eine Byte- Variable. Also lernen wir jetzt mit der Word- Variable den nächsten Variablentyp kennen.
Die Word- Variable ist eine 16 Bit Variable und kann folglich Werte zwischen 0 und 65535 annehmen.
Wir generieren aus Einzeltasterbetätigungen eine mehrstellige Zahl
Was jetzt passiert ist nicht ganz leicht zu erklären. Wenn Ihr aber gleich seht wie es geht, werdet Ihr es sicher auf Anhieb verstehen. Unser Zugangscode soll hier nun 4321 sein.
Unsere Variable Passwort aus dem Beispielcode ist nach Programmstart ja erst einmal 0 (Wenn wir unser Codeschloß betätigen drücken wir zuerst die RESET-Taste, damit wir klare Ausgangsbedingungen haben und auch die Variable Passwort garantiert 0 ist.
Wenn wir Zahlen eintippen, beginnen wir ja gewöhnlich mit der linken Ziffer. In unserem Fall also die 4. In der Tasterroutine steht:
Passwort = Passwort + 4
Folglich wird aus Passwort = 0 jetzt Passwort = 4, soweit alles kein Problem. Die nächste Zahl, die 3 soll jetzt aber rechts von der 4 stehen, und dazu müßte die 4 praktisch erst einmal eine Stelle nach links rücken. Wir verwenden für unsere gängige Zahlendarstellung ja bekanntlich das Dezimalsystem. Also überlegen wir, welche kleinste Zahl wir kennen, bei der die 4 an erster Stelle steht:
Na?- ja die 40 ist die kleinste Zahl in unserem Dezimalsystem, bei der die 4 an erster Stelle steht. Und noch etwas wichtiges können wir erkennen: ganz rechts steht wieder eine 0 und eine 0 hatten wir auch als Ausgangsvariable.
Wie können wir erreichen, dass aus der 4 eine 40 wird?
Richtig, 4 x 10 = 40.
Wir müssen also unsere Variable Passwort mit 10 multiplizieren:
Passwort = Passwort * 10
Um Zahlen in BASCOM zu multiplizieren verwenden wir den Stern: * Ihr findet diesen gewöhnlich über dem +- Zeichen Beispiel siehe oben
Wenn wir jetzt die nächste Zahl (also die 3) eingeben, addieren wir zur Variablen Passwort (jetzt ja mit Wert 40) die 3.
40 + 3 = 43
Seht Ihr! die 3 steht genau da, wo wir sie haben möchten
Wenn wir 43 jetzt erneut mit 10 multiplizieren (430) haben wir Platz um die nächste Zahl (2) einzugeben.
Mit der 1 verfahren wir genauso.
Was müssen wir also in den Tasterroutinen machen? In jeder Tastersubroutine müssen wir zunächst mit 10 multiplizieren und dann den Tasterwert addieren.
Auch bei Eingabe der ersten Zahl stört die Multiplikation mit 10 nicht, obwohl wir da ja noch keine Stelle nach links rücken müssen, denn die Variable Passwort ist da ja noch 0 und 0 x 10 bleibt 0, also keine Veränderung.
Das ist doch eine geniale Spielerei mit der Mathematik. Mit solch logischen Überlegungen lassen sich viele Probleme bei der Programmierung von Mikrocontrollern lösen.
Lasst uns das Programm ergänzen und ausprobieren:
Alles anzeigen
Einige Veränderungen gibt es zu kommentieren:
Die Rechnung: Passwort = Passwort * 10 + 4 können wir also so nicht schreiben.
Stattdessen schreiben wir:
Passwort = Passwort * 10
Passwort = Passwort + x
Der Code kann noch kompakter werden
Wenn Ihr mal einen Blick auf die Taster- Subroutinen werft seht Ihr, dass diese sich kaum unterscheiden und bei der Zeile Passwort = Passwort *10 sogar identisch sind (haben wir ja gerade erst eingefügt)
Immer wenn Ihr so etwas seht, gibt es meist etwas zu komprimieren.
Bevor Ihr weiterlest solltet Ihr etwas nach oben scrollen und einmal selbstständig überlegen wie man so etwas erreichen kann
Als Sichtblocker auf den Folgetext gibt es hier noch einmal die Platinenansicht:
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Halten wir zunächst einmal fest: Im Programm passiert bei der Abfrage zunächst immer nur etwas, wenn eine Taste gedrückt wird. Wie könnten wir das mit einer Programmzeile ausdrücken?
Wenn kein Taster gedrückt wird, dann passiert nichts
oder anders herum ausgedrückt:
Wenn ein Taster (1, 2, 3 oder 4) gedrückt wird dann...
Wir brauchen also zunächst mal eine Variable für die Tasterbetätigung in die die Werte 1-4 passen:
Dim Taster as Byte' Werte 0,1,2,3,4 passen in diesen Variablentyp
Jetzt versuchen wir unsere Bedingung für BASCOM verständlich zu formulieren:
If Taster > 0 then 'hier folgt unsere Auswertung wenn ein Taster gedrückt wirdEnd If
Warum >(größer) als 0?
Wenn kein Taster gedrückt wurde sorgen wir im Programm dafür, das die Variable Taster immer = 0 ist, wir fragen also auf ungleich 0 ab, was in unserem Beispiel mit >(größer) 0 gleichzusetzen ist.
Da wir hier 4 Taster auswerten möchten müssen wir in der Taster- Subroutine noch festhalten, welcher Taster denn betätigt wurde und das geht ganz einfach:
'---------------------------------------------------------------------------'Sub-Routinen für Tasterauswertung'--------------------------------------------------------------------------- Taster_1_gedrueckt:
Taster = 1
Return
Taster_2_gedrueckt:
Taster = 2
Return
Taster_3_gedrueckt:
Taster = 3
Return
Taster_4_gedrueckt:
Taster = 4
Return
Das sollte soweit klar sein, der betätigte Taster weist der Variablen Taste den jeweiligen Wert zu:
If Taster > 0 Then
Passwort = Passwort * 10
Passwort = Passwort + Taster
Taster = 0
End If
Zum Abschluss unserer neu konstruierten Abfrageschleife setzten wir die Variable Taster wieder auf 0, da wir den aktuellen Wert ja addiert haben und Taster wieder 0 sein muss, damit nicht immer wieder erneut abgefragt wird, bevor ein neuer Tastendruck erfolgt.
Werfen wir einen Blick auf den neuen Code:
Alles anzeigen
Jetzt haben wir einen recht gut komprimierten Quellcode.
Weiterer Vorteil: Wir können auch ein zwei- oder dreistelliges Passwort ohne Änderung des eigentlichen Programms "programmieren". Selbst ein 5 stelliges Passwort funktioniert, sofern die Variable Passwort noch in die Word- Variable passt (siehe oben).
1.2.1a Logische Programmentwicklung am Beispiel des Codeschlosses
Wie bereits beschrieben, ist das bisher vorgestellte Codeschloßprogramm recht einfacher Natur. Es sollte lediglich an einem praxisnahen Beispiel die Verwendung von mehreren Tastern verdeutlichen.
Zwar wird eine vierstellige Tastenbetätigung abgefragt, die Reihenfolge ist aber beliebig und auch verschiedene Tastenkombinationen sind nicht ausgeschlossen.
Das es auch anders geht, soll nun an einem neuen Programm demonstriert werden. Dies soll jetzt aber nicht einfach so präsentiert werden, sondern ich möchte die Änderungen schrittweise durchführen und jeweils vorher erläutern,was verändert werden soll und welche logischen Schlussfolgerungen zu diesen Änderungen geführt haben. Damit soll Euch näher gebracht werden, wie sich ein Programm von der Grundidee bis zum Endprodukt entwickelt, denn die wenigsten Programme werden ohne Änderungen einfach niedergeschrieben.
Ausschlaggebend für diese Erweiterung war der Kontakt mit businski im bascomforum. Mit Ihm habe ich wechselweise das Programm immer weiter eingekürzt, sodass immer mehr Speicherplatz des doch recht kleinen Attiny 13 eingespart werden konnte. An dieser Stelle also ein Dank an businski für die freundliche Unterstützung.
Unser Ausgangsprogramm zur Erinnerung
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 im 1 erhöhen statt I=I+1
- Passwort = Passwort + 1
- Return
- Taster_2_gedrueckt:
- Incr I'I im 1 erhöhen statt I=I+1
- Passwort = Passwort + 2
- Return
- Taster_3_gedrueckt:
- Incr I'I im 1 erhöhen statt I=I+1
- Passwort = Passwort + 3
- Return
- Taster_4_gedrueckt:
- Incr I'I im 1 erhöhen statt I=I+1
- Passwort = Passwort + 4
- Return
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Unser Ziel in diesem Kapitel
Wir wollen jetzt erreichen, dass unser Codeschloss auch die richtige Reihenfolge der Tasterbetätigung mit auswertet. Dafür müssen wir uns erst einmal bewusst werden, was die Tastereingabe eigentlich bewirkt. Wir haben den Tastern die folgenden Funktionen zugewiesen:
- Taster 1 addiert den Wert 1
- Taster 2 addiert den Wert 2
- Taster 3 addiert den Wert 3
- Taster 4 addiert den Wert 4
Wenn wir die Zahlen jetzt nicht addieren sondern nebeneinander betrachten so erhalten wir bei viermaliger Betätigung der Taste 1 also folgendes:
1111 (also eintausendeinhundertundelf)
und bei viermaligem Betätigen der Taste 4 entsprechend folgendes:
4444 (also viertausendvierhundertvierundvierzig)
Was soll das ganze jetzt?
Ganz einfach:
Bei Eingabe von 1,2,3,4 erhalten wir:
1234 (also eintausendzweihundertvierunddreißig)
aber bei Eingabe von 4, 3, 2, 1:
4321 (also viertausenddreihunderteinundzwanzig)
Bei den letzten beiden Auswertungen haben wir die gleichen Tasten betätigt, wir konnten die Reihenfolge jedoch eindeutig unterscheiden.
Dies wollen wir jetzt auch in unserem Programm erreichen.
Da wir nur vier Taster zur Verfügung haben können wir hier nur Zahlen von 1111 bis 4444 eingeben. Die Funktion, welche wir im folgenden erstellen kann jedoch jede mehrstellige Zahl erzeugen die in unsere Zielvariable passt.
Zielvariable ist das richtige Stichwort: Bisher kennen wir die Bit- Variable, welche nur 0 oder 1 sein kann, sowie die Byte- Variable die, wie wir wissen eine 8 Bit- Variable ist und folglich Werte zwischen 0 und 255 annehmen kann.
Unsere jetzt geforderte höchste Eingabemöglichkeit (4444) passt folglich nicht in eine Byte- Variable. Also lernen wir jetzt mit der Word- Variable den nächsten Variablentyp kennen.
Die Word- Variable ist eine 16 Bit Variable und kann folglich Werte zwischen 0 und 65535 annehmen.
Wir generieren aus Einzeltasterbetätigungen eine mehrstellige Zahl
Was jetzt passiert ist nicht ganz leicht zu erklären. Wenn Ihr aber gleich seht wie es geht, werdet Ihr es sicher auf Anhieb verstehen. Unser Zugangscode soll hier nun 4321 sein.
Unsere Variable Passwort aus dem Beispielcode ist nach Programmstart ja erst einmal 0 (Wenn wir unser Codeschloß betätigen drücken wir zuerst die RESET-Taste, damit wir klare Ausgangsbedingungen haben und auch die Variable Passwort garantiert 0 ist.
Wenn wir Zahlen eintippen, beginnen wir ja gewöhnlich mit der linken Ziffer. In unserem Fall also die 4. In der Tasterroutine steht:
Passwort = Passwort + 4
Folglich wird aus Passwort = 0 jetzt Passwort = 4, soweit alles kein Problem. Die nächste Zahl, die 3 soll jetzt aber rechts von der 4 stehen, und dazu müßte die 4 praktisch erst einmal eine Stelle nach links rücken. Wir verwenden für unsere gängige Zahlendarstellung ja bekanntlich das Dezimalsystem. Also überlegen wir, welche kleinste Zahl wir kennen, bei der die 4 an erster Stelle steht:
Na?- ja die 40 ist die kleinste Zahl in unserem Dezimalsystem, bei der die 4 an erster Stelle steht. Und noch etwas wichtiges können wir erkennen: ganz rechts steht wieder eine 0 und eine 0 hatten wir auch als Ausgangsvariable.
Wie können wir erreichen, dass aus der 4 eine 40 wird?
Richtig, 4 x 10 = 40.
Wir müssen also unsere Variable Passwort mit 10 multiplizieren:
Passwort = Passwort * 10
Um Zahlen in BASCOM zu multiplizieren verwenden wir den Stern: * Ihr findet diesen gewöhnlich über dem +- Zeichen Beispiel siehe oben
Wenn wir jetzt die nächste Zahl (also die 3) eingeben, addieren wir zur Variablen Passwort (jetzt ja mit Wert 40) die 3.
40 + 3 = 43
Seht Ihr! die 3 steht genau da, wo wir sie haben möchten
Wenn wir 43 jetzt erneut mit 10 multiplizieren (430) haben wir Platz um die nächste Zahl (2) einzugeben.
Mit der 1 verfahren wir genauso.
Was müssen wir also in den Tasterroutinen machen? In jeder Tastersubroutine müssen wir zunächst mit 10 multiplizieren und dann den Tasterwert addieren.
Auch bei Eingabe der ersten Zahl stört die Multiplikation mit 10 nicht, obwohl wir da ja noch keine Stelle nach links rücken müssen, denn die Variable Passwort ist da ja noch 0 und 0 x 10 bleibt 0, also keine Veränderung.
Das ist doch eine geniale Spielerei mit der Mathematik. Mit solch logischen Überlegungen lassen sich viele Probleme bei der Programmierung von Mikrocontrollern lösen.
Lasst uns das Programm ergänzen und ausprobieren:
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.1a-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 Passwort as Word' Jetzt als word- Variable
- '---------------------------------------------------------------------------
- '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 Passwort = 4321 then'Hier steht unser Zugangscode
- Led = 1'Türöffner einschalten
- Wait 3
- Led =0'Türöffner ausschalten
- Passwort = 0'Zurücksetzen
- End if
- Loop
- '---------------------------------------------------------------------------
- 'Sub-Routinen für Tasterauswertung
- '---------------------------------------------------------------------------
- Taster_1_gedrueckt:
- Passwort = Passwort * 10
- Passwort = Passwort + 1
- Return
- Taster_2_gedrueckt:
- Passwort = Passwort * 10
- Passwort = Passwort + 2
- Return
- Taster_3_gedrueckt:
- Passwort = Passwort * 10
- Passwort = Passwort + 3
- Return
- Taster_4_gedrueckt:
- Passwort = Passwort * 10
- Passwort = Passwort + 4
- Return
Einige Veränderungen gibt es zu kommentieren:
- Wie erklärt geben wir in jeder Taster-Subroutine zusätzlich Passwort = Passwort * 10 ein
- Die Variable Passwort wandeln wir in eine Word- Variable um
- Die Variable I wird nicht mehr benötigt, die Zahl vergrößert sich automatisch (durch die Multiplikation mit 10)
- Die If- Abfrage mit I in der Do- Loop- Schleife entfällt, da die Variable Passwort ja direkt die richtige Größe erhält.
Die Rechnung: Passwort = Passwort * 10 + 4 können wir also so nicht schreiben.
Stattdessen schreiben wir:
Passwort = Passwort * 10
Passwort = Passwort + x
Der Code kann noch kompakter werden
Wenn Ihr mal einen Blick auf die Taster- Subroutinen werft seht Ihr, dass diese sich kaum unterscheiden und bei der Zeile Passwort = Passwort *10 sogar identisch sind (haben wir ja gerade erst eingefügt)
Immer wenn Ihr so etwas seht, gibt es meist etwas zu komprimieren.
Bevor Ihr weiterlest solltet Ihr etwas nach oben scrollen und einmal selbstständig überlegen wie man so etwas erreichen kann
Als Sichtblocker auf den Folgetext gibt es hier noch einmal die Platinenansicht:
So werden Brücken und Jumper für das oben stehende Programm gesteckt
Halten wir zunächst einmal fest: Im Programm passiert bei der Abfrage zunächst immer nur etwas, wenn eine Taste gedrückt wird. Wie könnten wir das mit einer Programmzeile ausdrücken?
Wenn kein Taster gedrückt wird, dann passiert nichts
oder anders herum ausgedrückt:
Wenn ein Taster (1, 2, 3 oder 4) gedrückt wird dann...
Wir brauchen also zunächst mal eine Variable für die Tasterbetätigung in die die Werte 1-4 passen:
Dim Taster as Byte' Werte 0,1,2,3,4 passen in diesen Variablentyp
Jetzt versuchen wir unsere Bedingung für BASCOM verständlich zu formulieren:
If Taster > 0 then 'hier folgt unsere Auswertung wenn ein Taster gedrückt wirdEnd If
Warum >(größer) als 0?
Wenn kein Taster gedrückt wurde sorgen wir im Programm dafür, das die Variable Taster immer = 0 ist, wir fragen also auf ungleich 0 ab, was in unserem Beispiel mit >(größer) 0 gleichzusetzen ist.
Da wir hier 4 Taster auswerten möchten müssen wir in der Taster- Subroutine noch festhalten, welcher Taster denn betätigt wurde und das geht ganz einfach:
'---------------------------------------------------------------------------'Sub-Routinen für Tasterauswertung'--------------------------------------------------------------------------- Taster_1_gedrueckt:
Taster = 1
Return
Taster_2_gedrueckt:
Taster = 2
Return
Taster_3_gedrueckt:
Taster = 3
Return
Taster_4_gedrueckt:
Taster = 4
Return
Das sollte soweit klar sein, der betätigte Taster weist der Variablen Taste den jeweiligen Wert zu:
- Taster 1 betätigt => Variable Taster = 1
- Taster 2 betätigt => Variable Taster = 2
- Taster 3 betätigt => Variable Taster = 3
- Taster 4 betätigt => Variable Taster = 4
If Taster > 0 Then
Passwort = Passwort * 10
Passwort = Passwort + Taster
Taster = 0
End If
Zum Abschluss unserer neu konstruierten Abfrageschleife setzten wir die Variable Taster wieder auf 0, da wir den aktuellen Wert ja addiert haben und Taster wieder 0 sein muss, damit nicht immer wieder erneut abgefragt wird, bevor ein neuer Tastendruck erfolgt.
Werfen wir einen Blick auf den neuen 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.1a-2
- '------------------------------------------------------------
- '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 Passwort as Word' Jetzt als word- Variable
- Dim Taster 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 Passwort = 4321 then'Hier steht unser Zugangscode
- Led = 1'Türöffner einschalten
- Wait 3
- Led =0'Türöffner ausschalten
- Passwort = 0'Zurücksetzen
- End if
- If Taster > 0 Then
- Passwort = Passwort * 10
- Passwort = Passwort + Taster
- Taster = 0
- End if
- Loop
- '---------------------------------------------------------------------------
- 'Sub-Routinen für Tasterauswertung
- '---------------------------------------------------------------------------
- Taster_1_gedrueckt:
- Taster = 1
- Return
- Taster_2_gedrueckt:
- Taster = 2
- Return
- Taster_3_gedrueckt:
- Taster = 3
- Return
- Taster_4_gedrueckt:
- Taster = 4
- Return
Weiterer Vorteil: Wir können auch ein zwei- oder dreistelliges Passwort ohne Änderung des eigentlichen Programms "programmieren". Selbst ein 5 stelliges Passwort funktioniert, sofern die Variable Passwort noch in die Word- Variable passt (siehe oben).
12.766 mal gelesen