[ Home ] [ Seitenende ] [ Teil 2a ] [ Teil 2b ]

Roboter-Auto „Joy-Car“ - Teil 1

Es werde Licht beim Roboter-Auto „Joy-Car“

Das Roboter-Auto „Joy-Car“ ist zusammengebaut und hat den ersten Funktionstest erfolgreich bestanden. Obwohl, einen Funktionstest zum Testen aller verbauter Komponenten wie z.B. aller Sensoren (2 Ultraschall-Sensoren für die Entfernungsmessung, 3 Infrarot-Sensoren für das Line-Tracking, 2 Infrarot-Sensoren für die Hinderniserkennung und 2 Infrarot-Sensoren für die Geschwindigkeitserfassung der beiden Antriebsmotoren) sowie aller Rot-Grün-Blau-LEDs (je 2 Doppel-LEDs an der Vorder- und je 2 Doppel-LEDs an der Rückseite) gibt es nicht, sodass wir die einzelnen Komponenten selbst testen müssen.

Doch zunächst müssen wir den „Joy-Car“-Roboter in Betrieb nehmen, indem wir die 4 Mignon Batterien vom Typ „AA“ mit der richtigen Polung in das 6 Volt Batteriefach einsetzen. Damit das in der Batterie befindliche elektro-chemische Kraftwerk gegen Auslaufen des stark ätzenden Elektrolyten geschützt ist, befindet sich dieses in einem elektrisch leitenden Metallbecher (= Kathode als Minuspol „-“). In der Mitte des Metallbechers ist ein mehrere Millimeter dicker Stift (= Anode als Pluspol „+“) in der Größe dreier Streichhölzer verbaut, der oben als kleiner Knubbel („+“) aus dem Becher herausragt. Wenn man alle Mignon-Batterien mit der richtigen Polung in das Batteriefach einsetzt, dann ergeben diese wegen der Reihenschaltung zusammen eine Batteriespannung U_Batt = 4 x 1,5 V = 6 V. Dabei entspricht der spiralförmige Federkontakt im Batteriefach dem Minuspol „-“ einer Mignon-Batterie. Da Batterien in der Regel nicht wieder aufladbar sind, bezeichnet man diese auch als Primärzellen. Im Gegensatz dazu bezeichnet man wieder aufladbare „Batterien“ als Sekundärzelle, auch Akkumulator oder Akku genannt.

Obwohl das Batteriefach des „Joy-Car“-Roboter über einen eigenen Ein-/Aus-Schiebeschalter verfügt, benutzen wir diesen nicht, da man zur Bedienung stets das Batteriefach aus der Halterung herausnehmen muss. Stattdessen benutzen wir den kleinen Ein-/Aus-Schiebeschalter des „Joy-Car“-Mainboards (siehe Seite 47 der PDF-Datei „MB-Joy-Car_Anleitung_2021-04-30.pdf“):

(Zum Vergrößern bitte auf das Bild klicken!)

Da die RGB-LEDs und die Antriebsmotoren recht viel Strom verbrauchen, werden wir das an die „+“ und „-“-Klemmen angeschlossene Batteriefach „BAT“ später abklemmen und stattdessen eine „USB 2.0“-Stecker in Form eines kleinen Adapters anklemmen, sodass sich z.B. eine Powerbank zwecks ausdauernder Energieversorgung anschließen lässt (siehe blaue Schraubklemmen im roten Kasten).

An die „+“ und „-“-Klemmen der blaue Schraubklemmen mit der Beschriftung „BAT“ lässt sich nämlich eine externe Stromversorgung mit einer Spannung von U_Bat = 4,5 V … 9 V anschließen (siehe Spezifikationen). -

Auf der „Joy-Car“-Webseite gibt es eine Garage mit Anleitungen, wo man alles findet, was man wissen muss. Angefangen vom Zusammenbau, über Erklärungen, bis hin zur Programmierung und Einrichtung des Joy-Cars. Dort kann man sich die ZIP-Archiv-Datei „MakeCode-Tutorials.zip (11,0 MiB)“ kostenlos auf den heimischen PC oder Notebook herunterladen und in das Verzeichnis „MakeCode-Tutorials“ entpacken. Dort wechseln wir ins Unterverzeichnis „07_led“ und laden das erste „MakeCode“-Programm „JoyCar-Tutorials-07-led01.hex“ in den „BBC micro:bit“-Mikrocontroller:

(Vergrößern: auf das Bild klicken! | Programm „JoyCar-Tutorials-07-led01.hex“)

Wir schalten die „micro:bit“-Entwicklungsumgebung von der Microsoft „MakeCode“-Block-Programmierung auf die (Mikro-) „Python“-Programmierung um:

(Vergrößern: auf das Bild klicken! | Programm „JoyCar-Tutorials-07-led01.py“)

Diesbezüglich stellt sich die Frage, weshalb wir ohne Not in die (Mikro-) „Python“-Programmierung wechseln. Ganz einfach:

a) weil wir zweisprachig programmieren,

b) weil es sich bei „Python“ um eine höhere Programmiersprache handelt und

c) weil sich der Quellkode von „Python“ mittels der künstlichen Intelligenz (KI)
von OpenAI und ChatGPT analysieren, interpretieren und erweitern lässt.

Wenn man also den Quelltext des (Mikro-) „Python“-Programms mittels „Copy & Paste“ in die Texteingabezeile von ChatGPT eingefügt, dann liefert die KI von OpenAI folgende Antwort:

(Vergrößern: auf das Bild klicken! | Programm „JoyCar-Tutorials-07-led01.py“)

Da das „strip“-Statement in die „dauerhaft“-Endlosschleife programmiert wurde, könnte man meinen, dass das Statement unendlich oft wiederholt werden muss, damit die 8 LED NeoPixel-Streifen ununterbrochen leuchten.

(Zum Vergrößern bitte auf das Bild klicken!)

Darüber hinaus meint die KI von ChatGPT, dass es zwischen jedem Statementaufruf eine Verzögerung von einer Sekunde gibt, die letztlich den Regenbogen-Effekt mit dem Farbwechsel herbei führt.

Gäbe es aber zwischen jedem Statementaufruf eine Verzögerung von einer Sekunde nebst Farbwechsel, dann würde jede einzelne LED-Anzeige deutlich wahrnehmbar und störend flackern!

Wie es im obenstehenden „strip“-Statement heißt, bezieht sich der Regenbogen nur auf die Regenbogenfarben und nicht darauf, dass dieser effektvoll glitzert oder sich dessen Farbverlauf fortwährend ändert. Soweit zum Verständnis des Regenbogens.

Wenn man sich den obenstehenden Quellkode des Programms „JoyCar-Tutorials-07-led01.py“ anschaut,

(Zum Vergrößern bitte auf das Bild klicken!)

dann stellt man fest, dass die acht NeoPixel mittels des „strip“-Statements nach dem Programmstart im „micro:bit“-Rechner zunächst konfiguriert, initialisiert und über den Port „Pin P0“ angesteuert(!) werden:

(Zum Vergrößern bitte auf das Bild klicken!)

Dabei wird mittels der sogenannten Instanziierung das Objekt namens „strip“ erzeugt und mittels des „strip“-Objekts die Programm-Bibliothek (= Befehlssammlung), engl. „library“, des „NeoPixel“-Herstellers „adafruit“ verfügbar gemacht:

1. Und zwar mit dem ersten „strip“-Statement <strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)>

2. Mit dem zweiten „strip“-Statement <strip.show_rainbow(1, 360)>

werden dann die acht RGB-LEDs aufgesteuert, sodass diese hell leuchten. Dabei erfolgt die Stromversorgung der acht RGB-LEDs wegen der größeren Vorsorgungsspannung nebst Stromstärken über das „JoyCar“-Mainboard:

(Zum Vergrößern bitte auf das Bild klicken!)

Wegen der „Endlosschleife“ mit der Funktion „on_forever“ meint die KI von ChatGPT, dass das zweite „strip“-Statement <strip.show_rainbow(1, 360)> immer wieder neu gestartet d.h. aufgerufen wird, sodass es zwischen den Aufrufen des Statements zwangsläufig jeweils zu einer Ladepause von einer Sekunde kommt, da das Statement stets auf’s Neue in den Arbeitsspeicher des „micro:bit“-Rechners geladen und von dort ausgeführt werden muss:

>> Das Skript definiert dann eine Funktion „on_forever“, die einen Regenbogen-Effekt auf dem LED-Streifen anzeigt, wobei zwischen jeder Farbe eine 1-Sekunden-Verzögerung besteht. D Das Skript führt dann die Funktion „on_forever“ dauerhaft mit dem Befehl „basic.forever“ aus. Dadurch wird ein Regenbogen-Effekt dargestellt, der auf dem LED-Streifen endlos wiederholt wird. <<

Wir wissen aber inzwischen, dass es beim fortwährenden Ausführen der „on_forever“-Funktion eben zu keiner Ladepause von einer Sekunde kommt, was die Vermutung nahe legt, dass es nicht wirklich des fortwährenden Aufrufen des Statement <strip.show_rainbow(1, 360)> bedarf:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_02.hex“)

Und siehe da, das Statement <strip.show_rainbow(1, 360)> muss nicht fortwährend in der „Endlosschleife“ mit der Funktion „on_forever“ ausgeführt werden, um die acht RGB-LEDs ununterbrochen leuchten zu lassen!

Darüber hinaus lässt sich das ununterbrochene Leuchten der acht RGB-LEDs aus Gründen der Energieersparnis auch nach fünf Sekunden mittels der beiden Statements

1. Statement <strip ausschalten>

2. Statement <strip anzeigen>

wieder ausschalten! Dabei dienst das erste Statement wieder der Konfiguration bzw. der Initialisierung und das zweite Statement der Ausführung!

Wir geben den geänderten und erweiterten Quelltext des (Mikro-) „Python“-Programms

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_02.py“)

wieder mittels „Copy & Paste“ in die Texteingabezeile von ChatGPT ein, um uns die Funktionsweise des Programms wie folgt erklären zu lassen:

(Zum Vergrößern bitte auf das Bild klicken!)

Wenn man sich die Hardware eines sogenannten Regenbogen-Gerätes anschaut,

(Zum Starten des Videoclips bitte auf das Bild klicken!)

dann wird schnell deutlich, wie das Regenbogenmuster mittels der zehn RGB-LEDs auf dem Vollkreis von 360^o abgebildet wird. Dabei erfolgt der umlaufende Farbwechsel der RGB-LEDs wegen der Trägheit des menschlichen Auges sehr zügig, sodass ein kompletter Farbwechselumlauf weniger als zwei Sekunden dauert.

Diesbezüglich lässt sich das Farbspektrum des Regenbogenmusters mittels zweier Parameter wie folgt festlegen:

Statement <strip.show_rainbow(0, 360)>

Dabei legt man mit dem ersten Parameter = 0 fest mit welchem Wert das Farbspektrum des Regenbogenmusters starten soll und mit zweiten Parameter = 360 legt man fest, wo das Farbspektrum enden soll:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_03.hex“)

Wie man im obenstehenden Quellkode unschwer sieht, wurde die Helligkeit der RGB-LEDs aus Energiespargründen maßgeblich auf den Wert 32 reduziert, um auf diese Weise zu erreichen, dass die vier 1,5 Volt Mignon-Batterien länger durchhalten.

Darüber hinaus wurde das „strip“-Statement <strip.show_rainbow(0, 359)> in die <for Index von 0 bis 359> Schleife verlagert, um zu zeigen, wie sich das volle Farbspektrum, schrittweise über alle RGB-LEDs verteilt, in weniger als eine Sekunde aufbaut.

Am Ende des Programms wird der „LED-Streifen“, engl. „strip“, automatisch ausgeschaltet, um Energie zu sparen. Dabei wird der Ausschaltvorgang mit dem ersten Statement initialisiert

1. Statement <strip ausschalten>

2. Statement <strip anzeigen>

und erst mit dem zweiten Statement umgesetzt, d.h. veranlasst!

‚Als Nächstes wandeln wir den Quellkode des „MakeCode“-Programms um in den von (Micro-) Python und erweitern das bisherige Programm um die Index-Anzeige, um auf diese Weise herauszufinden, ob der Index bei 0 oder 1 zu zählen anfängt.

Dazu muss man wissen, dass die Zahl null in der Mathematik und in der Informatik auch eine Zahl ist „mit der man rechnen muss“ und rechnen kann. Wenn also das Regenbogen-Farbspektrum von 360 Grad programmiertechnisch umgesetzt werden soll, dann muss man in der Schleife den Wertebereich von 0 bis 359 programmieren.

Der Knackpunkt im Kopf der <for … next>-Schleife ist aber der, dass sich der Index im Wertebereich bis 360 befinden muss! Dabei befindet sich der Wert 359 im Wertebereich [ bis 360 ], während sich der Wert 360 bereits außerhalb des Wertebereichs [ bis 360 ] befindet:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_04.py“)

Wichtig zu wissen ist also, dass der Schleifenzähler Index der <for … next>-Schleife beim Index = 0 beginnt und beim Index = 359 aufhört. Und zwar mit dem Wertebereich [ 0, …, 359 ], was nach Adam Riese insgesamt 360 verschiedenen Werten entspricht!

Interessant ist bei dem obenstehenden Programm noch, dass das Farbspektrum des Regenbogens mit dem Index = 0 beginnt, sodass alle acht RGB-LEDs rund herum rot leuchten. Demzufolge wird das Farbspektrum des Regenbogens erst mit dem Index = 1 gestartet. Wenn man also erreichen will, dass alle acht RGB-LEDs sofort mit dem Farbspektrum des Regenbogens leuchten, dann muss man dafür sorgen, dass das „strip“-Statement mit dem Farbspektrum nicht bei 0 beginnt, sondern bei 1:

Statement <strip.show_rainbow(1, Index)

Beim nachfolgenden Programm „joy-car_teil_01_prog_05.hex“ sieht man, dass das Farbspektrum des Regenbogens tatsächlich mit dem Index = 0 beginnt, sodass alle acht RGB-LEDs rund herum zunächst rot leuchten. Beim zweiten Schleifendurchlauf mit dem Index = 1 allerdings leuchten dann alle acht RGB-LEDs in den Regenbogenfarben:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_05.py“)

Im Zusammenhang mit dem Startwert Index = 1 für das bunte Farbspektrum des Regenbogens könnte man auch auf die Idee kommen und den Schleifenzähler mit dem Index-Startwert der <for … next>-Schleife beim Index = 1 wie folgt beginnen zu lassen:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_06.py“)

Wenn man das Programm „joy-car_teil_01_prog_06.hex“ startet, dann wird man bei der Ausführung im Vergleich zum vorherigen Programm „joy-car_teil_01_prog_05.py“ wider Erwarten keinen Unterschied feststellen können, da das bunte Farbspektrum des Regenbogens wie gehabt mit dem Index = 0 beginnt, sodass zunächst alle acht RGB-LEDs rund herum rot leuchten!

Der Grund dafür, weshalb sich gegenüber dem Vorgängerprogramm im Verhalten nichts ändert, ist ganz einfach der, dass die Wertzuweisung im Statement <Index = 1> (siehe Zeile 7) durch die Initialisierung des Schleifenzählers Index der <for … next>-Schleife (siehe Zeile 8) mit dem Startwert Index = 0 überschrieben wurde!

Wenn man also möchte, dass alle acht RGB-LEDs von Anfang an mit dem vollen Farbspektrum des Regenbogens leuchten, dann muss man nur den Schleifenzähler Index der <for … next>-Schleife (siehe Zeile 7) sofort mit dem Startwert Index = 1 (siehe roter Kreis) beginnen lassen:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_07.py“)

Wenn man also den „Index“-Schleifenzähler bei der <for … next>-Schleife (siehe Zeile 7) im Range [ 1, …, 360 ] arbeiten lässt, dann leuchten alle RGB-LEDs von Anfang an mit dem vollen Farbspektrum des Regenbogens.

Sollte man meinen! Aber das Programmieren des „Index“-Schleifenzählers der <for … next>-Schleife (siehe Zeile 7) mit dem Range [ 1, …, 360 ] ist das eine und das „eigenwillige Verhalten“ des Farbspektrums beim Regenbogen ist das andere!

Obwohl jetzt die <for … next>-Schleife mit dem „Index“-Schleifenzähler im Range [ 1, …, 360 ] arbeitet, kümmert das das Farbspektrum des Regenbogens nicht im geringsten, startet dieses stets mit der Farbe Rot (siehe Zeile 10), obwohl der Schleifenzähler den Wert Index = 1 hat:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_08.py“)

Um herauszufinden, weshalb das Farbspektrum des Regenbogens stets bei der Farbe Rot (siehe Zeile 10) anfängt, brauchen wir weitere Informationen. Mal sehen, was die KI von ChatGPT dazu herausfindet. Wir fügen den Quellkode des obenstehenden Programms mittels Copy & Paste in die Texteingabe von ChatGPT ein und erfahren folgendes:

(Zum Vergrößern bitte auf das Bild klicken!)

Wir bemühen die KI von ChatGPT ein weiteres Mal mit der Frage: „Weshalb starten die NeoPixel LEDs stets mit der Farbe Rot?“ und erfahren folgendes:

(Zum Vergrößern bitte auf das Bild klicken!)

Jetzt wissen wir, dass der „Index“-Schleifenzähler bei der <for … next>-Schleife mit dem Range [ 1, …, 360 ] und das Statement <strip.show_rainbow(1, Index) mit dem gleichen Range [ 1, …, Index ] zusammen gehören:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_09.py“)

Ein schillernder Regenbogen zum Ein- oder Ausschalten

Zur Vermeidung von Lichtverschmutzung, der Energieverschwendung und wegen des Bedienkomforts sollte sich elektrisches Licht jederzeit stets manuell oder automatisch per Schalter oder Taster ein- oder ausschalten lassen!

Wenn später das fahrende Roboter-Auto „Joy-Car“ auch rechts oder links abbiegen soll, dann muss der Fahrtrichtungswechsel zuvor durch Betätigen des Fahrtrichtungsanzeigers (= Blinker) angezeigt werden. Dabei verhält es sich so, dass der Fahrzeugführer den Blinkhebel nach dem Abbiegen des Kfz nicht wieder manuell in die Mittenstellung bringen muss, da dies automatisch erfolgt. Und zwar in Abhängigkeit des Lenkradeinschlags der Vorderräder. Demzufolge sollte sich der Blinker nach dem Abbiegen, wenn die Vorderräder wieder auf Geradeausfahrt stehen, automatisch abschalten.

Da der „micro:bit“-Rechner über zwei Taster A und B verfügt, verwenden wir diese im nachfolgenden Programm „joy-car_teil_01_prog_10.hex dazu, den schillernden Regenbogen jederzeit ein- oder ausschalten zu können:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_10.py“)

Wie man anhand des roten und grünen Kastens sieht, befinden wir uns jetzt mitten in der Objekt orientierten Programmierung (OOP). Dazu gleich mehr.

Bei den bisherigen „MicroPython“-Programmen bis zum Programm „joy-car_teil_01_prog_09.py“ verhielt es sich so, dass wir diese als Ganzes, d.h. linear von oben, engl. „on top“, nach unten, engl. „ top down“, als Monoblock ohne jegliche Verzweigungen in irgendwelche Unterprogramme oder Funktionen programmiert haben.

Wie der Name „Funktion“ bereits ausdrückt, tut sich was in einer Funktion, wird in einer Funktion etwas herbeigeführt oder eine Aufgabe bewerkstelligt, d.h. gelöst.

Ein weniger gutes Beispiel, das aber sehr anschaulich ist, wäre ein gut ausgebildeter und disziplinierter Soldat beim Militär, der, gemäß Befehl und bedingungslosem Gehorsam, ohne Wenn und Aber wie eine Tötungsmaschine funktioniert und dabei Menschenrechte verletzt und ignoriert. Von einem „guten“ Soldaten erwartet man, dass er einfach nur funktioniert und Befehle ausführt. Und zwar ohne groß nachzudenken oder Widerspruch zu leisten. Wer als Soldat Befehle verweigert oder nicht ausführt, landet demzufolge wegen Befehlsverweigerung im Militärgefängnis.

Von einem Smartphone als elektronisches Kommunikationsgerät erwartet man, dass es gemäß der zugesicherten Eigenschaften (BGB), wie erwartet einwandfrei funktioniert, Kommandos entgegennimmt und z.B. Webseiten aufruft, Musik oder Videos abspielt. Und wenn etwas mal nicht so funktioniert, wie es sein sollte, dann erinnert man sich als IT-Fachmann an den Spruch, dass „der größte Fehler als ‚DAU’ immer vor der PC-Tastatur sitzt“. Damit ist natürlich der Mensch als Anwender gemeint, verächtlich auch als „DAU“ bezeichnet: „Dümmster, anzunehmender User“.

Einer Funktion kann man beim Funktionsaufruf in Form eines Parameters etwas mit auf den Weg geben, eine Eigenschaft zuweisen oder ein bestimmtes Kommando erteilen. Funktionen tun also etwas, führen etwas aus, bewerkstelligen Dinge und können dabei z.B. auch Ergebnisse mittels des Statements <return()> an das aufrufende Programm zurückliefern:

(Zum Vergrößern bitte auf das Bild klicken!)

Eine Funktion, die innerhalb einer sogenannten Klasse programmiert wurde, nennt man Methode.

Im obenstehenden Programm „joy-car_teil_01_prog_10.hex haben wir es also mit zwei Funktionen und zwar mit den Tastern A und B zu tun.

Wenn man das obenstehende Programm „joy-car_teil_01_prog_10.py“ mit dem vorherigen Programm „joy-car_teil_01_prog_09.py“ vergleicht, dann fällt auf, dass das

Statement <strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)>

vom Hauptprogramm in die Funktion <on_button_pressed_a()> verschoben wurde (siehe grüner Kasten). Und zwar mit der Folge, dass die Klasse „neopixel()“ nun nicht mehr von außen aus dem Hauptprogramm heraus erreichbar ist! Und das, obwohl die Instanz- bzw. Objektvariable „strip“ mittels des

Statements <global strip>

als globale Variable deklariert wurde!

Der Grund dafür ist der, dass es die globale Instanz- bzw. Objektvariable auch geben muss, diese existieren muss! Und zwar im Hauptprogramm (siehe roter Kasten) mit dem

Statement <strip: neopixel.Strip = None>

Dabei bedeutet die Angabe „None“, dass die neue Instanz „strip“ zwar instanziiert und der Klasse „neopixel()“ zugewiesen, aber eben noch nicht initialisiert wurde, da die Initialisierung erst später durch Betätigen des „Tasters A“ beim Aufruf der Funktion <on_button_pressed_a()> mittels des

Statements <strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)>

erfolgt. -

Jetzt wissen wir,

a) dass es nicht nur globale Variablen im Hauptprogramm gibt,

b) sondern auch lokale Variablen in den jeweiligen Funktionen,
die gegenüber dem Hauptprogramm abgeschirmt sind,

c) dass man aus der Funktion heraus auf eine Variable im Hauptprogramm
zugreifen kann, indem man diese in der Funktion als globale Variable wie
folgt mit dem Statements <global strip> deklariert und

d) dass sich die neue Instanz bzw. Objektvariable „strip“ im Hauptprogramm unbestimmt deklarieren (= None)
und erst später mittels des Statements <strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)>
in einer Funktion initialisieren lässt!

Wenn man den obenstehenden Quellkode des Programms „joy-car_teil_01_prog_10.py“ in die Texteingabezeile der KI von ChatGPT mittels „Copy and Paste“ einpflegt, dann kann man sich von ChatGPT erklären lassen, was es mit der Instanziierung auf sich hat

(Zum Vergrößern bitte auf das Bild klicken!)

und was eine Instanzvariable ist:

(Zum Vergrößern bitte auf das Bild klicken!)

Selbstverständlich kann man sich von der KI der ChatGPT auch erklären lassen, was das das obenstehende Programm „joy-car_teil_01_prog_10.py“ macht und wie es funktioniert:

(Zum Vergrößern bitte auf das Bild klicken!)

Diesbezüglich muss noch erläutert werden, weshalb im obenstehenden Programm „joy-car_teil_01_prog_10.py“ die Batteriespannung UBatt als auch die Stromstärke IBatt des „Joy-Car“-Mainboards abgefragt und angezeigt werden.

In der Praxis hat sich nämlich herausgestellt, dass sich das „Joy-Car“-Mainboard bei einer

· Batteriespannung UBatt < 4,34 V
mit I = 23 mA im Stromsparmodus ( " Statement <strip.set_brightness(32)>)

ohne Vorwarnung plötzlich „verabschiedet“ und seinen Dienst versagt, sodass sich beim Aufrufen des Programms und dem Betätigen des Tasters A die 8 bunten RGB-LEDs nicht mehr zum Leuchten bringen lassen, weil die 4 x 1,5 V = 6 V Mignon-Batterien bereits zu stark entladen sind!

Wenn man das Programm „joy-car_teil_01_prog_10.py“ startet, dann werden im Hauptprogramm zunächst die Laufschrift „Regenbogen-LEDs“ und anschließend die Batteriespannung UBatt als Leerlaufspannung angezeigt.

Und im Leerlauf, weil die 8 bunten RGB-LEDs noch nicht eingeschaltet sind!

Wenn man dann später den Taster A betätigt, sodass sich die 8 bunten RGB-LEDs einschalten, dann verringert sich die Batteriespannung wegen des Laststroms der LEDs um etwa 20 mV.

Am zuverlässigsten lässt sich aber der Betrieb des Programms im Stromsparmodus ( " Statement <strip.set_brightness(32)>) anhand der verringerten Stromstärke I_min = 23 mA gegenüber der Stromstärke I_max = 82 mA unter Volllast erkennen. -

Als nächstes verbessern wir das bisherige Programm dahingehend, dass man nur noch einen (Wechsel-) Taster A benötigt, um die 8 bunten RGB-LEDs des Regenbogens ein- oder ausschalten:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_11.py“)

Wie man im obenstehenden Quellkode sieht, gibt es jetzt die neue Funktion mit dem

· Statement <NeoPixel_anzeigen(anzeigen_ja_nein, Helligkeit_LEDs)>

und den Übergabe-Parametern anzeigen_ja_nein und Helligkeit_LEDs (siehe roter Kasten), sodass mittels dieser beim Aufrufen der Funktion bereits festlegen lässt, ob die 8 bunten RGB-LEDs ein- oder ausgeschaltet werden sollen und falls ja, mit welcher Helligkeit diese leuchten sollen (siehe grüner Kasten).

Demzufolge gibt es im Hauptprogramm die beiden korrespondierenden globalen Variablen <schalte_Ein_Aus> und <NeoPixel_Helligkeit> mit den Übergabewerten [ schalte_Ein_Aus = True ] und [ NeoPixel_Helligkeit = 32 ] (siehe blauer Kasten), die beim Aufrufen der Funktion <NeoPixel_anzeigen(anzeigen_ja_nein, Helligkeit_LEDs)> mit auf den Weg gegeben werden (siehe grüner Kasten).

Diesbezüglich verfügt die Funktion <NeoPixel_anzeigen(anzeigen_ja_nein, Helligkeit_LEDs)> über ihre eigenen lokalen Variablen <anzeigen_ja_nein> und <Helligkeit_LEDs> in Form der Parameter (siehe roter Kasten). Dabei müssen die lokalen Variablen (= Parameter) der Funktion <NeoPixel_anzeigen()> vom Typ her mit denen der globalen Variablen <schalte_Ein_Aus> und <NeoPixel_Helligkeit> im Hauptprogramm vom Typ „boolean“ (= wahrheitsgemäß „richtig“ oder „falsch“) und „integer“ (= ganzzahlig numerisch) unbedingt identisch sein!

In diesem Zusammenhang ist noch neu und besonders interessant, dass die Funktion <NeoPixel_anzeigen(anzeigen_ja_nein, Helligkeit_LEDs) nicht nur zwei Parameter entgegennimmt, sondern den booleschen Wert „True“ oder „False“ der lokalen Variablen <anzeigen_ja_nein> im

· Statement <return(anzeigen_ja_nein)>

an die aufrufende Funktion <on_button_pressed_a()> (siehe grüner Kasten) zurückliefert!

Wichtig zu wissen ist auch noch, dass die Funktion <NeoPixel_anzeigen()> den booleschen Wert der Variablen <anzeigen_ja_nein> nach dem Ein- oder Ausschalten ins Gegenteil verkehrt, sodass von vormals „True“ auf „False“ gewechselt wird und umgekehrt. Auf diese Weise wird dann nämlich der Wechsel-Schalter „Taster A“ realisiert.

Beim Tastendruck auf den Wechsel-Schalter „Taster A“ wird in der Laufschrift des „micro:bit“-Rechners als Hilfestellung für den Programmierer angezeigt, ob der Wert der lokalen, booleschen Variablen <anzeigen_ja_nein> auf „True“ oder „False“ steht.

Wenn es darum geht zu wissen und zu verstehen, wie das obenstehende Programm „joy-car_teil_01_prog_11.hex“ funktioniert, dann kann man sich wie gehabt von der KI der ChatGPT helfen lassen:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_11.py“)

Da der Taster B jetzt frei geworden ist, dieser nicht mehr zum Ausschalten der 8 bunten RGB-LEDs des Regenbogens gebraucht wird, lässt sich dieser anderweitig verwenden, nämlich zum Umschalten der Helligkeit. Und zwar mittels der globalen Variablen <NeoPixel_Helligkeit> und der Umschaltung von [ NeoPixel_Helligkeit = 32 ] auf [ NeoPixel_Helligkeit = 255 ] und wieder zurück. Dabei wird der jeweilige Variablenwert beim Aufrufen der Funktion (siehe grüner Kasten) mit dem

· Statement <NeoPixel_anzeigen(anzeigen_ja_nein, Helligkeit_LEDs)>

an die lokale Variable <Helligkeit_LEDs> im Funktionskopf übergeben (siehe roter Kasten):

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_12.py“)

Da sich die Funktion <on_button_pressed_b():> noch etwas vereinfach lässt, geht’s mit dem Programmieren gleich weiter:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_13.py“)

Wenn wissen will, wie das obenstehende Programm „joy-car_teil_01_prog_13.hex“ funktioniert, dann kann man sich wie gehabt von der KI der ChatGPT helfen lassen:

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_13.py“)

Wir erweitern das obenstehende Programm ein letztes Mal. Und zwar indem wir die Batteriespannung des Batteriefaches vom „JoyCar“-Mainboard messen! Dazu ist es allerdings erforderlich, dass wir die bisherige Funktion <messe_UBatt()> dahingehend abändern, sodass die gemessene Spannung UBatt nicht mehr in der Funktion selbst angezeigt wird.

Da wir die gemessene Spannung UBatt der globalen Variablen <UBatt> zunächst nur auswerten wollen, müssen wir diese mittels des Statements <return(UBatt)> an das aufrufende Hauptprogramm wie folgt zurückliefern (siehe roter Kasten):

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_14.py“)

Zum Einsatz kommt dann die Funktion der Spannungsmessung <messe_UBatt()> erstmals bei der „Wenn … dann“-Abfrage im

· Statement <if messe_UBatt() >= 4.4:>

(siehe grüner Kasten).

Dabei besteht das Geniale darin, dass die Funktion <messe_UBatt()> (siehe roter Kasten) innerhalb der „if … then“-Abfrage aufgerufen und gleichzeitig in dieser ausgewertet wird, da die Funktion <messe_UBatt()> das Messergebnis an den Funktionsaufruf in der „if … then“-Abfrage mittels des

· Statements <return(UBatt)>

sofort zurückliefert (siehe grüner Kasten)!

Und wie funktioniert das Ganze, das obenstehende Programm?

So lange die im Leerlauf gemessene Spannung UBatt >= 4,4 V ist werden der Schriftzug „Regenbogen“ als Laufschrift im LED-Display des „micro:bit“-Rechners angezeigt und die beiden „input“-Abfragen der Taster A und B ausgeführt.

Sollte dann die Batteriespannung im Laufe der Zeit bis auf weniger als UBatt < 4,4 V abgesunken sein, so wird die Laufschrift „Batterien wechseln!“ des „JoyCar“-Mainboard Batteriefaches angezeigt, um dem Anwender zu signalisieren, dass die Batterien entladen sind und die Elektronik des des „JoyCar“-Mainboard nebst der „NeoPixel“-LEDs zu spinnen anfangen, um schließlich den Dienst gänzlich zu quittieren.

Dabei gilt es noch anzumerken, dass das Testen des Ladezustandes einer Batterie stets unter Last erfolgen sollte, da das Messen der Leerlaufspannung (ohne Last) wegen des Innenwiderstandes der Batterie zu falschen Ergebnissen führt.

Wenn man beim „JoyCar“-Roboterauto alle 8 „NeoPixel“-LEDs bei voller Helligkeit zum Leuchten bringt, dann stellt sich eine Stromstärke von bis zu I_ges = 8 * 60 mA = 480 mA ein. Bei einer mittleren Lastspannung von 4 x 1,15 V = 4,6 V entspräche dies einem Lastwiderstand R_Last = U_Last / I_Last = 4,6 V / 0,480 A ≈ 9,58 W und einer entnommenen Verbraucherleistung von

P_Last = U_Last * I_Last

= I_Last * R_Last * I_Last

= I_Last² * R_Last = ( 0,48 A )² * 9,58 W = 0,2304 A² * 9,58 V/A = 2,207 W ≈ 2,21 W

Bedenkt man abschließend, dass die 8 „NeoPixel“-LEDs, die ja in Regenbogenfarben leuchten, wegen der unterschiedlichen Farben teils auch unterschiedlich hell leuchten bzw. unterschiedliche Durchflussströme I_Fluss aufweisen, dann müsste man alle 8 „NeoPixel“-LEDs in ein und der selben Farbe, wie z.B. Rot, leuchten lassen, um auf diese Weise zu einem noch größeren Laststrom von mehr als 480 mA zu kommen.

Eine herkömmliche 1,5 Volt „Mignon“-Batterie von Typ „AA“ und IEC-Klasse „LR6“ verfügt über eine gespeicherte, elektrische Energie von W_el = 3,0 Wh. Bei 4 x 1,5 V „Mignon“-Batterien entspricht dies einer gespeicherten, gesamten Energie von W_{el, ges} = 4 * W_el = 4 * 3,0 Wh = 12 Wh.

Demzufolge ließen sich die 8 „NeoPixel“-LEDs in Regenbogenfarben bis zu

t_Dauer = W_{el, ges} / P_Last

= 12 Wh / 2,21 W = 5,42986 h ≈ 5,43 h ununterbrochen lang betreiben.

Zum Vergleich: Moderne Smartphones verfügen heutzutage über eine Akkukapazität von Q_Batt = 5000 mAh = 5 Ah.

Würde man an dem Smartphone-Akku die 8 „NeoPixel“-LEDs in Regenbogenfarben leuchten lassen, dann könnte man diese

t_Dauer = Q_Batt / I_Last

= 5 Ah / 480 mA = 5 Ah / 0,48 A = 10,41667 h ≈ 10,4 h ununterbrochen lang betreiben.

Dazu muss aber noch gesagt werden, dass in den Smartphones sogenannte „Lithium-Ionen-Akkus“ verbaut werden, die nicht nur wesentlich kleiner, leichter und wieder aufladbar sind als z.B. „Alkali-Mangan“-Batterien, sondern auch über eine mehr als doppelt so große Akkukapazität verfügen. -

Lassen wir uns von der KI der ChatGPT noch ausführlich erklären, wie das Programm „joy-car_teil_01_prog_14.hex“

(Vergrößern: auf das Bild klicken! | Programm „joy-car_teil_01_prog_14.py“)

[ Home ] [ Seitenanfang ] [ Teil 2a ] [ Teil 2b ]