|
|
[ Home
] [ Seitenende ] [ Teil 1 ] [ Teil 2a ] [ Teil 2b ] [ Teil 4 ] |
|
||
|
|
Roboter-Auto „Joy-Car“ - Teil 3 Einführung in die
Objekt orientierte Programmierung (OOP) Bezüglich der Programmierung der Beleuchtung und der „NeoPixel“-LEDs des „Joy-Car“-Roboters sind wir beim Programm „joy-car_teil_02_prog_45.py
stehengeblieben. Und zwar bei dem ·
Statement neopixel.create(DigitalPin.P0,
8, NeoPixelMode.RGB)>,
das im Übrigen auch weggelassen werden kann:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_01.py“) Wenn man die obenstehende Programmierung des
Blinkers rechts mit der des nachfolgenden Blinkers links vergleicht, dann
fällt auf, dass sich diese oben im pinkfarbenen Kasten und nachfolgend in
den hellgrünen Kästen unterscheidet:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_01.py“) Um die beiden Blinker-Funktionen später zu einer
Blinker-Funktion zusammenführen zu können, muss man beide
Funktionen schrittweise
vereinheitlichen. Demzufolge wird der Quellkode im pinkfarbenen Kasten und in den hellgrünen
Kästen
zunächst auskommentiert, sodass diese nicht mehr wirksam sind (siehe Programm „joy-car_teil_03_prog_02.py“).
Wenn man das Programm „joy-car_teil_03_prog_02.hex“
startet, dann wird als Erstes das sogenannte Standlicht (vorn und hinten) einschaltet. Wenn man dann als nächstes
den Taster B für den Linksblinker betätigt, dann beginnt der Blinker links wie erwartet zu blinken, wobei aber
gleichzeitig das Standlicht wider Erwarten ausgeschaltet
wird. Wie man anhand des nachfolgenden Screenshots
sieht, wurden die beiden Funktionen ·
Funktion <Blinker_rechts_blinkt(schalte_Ein_Aus)> (siehe pinkfarbener Kasten) und ·
Funktion <Blinker_links_blinkt(schalte_Ein_Aus)> (siehe hellgrüne Kästen) teils unterschiedlich programmiert, sodass
sich die Frage stellt, welche Funktion wie geändert werden muss. Muss man beide
Funktionen ändern oder
nur eine? Und, falls man nur eine der beiden Funktionen ändern muss, welche der beiden? Wie man im Quellkode des pinkfarbenen
Kastens
sieht, werden alle 8 „NeoPixel“-LEDs dunkel geschaltet, sobald der Rechtsblinker mittels des Tasters B ausgeschaltet wird. Demzufolge wird
auch das beim Programmstart eingeschaltete Standlicht ausgeschaltet! Auch wenn man den Rechtsblinker mittels des Tasters B wieder einschaltet, bleibt das Standlicht ausgeschaltet, weil zuvor alle alle 8 „NeoPixel“-LEDs im pinkfarbenen Kasten dunkel
geschaltet wurden. Um den Programmfehler
„Standlicht wird ohne Veranlassung durch den Anwender ausgeschaltet!“
zu beheben, muss man den bisherigen Quellkode im pinkfarbenen Kasten durch den Quellkode im blauen, hellgrünen und dunkelgrünen Kasten ersetzen:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_03.py“) Bei dem nachfolgenden Programm „joy-car_teil_03_prog_04.py“
wurden die vorgenannten Änderungen des Programmkodes eingepflegt und die
zuvor auskommentierten Programmzeilen gelöscht, sodass das
Programm nicht nur einwandfrei funktioniert, sondern auch entsprechend
aufgeräumt ist. Bei dem obenstehenden Programm wurden bisher nachfolgende Funktionen der „NeoPixel“-LEDs programmiert: 1.
Tagfahrlicht Beim Micro-Python und dem „micro:bit“-Mikrocontroller und dem neuen Programm „joy-car_teil_03_prog_05.py“
erfolgt das Einschalten des Tagfahrlichtes wie folgt: ·
Statement <schalteTagfahrlicht
= True> ·
Statement <Tagfahrlicht(schalteTagfahrlicht)> Zum Ausschalten des Tagfahrlichtes muss man das Attribut
<True> nur auf <False> setzen: ·
Statement <schalteTagfahrlicht
= False> ·
Statement <Tagfahrlicht(schalteTagfahrlicht)> 2.
Standlicht ·
Statement <schalteStandlicht
= True> ·
Statement <Standlicht(schalteStandlicht)> Zum Ausschalten des Standlichts muss man das Attribut
<True> nur auf <False> setzen: ·
Statement <schalteStandlicht
= False> ·
Statement <Standlicht(schalteStandlicht)> 3.
Warnblinker ·
Statement <schalteWarnblinker
= True> ·
Statement <Warnblinker_blinkt(schalteWarnblinker)> Zum Ausschalten des Standlichts muss man das Attribut
<True> nur auf <False> setzen: ·
Statement <schalteWarnblinker
= False> ·
Statement <Warnblinker_blinkt(schalteWarnblinker)> 4.
Rechtsblinker ·
Statement <schalteBlinker_rechts
= True> ·
Statement <Blinker_rechts(schalteBlinker_rechts)> Zum Ausschalten des Standlichts muss man das Attribut
<True> nur auf <False> setzen: ·
Statement <schalteBlinker_rechts
= False> ·
Statement <Blinker_rechts (schalteBlinker_rechts)> 5.
Linksblinker ·
Statement <schalteBlinker_links
= True> ·
Statement <Blinker_rechts(schalteBlinker_links)> Zum Ausschalten des Standlichts muss man das Attribut
<True> nur auf <False> setzen: ·
Statement <schalteBlinker_links
= False> ·
Statement <Blinker_rechts (schalteBlinker_links)> Bezüglich der Programmierung der „NeoPixel“-LEDs verhält es sich so,
dass diese einerseits auf die vorgenannten Funktionen aufsetzt und andererseits auf globale Variable vom Typ
„boolean“. Dies ist dem Umstand
geschuldet, dass sich alle „NeoPixel“-LEDs mit nur einem Taster A oder B
sowohl einschalten als auch ausschalten lassen:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_05.py“) Außerdem muss man im obenstehenden Quellkode
der Funktion <einschaltenLEDs()> u.a.
auch die Variablen <aktWert>, <minWert> und <maxWert> global verfügbar
machen und den <Wenn …, dann>-Schleifenzähler <aktWert> entsprechend programmieren (siehe blaue Kästen oben). Damit sich obenstehenden „NeoPixel“-LED-Funktionen auch ansteuern und
aufrufen lassen, muss man im Hauptprogramm
noch die globalen Variablen <aktWert>, <minWert> und <maxWert> deklarieren und initialisieren
(siehe blauen Kasten unten):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_05.hex“) Im obenstehenden Quellkode wurde außerdem in
der Funktion <rechts_links_Blinken()> der ursprüngliche Taster A (= Blinker rechts) auskommentiert und der Taster A (= einschaltenLEDs) neu eingerichtet (siehe rote Kästen oben). Wir erweitern das obenstehende Programm, indem
wir eine Arbeitsteilung zwischen
dem Taster A und dem Taster B vornehmen. Und zwar in der Weise, dass man
mit dem Taster A eine der fünf „NeoPixel“-LED-Funktionen einschaltet und mit dem Taster B zu einem beliebigen Zeitpunkt wieder ausschaltet:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_06.py“) Wenn man das obenstehende Programm startet,
dann sind zunächst alle „NeoPixel“-LEDs und deren fünf
Funktionen ausgeschaltet. Wenn
man dann den Taster A betätigt, dann wird
in der Laufschrift des LED-Displays die Ziffer „1“ angezeigt.
Und zwar entsprechend der Initialisierung der Variablen <aktWert> im ·
Statement <aktWert = 1> des Hauptprogramms
(siehe unten). Nach der Laufschriftanzeige wird die Funktion
<Tagfahrlicht(schalteTagfahrlicht)>
gestartet, sodass die beiden vorderen „NeoPixel“-LEDs Nr. 1 und Nr. 2 weiß leuchten. Dabei leuchtet das Tagfahrlicht so lange bis der Strom ausfällt oder
der Taster B gedrückt wird, um das
Tagfahrlicht wieder auszuschalten.
Nach dem Ausschalten des Tagfahrlichts in der Funktion <ausschalten_LEDs()> (siehe oben im roten Kasten) wird der
„Schleifenzähler“ der Variablen <aktWert> (= aktueller Wert) inkrementiert,
d.h. um +1 erhöht: ·
Statement <aktWert = aktWert + 1> Wenn man anschließend den Taster A ein weiteres Mal betätigt, dann wird
in der Laufschrift des LED-Displays die Ziffer „2“ angezeigt,
die Funktion <Standlicht(schalteStandlicht)> aufgerufen und das Standlicht eingeschaltet. Auf diese Weise lassen
sich der Reihe nach alle fünf Beleuchtungsfunktionen aufrufen und ausführen. In diesem Zusammenhang sei nochmals erwähnt,
dass sich das Standlicht jederzeit und
unabhängig von den ausgewählten „NeoPixel“-LED-Funktionen mittels des Touch-Sensors
(= „micro:bit“-Logo) ein- und ausschalten
lässt (siehe blauer Kasten unten):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_06.hex“) Das obenstehende Programm funktioniert zwar
einwandfrei, hat aber noch den Nachteil, dass sich die fünf Funktionen (Tagfahrlicht, Standlicht,
Warnblinker, Blinker_rechts und Blinker_links)
immer nur sequentiell, d.h. der Reihe nach, mit dem Taster A einschalten und mit dem Taster B ausschalten lassen. Demzufolge lässt sich derzeit noch nicht
beliebig durch die „NeoPixel“-LED-Anzeigen „blättern“, sodass
sich diese eben nicht in beliebiger Reihenfolge aufrufen lassen. Aber genau das soll sich jetzt mit dem
nächsten Programm „joy-car_teil_03_prog_07.py“
ändern! Dazu muss man eine weitere Arbeitsteilung zwischen den beiden Tastern A und B
vornehmen. Und zwar der Gestalt, dass man durch mehrmaliges Betätigen des Taster A einen Zahlenwert aus dem Bereich [ 1, 2, …, 5 ] auswählt und damit festlegt, welche
der fünf Funktionen (Tagfahrlicht,
Standlicht, Warnblinker, Blinker_rechts und Blinker_links) als nächstes durch Betätigen des Tasters B ausgeführt werden soll. Dabei wurde die
Funktionsweise des Tasters B so programmiert, dass
sich dieser als Wechselschalter
benutzen lässt. Demzufolge ist es mit dem Taster B
möglich, z.B. den Blinker
rechts
beliebig ein- oder auszuschalten:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_07.hex“) Wenn man sich den Quellkode im roten Kasten oben anschaut, dann
wundert man sich vielleicht, weshalb die beiden <if … then>-Abfragen nicht zu einer einzigen mittels
<else> wie folgt
zusammengefasst wurden:
(Zum Vergrößern bitte
auf das Bild klicken!) Der Knackpunkt bei der <if … then>-Abfrage ist der, dass bei
dieser wegen <and> (= logisch „UND“) zwei
Bedingungen gleichzeitig erfüllt sein müssen, um den nachfolgenden
Programmkode auszuführen. Da
sich aber der aktuelle Wert
der globalen Variablen <aktWert> mit jedem
Tastendruck auf den Taster A ändert, erhöht sich bei jedem neuen
Tastendruck der aktuelle Wert der
globalen Variablen <aktWert> um +1, sodass bei jedem weiteren Durchlauf der Funktion <schalten_LED_Funktion()> die <else>-Bedingung nebst Programmkode abgearbeitet würde. Mit der Folge, dass ein heilloses und nicht mehr
durchschaubares Durcheinander bei den „NeoPixel“-LED-Anzeigen entstehen würde, wenn auch
die restlichen <if … then>-Abfragen mittels der <else>-Bedingung programmieren würde! Wenn man allerdings bei der <if … then>-Abfrage die beiden mit <and> (= logisch „UND“) verbundenen Bedingungen entsprechend trennt und in zwei
<wechsel_Schalter>-Abfragen mit jeweils <True> und <False> aufteilt, dann
wird das Ganze wieder anschaulicher und überschaubarer (siehe Programm „joy-car_teil_03_prog_08.py“):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_08.hex“) Bei dem obenstehenden Programm und dessen
Quellkode lassen sich die fünf „NeoPixel“-LED-Funktionen mit dem Taster A aus dem Bereich [ 1, …, 5 ] einzeln der Reihe nach beginnend von
„1“ bis „5“ auswählen und mittels des Tasters B bestätigen und ausführen, sodass z.B. bei der Auswahl „3“
der Warnblinker mit allen vier „NeoPixel“-LEDs rundum gelb blinkt. Wenn man dann als nächstes mit der Auswahl „4“
(" Taster A) fortfahren
will, dann empfiehlt es sich von wegen der logischen Abfolge, dass man
zuvor die vorherige Auswahl „3“ durch erneutes Drücken des Tasters B beendet, sodass der Warnblinker aufhört zu blinken. Erst danach sollte
man durch erneutes Drücken des Tasters A mit der Auswahl „4“
und der Bestätigung durch Drücken des Tasters B mit der nächsten „NeoPixel“-LED-Funktion fortfahren. Das ist
zwar etwas umständlich, sorgt aber dafür, dass immer nur eine „NeoPixel“-LED-Funktion aufgerufen und
ausgeführt wird. Selbstverständlich kann man durch mehrmaliges
Drücken des Tasters A und des Tasters B mehrere „NeoPixel“-LED-Funktionen parallel
ausführen lassen, ohne diese beim „Durchblättern“ immer wieder zuvor
auszuschalten, sodass diese weiterhin aktiv bleiben. Aber schon nach
kurzer Zeit werden die sich überlappenden „NeoPixel“-LED-Funktionen unübersichtlich,
sodass man den Überblick verliert und nicht weiß, ob die eine oder andere „NeoPixel“-LED-Funktion tatsächlich
einwandfrei funktioniert! Beim nachfolgenden Programm „joy-car_teil_03_prog_09.py“)
wurde das etwas umständliche „Durchblättern“ der verschiedenen „NeoPixel“-LED-Funktionen dahingehend
verbessert, indem bereits nach dem Ausschalten der jeweils aktiven „NeoPixel“-LED-Funktion der „Schleifenzähler“
der Variablen <aktWert> automatisch inkrementiert,
d.h. um +1 erhöht wird (siehe roter Kasten ganz unten):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_09.hex“) Wie man ferner im obenstehenden Sourcecode
sieht, wurden fünf weitere „NeoPixel“-LED-Funktionen dem Programm
hinzugefügt: 1.) Abblendlicht (#3), 2.) Fernlicht (#4), 3.) Rückfahrlicht
(#8), 4.) Nebelschlusslicht (#9) und 5.) Bremslicht (#10). Darüber hinaus wurden bei den „NeoPixel“-LED-Funktionen <Tagfahrlicht()>, <Standlicht()> und <Warnblinker_NeoPixel()> alle ·
Statements <JoyCar.light(ToggleSwitch.OFF)> entfernt und durch den nachfolgenden
Programmkode ersetzt bzw. ergänzt (siehe grüner Kasten):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_09.py“) Wie man im obenstehenden Quellkode sieht,
werden die „NeoPixel“-LEDs im Prinzip so ausgeschaltet, wie sie zuvor eingeschaltet wurden! Nur mit dem
Unterschied, dass die „NeoPixel“-LEDs beim Ausschalten nicht elektrisch ausgeschaltet,
d.h. stromlos, gemacht, sondern vielmehr nur dunkel gesteuert werden.
Und zwar durch die „NeoPixel“-Farbe Schwarz und die Helligkeit
= 0. Gegenüber dem ·
Statements <JoyCar.light(ToggleSwitch.OFF)> hat dies den Vorteil, dass nicht alle „NeoPixel“-LEDs auf einen Schlag
ausgeschaltet werden, sondern nur die betreffenden „NeoPixel“-LEDs, die zuvor ganz
bewusst und gezielt eingeschaltet wurden. Wie man im obenstehenden Quellkode sieht,
werden die beiden vorderen „NeoPixel“-LEDs in einer <for … next>-Schleife initialisiert, wobei
der engl. „range“, d.h. Bereich
des Intervalls von [ 0, …, 3 ] reicht und insgesamt 4 Werte einschließlich der Null umfasst (siehe blaue Kreise). Dabei stellt
sich die Frage, ob der Schleifenzähler i
ebenfalls im Bereich des Intervalls von [ 0, …, 3 ] verläuft. Und genau
das tut er nicht(!), weil die Abbruch-Bedingung für den Schleifenzähler i < 3 ist: [ 0, …, < 3 ].
Bei älteren Programmiersprachen wie z.B. „C“
gibt es noch drei Parameter
im Schleifenkopf der <for … next>-Schleife mit denen die Startbedingung (= Anfangswert) und
die Abbruchbedingung (= Endwert)
unmissverständlich und eindeutig initialisiert werden:
(Vergrößern: auf das
Bild klicken! | Quelle: Wikipedia) Aber weshalb komme ich nochmals auf die <for … next>-Schleife zu sprechen? Ganz
einfach deshalb, weil, wenn man sich in der <for … next>-Schleife den laufenden Wert des Schleifenzählers anzeigen lässt,
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_10.hex“) die „NeoPixel“-LEDs plötzlich zu spinnen
anfangen! Der Grund dafür ist der, dass die erste
„NeoPixel“-LED (= Nr. „0“) steuer- und datenmäßig
digitale Informationen darüber
empfängt, wann welche „NeoPixel“-LED an welcher Adresse wie hell und bunt leuchten
soll und diese an die zweite „NeoPixel“-LED (= Nr. „1“)
sequentiell weiter gibt, d.h. so lange durchschiebt, bis die Empfänger-„NeoPixel“-LED erreicht wird und zu
Leuchten anfängt: (Vergrößern: auf das
Bild klicken! | Quelle: MB-Joy-Car_Manual_2021-04-30.pdf,
Seite 44) „Back to the roots!“, zurück zu den Wurzeln bzw. zur Fehlersuche mit dem Aufblitzen der „NeoPixel“-LEDs. Während bei
den Programmen „joy-car_teil_02_prog_42.hex“
und „joy-car_teil_02_prog_43.hex“
(siehe im 2. Teil des Tutorials)
das Problem mit dem blauen Aufblitzen noch nicht gelöst werden konnte, ist es beim Programmen
„joy-car_teil_02_prog_44.hex“
erstmals behoben! Wenn man das Bild
72 mit dem Bild
73 (siehe pinkfarbener Kasten) vergleicht, dann
sieht man, dass die Ursache das fehlerhafte
·
Statement <strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)> war! Mit dem Programm
„joy-car_teil_03_prog_09.py“
wurden hier im dritten Teil fünf weitere „NeoPixel“-LED-Funktionen hinzugefügt: 1.)
Abblendlicht (#3), 2.) Fernlicht (#4), 3.) Rückfahrlicht (#8), 4.) Nebelschlusslicht (#9) und 5.) Bremslicht (#10) (siehe Bild 11). Dabei wurden die vorderen „NeoPixel“-LEDs für das Abblendlicht (#3) und das Fernlicht (#4) auf die vorderen „NeoPixel“-LEDs Nr. 0
(= rechts) und Nr. 3 (= links) gelegt, da
diese mehr als doppelt so hell leuchten als das Tagfahrlicht (#1)
und das Standlicht (#2). Legt man wie im Programm „joy-car_teil_03_prog_11.py“
die „NeoPixel“-LEDs für das Abblendlicht (#3) aber testweise auf
die vorderen „NeoPixel“-LEDs Nr. 1 (= rechts) und Nr. 2 (= links), aktiviert
das Abblendlicht und den Blinker rechts (siehe Quellkode am Ende des
Programms) und startet abschließend das Programm, dann schalten sich sofort
das Abblendlicht und kurz darauf der Blinker rechts ein, gefolgt von hellweißen
Blitzen
auf der „NeoPixel“-LED Nr. 1 (= rechts), die von dem hellen Abblendlicht der Helligkeit mit dem Statement <helligkeit_weisse_NP = 64>. Im vorliegenden Fall lässt sich aber das hellweiße
Blitzen
abschalten! Und zwar indem man den Taster B
mit der laufenden Nr. #6 = <Blinker_rechts()> ausschaltet
(siehe Bild 11)! Und da es sich
bei dem Taster B um einen
„Wechselschalter“ handelt, lässt der <Blinker_rechts()> durch erneutes
Drücken des Tasters B auch wieder
einschalten. Das hellweiße Blitzen lässt sich aber auch
durch Berühren des Touch-Sensors (= „micro:bit“-Logo) abschalten, wobei die „NeoPixel“-LEDs für das Abblendlicht (#3) ausgeschaltet werden, sodass der <Blinker_rechts()> weiterhin für sich
allein vor sich her blinkt! Selbstverständlich lässt sich der Touch-Sensor auch ein weiteres Mal
berühren, sodass sich das Abblendlicht
(#3) wieder mit den hellweißen
Blitzen
einschaltet! Bezüglich des hellweißen Blitzen wissen wir jetzt,
dass wir es dabei mit den beiden Funktionen ·
Funktion <Abblendlicht(Abblendlicht_einschalten)> und ·
Funktion <Blinker_rechts()> bzw. <Blinker_rechts_blinkt(schalte_Ein_Aus)> zu tun haben. Außerdem wissen wir, dass beide
Funktionen die „NeoPixel“-LEDs Nr. 1 (= rechts) und Nr. 2 (= links) gemeinsam
benutzen, sodass dadurch das hellweiße Blitzen überhaupt erst möglich wird! Zu guter
Letzt wissen wir, dass das hellweiße Blitzen
durch das plötzliche Ausschalten des
hellweißen Abblendlichtes (#3) zustande kommt:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_11.py“) Wenn man sich die
obenstehenden Quellkode anschaut, dann stellt sich die Frage, welcher Teil
des Programmkodes das plötzliche Ausschalten das hellweiße Blitzen der „NeoPixel“-LEDs bewirkt. Ist es der
Programmkode im blauen Kasten oder im roten Kasten? Mit dem Programmkode im blauen
Kasten
(siehe oben) werden die „NeoPixel“-LEDs des Blinkers rechts abwechselnd ein- und ausgeschaltet, sodass dieser im Sekundentakt ( = 2 x 500 ms = 1 s) blinkt! Zu diesem Zweck muss die Funktion <Blinker_rechts_blinkt(schalte_Ein_Aus)> fortwährend aufgerufen werden. Um dies
sicherzustellen wurde die Funktion <Blinker_rechts_blinkt(schalte_Ein_Aus)> als vom Typ <basic.forever(rechts_links_Blinken)> deklariert:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_11.hex“)
Wie man im
nachfolgenden Screenshot sieht, muss man in der Funktion <Blinker_rechts_blinkt(schalte_Ein_Aus)> den Programmkode im roten Kasten mit Ausnahme von <else> komplett löschen, damit das hellweiße
Blitzen
der „NeoPixel“-LEDs beim Einschalten des Blinkers rechts aufhört:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_12.py“) Wie man im obenstehenden Screenshot sieht,
wird das Blinken des rechten Blinkers durch den Programmkode im blauen
Kasten
bewerkstelligt, sodass das nachträgliche, nachgeschaltete Ausschalten der „NeoPixel“-LEDs keinen Sinn macht. Noch dazu, wo der
Programmkode im roten Kasten wegen der <else>-Verzweigung in den Blinkpausen(!) fortwährend ausgeführt wird und das Tagfahrlicht, das Standlicht oder das Abblendlicht in den Blinkpausen(!) immer wieder eingeschaltet wird,
sodass es zwangsläufig zu dem hellweißen Aufblitzen kommt! Darüber
hinaus muss der oben im roten Kasten zu sehende
Quellkode auch in der Funktion <Blinker_links_blinkt(schalte_Ein_Aus)> gelöscht
werden. -
Mit dem Programm
„joy-car_teil_03_prog_12.py“
und dem nachfolgenden, erweiterten Programm
„joy-car_teil_03_prog_13.py“
lassen sich nacheinander gleich mehrere „NeoPixel“-LED-Funktionen einschalten. So
lassen sich z.B. mit dem Taster A das Standlicht und anschließend noch dazu der Warnblinker einschalten. Und, da beide „NeoPixel“-LED-Funktionen auf ein- und
dieselben „NeoPixel“-LEDs geschaltet sind, wird
das Standlicht mit dem Warnblinker, der ja als Zweites hinzugeschaltet
wurde, überblendet, sodass letztlich nur der Warnblinker blinkt. Mit dem Taster B
wiederum lassen sich nacheinander eingeschaltete „NeoPixel“-LED-Funktionen einzeln wieder ausschalten.
Und zwar in beliebiger Reihenfolge! Wenn man also mit dem
Taster B als erstes den Warnblinker (#5) ausschaltet, dann
leuchtet anschließend sofort wieder das Standlicht auf. Demzufolge lassen sich mit dem Taster A alle zehn „NeoPixel“-LED-Funktionen der Reihe nach von
1.) bis 10.) „durchblättern“ und dabei die eine oder andere „NeoPixel“-LED-Funktion einschalten. Und,
wenn sich diese nicht gegenseitig in die Quere kommen, d.h. die gleichen „NeoPixel“-LEDs ansteuern, dann lassen sich z.B. bis
zu drei „NeoPixel“-LED-Funktionen nacheinander
einschalten wie z.B. 1.) das Standlicht (#2), dann 2.) das Rückfahrlicht (#8)
und 3.) noch das Nebelschlusslicht (#9). Dabei lassen sich dann alle drei „NeoPixel“-LED-Funktionen mittels des Tasters B wieder in der gleichen oder beliebigen
Reihenfolge ausschalten. Wenn man also mehrere „NeoPixel“-LED-Funktion eingeschaltet
hat und diese später wieder ausschalten möchte, dann ist man gut
beraten, wenn man sich die laufenden Nummern #2, #8 und #9 der zuvor eingeschalteten „NeoPixel“-LED-Funktionen auf einen Zettel
notiert hat. Anderenfalls wird es früher oder später passieren, dass man den
Überblick über die eingeschalteten „NeoPixel“-LED-Funktionen verliert und
stattdessen versehentlich eine weitere „NeoPixel“-LED-Funktion einschaltet. Ergonomisch
und vorteilhaft wäre es demzufolge, wenn sich alle im Laufe der Zeit
eingeschalteten „NeoPixel“-LED-Funktionen sozusagen auf einen Schlag mit nur einem einzigen
Tastendruck ausschalten ließen! Und genau das leistet das nachfolgende,
erweiterte Programm „joy-car_teil_03_prog_13.py“.
Dabei gilt
es zu beachten, dass es dabei programmiertechnisch nicht damit getan
ist, alle acht „NeoPixel“-LEDs einfach so
auszuschalten bzw. dunkel zu schalten! Und zwar deswegen, weil alle zehn „NeoPixel“-LED-Funktionen mittels entsprechender boolescher Variablen ·
schalteTagfahrlicht, ·
schalteStandlicht, ·
schalteAbblendlicht, ·
schalteFernlicht, ·
schalteWarnblinker, ·
schalteBlinker_rechts, ·
schalteBlinker_links, ·
schalteRueckfahr, ·
schalteNebel und ·
schalteBremslicht auf die Attribute „True“
(= EIN) oder „False“
(= AUS) programmiert wurden! Wie man anhand der nachfolgenden Tabelle
sieht, gehört zu jeder „NeoPixel“-LED-Funktion (= 3. Spalte) die
dazugehörige boolesche Variable (= 2. Spalte) sowie
eine fortlaufende Nummer (= 1. Spalte):
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_13.hex“) Wie man in
der obenstehenden Tabelle unschwer sieht, beginnt die laufende Nummerierung bei Null, obwohl die Laufschrift des 5x5 Matrix
LED-Displays weiterhin die Nummerierung von 1 bis 10 anzeigt. Dies ist dem Umstand
geschuldet, dass der Mensch als Anwender nur über 10 Finger (= Dezimalsystem) verfügt
und dieser stets bei 1 zu zählen anfängt. Im Gegensatz zu der obenstehenden
Tabelle, deren laufende Nummerierung bei 0 beginnt, weil der Computer
bzw. die ALU
(= engl. „Arithmetic
Logic
Unit“, d.h.
arithmetisch-logische Einheit = binäres Rechenwerk) nur über „zwei Finger“
für logisch Null (= „02“) und logisch Eins (= „12“)
verfügt. Dafür, dass der Computer mit seinen „zwei Fingern“ nur von Null bis Eins
zählt, tut er das um ein Vielfach schneller als der Mensch! Programmiertechnisch wird die obenstehende
Tabelle als sogenanntes Array
programmiert, obwohl es in Python
streng genommen kein echtes Array
wie in anderen Programmiersprachen gibt:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_13.py“) Wie man im obenstehenden Array <NeoPixel_FunktionsListe> sieht, besteht dieses
aus insgesamt 10 Arrayzeilen, wobei sich jede
einzelne Arrayzeile wiederum aus
insgesamt 3 Arrayspalten zusammensetzt. Übrigens: Die Daten
des Array <NeoPixel_FunktionsListe> befinden sich im roten Kasten. Dementsprechend
enthält das obenstehende Array insgesamt 10 Datensätze im Bereich [0, …, 9] = 10 Zeilen. Dabei setzt sich
jeder Datensatz aus insgesamt drei
Datenfeldern. In diesem Zusammenhang lässt sich das Array auch mit einer kleinen Datenbank
vergleichen, die sich wiederum in Form einer kleinen Tabelle wie folgt in einem engl. „Spreadsheet“,
d.h. einer Tabellenkalkulation, darstellen und
„berechnen“ lässt:
(Vergrößern: auf das
Bild klicken! | Tabelle „joy-car_teil_03_prog_13.ods“) Das obenstehende Programm zur Tabellenkalkulation kann man sich
übrigens von „LibreOffice“
kostenlos aus dem Internet herunterladen. - Selbstverständlich lässt sich das Array <NeoPixel_FunktionsListe> (siehe oben im Bild 20) auch kürzer
programmieren bzw. direkt initialisieren:
(Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_14.py“) Das „Resetten“, d.h. Zurücksetzen
der zuvor aktivierten „NeoPixel“-LED-Funktionen findet in der <for … next>-Schleife <for i in range(laenge_NP_FktListe)> statt und ist natürlich vom Programmkode her
entsprechend umfangreicher. Dabei muss das Zurücksetzen auch im Array <NeoPixel_FunktionsListe> eingetragen werden. Und
zwar mit dem fortlaufenden ·
Statement <NeoPixel_FunktionsListe[i][1] == schalteTagfahrlicht>
usw.: (Vergrößern: auf das
Bild klicken! | Programm „joy-car_teil_03_prog_14.hex“) Bezüglich des Programms stellt sich noch die
Frage, wie sich dieses bedienen lässt: Bedienungsanleitung:
Nachdem man das Programm „joy-car_teil_03_prog_14.hex“
in den Flashspeicher des „micro:bit“-Rechners des „Joy-Car“-Roboters geladen hat, startet sich dieses
automatisch, sodass in der roten LED-Laufschrift der abgekürzte Programmname „Prog_14“ angezeigt wird. ·
Wenn man das Programm in der „micro:bit“-Programmier-Entwicklungsumgebung im Browser laufen lässt bzw. dort importiert,
dann erscheint in der roten LED-Laufschrift der Hinweis „Batterien wechseln!“, womit die vier 1,5 Volt Batterien vom Typ
„AA“ im Batteriefach des „Joy-Car“-Roboters gemeint sind.
Aufgrund der Simulation des „micro:bit“-Rechners ist diese Meldung aber bedeutungslos! ·
Das Programm lässt sich von außen mittels des Tasters A (links) und des Tasters B (rechts) sowie des Touch-Sensors (= oben im Kopf des „micro:bit“-Rechners) bedienen. ·
Dabei
dient der Taster A (links) dazu, die
laufende Nummerierung im Bereich [ 1, …, 10 ] zu starten bzw. fortlaufend durchzuschalten,
sodass der Zähler jeweils um +1 inkrementiert, d.h. erhöht wird. Nachdem der Wert 10
erreicht wurde, beginnt der Zähler wieder beim Wert 1
usw. Auf diese Weise lassen
sich nachfolgende „NeoPixel“-Funktionen, auch in mehrfacher
Kombination, ansteuern und auswählen: 1.) Tagfahrlicht, 2.) Standlicht, 3.) Abblendlicht, 4.) Fernlicht, 5.) Warnblinker, 6.) Blinker_rechts, 7.) Blinker_links, 8.) Rückfahrlicht, 9.) Nebelschlusslicht
und 10.) Bremslicht ·
Nachdem man eine der zehn „NeoPixel“-Funktionen angesteuert bzw.
„ausgewählt“ hat, lässt sich diese durch Betätigen des Tasters B starten/ausführen und auch wieder durch
erneutes Betätigen des Tasters B beenden/deaktivieren! Demzufolge arbeitet
der Taster B als sogenannter
Wechselschalter. Bedingt durch den booleschen Wechselschalter (= True/False) kommt es
vor, dass man den Taster B zwei Mal betätigen muss bis dieser von „False“ auf „True“ umgeschaltet und die „NeoPixel“-Funktion aktiviert hat! ·
Die mittels Taster B aktivierten „NeoPixel“-LED-Funktionen, auch in
Mehrfach(!)-Kombination, lassen sich alle auf einen Schlag mittels des Touch-Sensors
(= „micro:bit“-Logo) ausschalten! - |
|||
|
|
[ Home
] [ Seitenanfang ] [ Teil 1 ] [ Teil 2a ] [ Teil 2b ] [ Teil 4 ] |
|
