MCK 1.1.3 Realistische Verkehrsampelsteuerung

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

  • Ampelsteuerung mitels Mikrocontroller
    1.1.3 Realistische Verkehrsampelsteuerung


    Einleitung
    Genauso einfach wie die Ansteuerung der LED- Zeile ist auch die Ansteuerung der Ampel- LED´s. Der Ablauf einer kompletten Ampelphase ist im Grunde genommen nichts anderes als ein spezielles Lauflicht mit unterschiedlicher Leuchtdauer der einzelnen LED´s.

    Genau diese unterschiedlichen Leuchtdauern sind bei der Umsetzung mit konventionellen elektronischen Bauteilen das Problem. Für die Umsetzung eines Lauflichtes gibt es schon seit langem spezielle Schaltkereise, die aber im Normalfall immer im gleichen Takt "weiterschalten". Bei der Simulation einer Ampel wurde daher immer die Leuchtdauer der gelben LED (als LED mit der kürzesten Schaltdauer) als Taktbasis verwendet. Die Rot- und Grünphase war somit immer ein vielfaches der Gelbphase. Wie wir kennen gelernt haben bereitet uns dies beim Mikroconteroller keine Schwierigkeiten. Dennoch gibt es doch einiges zu beachten.

    Vor allem jüngere Bascom- Einsteiger sind noch nicht mit den einzelnen Ampelphasen der deutschen Verkehrsampel vertraut. Auf die Frage, welche Farbe nach Rot aufleuchtet kommt fast immer die Antwort: "Gelb". Dies ist aber falsch, wie alle erfahrenen Verkehrsteilnehmer wissen. Wenn ein Autofahrer auf eine gelb leuchtende Ampel zufährt und er nicht die vorherige Phase gesehen hat, wüßte er nicht ob im nächsten Moment "Rot" aufleuchtet und er bremsen muß, oder ob nachfolgend "Grün" aufleuchtet und er die Fahrt fortsetzen darf.




    Aus diesem Grund schaltet die Ampel nach dem alleinigen Aufleuchten von "Gelb" immer auf "Rot". Im Unterschied dazu wechselt die Ampel von "Rot" immer zunächst auf "Rot" und "Gelb" gleichzeitig. Dadurch weiß der Verkehrsteilnehmer, das nach "Rot / Gelb", "Grün" folgt.


    Darüber hinaus sind die Schaltzeiten der Gelbphase und der Rot- / Gelbphase auch unterschiedlich lang. Rot / Gelb leuchtet 1,5 Sekunden, während die Gelbphase 3 Sekunden leuchtet um heranfahrenden Verkehrsteilnehmern die Möglichkeit zu geben, den Ampelbereich zu räumen.


    Die Länge der Rot- und Grünphase sind abhängig von den örtlichen Gegebenheiten und können individuell eingestellt werden. Da wir im Moment nur eine Ampel ansteuern können, begnügen wir uns damit, eine Ampelkreuzung nur von einer Seite aus zu betrachten.

    Mit diesem Hintergrundwissen können wir uns jetzt an die Programmierung machen.








    Vorbereitung unserer Experimentierplatine
    Da auf der Experimentierplatine ein Bereich für die Ampelsteuerung vorgesehen ist, werfen wir zunächst noch einmal einen Blick auf den Bestückungsdruck:



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


    Auf der Stiftleiste für die Ampelansteuerung finden wir die Bezeichnungen A1, A2, A3, wobei A1 mit der roten LED, A2 mit der gelben LED undA3 mit der grünen LED verbunden ist. Als Ausgänge von unserem Controller werden wir in diesem Beispiel die Portpins PB1, PB2 und PB0 verwenden.
    Folglich setzen wir die ersten drei Jumper (von links) in die untere Position und nehmen drei unserer Steckbrücken zum Verbinden von C1 mit A1, C2 mit A2 und C3 mit A3. Port PB1 ist somit für die rote LED zuständig, PB2 für die gelbe LED und PB0 für die grüne LED. Dies berücksichtigen wir bei der Aliasvergabe und nennen die Ausgänge Led_rot, Led_gelb und Led_gruen




    Achtet unbedingt darauf bei Led_gruen nicht das "ü" zuverwenden. Die Verwendung der Buchstaben "Ä, Ö, Ü, ä, ö und ü" sind neben weiteren im Programmcode von BASCOM nicht erlaubt und werden rot eingefärbt und darüber hinaus als Fehlermeldung ausgegeben!


    Das Programm für unsere Ampelsteuerung
    Wie oben bereits geschrieben wurde stehen die Zeiten für die Rot / Gelbphasemit 1, 5 Sekunden, also 1500 ms und die Gelbphase mit 3 Sekunden bereits fest. Um nicht wie beim Vorbild minutenlang auf einen Lichtwechsel zu warten, wählen wir sowohl für die Rotphase, als auch für die Grünphase eine Zeit von 10 Sekunden.

    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.1.3
    13. '------------------------------------------------------------
    14. 'Beschreibung: Ampel Basisschaltung
    15. '************************************************************
    16. $regfile = "attiny13.dat" 'verwendeter Controller
    17. $crystal = 1200000 'Taktfrequenz
    18. $hwstack = 6 'Stackwerte und Framesize zuweisen
    19. $swstack = 6
    20. $framesize = 28
    21. '==============================================================================
    22. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    23. '------------------------------------------------------------------------------
    24. Config Portb = Output 'Ganzer Port B als Ausgang
    25. Led_rot Alias Portb.1 'Alias für rote Ampel- LED
    26. Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
    27. Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
    28. '==============================================================================
    29. 'Hauptprogramm
    30. '------------------------------------------------------------------------------
    31. Do 'Schleifenanfang
    32. Led_rot = 1 'Rote LED einschalten
    33. Wait 10 '10 Sekunden Rotphase
    34. Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
    35. Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
    36. Led_rot = 0 'Rote LED ausschalten
    37. Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
    38. Led_gruen = 1 'Grüne LED einschalten
    39. Wait 10 '10 Sekunden Grünphase
    40. Led_gruen = 0 'Grüne LED ausschalten
    41. Led_gelb = 1 'Gelbe LED einschalten
    42. Wait 3 '3 Sekunden Gelbphase
    43. Led_gelb = 0 'Gelbe LED ausschalten
    44. ' Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
    45. Loop 'Zurück zu Do (Schleifenanfang)
    46. '==============================================================================
    47. End
    Alles anzeigen

    Hier folgt unser Experimentierboard. Habt ein wenig Geduld, die Zeiten sind genau so lang wie im Programm. Das dauert bei Rot und Grün ein wenig:




    Wir erweitern unser Ampelprogramm





    An unserem Attiny 13 habern wir noch zwei Portpins frei, sodass wir diese für alternative Zwecke nutzen können. In Städten mit Straßenbahnverkehr gibt es viele Kreuzungen an denen man beim Abbiegen auf Schienenfahrzeuge achten muß. Die Straßenverkehrsordnung sieht hierfür extra ein eigenes Leuchtwarnsignal vor, wie es oben abgebildet ist. Dieses Signal ist nur während der Grünphase aktiv, sodass wir hier die Funktion ergänzen können. Am fertigen Programm könnt Ihr sehen, dass dies mit viel Text verbunden ist, der sich eigentlich immer wiederholt. Für solche Anforderungen gibt es bessere und auch flexieblere Methoden, mit welchen wir uns nach diesem Programm beschäftigen wollen.

    Zunächst steckt einmal die fehlenden beiden Jumper in die untere Position. Als Warnlampen verwenden wir die Würfel- LED´s in den Ecken. Dies gibt einen naturgetreuen Effekt von wechselseitig blinkenden Zusatzampeln, welche im Original auf beiden Straßenseiten stehen.
    Die erforderlichen Steckbrücken entnehmt Ihr bitte der folgenden Abbildung:



    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.1.3
    13. '------------------------------------------------------------
    14. 'Beschreibung: Ampel mit Warnung vor Schienenfahrzeugen
    15. '************************************************************
    16. $regfile = "attiny13.dat" 'verwendeter Controller
    17. $crystal = 1200000 'Taktfrequenz
    18. $hwstack = 6 'Stackwerte und Framesize zuweisen
    19. $swstack = 6
    20. $framesize = 28
    21. '==============================================================================
    22. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    23. '------------------------------------------------------------------------------
    24. Config Portb = Output 'Ganzer Port B als Ausgang
    25. Led_rot Alias Portb.1 'Alias für rote Ampel- LED
    26. Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
    27. Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
    28. Warn_led_1 Alias Portb.4 'Alias für Warnlampe 1
    29. Warn_led_2 Alias Portb.3 'Alias für Warnlampe 2
    30. '==============================================================================
    31. 'Hauptprogramm
    32. '------------------------------------------------------------------------------
    33. Do 'Schleifenanfang
    34. Led_rot = 1 'Rote LED einschalten
    35. Wait 10 '10 Sekunden Rotphase
    36. Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
    37. Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
    38. Led_rot = 0 'Rote LED ausschalten
    39. Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
    40. Led_gruen = 1 'Grüne LED einschalten
    41. '===============================================================================
    42. ' Die 10 Sekunden der Grünphase lassen wir die Warnlampen wechselseitig blinken
    43. '===============================================================================
    44. Warn_led_1 = 1 'zunächst nur eine einschalten
    45. Waitms 500
    46. Warn_led_1 = 0 'und dann immer wechseln
    47. Warn_led_2 = 1
    48. Waitms 500 '1 Sekunde verstrichen
    49. Warn_led_1 = 1
    50. Warn_led_2 = 0
    51. Waitms 500
    52. Warn_led_1 = 0
    53. Warn_led_2 = 1
    54. Waitms 500 '2 Sekunden verstrichen
    55. Warn_led_1 = 1
    56. Warn_led_2 = 0
    57. Waitms 500
    58. Warn_led_1 = 0
    59. Warn_led_2 = 1
    60. Waitms 500 '3 Sekunden verstrichen
    61. Warn_led_1 = 1
    62. Warn_led_2 = 0
    63. Waitms 500
    64. Warn_led_1 = 0
    65. Warn_led_2 = 1
    66. Waitms 500 '4 Sekunden verstrichen
    67. Warn_led_1 = 1
    68. Warn_led_2 = 0
    69. Waitms 500
    70. Warn_led_1 = 0
    71. Warn_led_2 = 1
    72. Waitms 500 '5 Sekunden verstrichen
    73. Warn_led_1 = 1
    74. Warn_led_2 = 0
    75. Waitms 500
    76. Warn_led_1 = 0
    77. Warn_led_2 = 1
    78. Waitms 500 '6 Sekunden verstrichen
    79. Warn_led_1 = 1
    80. Warn_led_2 = 0
    81. Waitms 500
    82. Warn_led_1 = 0
    83. Warn_led_2 = 1
    84. Waitms 500 '7 Sekunden verstrichen
    85. Warn_led_1 = 1
    86. Warn_led_2 = 0
    87. Waitms 500
    88. Warn_led_1 = 0
    89. Warn_led_2 = 1
    90. Waitms 500 '8 Sekunden verstrichen
    91. Warn_led_1 = 1
    92. Warn_led_2 = 0
    93. Waitms 500
    94. Warn_led_1 = 0
    95. Warn_led_2 = 1
    96. Waitms 500 '9 Sekunden verstrichen
    97. Warn_led_1 = 1
    98. Warn_led_2 = 0
    99. Waitms 500
    100. Warn_led_1 = 0
    101. Warn_led_2 = 1
    102. Waitms 500 '10 Sekunden verstrichen
    103. Warn_led_2 = 0 'Warn_led_2 leuchtet ja noch, also auch ausschalten
    104. '=============================================================================
    105. Led_gruen = 0 'Grüne LED ausschalten
    106. Led_gelb = 1 'Gelbe LED einschalten
    107. Wait 3 '3 Sekunden Gelbphase
    108. Led_gelb = 0 ' Gelbe LED ausschalten
    109. ' Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
    110. Loop 'Zurück zu Do (Schleifenanfang)
    111. '==============================================================================
    112. End 'end program
    Alles anzeigen
    Hier wieder unser Experimentierboard:




    Achtet beim Compilieren mal auf den Speicherbedarf! 36 % werden für diese arbeitsaufwändige Programmierung benötigt. Das das auch anders geht werden wir im folgenden sehen:


    Die For- Next Schleife erspart viel Arbeit

    Bevor wir uns dem nächsten Bascombefehl zuwenden, müssen wir uns erst einmal mit den sogenannten Variablen beschäftigen, elementare Theorie, die ich Euch nicht ersparen kann.


    Die Variable => Platzhalter für veränderbare Werte im Programm

    Ähnlich wie unser Aliasname ein Platzhalter für einen Portpin ist, so ist eine Variable ein Platzhalter für einen Wert im Programm, der innerhalb des Programms aber verändert oder berechnet werden kann. Variablen gibt es in unterschiedlichen Ausführungen für verschieden lange Zahlen und sogar Text. Hauptgrund für die Unterteilung ist der unterschiedliche Speicherbedarf, den die einzelnen Variablen benötigen, denn diese Werte werden im Programm permanent zwischengespeichert und können bei Bedarf jederzeit an allen Stellen des Programms verwendet werden.. Für den Anfang begnügen wir uns mit den ersten beiden Variablentypen:

    Die BIT- Variable kennt nur zwei Zustände: An oder Aus (0 oder 1 , Schalter offen, Schalter geschlossen). Dennoch basiert die gesamte Computertechnik auf diesen beiden Zuständen. Dies wird dadurch erreicht, dass der Computer nicht nur einzelne Bits verarbeitet, sondern mit diesen auch in Gruppen arbeiten kann. Hierbei hat man sich auf eine gewisse Grundstruktur festgelegt. So ist die nächst höhere Einheit nach Bit das Byte. Ein Byte besteht aus einer Gruppe von 8 Bits. Man kann sich dies vereinfacht als acht Schalter vorstellen, die in ein Gehäuse eingebaut sind. Wenn wir den Computer anweisen ein Byte zu lesen, schaut dieser bildlich gesehen auf alle 8 Schalterstellungen gleichzeitig. Man ist in der Lage mit diesen 8 Schaltern 256 (inklusive 0(alles aus)) verschiedene Kombinationen darzustellen. Grundlage hierzu bildet das Binärsystem. Im Gegensatz zu unserem Dezimalsystem (Dezi => Zehn) kennt das Binärsystem nur jene erwähnten zwei Zustände (Bi => Zwei). Grundlage sind hier die Zweierpotenzen, die sich jeweils aus der Verdoppelung des vorangegangen Wertes ergeben: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ...

    Am einfachsten ist die Erklärung wieder mit einer Abbildung. Im folgenden seht Ihr 9 Dipschalter mit jeweils 8 einzelnen Schaltern, wie sie in ähnlicherForm für die Bestückung von Platinen verwendet werden. Links ist die Schalterstellung (ein / aus) bezeichnet, unter den Schaltern sind diese numeriert. Die Numerierung erfolgt nicht von 1-8, sondern von 7-0. Dies wird uns im Zusammenhang mit den Mikrocontrollern noch öfters begegnen und wir wollen uns gleich daran gewöhnen.
    Über den Schaltern finden wir wieder Zahlen. Diesmal die von 1 bis 128, also den ersten 8 aus der Binärzahlenkette, die ich oben aufgeführt habe. Immer wenn der Schalter unter der entsprechenden Zahl eingeschaltet ist, müssen wir diese im schwarzen Feld darüber in der Additionsaufgabe anstatt der vorhandenen 0 einsetzen. Wenn wir das für alle Schalter gemacht haben können wir die Werte im schwarzen Feld addieren und erhalten als Ergebnis den Dezimalwert des 8 stelligen Binärwertes, der mit den entsprechenden Schaltern eingestellt wurde.



    In unserem nächsten Programm wollen wir nun eine Zählvariable für die For- Next- Schleife verwenden. Jede Variable, welche im Programm verwendet werden soll muß im Programm "angemeldet" werden, damit das Programm diese auch kennt und sie verwenden kann. Da es wie gesagt Variablen mit unterschiedlichen Dimensionen (Größen) gibt lautet der Befehl in BASCOM für die "Anmeldung":

    DIM {Name der Variable} as {Variablentyp}

    In unserem Fall möchten wir eine Bytevariable (die in der For- Next- Schleife bis maximal 255 zählen kann) mit dem Namen "I" verwenden; schreiben also folglich:

    DIM I as Byte

    Danach können wir die Variable I im Programm verwenden und dieser beliebige Werte von 0-255 zuweisen oder berechnen lassen.



    Der DIM- Befehl steht in der Regel immer vor der Do- Loop- Schleife, da diese Angabe nur einmalig am Anfang erforderlich ist.


    Aufbau der For- Next - Schleife
    Die Bezeichnung dieser Schleife (For - Next) beinhaltet gleich zwei (zusammengehörende) BASCOM- Befehle, welche im Programm jedoch nicht in einer Zeile verwendet werden, sondern zu Anfang und am Ende der Schleife stehen. Zunächst kommt sozusagen ein Ausgangsbefehl, in welchem festgelegt wird, ab welchem Startwert unsere Zählvariable (im Beispiel I) gezählt werden soll und als zweites der Wert, bis zu welchem gezählt werden soll, bevor das Programm die Schleife verlassen soll:

    For I = 1 to 10

    Sobald das Programm zum Befehl For kommt setzt es die Zählvariable (I) auf den Startwert und durchläuft so oft die Schleife, bis der Endwert wahr ist. In unserem Fall also:

    1,2,3,4,5,6,7,8,9,10

    Zwischen dem For-Befehl und dem Next- Befehl kann beliebiger Programmcode stehen. Beispielsweise eine Warteanweisung von 1 Sekunde (Wait 1)


    For I=1 to 10
    Wait 1
    Toggle Led_1 'Eine Kontroll-LED blinkt mit 1 Sekunde Pause jeweils 1 Sekunde lang
    Next I

    Die Zählvariable kann im Programm auch als ganz normale Variable verwendet werden:


    For I=1 to 10
    Wait I
    Toggle Led_1 'Eine Kontroll-LED blinkt mit immer längeren Impuls- Pausenzeiten
    Next I


    Was passiert im Programm? Im ersten Durchlauf ist I=1, es wird also 1 Sekunde gewartet, beim zweiten Durchlauf ist I=2, die LED bleibt 2 Sekunden dunkel, im nächsten Durchlauf wird sie 3 Sekunden eingeschaltet, bis das Programm nach 10 Sekunden Schaltzeit die Schleife verläßt.


    Was wir jetzt über die For- Next- Schleife wissen reicht bereits für unser Programm aus. Ändern wir unseren Programmcode für die Ampel mit Warnblinker


    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.1.3
    13. '------------------------------------------------------------
    14. 'Beschreibung: Ampel mit Warnung vor Schienenfahrzeugen
    15. 'mit For- Next- Schleife
    16. '************************************************************
    17. $regfile = "attiny13.dat" 'verwendeter Controller
    18. $crystal = 1200000 'Taktfrequenz
    19. $crystal = 1200000 'Taktfrequenz
    20. $hwstack = 6 'Stackwerte und Framesize zuweisen
    21. $swstack = 6
    22. $framesize = 28
    23. '==============================================================================
    24. 'Ausgänge / Eingänge deklarieren / Aliasvergabe
    25. '------------------------------------------------------------------------------
    26. Config Portb = Output 'Ganzer Port B als Ausgang
    27. Led_rot Alias Portb.1 'Alias für rote Ampel- LED
    28. Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
    29. Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
    30. Warn_led_1 Alias Portb.4 'Alias für Warnlampe 1
    31. Warn_led_2 Alias Portb.3 'Alias für Warnlampe 2
    32. '==============================================================================
    33. 'Variablen deklarieren
    34. '------------------------------------------------------------------------------
    35. Dim I As Byte 'Zählvariable für die For- Next- Schleife
    36. '==============================================================================
    37. 'Hauptprogramm
    38. '------------------------------------------------------------------------------
    39. Do 'Schleifenanfang
    40. Led_rot = 1 'Rote LED einschalten
    41. Wait 10 '10 Sekunden Rotphase
    42. Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
    43. Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
    44. Led_rot = 0 'Rote LED ausschalten
    45. Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
    46. Led_gruen = 1 'Grüne LED einschalten
    47. '===============================================================================
    48. 'Die 10 Sekunden der Grünphase lassen wir die Warnlampen wechselseitig blinken
    49. 'Diesmal mit der For- Next- Schleife
    50. '===============================================================================
    51. For I = 1 To 10 '10 Durchläufe sollen durchgeführt werden
    52. Warn_led_1 = 1 'Wenn Ihr den Code zwischen For und Next
    53. Waitms 500 'einrückt, könnt Ihr immer gut sehen
    54. Warn_led_1 = 0 'was zwischen beiden Befehlen steht
    55. Warn_led_2 = 1
    56. Waitms 500
    57. Warn_led_2 = 0
    58. Next I 'Zum Ende sind beide Warnleuchten wieder ausgeschaltet
    59. '=============================================================================
    60. 'Weiter geht´s im normalen Ampelprogramm
    61. Led_gruen = 0 'Grüne LED ausschalten
    62. Led_gelb = 1 'Gelbe LED einschalten
    63. Wait 3 '3 Sekunden Gelbphase
    64. Led_gelb = 0 ' Gelbe LED ausschalten
    65. 'Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
    66. Loop 'Zurück zu Do (Schleifenanfang)
    67. '==============================================================================
    68. End 'end program
    Alles anzeigen

    Wie Ihr seht, ist unser Programm bedeutend kürzer geworden. Eine neue Platinenansicht benötigen wir nicht, da sich an der Programmausführung nichts geändert hat.

    Statt vorher 36% benötigt das Programm jetzt nur noch 21% Speicherplatz.


    Die For- Next- Schleife kann noch mehr

    Bevor wir im Kurs weiter machen wollen wir noch einen erweiterten Blick auf die For- Next- Schleife werfen:

    Im Programmbeispiel haben wir bei 1 mit dem Zählen begonnen. Das ist aber nicht notwendig, es geht auch von jedem anderen Wert, der in die Zählvariable "passt" (in unserem Fall eine Bytevariable, also 0- 255):

    For I=10 to 20
    For I = 150 to 180

    Auch das Zählen muss nicht in Einerschritten erfolgen. Hier gibt es einen Zusatzbefehl:

    For I = 2 to 10 Step 2 'Wir zählen in Zweierschritten: 2,4,6,8,10

    For I = 5 to 50 Step 5 'Wir zählen von 5 bis 50: 5,10,15,20,25,...45,50

    Und wir setzen noch einen drauf: es geht auch rückwärts

    For I = 100 to 0 Step -1 'Count down von 100 nach 0

    Soll eine Schleife nicht bis zum Ende ausgeführt werden, weil sich beispielsweise die Ausgangsbedingungen geändert haben, so ist das jederzeit mit Exit For möglich
    .

    So geht es weiter

    Nachdem wir uns jetzt intensiv mit dem Schalten von Ausgängen befasst haben wenden wir uns im nächsten Kapitel der Eingabe mittels Taster zu. Wir haben damit erstmals die Möglichkeit während des laufenden Programms auf dessen Verlauf Einfluß zu nehmen.
    Hier geht es weit

    597 mal gelesen