MCK 1.2.1 Entprellen von Tastern

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Entprellen von Tastern
    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.



    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:
    1. Zuerst mal Debounce, klar, um den Befehl aufzurufen.
    2. 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.
    3. 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"
    4. 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.
    5. Nach einem weiteren Komma folgt noch Sub, dass nehmen wir als zum Befehl gehörend einfach so zur Kenntnis und wird nicht geändert.
    Nachdem wir nun den Befehl in der Do- Loop- Schleife kennen gelernt haben, fehlt nur noch die eigentliche Subroutine



    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

    1. '==============================================================================
    2. 'Sub- Routinen (ein Kommentartext kann nicht schaden!!!
    3. '------------------------------------------------------------------------------
    4. Taster_gedrueckt:
    5. 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
    6. Return

    Zum Beispiel können wir eine Variable mit jedem Tasterdruck um 1 erhöhen:

    BASCOM-Quellcode

    1. '==============================================================================
    2. 'Sub- Routinen (ein Kommentartext kann nicht schaden!!!
    3. '------------------------------------------------------------------------------
    4. Taster_gedrueckt
    5. I=I+1
    6. Return
    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:


    So werden Brücken und Jumper für das folgende Programm gesteckt

    BASCOM-Quellcode

    1. '************************************************************
    2. ' Kleiner Mikrocontroller Einsteigerkurs
    3. ' (c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. ' Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. ' Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. ' Name:
    12. ' Unit: 1.2.1
    13. '------------------------------------------------------------
    14. 'Beschreibung: Debounce Toggeln einer LED mittels Taster
    15. '************************************************************
    16. $regfile = "attiny13.dat" 'verwendeter Controller
    17. $crystal = 1200000 'Taktfrequenz
    18. $hwstack = 6 'Stackwerte und Framesize weisen
    19. $swstack = 6
    20. $framesize = 28
    21. '==============================================================================
    22. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    23. '------------------------------------------------------------------------------
    24. '
    25. '==============================================================================
    26. Config Portb.0 = Output
    27. Led Alias Portb.0
    28. Config Portb.1 = Input
    29. Taster Alias Pinb.1
    30. Portb.1 = 1 'Pullupwiderstand
    31. '==============================================================================
    32. 'Hauptprogramm
    33. '------------------------------------------------------------------------------
    34. Do
    35. Debounce Taster , 0 , Taster_gedrueckt , Sub
    36. Loop
    37. '==============================================================================
    38. 'Sub- Routinen
    39. '------------------------------------------------------------------------------
    40. Taster_gedrueckt:
    41. Toggle Led
    42. Return
    43. '==============================================================================
    44. End 'end program
    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:

    BASCOM-Quellcode

    1. '************************************************************
    2. ' Kleiner Mikrocontroller Einsteigerkurs
    3. ' (c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. ' Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. ' Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. ' Name:
    12. ' Unit: 1.2.1
    13. '------------------------------------------------------------
    14. 'Beschreibung: Codeschloß mit 4 (5) Tastern
    15. '************************************************************
    16. '==============================================================================
    17. $regfile = "attiny13.dat" 'verwendeter Controller
    18. $crystal = 1200000 'Taktfrequenz
    19. $hwstack = 32 'Grundeinstellung
    20. $swstack = 4 'Grundeinstellung
    21. $framesize = 4 'Grundeinstellung
    22. '==============================================================================
    23. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    24. '------------------------------------------------------------------------------
    25. 'Ausgang configurieren
    26. Config Portb.0 = Output
    27. Led Alias Portb.0
    28. 'Eingänge configurieren
    29. Config Portb.1 = Input
    30. Taster_1 Alias Pinb.1
    31. Portb.1 = 1 'Pullupwiderstand
    32. Config Portb.2 = Input
    33. Taster_2 Alias Pinb.2
    34. Portb.2 = 1 'Pullupwiderstand
    35. Config Portb.3 = Input
    36. Taster_3 Alias Pinb.3
    37. Portb.3 = 1 'Pullupwiderstand
    38. Config Portb.4 = Input
    39. Taster_4 Alias Pinb.4
    40. Portb.4 = 1 'Pullupwiderstand
    41. 'Natürlich benötigen wir jetzt für jeden Taster eine Unterroutine ,
    42. 'Sowie jeweils einen Debouncebefehl in Der Do - Loop - Schleife:
    43. Do
    44. Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
    45. Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
    46. Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
    47. Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
    48. Loop
    49. End 'end program
    50. '-----------------------------------------------------------------------------
    51. 'Sub- Unterroutinen für Tasterauswertung:
    52. '-----------------------------------------------------------------------------
    53. Taster_1_gedrueckt:
    54. 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
    55. Return
    56. Taster_2_gedrueckt:
    57. 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
    58. Return
    59. Taster_3_gedrueckt:
    60. 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
    61. Return
    62. Taster_4_gedrueckt:
    63. 'Hier stehen die Anweisungen die bei Tastendruck ausgeführt werden sollen
    64. Return
    Alles anzeigen

    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.
    Wir richten also unsere Variablen folgendermaßen ein:

    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.



    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

    1. '************************************************************
    2. ' Kleiner Mikrocontroller Einsteigerkurs
    3. ' (c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. ' Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. ' Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. ' Name:
    12. ' Unit: 1.2.1
    13. '------------------------------------------------------------
    14. 'Beschreibung: Codeschloß mit 4 (5) Tastern
    15. '************************************************************
    16. '==============================================================================
    17. $regfile = "attiny13.dat" 'verwendeter Controller
    18. $crystal = 1200000 'Taktfrequenz
    19. $hwstack = 32 'Grundeinstellung
    20. $swstack = 4 'Grundeinstellung
    21. $framesize = 4 'Grundeinstellung
    22. '==============================================================================
    23. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    24. '------------------------------------------------------------------------------
    25. 'Ausgang configurieren
    26. Config Portb.0 = Output
    27. Led Alias Portb.0
    28. 'Eingänge configurieren
    29. Config Portb.1 = Input
    30. Taster_1 Alias Pinb.1
    31. Portb.1 = 1 'Pullupwiderstand
    32. Config Portb.2 = Input
    33. Taster_2 Alias Pinb.2
    34. Portb.2 = 1 'Pullupwiderstand
    35. Config Portb.3 = Input
    36. Taster_3 Alias Pinb.3
    37. Portb.3 = 1 'Pullupwiderstand
    38. Config Portb.4 = Input
    39. Taster_4 Alias Pinb.4
    40. Portb.4 = 1 'Pullupwiderstand
    41. '---------------------------------------------------------------------------
    42. 'Variablen Dimensionieren
    43. '---------------------------------------------------------------------------
    44. Dim I as Byte
    45. Dim Passwort as Byte
    46. '---------------------------------------------------------------------------
    47. 'Hauptprogramm
    48. '---------------------------------------------------------------------------
    49. Do
    50. Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
    51. Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
    52. Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
    53. Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
    54. Loop
    55. End 'End program
    56. '---------------------------------------------------------------------------
    57. 'Sub-Routinen für Tasterauswertung
    58. '---------------------------------------------------------------------------
    59. Taster_1_gedrueckt:
    60. Incr I 'I im 1 erhöhen statt I=I+1
    61. Return
    62. Taster_2_gedrueckt:
    63. Incr I 'I im 1 erhöhen statt I=I+1
    64. Return
    65. Taster_3_gedrueckt:
    66. Incr I 'I im 1 erhöhen statt I=I+1
    67. Return
    68. Taster_4_gedrueckt:
    69. Incr I 'I im 1 erhöhen statt I=I+1
    70. Return
    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:
    • Bei Taster 1 eine 1
    • Bei Taster 2 eine 2
    • Bei Taster 3 eine 3
    • Bei Taster 4 eine 4
    Folglich müssen wir in den einzelnen Taster- Sub´s nur die entsprechenden Werte zur Variablen Passwort hinzuaddieren.

    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

    1. '************************************************************
    2. ' Kleiner Mikrocontroller Einsteigerkurs
    3. ' (c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. ' Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. ' Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. ' Name:
    12. ' Unit: 1.2.1
    13. '------------------------------------------------------------
    14. 'Beschreibung: Codeschloß mit 4 (5) Tastern
    15. '************************************************************
    16. '==============================================================================
    17. $regfile = "attiny13.dat" 'verwendeter Controller
    18. $crystal = 1200000 'Taktfrequenz
    19. $hwstack = 32 'Grundeinstellung
    20. $swstack = 4 'Grundeinstellung
    21. $framesize = 4 'Grundeinstellung
    22. '==============================================================================
    23. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    24. '------------------------------------------------------------------------------
    25. 'Ausgang configurieren
    26. Config Portb.0 = Output
    27. Led Alias Portb.0
    28. 'Eingänge configurieren
    29. Config Portb.1 = Input
    30. Taster_1 Alias Pinb.1
    31. Portb.1 = 1 'Pullupwiderstand
    32. Config Portb.2 = Input
    33. Taster_2 Alias Pinb.2
    34. Portb.2 = 1 'Pullupwiderstand
    35. Config Portb.3 = Input
    36. Taster_3 Alias Pinb.3
    37. Portb.3 = 1 'Pullupwiderstand
    38. Config Portb.4 = Input
    39. Taster_4 Alias Pinb.4
    40. Portb.4 = 1 'Pullupwiderstand
    41. '---------------------------------------------------------------------------
    42. 'Variablen Dimensionieren
    43. '---------------------------------------------------------------------------
    44. Dim I as Byte
    45. Dim Passwort as Byte
    46. '---------------------------------------------------------------------------
    47. 'Hauptprogramm
    48. '---------------------------------------------------------------------------
    49. Do
    50. Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
    51. Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
    52. Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
    53. Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
    54. 'Auswertung
    55. '--------------------------------------------------------------------------
    56. If I = 4 then
    57. If Passwort = 16 then
    58. Led = 1 'Türöffner einschalten
    59. Wait 3
    60. Led =0 'Türöffner ausschalten
    61. End if
    62. Incr I 'Wir erhöhen I um 1, damit die Schleife nicht erneut angesprungen wird
    63. End if
    64. Loop
    65. '---------------------------------------------------------------------------
    66. 'Sub-Routinen für Tasterauswertung
    67. '---------------------------------------------------------------------------
    68. Taster_1_gedrueckt:
    69. Incr I 'I um 1 erhöhen statt I=I+1
    70. Passwort = Passwort + 1
    71. Return
    72. Taster_2_gedrueckt:
    73. Incr I 'I um 1 erhöhen statt I=I+1
    74. Passwort = Passwort + 2
    75. Return
    76. Taster_3_gedrueckt:
    77. Incr I 'I um 1 erhöhen statt I=I+1
    78. Passwort = Passwort + 3
    79. Return
    80. Taster_4_gedrueckt:
    81. Incr I 'I um 1 erhöhen statt I=I+1
    82. Passwort = Passwort + 4
    83. Return
    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



    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

    483 mal gelesen