MCK 1.2.1a Logische Programmentwicklung am Beispiel des Codeschlosses

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

  • Logische Programmentwicklung am Beispiel des Codeschlosses
    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


    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 im 1 erhöhen statt I=I+1
    70. Passwort = Passwort + 1
    71. Return
    72. Taster_2_gedrueckt:
    73. Incr I'I im 1 erhöhen statt I=I+1
    74. Passwort = Passwort + 2
    75. Return
    76. Taster_3_gedrueckt:
    77. Incr I'I im 1 erhöhen statt I=I+1
    78. Passwort = Passwort + 3
    79. Return
    80. Taster_4_gedrueckt:
    81. Incr I'I im 1 erhöhen statt I=I+1
    82. Passwort = Passwort + 4
    83. Return
    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:

    • Taster 1 addiert den Wert 1
    • Taster 2 addiert den Wert 2
    • Taster 3 addiert den Wert 3
    • Taster 4 addiert den Wert 4
    Dies ist erst einmal eine durchaus logische Zuordnung. Im Programm haben wir die einzelnen Werte addiert und so ein Ergebnis zwischen 4 (4 x 1) und 16 (4 x 4) erhalten.

    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

    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.1a-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 Passwort as Word' Jetzt als word- Variable
    45. '---------------------------------------------------------------------------
    46. 'Hauptprogramm
    47. '---------------------------------------------------------------------------
    48. Do
    49. Debounce Taster_1 , 0 , Taster_1_gedrueckt , Sub
    50. Debounce Taster_2 , 0 , Taster_2_gedrueckt , Sub
    51. Debounce Taster_3 , 0 , Taster_3_gedrueckt , Sub
    52. Debounce Taster_4 , 0 , Taster_4_gedrueckt , Sub
    53. 'Auswertung
    54. '--------------------------------------------------------------------------
    55. If Passwort = 4321 then'Hier steht unser Zugangscode
    56. Led = 1'Türöffner einschalten
    57. Wait 3
    58. Led =0'Türöffner ausschalten
    59. Passwort = 0'Zurücksetzen
    60. End if
    61. Loop
    62. '---------------------------------------------------------------------------
    63. 'Sub-Routinen für Tasterauswertung
    64. '---------------------------------------------------------------------------
    65. Taster_1_gedrueckt:
    66. Passwort = Passwort * 10
    67. Passwort = Passwort + 1
    68. Return
    69. Taster_2_gedrueckt:
    70. Passwort = Passwort * 10
    71. Passwort = Passwort + 2
    72. Return
    73. Taster_3_gedrueckt:
    74. Passwort = Passwort * 10
    75. Passwort = Passwort + 3
    76. Return
    77. Taster_4_gedrueckt:
    78. Passwort = Passwort * 10
    79. Passwort = Passwort + 4
    80. Return
    Alles anzeigen


    Einige Veränderungen gibt es zu kommentieren:

    1. Wie erklärt geben wir in jeder Taster-Subroutine zusätzlich Passwort = Passwort * 10 ein
    2. Die Variable Passwort wandeln wir in eine Word- Variable um
    3. Die Variable I wird nicht mehr benötigt, die Zahl vergrößert sich automatisch (durch die Multiplikation mit 10)
    4. Die If- Abfrage mit I in der Do- Loop- Schleife entfällt, da die Variable Passwort ja direkt die richtige Größe erhält.
    Wir können in BASCOM mehrbegriffige mathematische Berechnungen nicht in einer Zeile verarbeiten, sondern müssen diese in Teilschritte mit einer Operation aufteilen!
    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
    Jetzt haben wir alles vorbereitet, um die Abfrage in die Do- Loop- Schleife zu verschieben:


    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

    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.1a-2
    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 Passwort as Word' Jetzt als word- Variable
    45. Dim Taster 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 Passwort = 4321 then'Hier steht unser Zugangscode
    57. Led = 1'Türöffner einschalten
    58. Wait 3
    59. Led =0'Türöffner ausschalten
    60. Passwort = 0'Zurücksetzen
    61. End if
    62. If Taster > 0 Then
    63. Passwort = Passwort * 10
    64. Passwort = Passwort + Taster
    65. Taster = 0
    66. End if
    67. Loop
    68. '---------------------------------------------------------------------------
    69. 'Sub-Routinen für Tasterauswertung
    70. '---------------------------------------------------------------------------
    71. Taster_1_gedrueckt:
    72. Taster = 1
    73. Return
    74. Taster_2_gedrueckt:
    75. Taster = 2
    76. Return
    77. Taster_3_gedrueckt:
    78. Taster = 3
    79. Return
    80. Taster_4_gedrueckt:
    81. Taster = 4
    82. Return
    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).

    93 mal gelesen