|
|
[ Easy
Elektro Start ] [ Seitenende ] [
zurück ] |
|
||||||||||||||||||||||||
|
|
Easy Elektro Start – Programmieren 1 Programmieren
mit den „micro:bit“- und „Calliope
mini“-Rechnern > Der BBC
micro:bit ist
ein preiswerter Einplatinencomputer, der von der British
Broadcasting Corporation im Juli 2015 vorgestellt wurde.
Vorrangiges Ziel des Projekts ist die Verbesserung der Schulbildung im Bereich der Informationstechnik. Das Gerät ist als Einplatinencomputer auf der
Basis eines ARM-Mikrocontrollers realisiert und kann mittels verschiedener
webbasierter Entwicklungsumgebungen programmiert werden. Der BBC micro:bit wurde ab 2014
von der BBC entwickelt und im Juli 2015 vorgestellt. Nachdem ursprünglich die
Auslieferung im Oktober des gleichen Jahres beginnen sollte, ist das Gerät
nach Verzögerungen seit März 2016 verfügbar. Seitdem wurden mit Unterstützung
verschiedener Partner mehr als eine Million Geräte kostenlos an 11- bis
12-jährige Schüler in Großbritannien verteilt.
Vergleichbare Initiativen gibt es außerdem in den Niederlanden und
in Island. Der Name des Geräts nimmt Bezug
auf den Heimcomputer BBC Micro des
britischen Computerunternehmens Acorn, der in den 1980er
Jahren verfügbar war und von der BBC für Lehrzwecke unterstützt wurde. Die
Verantwortung für die weitere Verbreitung und Unterstützung des BBC
micro:bit, der über verschiedene Elektronikhändler auch für Privatpersonen
erhältlich ist, wurde ab Oktober 2016 an eine gemeinnützige Stiftung mit dem
Namen Micro:bit Educational Foundation übertragen. Mit dem Calliope mini ist
seit August 2017 über den Cornelsen Verlag ein
vergleichbarer, deutlich teurerer Computer erhältlich, der in Deutschland
entwickelt wurde. Dieser ist auf Grund abweichender Pinbelegung weitgehend
Code-kompatibel zum BBC micro:bit, besitzt jedoch zusätzlich zu dessen
Hardware-Ausstattung weitere Bauteile wie einen Lautsprecher, ein Mikrofon und
eine RGB-Leuchtdiode. Der Preis des BBC micro:bit für
Privatanwender beträgt je nach Anbieter rund 11–13 £ beziehungsweise
rund 16–30 € (Stand
August 2017). < (Quelle: Wikipedia)
(Zum Vergrößern bitte
auf das Bild klicken!) Der „micro:bit“-Rechner der BBC verfügt über den gleichen Prozessor
vom Typ „Cortex
M0“ des Herstellers ARM Ltd. wie das
deutsche Pendant „Calliope mini“. Allerdings hat der „Calliope mini“ einige Sensoren
mehr als der „micro:bit“ und verfügt darüber
hinaus über einen sogenannten MOS-FET-Transistor,
sodass sich mit diesem auch Glühlampen und kleine Motoren an einer externen
Spannungsquelle mit höherer Spannung und größerem Motorstrom betreiben lassen. Mit beiden Einplatinencomputer
lassen sich bunte „Block“-Programme programmieren, die sich in der jeweiligen
Entwicklungs- und Programmierumgebung in die höheren „JavaScript“-
oder „MicroPython“-Programmiersprachen
umwandeln lassen, die dann wiederum auf beiden Hardware-Plattformen laufen und zueinander kompatibel sind. >> Der Calliope mini ist ein Einplatinencomputer, der für Bildungszwecke
entwickelt wurde und an deutschen Grundschulen
eingesetzt wird. Ziel ist es, Schülern ab der dritten Klasse einen
spielerischen Einstieg in das Programmieren
und algorithmische
Denken zu ermöglichen. Neben Schülern sollen auch Lehrkräfte und das
Bildungssystem erreicht werden, damit langfristig mehr digitale Inhalte an
Schulen vermittelt werden können. Die Programmierung
des Mikrocontrollers ist über unterschiedliche,
webbasierte Entwicklungsumgebungen möglich.
(…) Der Calliope mini wurde im
Jahr 2015 parallel und auf Grundlage des BBC
micro:bit entwickelt und mithilfe von Lehrkräften erweitert.
Im Vergleich zu dem BBC micro:bit besitzt der Calliope mini zusätzliche
Bauteile wie einen Lautsprecher, ein Mikrofon und eine RGB-Leuchtdiode, zwei Grove-Konnektoren,
erweiterte In- und Output Optionen und eine für Kinder kurzschlussvermeidende
Sternenform. Seit Sommer 2017 ist der Mikrocontroller käuflich zu erwerben. Hinter der
Weiterentwicklung steckt die Calliope gemeinnützige GmbH. Gesellschafter sind
die Professorinnen Gesche Joost und Franka Futterlieb, der
Psychologe Stephan Noller, der Designer Jørn Alraun, der
IT-Berater Maxim Loick und der Wirtschaftswissenschaftler Klaus Jürgen Buß. Der Name "Calliope
mini" bezieht sich auf die griechische Muse Kalliope,
eine Tochter des Zeus und Schutzgöttin der Wissenschaft, der Philosophie und
der epischen Dichtung. Sie gilt unter Informatikern als die „Tabletmuse“, da
sie früher häufig mit einer Schreibtafel dargestellt wurde. Informatiker
bezeichnen sie als eine frühe Vorbotin digitaler Bildungsideale. <<
(Quelle: Wikipedia)
(Zum
Vergrößern bitte auf das Bild klicken!) Wir legen
gleich los und steigen in die Programmierung
des „micro:bit“- und „Calliope mini“ ein. Und zwar direkt
in der online Entwicklungsumgebung
im Browser [ weiterlesen
] Wir
greifen das „Block“-Programm „mini-programm_01_04.hex“ auf,
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_01.hex) und
erweitern dieses wie folgt:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope-prog_01_02.hex) „Auf dem
Zweiten sieht man besser!“ so lautet der Werbespruch beim Zweiten Deutschen
Fernsehen (ZDF). In unserem Fall aber müsste es heißen „Auf den zweiten Blick
sieht man besser! Und, die „Suppe wird nie so heiß gegessen, wie sie gekocht
wurde!“ Was sagt uns das? Wenn man sich auf den ersten Blick das
obenstehende Programm „calliope-prog_01_02.hex“ anschaut, dann
bekommt man schon Respekt vor dem Programmieren, weil sich die Funktionsweise
des Programms eben nicht auf den ersten Blick erschließt. „Aber alles hat ein Ende, nur die Wurst hat
zwei!“ Zum Glück hat unser Programm aber nur ein Ende und auch nur einen
Anfang. Und der heißt „beim Start“. Wie wir ja bereits wissen, wird der Programmblock „beim Start“ gleich beim Starten
des Programms aufgerufen, gestartet und abgearbeitet:
(Zum Vergrößern bitte
auf das Bild klicken!) Das
obenstehende Programm begrüßt den Anwender mit „Blitz & Donner“, um uns
dann noch mitzuteilen, dass sich mit dem Programm
die drei Taster „A“, „B“ und „A&B“
bedienen lassen. Aber in Wirklichkeit gibt es auf dem „Calliope mini“ und auf dem „micro:bit“ nur die die beiden
Taster „A“ und „B“, sodass der dritte Taster „A&B“ nur virtuell existiert und sich
aus der Tastenfolge Taste „A“ drücken, festhalten und dann zusätzlich
noch den Taster „B“ drücken,
zusammensetzt! Macht zusammen Taster
„A&B“! Die umgekehrte
Reihenfolge geht dabei natürlich auch: zuerst Taste „B“ drücken, festhalten und dann
zusätzlich noch den Taster „A“ drücken, macht zusammen Taster „B&A“! Und damit
sind wir schon wieder bei der booleschen Algebra,
d.h. dem Rechnen mit wahren
und unwahren bzw. richtigen (= „true“) und falschen (=
„false“) Werten: „UND“- Gatter = „ Das Sybol „ (0 UND 0)10 = (0 (0 UND 1)10 = (0 (1 UND 0)10 = (1 (1 UND 1)10 = (1 „ODER“- Gatter = „ Das Sybol „ (0 ODER 0)10 = (0 (0 ODER 1)10 = (0 (1 ODER 0)10 = (1 (1 ODER 1)10 = (1
Während
sich also mit dem rechten Taster
„B“ die Sekundenzahl
der Variablen „time_sekunden“ von 4 Sekunden schrittweise
um +1 erhöhen lässt, lässt sich die die Sekundenzahl mit dem linken Taster „A“ von 4 Sekunden schrittweise um -1 herabsetzen!
Dabei kann
es natürlich vorkommen, dass die Sekundenzahl für die gestoppte
Zeitdauer zwischen Blitz und Donner kleinere Werte als Null annimmt, d.h. negativ wird: time_sekunden < 0. Wie aber bereits gesagt, kann die Zeit physikalisch niemals rückwärts laufen.
Demzufolge kann es zwischen Blitz und Donner auch keine
negative Entfernungsangabe darüber
geben, wie weit das Gewitter noch von unserem Standort aus entfernt ist! Wenn wir
also nicht wollen, dass der Anwender unser schönes Programm „Blitz & Donner“ als
dilettantisch (= unfachmännisch, stümperhaft) programmiert abtut, dann
sollten wir auf den Fall, dass die Sekunden und damit
natürlich auch die Entfernung des Gewitters gegenüber dem eigenen
Standort negativ werden, unbedingt reagieren und das Berechnen der
Entfernung mit negativen Werten ausschließen:
(Zum Vergrößern bitte auf das Bild klicken!) Wie man in
der obenstehenden „Wenn … dann …“-Bedingung sieht,
werden negative Sekundenwerte der Variablen „time_sekunden“ mit dem ·
Statement < wenn time_sekunden < 0 dann > abgefangen
und die weitere Berechnung mit dem ·
Statement < setze
rechne_boolean auf falsch > mittels
des Parameters „falsch“ verhindert. Wenn die
Abfrage der Variablen „time_sekunden“ einen Wert < 0 ergibt, dann wird als Erstes die Lichtfarbe der RGB-LED auf Rot gesetzt und damit zugleich eingeschaltet, sodass
diese hell leuchtet. Als Zweites wird der Bildschirminhalt gelöscht und die Laufschrift „Wert < 0 unzulässig!“ angezeigt. Nachdem die Laufschrift durchgelaufen ist, wird die RGB-LED wieder ausgeschaltet. Demzufolge leuchtet die RGB-LED nur so lange bis Laufschrift
durchgelaufen ist! Wie man im
Programmteil „dauerhaft“ (= Endlosschleife) sieht, wird dann als Nächstes die „Wenn … dann …“-Abfrage gestartet, ob der eingetastete Sekundenwert der Variablen „time_sekunden“ im Bereich [ 0, , 3 ]
liegt. Dies ist nämlich der Bereich im dem sich das Gewitter praktisch über dem Standort des Anwenders
befindet bzw. von diesem nur noch s = v * t = 343,2 m/s * 3 s = 1 029,6 m entfernt
ist! Je nachdem
wie schnell das Gewitter in Richtung des Standorts des Anwenders zieht, kann
es dann nämlich schnell gefährlich werden. Deshalb wird die Warnmeldung „Achtung! Gefahr! Das
Gewitter befindet sich direkt ueber dir! Sofort in Sicherheit begeben!“ als Laufschrift
angezeigt, währenddessen die RGB-LED rot leuchtet, um dem Anwender zu signalisieren, dass es
gefährlich wird:
(Zum
Vergrößern bitte auf das Bild klicken!) Damit der Anwender den Warnhinweis
besser einschätzen kann, geht es nach der Laufschrift direkt zur Entfernungsberechnung
(siehe roter Kasten):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_02.hex) Nach der Laufschriftanzeige über die
berechnete Entfernung, wie weit
das Gewitter noch vom Standort des Anwenders entfernt ist, wird die Endlosschleife im
Programmblock „dauerhaft“ verlassen und damit
es keine weiteren Entfernungsanzeigen mehr gibt bzw. geben kann,
wird die boolesche Variable „rechne_boolean“
auf den booleschen Wert = „falsch“ gesetzt (siehe grüner Kasten). Demzufolge muss die Entfernungsberechnung
nebst Laufschriftanzeige ab
sofort wieder mittels der Tastenfolge
Taste „A&B“ neu gestartet werden, wenn der Anwender neue Sekundenwerte
mittels ·
des linken Tasters „A“ (= Sekundenwert dekrementieren,
d.h. t = t - 1)
oder ·
des rechten Tasters „B“ (= Sekundenwert inkrementieren, d.h. t = t + 1) eintastet und sich das Berechnungsergebnis
anzeigen lassen will. - So, nun wird es langsam
Zeit, dass wir uns das „Block“-Programm
„calliope_prog_01_02.hex“ (siehe weiter oben)
auch mal in die professionelle „Python“-Programmiersprache
übersetzen lassen. Und das geht in der online Programmier-Weboberfläche des „Calliope mini“ oder des „micro:bit“ einfacher als
man denkt. Zu diesem Zweck muss man nämlich oben in der Bedien- und Menüleiste einfach nur auf die Schaltfläche <Python> klicken und schon bekommt man den
übersetzten „Python“-Sourcecode wie folgt angezeigt:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_02.py) Da es sich bei dem „Calliope mini“
und dem „micro:bit“ um Einplatinencomputer
mit nur einem Prozessor bzw. einem Prozessorkern
handelt, sind diese natürlich nicht so leistungsfähig wie z.B. Windows-PCs mit Windows
10 und Mehrkernprozessoren
von Intel oder AMD, kosten dafür aber nur
einen Bruchteil eines Windows-PC. Wegen des kleineren Arbeitsspeichers (RAM), der
geringeren Taktfrequenz
des Prozessors und damit der geringeren Leistungsfähigkeit arbeiten sowohl
der „Calliope
mini“ als auch der „micro:bit“ als Einplatinenrechner
nur mit einem abgespeckten Python,
dem sogenannten „MicroPython“, das
den analogen und digitalen Regel-
und Steuerungszwecken von Mikrocontrollern
angepasst wurde. Wie bereits gesagt wurde,
sind die beiden Einplatinencomputer „calliope mini“
und „micro:bit“
wegen des gleichen ARM Cortex M0 Prozessors zueinander kompatibel. Des
Weiteren verhält es sich so, dass beide Programmier-Entwicklungsumgebungen im Browser
vom Microsoft entwickelt wurden.
Und trotzdem sind die mit der „Block“-Programmierung
erstellen Programme vom Typ „hex“,
das ist der Dateierweiterungsname, nicht
zueinander kompatibel. Dazu muss man wissen, dass
es sich z.B. bei dem Programm „calliope_prog_01_02.hex“ um ein Quellkode-Programm wie
z.B. dem „Block“-Programm vom „Calliope mini“ oder dem „micro:bit“ handelt, das mittels eines speziellen Compilers (=
Übersetzungsprogramm in Maschinenkode)
in den Maschinen-/Prozessorkode kompiliert, d.h. „übersetzt“ wurde.
Demzufolge enthält die „hex“-Datei nur hexadezimalen Kode mit hexadezimalen Ziffern
von [ 0, , 9, …, A, B, C, D, E, F ]2
= [ 0, , 9, 10, 11, 12, 13, 14, 15 ]10
. Ferner verhält es sich so, dass das in Prozessorkode kompilierte Programm
nur hexadezimalen Kode
enthält, der nur von dem jeweiligen „Calliope mini“- oder „micro:bit“-Prozessor verstanden wird. Demzufolge
lassen sich in das „hex“-Format kompilierte Programme zwischen dem „Calliope mini“ und „micro:bit“ nicht tauschen. Aber trotzdem gibt es natürlich eine
Möglichkeit, den Sourcekode, der
auf einem „Calliope
mini“
erstellt wurde auf einen „micro:bit“ zu übertragen und
dort zu kompilieren! Dabei heißt das Zauberwort engl. „Copy & Paste“, d.h. „Kopieren und
Einfügen“:
(Zum Vergrößern bitte
auf das Bild klicken!) Bei dem Copy & Paste
von Sourcecode ist es natürlich
wichtig und unumgänglich, dass sich beide Editoren vom „Calliope mini“ und
„micro:bit“ im
selben Programmiermodus befinden, d.h. mit der gleichen Programmiersprache
wie z.B. Python arbeiten (siehe obenstehendes Bild)! Die in der Entwicklungsumgebung von „Calliope mini“ und
„micro:bit“
integrierten Editoren sind
natürlich nicht so leistungsfähig und komfortabel wie z.B. spezielle Editoren
für das Programmieren sogenannter
Hochsprachen wie z.B. Java, C/C++ oder Python. Ein beliebter und allseits
bekannter (Programmier-) Editor
(6,2 Mio. Downloads beim Computerportal www.chip.de)
ist der sogenannte „Notepad++“-Editor,
den man sich [ hier ] aus
dem Internet kostenlos herunterladen
kann:
(Zum
Vergrößern bitte auf das Bild klicken!) Wie man im obenstehenden
Bild sieht, lässt sich der Sourcecode
im „Notepad++“-Editor
ähnlich einem Gummiband auseinanderziehen
oder, wenn man auf das Quadrat mit dem „-“ klickt (siehe roter Kreis), zusammen
stauchen, sodass nur die für das Programmieren
relevanten Programmzeilen angezeigt werden, während die anderen ausgeblendet
werden. Selbstverständlich lässt
sich das „Copy & Paste“ auch in Verbindung mit dem
„Notepad++“-Editor
nutzen und der mit der Maus markierte Sourcecode von einem Editor in
den anderen übertragen und abspeichern:
(Zum
Vergrößern bitte auf das Bild klicken!) Weiter geht’s mit der „Block“-Programmierung.
Da die Einplatinenrechner „Calliope mini“ und „micro:bit“, aber auch der „Arduino UNO“ in
ihren Kommunikationsmöglichkeiten beschränkt sind, weil es bis jetzt kein
echtes LCD-Display
gibt, machen wir uns die serielle „RS-232“-Schnittstelle am seriellen Port „COM4“ (= Calliope mini) zu
nutze, die nach außen über den USB-Anschluss
mittels des ·
Statements
< seriell
Umleitung auf USB > zugänglich gemacht wird. Des Weiteren müssen wir die
seriellen Schnittstelle dahingehend konfigurieren, dass
wir die Übertragungsgeschwindigkeit
mit 9600 Baud (=
Zeichen, d.h. Ziffern, Symbole pro Sekunde) mittels des ·
Statements
< seriell
setze Baudrate auf 9600 >
festlegen. Bisher wurde das „Blitz & Donner“-Programm so
gut wie möglich kommunikativ, d.h. selbstredend programmiert, indem dieses
dem Anwender mitteilt, welche Bedientasten, nämlich die Taster „A“, „B“ und „A+B“ nebst entsprechenden Funktionen, zur Verfügung stehen. Da das auch weiterhin so
bleiben soll, müssen wir die selbstredenden Mitteilungen (= Laufschrift) auch
über die serielle Schnittstelle nach außen kommunizieren:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_03.hex) Die über die serielle
Schnittstelle
gesendeten Textstrings in Form von Textzeilen
kann man sich auf dem „PuTTY“-Programm wie
folgt anschauen:
(Zum
Vergrößern bitte auf das Bild klicken!) Selbstverständlich muss das „PuTTY“-Programm als Erstes gestartet und
ausgeführt werden, damit es später die seriell übertragenen Textstrings in der „PuTTY“-Konsole anzeigen kann! Werfen wir der
Vollständigkeit halber noch einen Blick auf die Konfiguration bzw. das Profil „Calliope mini“
des „PuTTY“-Programms,
das sich auch abspeichern lässt:
(Zum
Vergrößern bitte auf das Bild klicken!) Falls man nicht (mehr)
weiß, über welchen seriellen „COM“-Port der „Calliope mini“
seriell Daten überträgt, so kann man das im „Geräte-Manager“
von Windows nachschlagen:
(Zum
Vergrößern bitte auf das Bild klicken!) Bei Windows 7, 8
und 10
lässt sich der „Geräte-Manager“ mittels der Tastenfolgen/Mausklicks auf <Start>, <Windows System>, <Systemsteuerung>, <Hardware und Sound> und <Geräte-Manager> erreichen (siehe
obenstehendes Bild). Das Programm „calliope_prog_01_03.py“ im Webverzeichnis hat den Nachteil, dass
die anzuzeigenden Textstrings bzw. Textzeilen jeweils doppelt programmiert werden müssen. Und zwar
einmal für die Laufschrift auf dem „Calliope mini“ im 5x5 Matrix LED-Display und zweitens
für die serielle Ausgabe über den USB-Anschluss
auf z.B. die „PuTTY“-Konsole (siehe weiter oben). Ergonomischer wäre es
natürlich, wenn die anzuzeigenden Textstrings bzw. Textzeilen nicht jeweils doppelt programmiert werden müssten! Um das doppelte Programmieren der anzuzeigenden Textstrings bzw. Textzeilen zu vermeiden, muss man diese nur in eine Schublade werfen. Und zwar in eine Schublade mit insgesamt vier Schubfächern - ähnlich einem Besteckkasten in der Küchenschublade -
, da ja bis zu vier Textstrings systematisch geordnet
abgelegt werden müssen. Diesbezüglich handelt es sich bei dem Besteckkasten um einen besonderen, der über eine
waagrechte Besteckzeile mit vier senkrechten
Besteckspalten verfügt:
Wie man anhand der
obenstehenden (Besteckkasten-) Tabelle
sieht, werden die einzelnen Spalten-Elemente
von Null an gezählt und zwar im Spalten-Bereich
[ 0, …, 3 ]; das macht nach Adam
Riese vier Spalten-Elemente!
Das Durchnummerieren der Spaltenelemente
nennt man indexieren - nicht
indizieren - und die laufende Nummer
nennt man Index. Im Englischen nennt man
eine Zeilen und Spalten orientierte Tabelle gleich „Array“
(siehe auch Wikipedia).
Dabei lässt sich das Array mit einem Schachbrett
vergleichen. Auch beim Schachbrett
gibt es Zeilen (=
waagrecht) und Spalten (= senkrecht). Bei der sogenannten Tabellenkalkulation
, engl. „Spreadsheet“,
d.h. gespreiztes (Rechen-) Blatt,
werden auch Zeilen und Spalten verwendet! Merkregel: Erst die Zeilen,
dann die Spalten!
Siehe Matrizenrechnung
in der Höheren Mathematik)! Beim nachfolgenden „Block“-Programm „calliope_prog_01_04.hex“ wird das Array „text_array“ mit vier Textstrings
initialisiert, d.h. mit Werten versehen: ·
Statement
< setze text_array auf Array
von „Blitz
& Donner!“ … - + > Das Ab- und Aufrufen einzelner
Array-Elemente
geschieht dann durch Bennennung des Array-Namens, gefolgt
vom jeweiligen Index: ·
Statement
< zeige Text text_array rufe Wert ab bei 0 > Wie man im nachfolgenden
Bild sieht, bietet das Array „text_array“
den Vorteil, dass man die Textstrings jetzt nur noch ein einziges Mal
eintasten muss:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_04.hex) Wie man im obenstehenden
Screenshot sieht, werden die einzelnen Array-Elemente noch von Hand durchnummeriert bzw. indexiert. Wie man im nachfolgenden
Bild sieht, lässt sich der Index zum Array „text_array“
auch automatisch Schritt für Schritt durchführen. Dazu muss man
dann eine sogenannte „for … next“-Schleife
mit dem ·
Statement
< für Index von 0 bis 3 mache … >
programmieren. Wie man sieht, muss man
dazu Anfangswert 0
und den Endwert 3
für den Index als Schleifenzähler
setzen, damit dieser später den Bereich
[ 0, …, 3
] durchläuft:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_05.hex) Das Heraufsetzen des „Index“-Schleifenzählers am
Ende der „for … next“-Schleife
geschieht automatisch ohne weiteres Zutun. Demzufolge gibt es bei der „Block“-Programmierung
einer „for …
next“-Schleife keinen
expliziten „next“-Befehl
nebst Inkrementierung (
Index = Index + 1 oder Index += 1 ) des „Index“-Schleifenzählers wie bei anderen Programmiersprachen.
Oder vielleicht doch?! Höchste Zeit, dass wir uns
jetzt mal den „Python“-Sourcekode
anschauen, indem wir in der Entwicklungsumgebung
vom „Calliope
mini“ von „Blöcke“ auf „Python“ umschalten:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_05.py) Wie man im obenstehenden
Bild bei der „for … next“-Schleife
sieht, wird der Schleifenzähler „Index“
abgefragt, ob sich dieser im Bereich,
engl. „range“, von 0 bis 3 befindet: 0 <= Index < 4. Dabei wird der Schleifenzähler „Index“ = 4 zwar erreicht, die „for … next“-Schleife
aber vor dem Erreichen des Schleifenzählers
„Index“ = 4 bereits verlassen:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_06.py) Wenn man sich unsicher
fühlt und befürchtet, das mit der ·
Abfragebedingung
< in range = [ 0, …, 3 ] > bzw. < in range
>= 0 oder < 4 > doch noch nicht so richtig
verstanden zu haben, der kann sich den Wert
des Schleifenzählers „Index“ hilfsweise
wie folgt innerhalb und außerhalb der „for … next“-Schleife
anzeigen lassen (siehe oben):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_06.py) Interessant und
beachtenswert ist noch, dass der Schleifenzähler
„Index“
bei der „Block“-Programmierung nach
dem Abarbeiten der „for … next“-Schleife wieder
automatisch auf Index = 0 gesetzt wird:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_06.hex) Werfen wir zum besseren Verständnis
deshalb noch einen Blick auf die „Block“-Programmierung
des „Block“-Programms „calliope_prog_01_06.hex“:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_06.hex) Neben der „for … next“-Schleife
gibt es noch eine weitere Schleife, nämlich die „do … while“-Schleife, die sich beim „Block“-Programmieren
mit dem „Calliope mini“ auf Deutsch „während … mache …“
heißt. Grammatikalisch besser müsste
es heißen „tue, mache … solange …“ bis die ·
Bedingung Index <=
text_array_elemente erfüllt ist. Dabei handelt
es sich bei der Variablen „text_array_elemente“ um
eine Zählvariable, die die Anzahl der Array-Elemente
enthält. Demzufolge muss die „während … mache …“-Schleife so
oft durchlaufen werden, bis alle Elemente des Arrays „text_array“ abgearbeitet sind:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_07.hex) Wie man im obenstehenden
Bild anhand der grünen Kästen sieht, muss man sich bei
der „während …
mache …“-Schleife
selbst um das Initialisieren des Schleifenzählers „Index“ kümmern: ·
Statement
< setze
Index auf 0 > Das gilt auch für das Inkrementieren (=
Erhöhen um +1) des Schleifenzählers „Index“ am Ende der Schleife: ·
Statement
< ändere
Index um 1 > Wenn die Variable „text_array_elemente“,
die ja die Anzahl der Array-Elemente speichert,
im weiteren Verlauf der Programmierung nicht mehr benötigt wird, kann
man sie auch weglassen und den ·
Parameter < Array-Länge text_array > direkt in
die Abfragebedingung
der „während …
mache …“-Schleife
einsetzen (siehe grüner Kasten):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_08.hex) So, nun kennen wir die beiden
Schleifenarten der „for“- und der „while“-Schleife, sodass
sich die Frage aufdrängt, welche von den beiden die bessere ist bzw. sein
könnte. Wenn es schnell gehen und
unkompliziert sein soll, dann wäre der „for“-Schleife mit dem Parameter „in range“ (in Python) bzw.
der „für“-Schleife
mit dem Parameter „von … bis “
(in Blocks) der Vorzug zu geben. Wenn es darum geht, dass
man in das Schleifengeschehen eingreift, z.B. indem man
den Schleifenzähler
Sprünge machen lässt oder einzelne Schleifendurchläufe überspringt,
wiederholt oder den Schleifenzähler während des Betriebs
mittendrin auf einen höheren Zählwert setzt, diesen also
manipuliert, dann wird man der „while“-Schleife
(in Python) bzw. der „während … mache“-Schleife
(in Blocks) den Vorzug geben (siehe grüne Kästen):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_08.py) Wir vervollständigen das
obenstehende „Blitz & Donner“-Programm, indem wir die beiden rot markierten Programmblöcke aus dem „Python“-Programm „calliope_prog_01_02.py“ an
der mit rotem
Pfeil gekennzeichneten Stelle in das „Python“-Programm „calliope_prog_01_08py“
einfügen und das Ganze als neues „Python“-Programm „calliope_prog_01_09.py“ abspeichern:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_09.py) Wie man im nachfolgenden
Screenshot sieht, fügen wir im „Python“-Programm „calliope_prog_01_09.py“ ein weiteres Textarray „text_array_2“
für die Laufschriftanzeige bei den Funktionsaufrufen
wie folgt hinzu:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_09.py) Wie man im obenstehenden
Bild im grünen Kasten
sieht, wird im ·
Textarray-Element
„text_array_2[3]“
der Textstring „Das Gewitter = “
und im ·
Textarray-Element „text_array_2[4]“
der Textstring „m entfernt!“ gespeichert. Bei der späteren Entfernungsberechnung zwischen Blitz und Donner wird dann die Entfernung
zusammen mit den beiden Textarray-Elementen
[3]
und [4]
wie folgt angezeigt: ·
„Das Gewitter = 1372.8 m
entfernt!“ → als Laufschrift auf dem 5x5 Matrix LED-Display ·
„Das Gewitter = “ „1372.8“ „m
entfernt!“ → als Zeilendarstellung im
„PuTTY“-Konsolefenster
(Zum
Vergrößern bitte auf das Bild klicken!) Schuld an der Zeilendarstellung im
„PuTTY“-Konsolefenster (siehe
roter Kasten im obenstehenden Bild) ist
die Programmierung der zeilenweisen Textanzeige in der Endlosschleife „on_forever()“ (
siehe grüner Kasten):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_09.py) „Wenn man weiß, wie es
geht, wie die Dinge funktionieren, dann sind sie ganz einfach zu verstehen!“
könnte man meinen. Okay, ich gebe es zu,
bisher wussten wir noch nicht, dass sich auch in Python einzelne Zeichenketten,
engl. „strings“, miteinander verbinden und dann als Ganzes z.B.
in der Laufschrift im
5x5 Matrix LED-Display anzeigen
lassen. Dabei gilt es zu beachten,
dass numerische Variablen wie z.B. die Variable
„entfernung“ vor
dem Verbinden mit einer Zeichenkette mittels des Befehls „str(entfernung)“ in
einen String umgewandelt
werden müssen ( siehe grüner Kasten):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_10.py)
Hier ein kleines Beispiel
für eine einfache HTML-Webseite: <HTML> <TITLE>Meine
erste Webseite!</TITLE> <BODY> <H2><I>Meine
erste, einfache Webseite!</I></H2> <P>Hallo
und herzlich willkommen <P>auf
meiner <U>ersten</U> <B>Webseite</B>,
die ich einfach so erstellt habe! <BR> <BR>Das
was man hier im <B>Browser</B> sieht, ist der reine ASCII-Text. <P>Das
was man <u>nicht</u>
sieht, ist die <B>HTML-Kodierung</B>, <BR>weil
der <B>Browser</B>
diese <font
color=red><u>nicht</u></font>
anzeigt! </BODY> </HTML> Und so sieht die einfache Webseite im
Browser
aus:
(Auf
den Screenshot klicken, um die Webseite
anzuzeigen!) Das „Blitz & Donner“-Programm
ist für’s Erste ziemlich ausgereift, sodass es sich anbietet, das „Python“-Programmieren
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_10.py) mit dem „Block“-Programmieren
(Bild vergrößern: auf
Bild klicken! Webverzeichnis calliope_prog_01_10.hex) zu vergleichen. Wenn man früher oder später
als professioneller Programmierer arbeiten und damit seinen
Lebensunterhalt verdienen will, dann müsste man sich rechtzeitig vom „Block“-Programmieren
verabschieden, um den Aufstieg vom Hobby-Programmierer zum Profi-Programmierer zu
schaffen. Aber ob man das „Block“-Programmieren
dem „Python“-Programmieren
vorzieht oder umgekehrt, ist nicht nur eine Frage des Geschmacks, sondern
vielleicht auch eine Frage, welcher Lerntyp man selbst ist. So gibt es z.B. Lerntypen, die dann am besten lernen,
wenn sie die Dinge anfassen, in die Hand nehmen und im sprichtwörtlichen
Sinne „begreifen“ können. Andere wiederum lernen am besten in Bildern, in bunten
Bildern, die ihre Fantasie anregt
und sie besonders motiviert, während wiederum andere mehr das Abstrakte, das
Puristische mögen, nämlich den reinen, schnörkellosen Text bzw. den strukturierten
Quellkode als simplen Text. Ich persönlich mag das „Block“-Programmieren,
wenn es darum geht, sich komplett in eine neue Programmiersprache einzuarbeiten. Da man beim „Block“-Programmieren
links vom eigentlichen Programm
den kompletten Befehlsumfang schön bunt aufgelistet bekommt, lässt
es sich gut experimentieren, lassen sich neue Dinge gut ausprobieren. Was ich beim „Block“-Programmieren auf
Dauer nicht mag, ist, dass man Befehle, Parameter, Verbindungsglieder
usw. immer wieder mit der Maus hin-
und herschieben muss und dabei den Mauszeiger
nicht zu früh loslassen darf, damit z.B. der Parameter zur richtigen Zeit an der richtigen Stelle einrastet. Wenn darüber hinaus ein „Block“-Programm
sehr umfangreich wird, dann fühle ich mich von den vielen bunten Statements erschlagen, fängt es an
mich zu nerven, sehne ich mich nach herkömmlich, klar strukturierten „Python“-Programmkode. Wenn man hingegen neu in
das „Python“-Programmieren
einsteigt und anfangs nicht weiß, wo und wie man am besten anfängt, weil man
noch überhaupt keine Befehle kennt, dann braucht es schon viel Geduld und
Ergeiz, die neue Programmiersprache
Stück für Stück zu erforschen und auszuprobieren. Wenn man allerdings schon
mit anderen Programmiersprachen
gearbeitet hat, dann stellt man überraschend fest, dass es Parallelen gibt,
dass die verschiedenen Programmiersprachen voneinander gelernt und
abgekupfert haben, sodass einem vieles vertraut vorkommt. Demzufolge dürfte uns
nachfolgend das Übersetzen des
obenstehenden „Python“-Programms in
die „C++“-Programmierung
für den Arduino
UNO nicht so schwer fallen. Programmieren
mit dem „Arduino UNO“-Rechner Wir setzen die für den Arduino abgespeckte
„C++“-Programmierung namens
„Sketch“
im Kapitel „Blitz und Donner programmieren“
fort und zwar mit dem neuen „Arduino UNO“-Programm
„sketch_prog_01_08.ino“ (siehe
auch Webverzeichnis). Wie wir bereits wissen,
verfügen der „Calliope mini“ als auch der „micro:bit“
beide über zwei Taster „A“
und „B“,
die sich für Steuerungszwecke programmieren lassen. Der „Arduino UNO“
hingegen hat zwar von Haus aus keine Taster „A“ und „B“, was aber letztlich kein Problem darstellt, da sich
mittels der analogen und digitalen Ein- und Ausgänge zwei Eingänge so
programmieren lassen, dass sich mit diesen zwei Taster „A“ und „B“ abfragen lassen. Das wäre dann sozusagen die Lösung
mittels Hardware. Aber es gibt natürlich auch
eine Lösung mittels Software,
indem wir mittels eines „Sketch“-Programms (=
C++ für den Arduino UNO) die USB-Tastatur des Desktop-PCs abfragen, auswerten und auf einzelne Tastaturanschläge
reagieren. Das wiederum zu programmieren dürfte nicht so schwierig sein,
handelt es sich doch bei der USB-Tastatur um eine solche, die über die serielle „RS-232“-Schnittstelle
abgefragt wird. Da es bei unseren Tastaturanschlägen
darum geht, einzelne Tastendrücke wie z.B. von einzelnen Buchstaben
abzufragen, müssen wir uns seitens der „Sketch“-Programmierung zuerst mit dem Umgang einzelner
Zeichen (=
Ziffern, Buchstaben, Sonderzeichen) beschäftigen. Dabei gilt es zu beachten,
dass sich nur mit Zahlen rechnen lässt, aber eben nicht mit Ziffern! Demzufolge sieht man es
einer Ziffer
wie z.B. „1“, „2“, …, „9“, …, „A“, …, „F“ nicht an, ob diese später
als hexadezimale Zahl interpretiert werden soll, um mit dieser rechnen
zu können oder eben nicht. Demzufolge muss die Anzeige der aktuellen Uhrzeit
auf der Ziffernblattanzeige
einer Analoguhr
vom Anwender ebenfalls interpretiert werden. Und, da das Ziffernblatt
nur Ziffern
von 1 bis 12 bzw. zusätzlich eventuell auch noch von 13 bis 24 aufgedruckt
hat, muss der Anwender die Uhrzeitanzeige auch dahingehend interpretieren,
ob es sich bei dieser um engl. „a.m.“
(=„at morning”, morgens) oder „p.m.“ (=„past morning”, nachmittags) handelt. Im nachfolgenden „Arduino UNO“-Programm „sketch_prog_01_08.ino“
(siehe Webverzeichnis)
geht es also darum, dass wir uns mit dem Programmieren
von engl. „char“, d.h. einzelnen
Zeichen im
Sinne von Ziffern und Buchstaben befassen. Dabei lassen sich aber auch mehrere Buchstaben
und Ziffern zu einer Zeichenkette, engl.
„string“ zusammensetzen.
Und zwar auch dann, wenn wir dem String den Datentyp „char“
zuweisen! Beim ·
Statement
< char textString_0;
> handelt es sich um die Deklarierung
der Variablen „textString_0“,
d.h. der Zuordnung zum Datentyp „char“,
wobei der Variablen noch kein Inhalt in Form eines Textstrings
zugewiesen wird. Die Initialisierung
des Textstrings „Hallo Welt!“
erfolgt also erst später und zwar im ·
Statement
< textString_0 = “Hallo Welt!“; > Das Interessante dabei ist
nun, dass sich der zugewiesene Textstrings
„Hallo
Welt!“ wider Erwarten nicht in der Variablen „textString_0“ (ab-) speichern lässt, weil dieser
zwar der Datentyp „char“
zugewiesen wurde, aber kein Parameter über die Größe des Speicherplatzes
zum Abspeichern des Textstrings
(siehe im Konsolefenster „COM5“). Obwohl also die „char“-Variable „textString_0“
mangels Speicherplatz keine Information des Textstrings „Hallo Welt!“ enthält, muss genau die
Information, dass kein Speicherplatz zugewiesen wurde, gespeichert
werden! Deshalb liefert das ·
Statement < Serial.println(sizeof(textString_0)); > das Ergebnis „1” im Konsolefenster
„COM5“:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis sketch_prog_01_08.ino) Wenn man der Variablen „textString_1“
vom Typ „char“ Speicherplatz
zwecks späterer Aufnahme einzelner Zeichen zuordnen will, dann muss man
diesen in Form einer eckigen Klammer
[ ]
nebst Angabe einer Zahl für die Anzahl der zu speichernden Zeichen
wie folgt hinzufügen, d.h. deklarieren: ·
Statement
< char textString_1[5];
> Jetzt erst ist die Variable „textString_1[5]“ in der Lage bis zu fünf Zeichen
jedweder Art in Form von Buchstaben, Ziffern, Symbolen aufzunehmen und zu speichern.
Dabei hindert einen niemand
daran, der Variable „textString_1[5]“
auch einen längeren Textstring wie z.B. „Hallo Welt!“
zuzuweisen, ·
Statement < char textString_1[5] = “Hallo Welt!“;
> sodass aber entsprechend
dem zugewiesenen Speicherplatz nur fünf Zeichen abgespeichert
werden, der Rest also abgeschnitten wird!
Handwerklich und programmiertechnisch
interessant ist der nachfolgende Programmkode
im roten Kasten des nachfolgenden
Screenshots, wenn es darum geht, dass man die Anzahl der Zeichen des Textstrings
„Das Pferd
frisst keinen Gurkensalat!“, der in der Variablen „textString_1“
vom Typ „char“
gespeichert werden soll, wie folgt dynamisch programmiert. Zu diesem Zweck schafft man
die temporäre Hilfsvariable tempString[ ]
vom Typ „char“.
Da diese Hilfevariable einen
beliebig langen Textstring aufnehmen können soll, muss diese wie folgt initialisiert
werden: ·
Statement
< char tempString[ ] = "Das Pferd frisst
keinen Gurkensalat!";
> Anschließend ermittelt man
die Stringlänge „stringLaenge“
der Hilfsvariablen tempString“: ·
Statement < int stringLaenge = sizeof(tempString); > Die ermittelte
Stringlänge des Textstrings "Das Pferd frisst
keinen Gurkensalat!" beträgt 37 Zeichen
(siehe „COM5“-Konsole
der seriellen Schnittstelle), obwohl es eigentlich nur 36 Zeichen
sind! Der Grund dafür ist der, dass der Stringlänge
= 36
Zeichen noch eine „0“ als Abschlusszeichen der Zeichenkette hinzugefügt wird! Jetzt wo wir die Stringlänge des Textstrings in der Variablen „stringLaenge“
gespeichert haben, lässt sich diese wie folgt bei der Deklarierung der Variablen
„textString_1“
vom Typ „char“
nebst der Reservierung von Platzhalterstellen wie folgt vornehmen: ·
Statement
< char textString_1[stringLaenge]; > → stringLaenge
= 37
Zeichen Wenn es jetzt noch darum
geht, die Variablen „textString_1“
vom Typ „char“ mit
dem Textstring in einem Stück
zu initialisieren, dann müssen wir leider feststellen, dass das ·
Statement < char textString_1[stringLaenge] = tempString;
> zu der übersetzten Fehlermeldung „Das Array muss mit einem in Klammern
eingeschlossenen Initialisierer initialisiert werden”
führt. Was auch immer dies bedeuten mag. Was aber fehlerfrei
funktioniert, sind die beiden aufgeteilten Statements (siehe roten Kasten): ·
Statements <
char textString_1[stringLaenge]; > <
strcpy(textString_1, tempString); >
(Bild vergrößern: auf
Bild klicken! Webverzeichnis sketch_prog_01_09.ino) Beim Arbeiten mit Textstrings gibt
es zwei Befehle die von Bedeutung sind und die man früher später braucht: ·
Statement < int Textstring_laenge_1 = sizeof(textString_1); > Mit
dem Befehl „sizeof(textString_1)” lässt sich die Größe des reservierten Speicherplatzes der Variablen „textString_1“ ermitteln. Dabei gilt es zu beachten, dass sich die Größe von z.B. 37 Zeichen (siehe grüner Kasten) aus 36 + 1 Zeichen für das Ende
des Speicherplatzes zusammen setzt! ·
Statement < int Textstring_laenge_2 = strlen(textString_1); > Mit
dem Befehl „strlen(textString_1)” lässt sich die definitive
Länge
des Textstrings,
der der Variablen „textString_1“
zugeordnet ist, ermitteln. Interessant ist auch noch,
dass sich ein längerer Textstring
der Variablen „textString_2“
auf bzw. über einen kürzeren Textstring
der Variablen „textString_1“
kopieren lässt! Dazu muss man wissen, dass
der ursprünglich reservierte Speicherplatz der Variablen „textString_1“ automatisch
auf den reservierten Speicherplatz der Variablen „textString_2“ angepasst wird, sodass beim längeren
Textstring nichts
abgeschnitten wird (siehe blauer Kasten im
obenstehenden Bild)! Demzufolge wird der kürzere Textstring „Das Pferd frisst keinen Gurkensalat!“
durch den längeren Textstring „Das Pferd frisst keine Tomaten
und auch keinen Gurkensalat!“ ausnahmslos ersetzt!
- Beim „Blitz & Donner“-Programm
(siehe Programm „calliope_prog_01_10.py“)
geht es hauptsächlich darum, mittels der Schallgeschwindigkeit die Entfernung
zwischen Blitz und Donner zu berechnen, wozu man die zwischen Blitz und
Donner verstrichene Laufzeit des Schalls in Sekunden zählen und diesen Wert
zwecks weiterer Berechnung eintasten muss. Da aber weder der „Calliope mini“,
der „micro:bit“
noch der „Arduino UNO“ über eine Tastatur verfügen, muss man sich zwecks der Dateneingabe etwas anderes einfallen lassen. Wenn man wie im
vorliegenden Fall davon ausgeht, dass sich das Gewitter in unmittelbarer
Nachbarschaft befindet, weil man den Donner nicht von beliebig weit her hören
kann, dann muss man den Defaultwert
(= voreingestellter, vorgegebener Wert) von tSchall = 4 s nur um einige +/- Sekunden nach oben oder
unten verändern können. Beim „Calliope mini“
und „micro:bit“ lassen
sich zu diesem Zweck die beiden Taster
„A“
und „B“
entsprechend nutzen. Und zwar Taster „A“
zum Herunterzählen und Taster „B“
zum Heraufzählen. Mit der Tastenkombination
„A&B“
lässt sich jederzeit die Berechnung
starten, wobei der jeweils zuletzt eingetastete Wert berücksichtigt wird. Damit aber der Anwender des
„Blitz &
Donner“-Programms
weiß, dass es die Taster „A“
und „B“
nebst der Tastenkombination „A&B“
gibt, muss das Programm diesen
darüber informieren:
(Zum
Vergrößern bitte auf das Bild klicken!) Wie man anhand des
obenstehenden Screenshots in der „Arduino UNO“-Konsole
sieht, werden die vier anzuzeigenden Textstrings mit dem laufenden Index [ 0, …, 3] in der Array-Variablen „text_array“ abgespeichert,
wobei das Array über eine Datenzeile mit je vier Datenspalten
verfügt. Bezüglich der Anzeige in
der Konsole darf man vermuten, dass diese über eine endliche Schleife
erfolgt, wobei diese von null an bis zu viermal durchlaufen wird:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_10.ino) Dass in der „Arduino UNO“-Konsole
auf Veranlassung des Programms insgesamt vier Textstrings unterschiedlicher
Zeichenlänge
von zusammen 15 + 25 + 25 + 32 = 97 Zeichen angezeigt in der (Array-) Variablen „text_arry“ gespeichert und untereinander
dargestellt werden sollen, geht auf das Programm und dessen Programmierung
zurück (siehe blauer Kasten im
obenstehenden Screenshot). Wie aber lässt sich aus Stringlänge = 97 Zeichen
herausrechnen, dass sich diese auf 4 Spalten aufteilen? Wenn jede der 4 Spalten über
eine max. Stringlänge von 24 Zeichen verfügt, dann macht das zusammen 24
Zeichen/Spalte * 4 Spalten = 96 Zeichen: Spalte
1: 24 Zeichen – 15 Zeichen = +9 restliche Zeichen Spalte
2: 24 Zeichen – 25 Zeichen = -1 restliches Zeichen Spalte
3: 24 Zeichen – 25 Zeichen = -1
restliches Zeichen Spalte
4: 24 Zeichen – 32 Zeichen = -8
restliche Zeichen = 15/24 + 25/24 + 25/24 + 32/24 = 97/24 ≈ 4 Spalten!
(siehe roter Kasten oben)! Umgekehrt folgt: 97 Zeichen / 4 Spalten ≈
24
Zeichen/Spalte! Im obenstehenden Screenshot
gibt es noch die Berechnungsformel zwecks Berechnung der Spaltenzahl ·
sizeof(text_array) /
sizeof(String), die übrigens identisch ist mit ·
sizeof(text_array) /
sizeof(text_array[0]) Setzt man die im Konsolefenster angezeigten Werte ein,
so folgt rechnerisch: sizeof(text_array) /
sizeof(text_array[0]) =
24 / 6 = 4 Spalten bezogen auf insgesamt ≈ 96 Zeichen! Wenn das Programm zur Initialisierung
der Variablen „text_array“
gelangt, dann weiß es, dass das Array insgesamt 97 Zeichen lang ist und aus 4 Spalten besteht. Demzufolge
hat jedes der 4 Arrayelemente bzw. der 4 Felder insgesamt = 97 Zeichen /
4 Spalten ≈ 24 Zeichen/Spalte (siehe oben). Erweitert
man den Quotienten 24 Zeichen/Spalte
mit 4,
so folgt: = 24 Zeichen * 4 / (1 Spalte * 4) =
96 Zeichen / 4 Spalten þ = 24 Zeichen / 1 Spalte. þ Jetzt wo wir wissen, wie
sich die Anzahl aller Spalten aus der gesamten Zeichenzahl (≈ 96
Zeichen) aller Arrayelemente (= 4 Spaltenfelder) berechnet können wir diese der
Variablen „i_max“
wie folgt zuordnen: ·
Statement < int i_max = sizeof(text_array) /
sizeof(text_array[0]); >, sodass sich der Schleifzähler i
den Bereich [ 0, …, i_max ]
durchläuft und dabei die einzelnen Array-Elemente in
Form der Textstrings in der Konsole angezeigt werden:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_11.ino) Wie bereits an anderer
Stelle erläutert wurde, gibt es neben der „while”-Schleife (siehe oben im grünen Kasten) auch noch die „for … next“-Schleife (siehe unten im roten Kasten):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_12.ino) Wie man im obenstehenden
Screenshot bei der „for … next“-Schleife
sieht, gibt es im Schleifenkopf insgesamt drei Parameter, die sich alle auf den Schleifenzähler i
beziehen bzw. mit diesem zu tun haben (siehe oben im roten Kasten): ·
der Parameter i = 0 legt
fest, ab welchem Anfangswert der Schleifenzähler i zu zählen anfangen soll, ·
der
Parameter i < i_max legt
fest, bis zu welchem Schleifenzählerwert
i < 4
und wie oft die Schleife durchlaufen werden soll, ·
der
Parameter i++ legt
fest, dass der Schleifenzähler i nach
jedem Schleifendurchlauf, d.h. am Ende der Schleife um
den Wert = +1
erhöht (= inkrementiert) werden soll: i = i + 1 oder kurz i++ . Wir wenden das gelernte
Wissen über das Erzeugen und Anlegen von Textarrays des Typs „String“ nebst Konsoleanzeige derselben mittels einer „for … next“-Schleife
auf das „Donner
& Blitz“-Programm
an. Und zwar in Anlehnung an
das zuletzt programmierte „Python“-Programm
„calliope_prog_01_10.py“,
das sich auch als „Block“-Programm
mit dem „Calliope
mini“ oder dem „micro:bit“ (ohne RGB-LED) nutzen lässt:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | calliope_prog_01_10.py) Wie man im Vergleich des
obenstehenden „Python“-Programms
des „Calliope
mini“ mit dem „Sketch“-Programm
des „Arduino
UNO“ sieht, ähneln sich die Programmiersprachen, gibt es
praktisch in jeder Programmiersprache die Möglichkeit, Arrays
anzulegen oder mit „while“-
oder „for“-Schleifen zu
arbeiten:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_13.ino) Im Unterschied zum „Python“-Programm
des „Calliope
mini“ gibt es beim „Arduino UNO“ von Haus aus kein einfaches 5x5
Matrix LED-Display, sondern nur die Möglichkeit, die Textstrings
der beiden Arrays „text_array“
und „text_array_2“ im
Konsolefenster der „Arduino“-Entwickleroberfläche
anzeigen zu lassen:
(Zum
Vergrößern bitte auf das Bild klicken!) Nachdem wir in den
obenstehenden Screenshots die beiden Textarrays für die Kommunikation des Programms mit dem Anwender programmiert haben und die Displayanzeigen in
der Arduino-Konsole
bisher nur unidirektional, d.h. einseitig in Richtung des Anwenders arbeiten,
geht es nachfolgend darum, auch den Anwender
mittels Tastatureingaben
mit dem Programm kommunizieren zu
lassen. Da der „Arduino UNO“
weder über ein 5x5 Matrix LED-Display noch über zwei integrierte Taster „A“
und „B“ verfügt, behelfen wir uns dahingehend, dass wir anstelle der Taster
die PC-Tastatur einsetzen, um Tastatureingaben
durch den Anwender vornehmen zu
lassen. Da der Anwender unabhängig von der jeweiligen Tageszeit einfach jederzeit
Tastatureingaben
tätigen können soll, müssen wir das Tastatur-Abfrageprogramm wie folgt in die Endlosschleife „void loop()“
packen:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_14.ino) Wir probieren das Programm „sketch_prog_01_14.ino“
aus, indem wir es starten, das Arduino-Konsolefenster
aufrufen, in der Eingabezeile der
Reihe nach die Tastatureingaben „b“, „a“ und „r“ eintasten und diese jeweils einzeln durch Mausklick auf die Schaltfläche <Senden>
bestätigen:
(Zum
Vergrößern bitte auf das Bild klicken!) Weiter geht’s mit der Programmierung
der Funktionen „on_button_pressed_b()“, „on_button_pressed_a()“
und „on_button_pressed_r()“. Dabei müsste die Funktion „on_button_pressed_r()“ in
Anlehnung an das „Python“-Programm
„calliope_prog_01_10.py“ eigentlich „on_button_pressed_ab()“ heißen,
aber die Programmierung der Abfrage Taster
„A“
und „B“
direkt nacheinander und unter Einhaltung der Reihenfolge ist nicht so
einfach, wie es zunächst den Anschein hat. Deshalb wird zunächst nicht die Tastenkombination „A&B“ abgefragt,
sondern einfach nur die Tastaturabfrage nach dem Buchstaben „r“, d.h. „r“ wie rechnen, da ja die Entfernung des Gewitters zum
Standort des Anwenders berechnet werden soll (siehe die beiden Screenshots
weiter oben):
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_15.ino) Wie man im obenstehenden
Screenshot sieht, müssen die Funktionen
„on_button_pressed_b()“, „on_button_pressed_a()“
und „on_button_pressed_r()“ außerhalb
der Funktionen „void setup()“
und „void loop()“ programmiert
werden, damit sie global über alle Funktionen hinweg nutzbar sind!
Wenn man sich den Quellkode
vom Programm „sketch_prog_01_15.ino“ anschaut (bitte auf den blauen
Link ï klicken!),
dann stellt man unschwer fest, dass es sich bei der Array-Variablen „text_array[ ]“ in
der Funktion „void setup()“ um
eine lokale Variable vom Typ „String“ handelt, da sich diese in
der Funktion selbst befindet. Demzufolge lässt sich die lokale Array-Variablen „text_array[ ]“ nur
innerhalb der Funktion „void setup()“ nutzen!
Bei der Array-Variablen „text_array_2[ ]“ ganz
zu Beginn des Hauptprogramms handelt es sich hingegen um eine globale
Variable vom Typ „String“, da sich diese in keiner lokalen Funktion befindet,
sondern vielmehr innerhalb des Hauptprogramms. Demzufolge
lässt sich die globlae Array-Variable
„text_array_2[
]“ über das gesamte Programm hinweg - auch innerhalb von lokalen Funktionen(!) - nutzen! - Schauen wir uns als
Nächstes noch die Tastaturabfragen „b“, „a“
und „r“ und
die zugehörigen Funktionsaufrufe an. Dabei gilt es zu beachten,
dass die Tastaturabfragen permanent, d.h. fortwährend, ununterbrochen
erfolgen, sodass diese innerhalb der Funktion „void loop()“ programmiert werden müssen:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_15.ino) Während also die Taster „A“ und „B“ beim
„Calliope mini“
und „micro:bit“ bzw.
deren äquivalenten Tastatureingaben „a“
und „b“ ausschließlich
dazu dienen, den voreingestellten Zeitwert
der Variablen „time_sekunden“ = 4 (Sekunden) zu erhöhen
(= Taster „b“) oder
zu verringern (= Taster „a“), dient die Tastatureingabe
„r“ (=
[be-] rechne die Gewitter-Entfernung) dazu, auf die Tastatureingaben zu
reagieren, diese auszuwerten und entsprechende Warnhinweise (siehe
Variable „text_array_2[ ]“) im
Konsolefenster anzuzeigen:
(Bild vergrößern: auf
Bild klicken! Webverzeichnis | sketch_prog_01_16.ino) So, nun sind wir mit dem „Sketch“-Programm „sketch_prog_01_16.ino“ für den „Arduino UNO“ an
einem Punkt angelangt, wo wir für den Anfang schon recht gut programmieren und
darauf stolz sein können. Weiter geht es nun endlich
zum Versuch 1 „Spannung, Strom und
Widerstand“ des KOSMOS Experimentierkasten
„Easy
Elektronik Start“ [ weiterlesen ] |
|
||||||||||||||||||||||||
|
|
[ Easy Elektro Start ] [ Seitenanfang ] [zurück ] |
|
||||||||||||||||||||||||
“
“ 
