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.
Ampelphasen.gif
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.
Ampelphasen.png
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:
Jumper-Kabel.gif
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
WIKI-Logo Wichtig.jpg
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.
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:
Ampel 01 ani.gif
Wir erweitern unser Ampelprogramm
Wechselblinker-klein.gif
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:
Jumper und Stecker Ampel 2.gif
So werden Brücken und Jumper für das folgende Programm gesteckt
Alles anzeigen
Hier wieder unser Experimentierboard:
Ampel 02 ani.gif
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:
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.
DIPschalter Binärerklärung.png
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.
WIKI-Logo Merktext.jpg
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
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
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.
Ampelphasen.gif
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.
Ampelphasen.png
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:
Jumper-Kabel.gif
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
WIKI-Logo Wichtig.jpg
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
- '************************************************************
- ' 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.1.3
- '------------------------------------------------------------
- 'Beschreibung: Ampel Basisschaltung
- '************************************************************
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 6 'Stackwerte und Framesize zuweisen
- $swstack = 6
- $framesize = 28
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- Config Portb = Output 'Ganzer Port B als Ausgang
- Led_rot Alias Portb.1 'Alias für rote Ampel- LED
- Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
- Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
- '==============================================================================
- 'Hauptprogramm
- '------------------------------------------------------------------------------
- Do 'Schleifenanfang
- Led_rot = 1 'Rote LED einschalten
- Wait 10 '10 Sekunden Rotphase
- Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
- Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
- Led_rot = 0 'Rote LED ausschalten
- Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
- Led_gruen = 1 'Grüne LED einschalten
- Wait 10 '10 Sekunden Grünphase
- Led_gruen = 0 'Grüne LED ausschalten
- Led_gelb = 1 'Gelbe LED einschalten
- Wait 3 '3 Sekunden Gelbphase
- Led_gelb = 0 'Gelbe LED ausschalten
- ' Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
- Loop 'Zurück zu Do (Schleifenanfang)
- '==============================================================================
- End
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:
Ampel 01 ani.gif
Wir erweitern unser Ampelprogramm
Wechselblinker-klein.gif
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:
Jumper und Stecker Ampel 2.gif
So werden Brücken und Jumper für das folgende Programm gesteckt
BASCOM-Quellcode
- '************************************************************
- ' Kleiner Mikrocontroller Einsteigerkurs
- ' (c) 2013/2014 ceperiga
- '------------------------------------------------------------
- ' Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- ' Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- ' Name:
- ' Unit: 1.1.3
- '------------------------------------------------------------
- 'Beschreibung: Ampel mit Warnung vor Schienenfahrzeugen
- '************************************************************
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 6 'Stackwerte und Framesize zuweisen
- $swstack = 6
- $framesize = 28
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- Config Portb = Output 'Ganzer Port B als Ausgang
- Led_rot Alias Portb.1 'Alias für rote Ampel- LED
- Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
- Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
- Warn_led_1 Alias Portb.4 'Alias für Warnlampe 1
- Warn_led_2 Alias Portb.3 'Alias für Warnlampe 2
- '==============================================================================
- 'Hauptprogramm
- '------------------------------------------------------------------------------
- Do 'Schleifenanfang
- Led_rot = 1 'Rote LED einschalten
- Wait 10 '10 Sekunden Rotphase
- Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
- Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
- Led_rot = 0 'Rote LED ausschalten
- Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
- Led_gruen = 1 'Grüne LED einschalten
- '===============================================================================
- ' Die 10 Sekunden der Grünphase lassen wir die Warnlampen wechselseitig blinken
- '===============================================================================
- Warn_led_1 = 1 'zunächst nur eine einschalten
- Waitms 500
- Warn_led_1 = 0 'und dann immer wechseln
- Warn_led_2 = 1
- Waitms 500 '1 Sekunde verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '2 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '3 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '4 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '5 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '6 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '7 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '8 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '9 Sekunden verstrichen
- Warn_led_1 = 1
- Warn_led_2 = 0
- Waitms 500
- Warn_led_1 = 0
- Warn_led_2 = 1
- Waitms 500 '10 Sekunden verstrichen
- Warn_led_2 = 0 'Warn_led_2 leuchtet ja noch, also auch ausschalten
- '=============================================================================
- Led_gruen = 0 'Grüne LED ausschalten
- Led_gelb = 1 'Gelbe LED einschalten
- Wait 3 '3 Sekunden Gelbphase
- Led_gelb = 0 ' Gelbe LED ausschalten
- ' Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
- Loop 'Zurück zu Do (Schleifenanfang)
- '==============================================================================
- End 'end program
Ampel 02 ani.gif
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
- Die Byte Variable
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.
DIPschalter Binärerklärung.png
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.
WIKI-Logo Merktext.jpg
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
- '************************************************************
- ' 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.1.3
- '------------------------------------------------------------
- 'Beschreibung: Ampel mit Warnung vor Schienenfahrzeugen
- 'mit For- Next- Schleife
- '************************************************************
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000 'Taktfrequenz
- $crystal = 1200000 'Taktfrequenz
- $hwstack = 6 'Stackwerte und Framesize zuweisen
- $swstack = 6
- $framesize = 28
- '==============================================================================
- 'Ausgänge / Eingänge deklarieren / Aliasvergabe
- '------------------------------------------------------------------------------
- Config Portb = Output 'Ganzer Port B als Ausgang
- Led_rot Alias Portb.1 'Alias für rote Ampel- LED
- Led_gelb Alias Portb.2 'Alias für gelbe Ampel- LED
- Led_gruen Alias Portb.0 'Alias für grüne Ampel- LED
- Warn_led_1 Alias Portb.4 'Alias für Warnlampe 1
- Warn_led_2 Alias Portb.3 'Alias für Warnlampe 2
- '==============================================================================
- 'Variablen deklarieren
- '------------------------------------------------------------------------------
- Dim I As Byte 'Zählvariable für die For- Next- Schleife
- '==============================================================================
- 'Hauptprogramm
- '------------------------------------------------------------------------------
- Do 'Schleifenanfang
- Led_rot = 1 'Rote LED einschalten
- Wait 10 '10 Sekunden Rotphase
- Led_gelb = 1 'Gelbe LED zuschalten aber nichts ausschalten!
- Waitms 1500 '1,5 Sekunden für die Rot-/Gelbphase
- Led_rot = 0 'Rote LED ausschalten
- Led_gelb = 0 'Gelbe LED ebenfalls ausschalten
- Led_gruen = 1 'Grüne LED einschalten
- '===============================================================================
- 'Die 10 Sekunden der Grünphase lassen wir die Warnlampen wechselseitig blinken
- 'Diesmal mit der For- Next- Schleife
- '===============================================================================
- For I = 1 To 10 '10 Durchläufe sollen durchgeführt werden
- Warn_led_1 = 1 'Wenn Ihr den Code zwischen For und Next
- Waitms 500 'einrückt, könnt Ihr immer gut sehen
- Warn_led_1 = 0 'was zwischen beiden Befehlen steht
- Warn_led_2 = 1
- Waitms 500
- Warn_led_2 = 0
- Next I 'Zum Ende sind beide Warnleuchten wieder ausgeschaltet
- '=============================================================================
- 'Weiter geht´s im normalen Ampelprogramm
- Led_gruen = 0 'Grüne LED ausschalten
- Led_gelb = 1 'Gelbe LED einschalten
- Wait 3 '3 Sekunden Gelbphase
- Led_gelb = 0 ' Gelbe LED ausschalten
- 'Die rote LED wird am Anfang der Schleife wieder eingeschaltet!
- Loop 'Zurück zu Do (Schleifenanfang)
- '==============================================================================
- End 'end program
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
14.018 mal gelesen