|
|
[ Home ] [ zurück ] [ Seitenende ] [ Teil 2 ] |
|
|||
|
|
micro:bit-Programmieren, Teil 1 1. Einleitung
Aufmerksam wurde ich auf den kleinen „micro:bit“-Rechner
des britischen Radio- und Fernsehsenders „British
Broadcasting Corporation“, kurz „BBC“, durch das deutsche Pendant namens
„Calliope mini“, über den in der „Zeit
Online“ unter dem Titel „Dieser Computer kann unser Schulsystem
revolutionieren“ berichtet wurde. >> Noller und Loick zählen
sich zur sogenannten Maker-Bewegung. Maker, das sind in der digitalen Welt
jene, die sich nicht mit den Geräten und Programmen zufriedengeben, die die
Computer-Industrie ihnen vorsetzt. Sie basteln lieber selber. Die beiden
Ur-Projekte dieser IT-Subkultur sind Arduino, ein nur handgroßer
Mikrocontroller, der 2005 in Italien für den Unterricht von Designstudenten
entwickelt wurde, und der Raspberry, ein Einplatinencomputer, mit dem
Forscher der Universität Cambridge das Interesse von Jugendlichen am Programmieren
ankurbeln wollten. Denn die handelsüblichen Geräte sind ja mittlerweile so
komplex, dass sich kaum noch einer traut, damit zu experimentieren. <<
(Quelle: Welt
Online) Wichtig dabei ist, dass es sich bei beiden
Systemen, d.h. beim „micro:bit“- und „Calliope mini“-Rechner nicht um
einen Mikrocontroller,
sondern tatsächlich um ein „embedded“
Computersystem mit einem 32-Bit ARM-Prozessor vom
Typ Cortex M0
mit integriertem Bluetooth
4 LE (= Low Energy) handelt. Da der „Calliope mini“ frühestens im ersten,
eher jedoch erst im zweiten Quartal 2017 im einschlägigen Elektronikhandel
verfügbar sein dürfte, gilt es, die Zeit bis dahin zu nutzen und sich mit dem
nahezu baugleichen „micro:bit“-Rechner und dessen Programmierung zu befassen.
Der „micro:bit“-Rechner lässt sich nämlich auch ohne Hardware
programmieren, da es zu diesem auf der Homepage
nicht nur diverse Programmiersprachen gibt, sondern auch die entsprechende
Simulation dazu. >> Da das wichtigste Ziel der BBC war,
Kinder zur Programmierung von Software zu motivieren, wird micro:bit von
Online-Programmier-Tools unterstützt, die sich an Anfänger richten. Momentan
werden vier unterschiedliche Programmiersprachen unterstützt: von Block
Editor sowie TouchDevelop von Microsoft, von einem visuellen
JavaScript-Editor von Code Kingdom und von MicroPython. Fortgeschrittene User
können das Board auch direkt in C/C++ der ARM-mbed-Entwicklungsumgebung
programmieren. (…) micro:bit-Programmierung Will man loslegen, geht man einfach zu dieser Website
und klickt auf „Create Code“ oder – wenn man schon einige Scripts erstellt
hat – klickt auf den Link „My scripts“ oben auf dieser Seite. Zuvor muss man
sich nicht einmal registrieren oder einen Account erstellen, sondern man kann
gleich mit der Programmierung anfangen. Die eigenen Scripts, wie sich die
Programme hier nennen, werden direkt in der Cloud gespeichert. Solange man
die Cookies im Browser nicht löscht, hat man auch später noch Zugriff darauf.
Man kann die Scripts natürlich auch auf dem eigenen Computer sichern oder
auch einem anderen Computer importieren. Und wenn man etwas kreiert hat, das
man glaubt vorzeigen zu können, kann man dieses Script recht einfach sharen
und veröffentlichen. Wie schon erwähnt, gibt es mehr als ein
Programmierwerkzeug. Alle sind sie „online“: Block Editor, TouchDevelop,
JavaScript, MicroPython und mbed. In der Theorie kann man mit allen die
gleichen Aufgaben erledigen, aber die Praxis schränkt das dann doch ein.
Dennoch arbeiten alle Tools ähnlich: man erstellt ein Script oder Programm,
klickt auf „Compile“ und erstellt so eine HEX-Datei, die man dann per
drag&drop auf dem Massenspeicher von micro:bit ablegt (wenn das Board an
einen PC angeschlossen ist, versteht sich). Das Board bootet anschließend neu
und führt das neue Script aus. Block
Editor Der Block Editor von Microsoft ist ein
grafisches Programmier-Tool mit Ähnlichkeiten zu Scratch, bei dem man per drag&drop
Programm-Konstrukt auf eine Arbeitsfläche schiebt und dann die Details wie
variable Namen und Werte von Konstanten einträgt. Man kann die Konstrukte
nicht nach Gutdünken verwenden, was syntaktisch korrekte Programme erzwingt.
Dieser Starrheit ist durchaus hilfreich, denn Programmierer können
bekanntlich ein Chaos mit den Algorithmen anrichten, die sie implementieren
wollen. Block Editor ist aber kein wirkliches Lern-Tool, sondern verhindert
lediglich Syntaxfehler. Mit diesem Tool ist wirklich schnelle
Programmierung möglich, was wohl an der Drag&drop-Technik liegt. Das
fertige Programm kann dann schnell auf einem virtuellen micro:bit getestet
werden. Richtige Debugging-Unterstützung fehlt allerdings. TouchDevelop Auch dieses Tool ist von Microsoft.
TouchDevelop ähnelt Block Editor darin, dass auch hier Syntaxfehler vermieden
werden, indem vorgefertigte Konstrukte angeboten werden. Der Unterschied
liegt darin, dass hier der Programmcode als Test vorliegt. Es handelt sich
also eher um ein textbasiertes Tool – in meinen Augen aber um ein
frustierendes Werkzeug, da es so tut, als hätte man die volle Kontrolle,
obwohl man dauernd auf das Drag&drop-Menü angewiesen ist. Wie bei Block
Editor auch kann der Code sehr schnell auf einem virtuellen micro:bit
ausprobiert werden und beim Thema Debugging gibt es ebenfalls Fehlanzeige. Für mich war TouchDevelop mühsam und es
bremste mich aus. JavaScript Der JavaScript-Editor stammt von Code Kingdom.
Dieser Editor verfügt über eine interessante Funktion zur Code-Abstraktion.
Mit einem Slider unten kann man einstellen, wieviele Code-Details angezeigt
werden. In der höchsten Abstraktionsstufe (Slider ganz links) arbeitet die
Sache ähnlich wie Block Editor voll grafisch, doch wenn man den Slider nach
rechts verschiebt, kann man richtige Java-Instruktionen eintippen. Wenn man
schon über Programmiererfahrung verfügt, wird man Letzteres bevorzugen, da
zusätzlich auch copy&paste unterstützt wird, was die Sache sehr
beschleunigt. Auch hier gibt es wieder einen Simulator zum Test des
erstellten Codes. Zunächst hatte ich Compiler-Probleme und das
erstellte Programm ließ sich nicht herunterladen. Nach einem Neustart des
Browsers klappte es dann. MicroPython Im Prinzip ist die Möglichkeit der
Programmierung des micro:bit in MicroPython eine tolle Sache, doch leider ist
diese Implementierung eher enttäuschend. Der Grund hierfür liegt am Editor
und der Notwendigkeit von Python bez. Einrückungen (was ich nicht leiden
kann). Ich fand es schwierig, ein Python-Script zum Funktionieren zu bringen,
da der Editor irgendwie mit Tabs und „end-of-line“-Zeichen oder sonst
irgendwo seine Probleme hat. Erst wenn man das Programm auf dem Board
ausführt, sieht man z. B. eine Fehlermeldung langsam über den Bildschirm
scrollen wie etwa 'line 11: indentation error blah, blah, blah'. Aber die
Tabs waren wirklich da, verdammt! Bei mir war es nötig, alle Tabs in jeder
Zeile jedes Mal neu einzugeben, um eine funktionierende HE-Datei zu erhalten.
Copy&paste klappt zwar, sorgt aber auch oft für Chaos. Richtig
frustrierend das! Bei MicroPython gibt es keinen Simulator. Für mich besteht der einzig positive Aspekt
darin, dass die Compilation und der Download sehr viel schneller als bei
anderen Tools funktionieren. Und wenn man sich durch die detaillierte
Help-Dokumentation arbeitet, kann man gut lernen, wie man mit MicroPython
programmiert. Laut Doku gibt es viele verfügbare Module, mit denen alle
Funktionen des Boards genutzt werden. Es wird sogar auf einen
Offline-Programmer für micro:bit mit der Bezeichnung uFlash (micro-flash) verlinkt,
dank dem man Projekte in MicroPython mit einem Editor der eigenen Wahl
realisieren kann. Letzteres macht MicroPython dann doch zu einer Option, die
man berücksichtigen sollte. mbed Zum Schluss noch das gute, alte mbed for micro:bit
direkt von ARM. Dieses Online Programmier-Tool setzt Programmiererfahrung
voraus und erlaubt die Programmierung in C/C++. Aber auch hier gilt: Kein
Simulator und auch kein Debugger. Aber immerhin eine ordentliche
Programmierumgebung mit richtigem Editor. Kein Spielzeug also. Damit kann man
also „richtige Applikationen“ halbwegs professionell entwickeln. Hinzu kommt
eine umfangreiche und gut dokumentierte Library von der Lancaster
University, die Zugriff auf alle Features von micro:bit gestattet.
Insgesamt also ein wirklich überzeugendes Stück Software. Es können auch
mbed-Libraries anderer Leute hinzugefügt werden, um neue Funktionen in
eigenen Projekten zu verwenden. Noch besser: Mit mbed kann man auch offline
arbeiten und damit auch einen richtigen Debugger einsetzen. Segger, der Hersteller
der J-Link-Pods, stellt eine spezielle
Firmware für micro:bit zur Verfügung, die dann auch Breakpoints und einen
Einzelschrittmodus erlaubt. Die mbed-Website ist sowieso der Ort für
Firmware-Updates (bislang wurden aber noch keine neuen Versionen
veröffentlicht) und für detaillierte technische Informationen zum Board. Um mit mbed für micro:bit loszulegen, muss man
lediglich die HTML-Datei auf seinem Massenspeicher doppelklicken. Dies führt
zur mbed-Website, wo man sich einloggen oder einen Account anlegen kann,
falls man noch keinen hat. Anschließend ist micro:bit als eine der eigenen
Plattformen verfügbar (als Neuling die einzige) und man kann sofort damit
arbeiten. Bluetooth
& OTA Die Online-Programmier-Tools für micro:bit
können auch auf Mobilgeräten genutzt werden, was wohl besonders für die ganz
junge Generation attraktiv ist, die ohne Smartphone fast nicht mehr atmen
kann. micro:bit ist ja mit BLE ausgestattet und es gibt eine App von Samsung für das Laden
eines Programms auf das Board per Funk bzw. OTA. Hierzu muss man natürlich
zuvor das Board mit dem Mobilgerät „pairen“. Diese Prozedur benötigt mehrere
Schritte und ist für den, der so etwas vielleicht noch nie gemacht hat, nicht
ganz trivial. (…) << (Quelle: Elektor-Verlag) Fazit >> Die beim Micro Bit zur Wahl stehenden
fünf Programmierumgebungen holen zudem jeden Anwender bei einem passenden
Einstiegspunkt ab – sei es kompletter Anfänger oder Fortgeschrittener. Und
sie bieten manche praktische Funktion, die man bei anderen Plattformen
vermisst, etwa fertige Code-Blöcke zur Kommunikation mit Smartphones.
Insofern scheint der BBC Micro Bit eine interessante Plattform auch für alle
jene zu sein, die häufiger mal eben schnell ein Konzept ausprobieren wollen.
<< (Quelle: Make) 2. Block-Programmieren und JavaScript
2.1 Von „Hello Word“ zur variablen Anzeige
Für den Programmier-Einsteiger als auch für
den fortgeschrittenen Programmier-Entwickler, der schon ein oder zwei
Programmiersprachen gelernt hat und beherrscht, ist es für den Einstieg in
eine neue Programmiersprache von Vorteil, wenn man sozusagen spielerisch,
d.h. auch nach der Methode „Versuch und Irrtum“ vorgehen kann. Das Problem
beim Erlernen einer neuen Programmiersprache ist dabei, dass man anfangs die
Befehle, d.h. Statements noch nicht kennt. Aber auch, wenn man den
Befehlsvorrat einer Programmiersprache kennt oder kennen würde, hilft einem
das nicht unbedingt weiter, da man mit den Befehlen noch nichts anfangen
kann, weil man nämlich noch nicht weiß, wozu der eine oder andere Befehl gut
ist. Man weiß zwar, was man sagen oder programmieren möchte, weiß aber eben
noch nicht, mit welchen Befehlen man das Gedachte umsetzen kann. Hilfreich wäre es hingegen, wenn man gesagt
bekommt, dass man sich bereits mit einer Hand voll Statements ganz gut
ausdrücken kann. Was man also bräuchte, wäre eine Kurzübersicht von
Statements, eine Einteilung der Befehle in bestimmte Kategorien, sodass man
sich schneller zurechtfindet:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man oben im Bild sieht, gibt es die Kurzübersicht, d.h. die Einteilung der
wichtigsten Befehle in bestimmte Kategorien
tatsächlich. Und zwar von Microsoft (MS), dem Entwickler
u.a. des „MS
Windows“-Betriebssystems, der Programmiersprachen „Visual BASIC“ oder „Visual C“, auch „C sharp“ („C#“) genannt, die
sich beide mit der Programmier-Oberfläche „MS Visual Studio .NET“
oder der kostenlosen Programmier-Umgebung „MS
Visual Studio Express“ (u.a. für Visual Basic, C++ und C# oder Java sharp
J#) für Schüler, Studenten oder semiprofessionelle Entwickler, auch „Coder“ bzw.
Softwareentwickler genannt, programmieren lassen. Für Webdesigner oder
Webdeveloper gibt es die ebenfalls kostenlose Entwicklungsumgebung „MS Visual Studio Code“. - Werfen wir also gleich einen Blick auf die Grundlagen der „micro:bit“-Programmierung im
Zusammenhang mit der visuellen
Programmierung in (Programm-) Blöcken:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man sieht, gestalten sich die Grundlagen der
„micro:bit“-Programmierung recht übersichtlich. Starten wir also mit der Anweisung „A – Zeige Zeichenfolge „Hello!“:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man im obenstehenden Screenshot sieht,
besteht unser erstes Programm aus nur zwei Programmzeilen, engl.
„statements“: ·
Bildschirminhalt löschen ·
Zeige Zeichenfolge „Hello!“ Der englischsprachige Ausdruck für Zeichenfolge lautet „string“ im Sinne einer Zeichenkette, d.h. das
Aneinanderreihen von Buchstaben und Ziffern nebst Anzeige auf dem Bildschirm.
Während sich Ziffern wie die Uhrzeit auf dem Ziffernblatt einer Uhr nur
anzeigen lassen, könnte man mit Zahlen
auch rechnen. Um das obenstehende Block-Programm auf die
Festplatte des heimischen PC herunterladen zu können, sollte man die
Ausführung des Programms zu nächst beenden. Klicken Sie zu diesem Zweck auf
die graue Schaltfläche „Quadrat“ rechts
neben der Schaltfläche „Herunterladen“. Klicken Sie dann auf die Schaltfläche „Herunterladen“, sodass sich das Fenster „Lade deinen Code herunter auf micro:bit …“ wie folgt öffnet:
(Zum Vergrößern bitte
auf das Bild klicken!) Klicken Sie im obenstehenden Fenster auf die Schaltfläche „Speichere die .hex-Datei auf deinen Computer.“ im rot umrandeten
Kasten, um das Programm auf die lokale Festplatte des heimischen PCs
herunterzuladen:
(Zum Vergrößern bitte
auf das Bild klicken!) Da wir dem Block-Programm noch keinen Programm- bzw. Dateinamen gegeben
haben, nennt sich dieses ganz einfach „microbit-Ohne-Titel.hex“ und befindet sich unter Windows 7 oder 10
standardmäßig im Dateiordner „Downloads“ (c:\Users\Benutzer\Downloads). Wechseln Sie jetzt in den Download-Ordner, und benennen Sie die
Datei in „microbit_teil_01_prog_01.hex“ um, damit sie sich
später von anderen Programmen unterscheiden lässt. Der Dateierweiterungsname
„hex“ besagt, dass es sich
um eine Datei handelt, die im hexadezimalen Format
abgespeichert wurde. [ Video 1 ] Beim hexadezimalen Zahlensystem gehen die
Zahlen einer Dekade von „0“ bis „9“ und dann weiter mit den Buchstaben „A“ …
„H“. Wenn Sie jemanden absolut nicht leiden können und diesen als Affen
titulieren, dann würden Sie sich wegen einer Beleidigung strafbar machen.
Aber man kann die Ziffernfolge „AFFE“ auch als eine hexadezimale Zahl „AFFE16“ zur Basis 16
(= hexadezimal) auffassen, die den dezimalen Wert „4505410“ zur Basis 10 hat. „Du blöder 45054!“ wäre dann keine Beleidigung
mehr, da es sich eben um eine dezimale Ziffernfolge handelt, die ins hexadezimale
Zahlensystem übersetzt „AFFE16“ bedeutet. Ein sogenannter „DAU“
würde sich also wegen seiner Unkenntnis über die Existenz anderer
Zahlensysteme nicht beleidigt fühlen J Übrigens: Der Windows-eigene Taschenrechner lässt
sich in den Modus für Programmierer umschalten, sodass sich mit diesem
problemlos hexadezimale Zahlen in dezimale umrechnen lassen:
(Zum Vergrößern bitte
auf das Bild klicken!) Die hexadezimal abgespeicherte Datei in „microbit_teil_01_prog_01.hex“ bedeutet also nichts anderes, als dass
diese aus vielen hexadezimalen Ziffernfolgen wie z.B. „00“, „09“,
„CD“, „F1“ usw. besteht, sodass sich die Datei
zwar im Browser
anzeigen, aber unter Windows nichts
damit anfangen lässt. Es sei denn, man lädt die hexadezimale Datei mittels des USB-Kabels in die Hardware des „micro:bit“-Rechners oder in dessen Emulation auf der
entsprechenden Webseite hoch!
Klicken Sie zu diesem Zweck im Browser-Fenster
auf die Schaltfläche „Projekte“, sodass sich das Fenster „Projekte“ wie folgt öffnet:
(Zum Vergrößern bitte
auf das Bild klicken!) Klicken Sie auf den rot umrandeten Kasten „Import from file …“, um die Datei
„microbit_teil_01_prog_01.hex“ auf der lokalen
Festplatte des heimischen PCs auszuwählen und in den „micro:bit“-Block-Emulator von Microsoft hochzuladen!
2.2 Wer die Wahl hat, hat die Qual (der Wahl)
Als nächstes werden wir international. Und zwar mit der englischsprachigen Anzeige des Textstrings „Hello World!“ und der deutschsprachigen „Hallo Welt!“. Und zwar auf Knopfdruck, wahlweise durch Drücken des Tasters „A“ oder „B“ (siehe links auf der „micro:bit“-Hardware):
(Zum Vergrößern bitte auf das
Bild klicken!) Wir
nennen das Block-Programm „microbit_teil_01_prog_02.hex“,
das Sie sich mittels der rechten Maustaste direkt vom Webserver in den „Download“-Ordner Ihres Windows-PCs
herunterladen können, um es anschließend sofort wieder in den „micro:bit“-Block-Emulator von Microsoft
hochzuladen! Bei
den beiden Abfragen „wenn Knopf A gedrückt“ oder „wenn Knopf B gedrückt“ wurde, wird der Anwender gefragt, ob er bereits einen
der beiden Taster A oder B gedrückt hat und falls ja, welchen! Streng
genommen handelt es sich dabei um eine sogenannte „wenn … dann“-Abfrage, englisch „if … then“-Abfrage. Ausführlicher müsste
es heißen „Wenn die Bedingung ‚Knopf A gedrückt’ erfüllt wurde, dann
wird diese oder jene Aktion
veranlasst.“ Deutlicher
wird das Ganze, wenn wir uns das Programm
„microbit_teil_01_prog_03.hex“
anschauen (siehe weiter unten). Das
grau unterlegte Statement „wenn …
dann“
leitet die bedingte Abfrage ein,
ob das violett unterlegte Statement „Button A
ist gedrückt“
erfüllt ist und, wenn ja, dass dann die blau unterlegte Konsequenz
„A – Zeige Zeichenfolge „Hello
World!“
umgesetzt wird. Diesbezüglich
gilt es zu beachten, dass sich der Taster, Knopf, Button A entweder kurz, länger oder auch dauerhaft
gedrückt halten lässt, sodass sich mit dem Button A auch eine Stoppuhr
programmieren ließe mit der sich die Zeitspanne
des Knopfdrückens erfassen ließe.
Dabei könnte man dann auch den Button A drücken, um die
Stoppuhr zu starten und durch Drücken des Button B wieder beenden. Funktionieren würde die Stoppuhr dabei aber nur, wenn der Status „gedrückt“ oder „nicht gedrückt“ der beiden Taster A und B fortwährend, d.h. in der Endlosschleife „dauerhaft“ abgefragt würde. In diesem Zusammenhang bleibt
also festzuhalten, dass es bezüglich der beiden Taster A und B zweierlei Betriebsmodi
gibt: a) das embedded
(Linux-) Betriebssystem des „micro:bit“-Rechners führt
permanent einen sogenannten Interrupt (=
Unterbrechung) aus bei dem es u.a. die beiden Taster A und B fortwährend abfragt,
ob diese evtl. zwischenzeitlich betätigt wurden. Dabei kommt es nur darauf
an, dass einer der beiden Knöpfe, engl. „button“, bedrückt wurde, wobei es
nicht darauf ankommt, ob und wie lange einer die beiden Taster A und B
gedrückt wurde (siehe Programm „microbit_teil_01_prog_02.hex“
weiter oben)! b) das embedded (Linux-)
Betriebssystem des „micro:bit“-Rechners führt nur dann einen fortwährenden Interrupt
aus, wenn dies vom Entwickler extra programmiert wurde! Dazu braucht es die
sogenannte Endlosschleife „dauerhaft“ nebst einer „wenn … dann“-Abfrage, ob der Taster A oder B
tatsächlich gedrückt wurde. Und falls ja, wie lange dieser gedrückt wurde (siehe
nachfolgendes Programm „microbit_teil_01_prog_03.hex“):
(Zum Vergrößern bitte
auf das Bild klicken!) [ Video ] 2.3 Der praktische Platzhalter mit dem man zählen kann
So, jetzt sind wir schon mittendrin, bringen
wir dem „micro:bit“-Rechner das Zählen
bei, um die Wirkungsweise der beiden Taster A und B noch besser zu
veranschaulichen. Da sich mit Ziffern nur die Uhrzeit anzeigen,
aber eben nicht rechnen lässt, brauchen wir als nächstes eine sogenannte „Variable“,
.d.h. einen Platzhalter mit dem man rechnen kann, d.h. eine numerische Variable vom Typ „integer“, d.h. ganzzahlig.
Schließlich rechnen wir im ganzzahligen Dezimalsystem von z.B. 0 bis 7 oder
noch höher. Dezimalzahlen wie z.B. 1,1, 3,4 oder 7,8 gibt es dabei also
nicht! Außerdem
halten wir fest, dass der Mikroprozessor eines
jeden Windows-, Linux- oder Android-Rechners (= Smartphone, Tablet-PC) nur zwei
Finger zum Zählen hat, sodass das Rechenwerk „ALU“
(= engl. „Arithmetic Logic Unit“) nur von null „0“ bis eins „1“, d.h. binär rechnen kann. Das
aber äußerst schnell und schneller als das menschliche Hirn es je können
wird! Da der ARM-Prozessor des „micro:bit“-Rechners über eine 32 Bit Architektur
verfügt, lassen sich mit diesem hexadezimale
Zahlen
bis c000003f16 = 12 * 167
+ 0 * 166 + 0 * 165 + 0 * 164 + 0 * 163
+ 0 * 162 + 3 * 161 + 15 * 160 = 3 221 225 535 ≈ 3,221 Milliarden rechnen. Dabei fällt
auf, dass die darstellbaren Zahlen nur die Wertigkeiten 160 bis 167
Bit umfassen, sodass sich mit 232 Bit nur theoretisch dezimale
Zahlen bis 4 294 967 295 = 4 Milliarden + 294 Millionen + 967 Tausend +
295 Werte berechnen lassen. Frage: Welcher
Zahlenbereich lässt sich mit dem ganzzahligen Typ „integer“ darstellen? Um die Frage
beantworten zu können, muss man wissen, dass sich der Typ „integer“
in der Regel auf ein binäres 8 Bit Muster bezieht mit 1111 11112 = FF16
= 15 * 161 + 15 * 160 = 240 + 15 = 25510, sodass sich damit
der Zahlenbereich von 0 … 254 darstellen lässt. Und
da sich mit dem binären 16 Bit Muster 1111 1111 1111 11112 = FFFF16
= F * 163 + F * 162 + F * 161 + F * 160
= 15 * 4 096 + 15 * 256 + 15 * 16 + 15 * 1 = 61 440+ 3 840 + 240 + 15 = 65 53510 schon der Zahlenbereich von 0 … 65534 darstellen lässt, dürfte dies für das
Programmieren von Schleifen nebst Schleifenzählern vollkommen
ausreichend sein. - Bei dem nachfolgenden Block-Programm „microbit_teil_01_prog_04.hex“
handelt es sich um einen Zähler,
der mit dem Wert n = 0 startet und diesen fortlaufend um den Wert +1
erhöht → n = n + 1 und zwar so oft, wie man den Taster A gedrückt hält. Lässt man den Taster A los, so hört der Zähler sofort mit dem
Zählen auf und zeigt den zuletzt berechneten Wert an. Dabei verwenden wir
erstmals eine sogenannte „Variable“,
.d.h. einen Platzhalter mit dem man rechnen kann. Doch bevor man die Variable benutzen kann,
muss man ihr einen Namen (hier der Buchstabe „n“ als Zählvariable) geben,
indem man sie im Programm deklariert,
d.h. einrichtet und dabei festlegt, ob es sich um eine Rechenvariable z.B. vom Typ „integer“ (= ganzzahlig), eine Textvariable z.B. vom Typ „string“ (= Zeichenkette) oder
ein einzelnes Zeichen bzw. einen Buchstaben vom Typ „char“, engl. „character“,
handelt. Wenn man dann später der Rechenvariable n noch einen Zahlenwert zuweist, so spricht man
vom Initialisieren einer Variablen. Bei unserem Block-Programm „microbit_teil_01_prog_04.hex“
erfolgt das Deklarieren und Initialisieren der Rechenvariablen n in einem Stück: var n = 0 und zwar mit dem Statement „ändere n auf 0“. [ Video ] Beim Drücken des Tasters A wird dann der aktuelle
Wert der Rechenvariablen n mit dem Statement „zeige
Nummer n“ auf der 5 x 5 LED-Matrix angezeigt und anschließend mit
dem Statement „ändere n auf n + 1“ um
den Wert +1 erhöht, sodass folgt: n = n + 1. Anstelle von n = n + 1 kann man auch verkürzt
schreiben n += 1 oder
einfach nur n++.
Dabei bedeutet letzteres, dass man von der Variablen n das Inkrement
bildet, indem man den aktuellen Wert um +1 erhöht. Umgekehrt kann man auch das Dekrement bilden, indem man den
aktuellen Wert um -1
erniedrigt: n--.
Anstelle von n = n - 1 kann
man auch verkürzt schreiben n -= 1. Die
unterschiedlichen Schreibweisen nennt man übrigens Syntax, d.h. den
programmiertechnischen „Satzbau“ bzw. Schreibweise. Beim Drücken des Tasters B wird unser Zähler quasi angehalten bzw. der
aktuelle Wert der Rechenvariablen n wieder auf null gesetzt: n = 0, sodass man mit dem Zählen
wieder von vorne anfangen kann. Dazu verwenden wir das Statement „ändere n
auf 0“. Damit der Anwender das auch mitbekommt, muss man noch das
Statement „zeige Nummer n“
programmieren:
(Zum Vergrößern bitte
auf das Bild klicken!) Dass man mit den beiden Tastern A und B
tatsächlich den „micro:bit“-Rechner steuern kann, ist recht interessant, da
dieser ja über keine alphanumerische Tastatur zwecks Dateneingabe
verfügt. Schließlich würde einem eine alphanumerische Tastatur auch nichts
nutzen, wenn man nicht sieht, was man gerade eingetastet hat! Wenn es aber weder eine alphanumerische
Tastatur noch ein grafikfähiges Display gibt, dann bleiben einem nur die drei
Taster A und B sowie A & B, wobei letzterer nur virtuell existiert, sodass man als
dritte Eingabemöglichkeit gleichzeitig die Taster A & B drücken muss. Die
beiden Taster A und B lassen sich aber elektrotechnisch nicht
wirklich gleichzeitig drücken lassen, sondern immer nur der Reihe
nach! Wenn auch so schnell, dass es der Anwender nicht merkt. Kennen Sie unter Windows den sogenannten „Affengriff“ mit der Tastenkombination
<Strg>, <Alt>,
<Entf>,
um den sogenannten Taskmanager zu starten, wenn gar
nichts mehr geht? Spätestens bei dieser Tastenkombination wird deutlich, dass
es praktisch unmöglich ist, alle drei Tasten gleichzeitig zu
drücken. Was also macht der Anwender? Wie hilft er sich? Ganz einfach, indem
er die Tasten der Reihe nach drückt und dabei erst die erste Taste <Strg> (= Steuerung) drückt und festhält, dann die zweite
Taste <Alt> (= alternativ, engl. „alternate“) drückt, ebenfalls gedrückt
hält und dann mit der rechten Hand kurz die dritte Taste <Entf> (= entfernen) drückt. Leider gibt es unter Windows 10 nicht mehr die Möglichkeit, den
Rechner mittels des Taskmanagers herunterzufahren. Wenn man also früher oder später einen
sogenannten Timer programmieren
möchte, der rückwärts zählt und einen daran erinnert, das sonntägliche
Frühstücksei nach spätestens sieben Minuten aus dem kochenden Wasser zu
nehmen, dann wird man mittels des Tasters A die Minuten, mit dem Tasters B die Sekunden einstellen und mit
der Tastenkombination A &
B den
Timer starten. Dabei müsste man die Taster A und B
auch noch so programmieren, dass sich die einzustellende Zeit möglichst
schnell durchblättern lässt, indem die Stunden oder Sekunden umso schneller
im Display, d.h. bei der 5 x 5 LED-Matrix, angezeigt werden, je
länger man einen der Taster A oder B gedrückt hält! Da wir aber die Anzeigegeschwindigkeit der Stunden oder
Sekunden bei der 5 x 5
LED-Matrix
nicht wirklich beschleunigen können, müssten wir uns in der Weise
behelfen, indem wir beim Durchlaufen der Stunden oder Sekunden, jeden zweiten,
geraden oder ungeraden Wert einfach überspringen! Beim nächsten Programm „microbit_teil_01_prog_05.hex“
wird es aber noch nicht so kompliziert, geht es einfach nur darum, ausgehend
vom Wert n = 120 um jeweils einen Schritt -1 rückwärts zu
zählen: n = n - 1 oder inkrementell
n-- bzw. n -=:
(Zum Vergrößern bitte
auf das Bild klicken!) Wenn man im obenstehenden Programm den Taster B gedrückt hält, dann wird der aktuell
angezeigte Wert in jeweils 15er
Schritten,
d.h. der Schrittlänge -15 rückwärts gezählt. Und zwar so lange,
wie man den Taster B gedrückt hält! Dabei
werden dann je nach dem Ausgangswert auch krumme
(Minuten-) Werte angezeigt, was natürlich ungewohnt ist und die
Lesbarkeit bzw. das Verständnis erschweren. Wenn man diesen Nachteil vermeiden will, dann muss man bis zum nächsten Viertelstundenwert rückwärts
zählen, bevor man den Taster B drückt und gedrückt
hält, um in 15 Minuten
Schritten
rückwärts zu springen. Diesbezüglich gibt es dann aber noch einen
Schönheitsfehler, den es noch zu beseitigen gilt. Wenn man nämlich mit dem Taster A bis auf einen Wert von z.B. 100
rückwärts zählt und dabei exakt beim Wert
n = 100 stoppt, indem man den
Taster A rechtzeitig loslässt,
um dann anschließend durch Drücken des Taster B in 15er Schritten rückwärts zu zählen, dann bekommt man
anstelle des Wertes 95 den Wert 94 angezeigt, weil zuvor beim Runterzählen mit
dem Taster A der zuletzt mit dem Statement n = n - 1 herabgesetzte Wert noch nicht angezeigt wurde! Wir verbessern das Programm dahingehend, indem
wir die Displayanzeige aus den beiden
Abfragen von Taster A und B herausnehmen und ans Programmende stellen. Da die Anzeige nun aber direkt innerhalb
der Endlosschleife „dauerhaft“ steht, hat dies zur Folge, dass der
zuletzt angezeigte, aktuelle Wert ständig angezeigt wird! Und zwar unabhängig
davon, ob einer der beiden Taster A oder B gedrückt wurde oder nicht. Von einer Anzeige
mit Laufschrift erwartet man aber, dass diese nur dann angezeigt wird, wenn
es neue Informationen gibt. Schließlich ist die Laufschrift nicht zu
übersehen bzw. erfordert diese auch ein konzentriertes Hinschauen, um die
Nachricht als Ganzes wahrzunehmen. Wenn man also erreichen will, dass die Laufschrift immer nur dann angezeigt
wird, wenn es neue Infos gibt, d.h. sich der Zählwert geändert hat, dann muss man diese mittels eines Schalters ein- und ausschalten
können. Zu diesem Zweck deklarieren wir die boolesche
Variable „display“, die gleich beim
Programmstart auf den Wert „wahr“, engl. „true“,
initialisiert wird. Demzufolge lautet das Statement „ändere
display auf wahr“:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man oben im Programm „microbit_teil_01_prog_06.hex“
sieht, wird die Displayanzeige mit der Laufschrift immer nur dann
eingeschaltet, wenn die „if … then“-Abfrage in Form des Statements „wenn
display = wahr, dann“ den Wert „wahr“, engl. „true“
ergibt. Und dies ist immer dann der Fall, wenn einer der beiden Taster A oder B
betätigt wurde. [ Video ] Im Programm
„microbit_teil_01_prog_07.hex“
beheben wir einen weiteren Schönheitsfehler, indem wir das Herunterzählen in
den negativen Wertebereich nach dem Erreichen des Wertes n = 0 unterbinden. Zu
diesem Zweck fügen wir eine weitere „if … then“-Abfrage in Form des Statements „wenn n < 0, dann“ ändere den Wert n auf n = 0 wie folgt ein (siehe roter Kasten):
(Zum Vergrößern bitte
auf das Bild klicken!) Was jetzt noch stört ist der Umstand, dass der
Timer stets vom festen Wert n = 120
aus startet und rückwärts zählt. Auch wenn sich dieser Wert im Alltag als
praxistauglich erweisen dürfte, so ist die fehlende Variabilität auf Dauer
doch nicht angemessen. Schließlich lassen sich die herkömmlichen,
mechanischen Timer mit Aufziehuhrwerk auch flexibel bis zur Zeitdauer von 60
Minuten einstellen. Also machen wir uns an die Arbeit und opfern
den Taster A, um diesen
anderweitig zu nutzen. Nämlich zum Hochzählen vom Anfangswert n = 0 aus auf einen
beliebig höheren Wert, sodass wir jetzt flexibel sind und der Anwender jetzt selbst bestimmen kann,
von welchem Wert n aus rückwärts gezählt werden soll. Zu
diesem Zweck zählen wir die Variable n in 5er Schritten hoch. Je länger also der Anwender den Taster A gedrückt hält, umso mehr steigt der
Wert der Variablen n an. Dies geschieht mit dem Statement „ändere n auf n + 5“ (ab) in der Schleife „wenn Button
A ist gedrückt, dann …“. Des Weiteren ändern wir die Programmierung des
Tasters B dahin gehend ab,
indem wir diesen nur noch in „Einser“-Schritten herunter zählen lassen. Dies
geschieht im Statement „ändere n auf n – 1“ (ab). Das Herunterzählen
mit dem Taster B in „Einser“-Schritten
ist deshalb akzeptabel, weil wir ja mit dem Tasters A noch nur in „Fünfer“-Schritten hoch zählen. Last but not least bauen wir in die Schleife
mit dem Statement „wenn n < 0, dann …“ mittels des Statements „spiele Note C für 1 Takt“ noch ein akustisches Signal ein mit dem wir
signalisieren, dass der Wert null beim Herunterzählen erreicht wurde (siehe Programm „microbit_teil_01_prog_08.hex“):
(Zum Vergrößern bitte
auf das Bild klicken!) 2.4 Analogen
Eingang als Berührungs-Sensor nutzen
Jetzt sind wir fast am Ziel unserer Wünsche, verfügen
wir gleich über einen sehr komfortablen Timer,
der richtig Spaß macht. Schließlich gibt es nämlich noch einen weiteren
„Taster“, der auf seinen Einsatz wartet. Es ist der „Taster“ namens „Pin P0“. Diesbezüglich gibt
es aber auch noch die Pins P1 und P2,
die sich ebenfalls entsprechend nutzen lassen. Obwohl sich die drei „Taster“ namens Pin P0,
Pin P1
und P2 programmieren lassen,
handelt es sich bei diesen keineswegs um physische Taster wie bei den Tastern A und B,
sondern vielmehr um elektrische Eingänge an die sich kleine
elektrische Spannungen anlegen lassen. Da die Eingänge Pin P0, Pin P1 und P2 über einen hochohmigen Widerstand von 10 MΩ auf die
Spannungsversorgung VCC = +3,3 V (engl. „Voltage at the common collector“,
d.h. Spannung am gemeinsamen Kollektor) für integrierte Schaltkreise gelegt
sind, sind diese sehr empfindlich, sodass diese bereits auf kleinste
Spannungen reagieren. So reicht es bereits aus, wenn man die beiden
Anschlüsse Pin P0 und GND
(engl. „ground“, d.h. Masse) direkt mit zwei Fingern berührt, um einen winzig
kleinen Strom zwischen den Kontakten fließen zu lassen, sodass der
„Sensor“-Taster ausgelöst, d.h. eingeschaltet wird:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie klein der Eingangsstrom ist, lässt sich
übrigens anhand des Ohmschen
Gesetzes wie folgt ausrechnen: REingang = UEingang / IEingang → IEingang = UEingang / REingang
= UVCC / RVCC = 3,3 V / 10 MΩ = 3,3 V / ( 10 * 106
Ω ) = 0,33 * 10-6
A = 0,33 µA Das sind 33/100 Millionstel Ampere! Das ist
eine so winzig kleine Stromstärke, so dass sie sich selbst mit einem
empfindlichen Amperemeter im Messbereich von 50 µA schon nicht
mehr messen lässt! - Wie man im nachfolgenden Programm „microbit_teil_01_prog_09.hex“
sehen kann, nutzen wir den neuen „Taster“ mit dem Pin P0 dazu, um vom „Konfigurations“-Modus (= Festlegen der Einstellungen, d.h. Hochzählen
auf den Startwert)
des Timers in den „Count down“-Modus umzuschalten:
(Zum Vergrößern bitte
auf das Bild klicken!) [ Video ] Wie man ferner im großen,
roten Kasten
im obenstehenden Programm sehen kann, wird beim Herunterzählen vom Startwert bis auf null auch noch ein Signalton ausgegeben, der dann allerdings auch schon mal
ziemlich nerven kann, wenn man sich nämlich sonntags ein 7-Minuten-Ei kocht
bei dem dann = 7 * 60 s = 420
Signaltöne
ausgegeben werden! Deshalb ist es beim Timer besser, wenn man sich beim Herunterzählen erst zum Ende
hin alarmieren lässt! Wie man im abgeänderten Programm „microbit_teil_01_prog_10.hex“
im Quellkode weiter unten sieht, wird der Signalton jetzt erst beim Erreichen des Wertes n < 15 aktiviert:
(Zum Vergrößern bitte
auf das Bild klicken!) Ferner fällt auf, dass der Sensor „Pin P0“ durch den Erschütterungs- bzw. Bewegungssensor ausgewechselt wurde. Jetzt muss man den Timer nach der Konfiguration, d.h. dem Hochzählen auf einen Startwert nicht mehr
explizit durch einen Tastendruck
einschalten, sondern ganz einfach nur durch leichtes Schütteln oder durch eine Drehung
z.B. des Handgelenks. - 2.5 Optimieren
zweier „Wenn … dann“-Abfragen
Programmieren ist das eine, Optimieren das andere. Bisher haben wir das „Timer“-Programm aus einer Idee heraus
einfach programmiert, wobei uns immer wieder Dinge eingefallen sind, wie man
den Timer verbessern kann, sodass
das Programm immer umfangreicher und komplexer wurde. Dabei haben wir
gelernt, dass sich eine fehlende Tastatur im Großen und Ganzen funktional
auch durch die beiden Taster A und B, den Sensor
„Pin P0“ sowie durch den Erschütterungs- bzw. Bewegungssensor ersetzen lassen. Ferner haben wir gelernt, dass es praktisch
und sinnvoll ist, verschiedene Funktionen des Timers voneinander zu trennen und
durch boolesche
„Schalter“ in Kombination mit
diversen „if … then“-Abfragen anzusteuern und auszulösen. Dabei hat es sich
heraus gestellt, dass sich einfache „if … then“-Abfragen gut programmieren und
ausprobieren lassen. Da unser Timer
im Wesentlichen aus zwei Hauptfunktionen besteht, nämlich a) der Konfiguration des Timers, b) dem Count down, mussten wird diesem Umstand Rechnung tragen
und die Anzeige der Zahlenwerte im Display, d.h. der 5 x 5 LED-Matrix, in
zwei „if … then“-Abfragen wie folgt aufteilen (siehe roter und grüner Kasten):
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man im obenstehenden Bild sieht, lassen
sich die beiden „if … then“-Abfragen zu einer „if … then … else“-Abfrage zusammenfassen, da
sich die unterschiedlichen Funktionalitäten
nicht in die Quere kommen bzw. nichts miteinander zu tun haben. Didaktisch-methodisch ist es für den Programmier-Einsteiger aber zunächst einfacher
nachzuvollziehen, wenn man die unterschiedlichen Funktionalitäten zunächst in
separaten „if … then“-Abfragen programmiert und erst später zusammenfasst,
d.h. optimiert (siehe Programm
„microbit_teil_01_prog_11.hex“):
(Zum Vergrößern bitte
auf das Bild klicken!) Übrigens, wenn Ihnen die übersetzte,
deutschsprachige „wenn …
dann“-Abfrage im ersten Teil und „ansonsten, wenn … dann“-Abfrage im zweiten Teil etwas ungewohnt und deshalb
gewöhnungsbedürftig vorkommt (siehe im Bild oben), dann schalten Sie doch die
Darstellung der Block-Programmierung vom Deutschen einfach ins Englische um! - Aber sehr wahrscheinlich haben Sie
zwischenzeitlich auch schon mal einen Blick auf den „JavaScript“-Quellkode geworfen, der nur
international auf Englisch daher kommt. >> JavaScript (kurz JS)
ist eine Skriptsprache, die ursprünglich für dynamisches
HTML in Webbrowsern entwickelt wurde, um Benutzerinteraktionen
auszuwerten, Inhalte zu verändern, nachzuladen oder zu generieren und so die
Möglichkeiten von HTML und CSS zu erweitern.[1]
Heute findet JavaScript auch
außerhalb von Browsern Anwendung, so etwa auf Servern und in Microcontrollern.[2][3] Der
als ECMAScript (ECMA 262) standardisierte Sprachkern von
JavaScript beschreibt eine dynamisch typisierte, objektorientierte, aber
klassenlose Skriptsprache. Sie wird allen objektorientierten Programmierparadigmen unter anderem auf der
Basis von Prototypen gerecht. In
JavaScript lässt sich je nach Bedarf objektorientiert, prozedural oder funktional programmieren.[4]
(Quelle: Wikipedia) [ Video
] 2.6 Beschleunigtes
Hoch- und Runterzählen
Sicherlich haben Sie schon einmal einen
Radiowecker, ein Uhren- oder Küchenradio mit LED- oder LCD-Display oder eine
Kaffeemaschine mit eingebauter Schaltuhr „programmiert“, d.h. beim Einstellen
von Datum und Uhrzeit schmerzlich eine Tastatur für die Datums- und
Uhrzeiteingabe vermisst. Stattdessen gibt es aus Kosten- und Platzgründen nur
ein paar Taster für die Menübedienung wie z.B. zwei „Select“-Taster ( ◄
► ) für die Menüauswahl, einen Rauf- und Runter-Taster (▲ ▼
) zum Hoch- oder Runterzählen für das Datum (Wochentag, Monat, Jahr) und die
Uhrzeit (12/24-Std.anzeige, Stunden, Minuten) sowie eine Speichertaste ( ■
) für die Übernahme und das Abspeichern der eingestellten Werte. Wenn man dann in ein paar Jahren bei einem
Schaltjahr, das Datum ändern muss, weil der elektronisch implementierte,
chinesische Kalender keine Schaltjahre kennt, dann wird es für den Anwender
schwierig. Vor allem dann, wenn er die Bedienungsanleitung nicht mehr im Kopf
oder diese sogar verlegt hat. Dann muss man sich mittels Versuch und Irrtum
mühsam durch die Menüführung tasten. Aber zum Glück gleichen sich die Geräte
untereinander in der Menüführung an, weil inzwischen überall die gleichen
Timer-Chips eines großen amerikanischen, japanischen, koreanischen oder
chinesischen Herstellers verbaut werden. Demzufolge ist es bei den Schaltuhren und Timern
üblich geworden, dass z.B. bei der Festlegung des Datums ein längerer Tastendruck
dazu führt, dass dieses im Display
plötzlich schneller durchläuft, sodass man nicht 30 Tage warten muss, bis man das Monatsende erreicht, dieses
übernehmen und abspeichern kann. Da wir für unseren „Rückwärtszähler“-Timer ebenfalls über keine
Tastatur, sondern nur über ein
paar Taster verfügen, sind wir
gut beraten, diesen ebenfalls so zu programmieren, dass sich dieser möglichst
intuitiv bedienen lässt, sodass ein längerer Tastendruck
auf den Taster A oder B dazu führt, dass dieser nach fünf Sekunden plötzlich schneller hoch oder runter
zählt. Dabei sollten wir stets das 7-Minuten-Ei vor Augen haben, das beim
Timer einen Zahlenwert von 7 Minuten * 60 Sekunden = 420 Sekunden für das Rückwärtszählen benötigt. Wenn dabei dann das Einstellen des Startwertes
von 420 Sekunden bedauerlicher Weise ebenfalls bis zu 420 Sekunden dauert,
bis man auf den Wert 420 hoch gezählt hat, dann hätte man bereits während des
Zeiteinstellens das 7-Minuten-Ei kochen können! Schließlich kann es ja nicht
sein, dass man sich extra einen Tag Urlaub nehmen muss, nur um die
Programmierung des Timers zu studieren und auszuprobieren! Wenn es also darum geht, dass wir den Timer beim Hoch- (= Taster A) und Runterzählen (= Taster B) nach ca. 5 Sekunden
beschleunigen, d.h. schneller zählen lassen, dann müssten wir die Tastdauer der beiden Taster A und B in Echtzeit erfassen, auswerten
und darauf entsprechend reagieren. Da wir aber noch nicht wissen, wie man in Echtzeit ein Zeitfenster von 5 Sekunden erfassen, müssen wir
zu einem kleinen Trick greifen und stattdessen einfach nur den zahlenmäßig
(nicht zeitmäßig) längeren
Tastendruck von 0 auf 5 erfassen →
m = m + 1, auswerten → if m > 5 then …
und darauf entsprechend reagieren → n = n + 50 . Immer dann, wenn also der Taster A länger als fünf Sekunden gedrückt gehalten wird, wird der Wert der Variablen n nicht mehr nur um den Wert +5 erhöht, sondern um das Fünfzigfache mit n = n + 50. Dazu bräuchte man dann noch einen weiteren Zähler m,
der ständig um den Wert +1 mit m = m + 1 in einer inneren Schleife
hoch gezählt wird, so lange man den Taster A gedrückt hält. Immer dann, wenn der neue Schleifenzähler m z.B. den Wert 5
mit m > 5 übersteigt, wird der
Wert der Variablen n um +50
mit n = n + 50 erhöht, um auf diese
Weise das Hochzählen auf den Startwert von z.B. n = 420
für das 7-Minuten-Ei zu beschleunigen. Lässt man dann aber wieder den Taster A los, dann muss der Wert der Variablen n
wieder auf n = n + 5 zurück gesetzt
werden, um beim erneuten Drücken des Tasters A wieder in 5er
Schritten
hoch zu zählen:
(Zum Vergrößern bitte
auf das Bild klicken!) Da die vielen und noch dazu ineinander geschachtelten
„wenn … dann“-Abfragen, engl. „if
… then“,
immer komplexer werden und sich erst dann richtig verstehen lassen, wenn man
das Programm „microbit_teil_01_prog_12.hex“
tatsächlich von Grund auf selbst programmiert hat, sollten wir uns nun der
„echten“, professionellen Programmierung wie z.B. in JavaScript
zuwenden:
(Zum Vergrößern bitte
auf das Bild klicken!) Bei dem obenstehenden Quellcode
fällt auf, dass wir es u.a. auch mit „basic“ zu tun haben, wie z.B.
„basic.clearScreen()“ zum Löschen der 5 x 5 LED-Matrix-Anzeige oder mit
„basic.forever()“ für die „Endlos“-Schleife, obwohl wir doch in JavaScript programmieren und nicht in BASIC. Aber keine Sorge, wir programmieren hier nach
wie vor in JavaScript. Dabei bedeutet die Angabe „basic“
nichts anderes, als dass wir hier in JavaScript hauptsächlich nur mit grundlegenden, elementaren „JavaScript“-Befehlen zu tun haben bzw. mit
diesen arbeiten. Dafür dürfte es hauptsächlich zwei Gründe geben: a) Zwar verfügt der kleine „micro:bit“-Rechner
nur über eine beschränkte Rechenleistung nebst Arbeitsspeicher, sodass sich
mit diesem keine großen, rechenintensiven Programme ausführen lassen, was
auch gar nicht beabsichtigt ist. Schließlich soll der Rechner klein und
preiswert sein, über möglichst viele Sensoren verfügen und dabei auch noch
wenig Strom verbrauchen. b) Da der kleine „micro:bit“-Rechner zu Ausbildungszwecken
mit dem Ziel, Jugendlichen den Zugang zur Computertechnik zu vereinfachen und
kostengünstig zu ermöglichen, entwickelt wurde, kommt es eben auch darauf an,
dass sich der Rechner möglichst einfach handhaben und programmieren lässt. - Damit sich der „JavaScript“-Quellkode auch auf dem
heimischen Windows-PC problemlos editieren,
d.h. lesen, anzeigen und verändern lässt, benötigen wir noch einen einfachen Texteditor, der für das Erstellen von
Quellkode unterschiedlicher
Programmiersprachen entwickelt wurde. Allseits bekannt und beliebt ist z.B.
der sogenannte „Notepad++“-Editor,
den man sich hier
kostenlos herunterladen und installieren kann. Da es sich bei „JavaScript“-Dateien um Textdateien handelt und
die meisten Textdateien in der sogenannten ASCII-Zeichenkodierung
vorliegen, die sich praktisch in jedem Texteditor und/oder auch in der
Textverarbeitung „Writer“
von LibreOffice
öffnen, anzeigen und bearbeiten lassen, lassen sich „JavaScript“-Dateien mit dem Datei-Erweiterungsnamen „.js“ auch unter Windows mit dem Dateisystem verknüpfen, sodass
ein Mausklick auf z.B. den Dateinamen „microbit_teil_01_prog_12.js“
genügt, um diese im „Notepad++“-Editor
zu öffnen und bearbeiten zu können. „JavaScript“-Dateien, die wir hier auf
einem lokalen Webserver abgelegt
sind, lassen sich auch direkt von einem externen Webserver
im „Notepad++“-Editor schreibgeschützt
öffnen und bearbeiten, aber nicht wieder zurück im Internet speichern. Aber mittels „Datei speichern unter …“ lassen sich natürlich beliebige Webseiten, Textdateien oder „JavaScript“-Dateien mittels Browser aus dem Internet herunterladen, auf der lokalen Festplatte des
heimischen PCs abspeichern und von dort aus weiter bearbeiten!
Selbstverständlich lässt sich der Link http://localhost/microbit/teil_01/programme/microbit_teil_01_prog_12.js
auch direkt im „Notepad++“-Editor öffnen, bearbeiten und mittels „Datei speichern unter …“ auf die lokale
Festplatte des heimischen PCs speichern und dort später weiter bearbeiten! [ Video
] 2.7 Krumme
Zahlen beim beschleunigten Hoch- und Runterzählen
Wenn man also im obenstehenden Programm den Taster A länger als ca. 5 Sekunden gedrückt hält, dann erhöht sich der Schleifenzähler n nicht mehr um fünf Schritte mit n = n + 5, sondern vielmehr um
fünfzig Schritte mit n = n + 50, was ja prinzipiell
in Ordnung ist, wenn da nicht die etwas schwer zu lesende, ruckelige Laufschrift wäre. Wird nämlich beim beschleunigten
Hochzählen ein krummer Wert wie z.B. 321 angezeigt, dann muss man
schon genau und konzentriert hinschauen, um diesen im dezimalen Zahlensystem
identifizieren und zuordnen zu können. Beim länger andauernden, beschleunigten
Hochzählen kann das dann schon ziemlich nerven, weil man dann längere Zeit
konzentriert auf die ruckelige Laufschrift schauen muss, obwohl
man ja nur will, dass sich die Zahlen schneller vergrößern. Ob es sich dann
bei der nächsten größeren Zahl um den Wert 321 oder 334 handelt, will man
dabei eigentlich nicht so genau wissen. Wenn wir also sicherstellen wollen, dass das
Programm auch vom Anwender angenommen und öfters angewendet wird, dann müssen
wir dafür sorgen, dass wir es anwender- und menschenfreundlicher gestalten,
d.h. für eine verbesserte Lesbarkeit der ruckeligen Laufschrift sorgen. Diesbezüglich bietet es sich an, dass wir beim
beschleunigten Hochzählen eben nicht auf krumme Zahlenwerte springen, sondern vielmehr am
ganzzahlig aufgerundete, da sich diese wegen der nachgeordneten null
besser lesen lassen! Wenn also beim schnellen Hochzählen der nächste höhere
Wert 321 berechnet wurde, dann springen wir eben nicht auf diesen,
sondern auf den aufgerundeten Wert 350, da sich dieser besser lesen lässt! Wie aber lässt sich das Ganze berechnen und
programmieren? Da es ja um das Auf- oder Abrunden eines krummen Zahlenwertes
geht, müssten wir das Statement
„var a = Math.round(4.60)“ programmieren, das es
aber im „basic“-Befehlsvorrat wider Erwarten nicht gibt, sodass wir
uns anderweitig behelfen müssen. Wenn wir den Wert n = 321 nehmen und diesen
durch 50 teilen, dann folgt l = n / 50 =
6,42.
Wenn man das Ergebnis 6,42 auf den ganzzahligen Wert l = 6 abschneidet,
dann folgt in umgekehrter Richtung k = l * 50 = 300: let n = 321 let k = 0 let l = n / 50 … … k = l * 50 Mit n = ( l + 1 ) * 50 folgt = ( 6 + 1 ) * 50
= 350. Demzufolge müssen wir einen Vergleich anstellen und prüfen, ob der ursprüngliche
Wert n = 321 größer oder gleich ist als der abgeschnittene Wert k = l * 50 =
300: if (n >= k) { n = (l + 1) * 50 } … … Wenn also der ursprüngliche Wert n = 321
größer oder gleich dem Wert k = 300 ist, dann müssen wir um weitere 50 Zähler nach oben zählen mit n = ( l + 1 ) * 50 = ( 6 + 1 ) * 50 = 7 * 50 = 350. Was aber, wenn der Wert n = 350 beträgt? Dann ist l = n / 50 = 350 / 50 = 6, sodass k
= l * 50 = 6 * 50 = 300 ist und sich der Wert
n auf n = ( l + 1 ) * 50 = ( 6
+ 1 ) * 50 = 7 * 50 = 350 vergrößert, d.h. unverändert
bleibt! Beim Wert
n = 394 ist l = n / 50 = 394 / 50 = 7, sodass k
= l * 50 = 7 * 50 = 350 ist und sich der Wert
n auf n = ( l + 1 ) * 50 = ( 7
+ 1 ) * 50 = 8 * 50 = 400 vergrößert! Beim Wert
n = 400 ist l = n / 50 = 400 / 50 = 8, sodass k
= l * 50 = 8 * 50 = 400 ist und sich der Wert
n auf n = ( l + 1 ) * 50 = ( 8
+ 1 ) * 50 = 9 * 50 = 450 vergrößert! Wie man sieht, kommt es bei dem
Rechenverfahren nicht darauf an, dass eine Zahl n auf den nächst höheren Wert
aufgerundet wird, sondern vielmehr auf den nächsten ganzzahligen Wert von
z.B. 350, 400 oder 450 vergrößert wird, da genau dieses das beschleunigte
Hochzählen unseres Timers ausmacht (siehe Programm „microbit_teil_01_prog_13.hex“:
(Zum Vergrößern bitte
auf das Bild klicken!) Jetzt bleibt nur noch die Frage zu erklären,
weshalb der Quotient l = n / 50 = 321 / 50 = 6
ergibt, obwohl dieser ja eigentlich 6,42
lauten müsste! Der Quotient
l wird deshalb auf den Wert 6
durch Abschneiden verkürzt, weil den Variablen
n, k, l allesamt nur für ganzzahlige
und nicht reelle Zahlen wie z.B. für 6,42 deklariert und initialisiert
wurden! Hätte man die Variable l als reelle Zahl deklarieren und initialisieren wollen,
hätte man u.a. folgendes kodieren müssen: l = 0.0 . Wenn man im obenstehenden Programm aber alle Variablen
als reell deklariert und
initialisiert, d.h. mit einer dezimalen Nachkomma- bzw. Nachpunktstelle versieht, dann bekommt
man bei der Programmausführung
angezeigt, dass dezimale Zahlen
und das Rechnen mit ihnen wider
Erwarten nicht unterstützt werden! - [ Update
] Wie sich heute, am 24. Juli 2019 überraschend herausstellt,
kann der kleine „micro:bit“-Rechner inzwischen auch mit reellen Zahlen, d.h.
Fließkommazahlen, rechnen, was damals im Dezember 2016 noch nicht möglich
war. Doch halt! Der „micro:bit“-Rechner, d.h.
dessen Hardware mit dem „ARM Cortex M0“-Mikroprozessor konnte schon von
Anfang an intern mit Fließkommazahlen rechnen, aber eben nicht der JavaScript-Compiler
von Microsoft. Doch inzwischen scheint man den Fehler seitens Microsoft entdeckt
und behoben zu haben, sodass man wie gewohnt mit Fließkommazahlen rechnen und
arbeiten kann (siehe Programm „microbit_teil_01_prog_13c.hex“). [ Video
9a ] [ Video 9b ] Nachfolgend kann man selbst ausprobieren, ob
das für das beschleunigte Hochzählen erweiterte Programm „microbit_teil_01_prog_14.hex“
auch in der gewünschten Weise funktioniert. Selbstverständlich kann man sich
auch den dazugehörigen Quellkode, engl.
„sourcecode“, auch direkt im Browser
anzeigen lassen. - Wer sich nun von den Nachwuchsprogrammieren für
besonders clever hält und meint, man könne auf die oben im Programm stehenden
Hilfsvariablen k und l verzichten und den Programmkode entsprechend
vereinfachen,
(Zum Vergrößern bitte
auf das Bild klicken!) der wird bei der Programmausführung „microbit_teil_01_prog_15.hex
eines Besseren belehrt, weil das Programm nicht mehr in der
gewünschten Weise funktioniert! Finden Sie heraus, weshalb dem so ist! [ Video
10 ] [ Video 11a ] Das
beschleunigte Herunterzählen Was jetzt noch fehlt, ist das beschleunigte
Herunterzählen, wenn man den Taster B länger als fünf Sekunden gedrückt
hält. Dabei ist der Vorgehensweise im Prinzip die gleiche, nur halt mit dem
Unterschied, dass nach unten gezählt werden muss. Nehmen wir wieder den Wert n = 321 und teilen diesen
durch 50, sodass folgt l = n / 50 =
6,42.
Wenn man das Ergebnis 6,42 auf den ganzzahligen Wert l = 6 abschneidet,
dann folgt in umgekehrter Richtung k = l * 50 = 6 * 50 = 300: let n = 321 let k = 0 let l = n / 50 … … k = l * 50 Mit dem Wert
k = 300 haben wir bereits das
Ziel des beschleunigte Herunterzählen erreicht, sodass die
nachfolgende, abgewandelte bzw. angepasste Berechnung nebst Programmierung entfällt,
Mit n = ( l - 1 ) * 50 folgt = ( 6 - 1 ) * 50 = 250.
Demzufolge müssen wir einen Vergleich anstellen und prüfen, ob der
ursprüngliche Wert n = 321 größer oder gleich ist als der abgeschnittene Wert
k = l * 50 = 300: if (n >= k) { n = (l -
1) * 50 } … … weil durch das Abschneiden des Wertes n = 321 auf l = n / 50 = 321 / 50 = 6,
(Zum Vergrößern bitte auf
das Bild klicken!) Selbstverständlich lässt sich das obenstehende
Programm „microbit_teil_01_prog_16.hex“
auch ausprobieren und dabei prüfen, ob dieses für das beschleunigte Herunterzählen in der gewünschten Weise funktioniert.
[ Video 11b ] Wenn man den obenstehenden Algorithmus wie folgt
ins Programm „microbit_teil_01_prog_14.hex“
einbaut,
(Zum Vergrößern bitte
auf das Bild klicken!) dann lässt sich mit dem Programm „microbit_teil_01_prog_17.hex“
ab sofort auch beschleunigt rückwärts zählen, um den Startwert n für den Timer
komfortabel mittels der Taster A (= hochzählen) und B (= runterzählen) einstellen zu können. [ Video
11c ] Bei dieser Gelegenheit wurden auch noch zwei
kleine, aber feine Programmverbesserungen programmiert: a) Wie bereits beschrieben, lässt sich der „Down counter“ (= Rückwärtszähler) durch leichtes
Schütteln oder Drehen des „micro:bit“-Rechners aktivieren, sodass dieser
sofort ab dem zuvor eingestellten Startwert
n rückwärts nach unten
bis auf null zählt. b) Da
man bei der Laufschriftanzeige der
„5 x 5 LED-Matrix“-Anzeige stets nur die letzte Ziffer einer
mehrstelligen Zahl angezeigt bekommt und dann später nicht mehr weiß, um
welchen Zahlenwert es sich ursprünglich handelte, lässt sich nun der
Demzufolge müsste es
in der Praxis ausreichen, wenn man nur die Kontaktfläche „Pin P0“ mit einem Finger berührt, um diesen als „Sensor“ auszulösen. Den zum Programm
„microbit_teil_01_prog_17.hex“
zugehörigen Quellkode kann man sich hier direkt im Browser anzeigen lassen oder mittels der rechten
Maustaste auf die lokale Festplatte des heimischen PCs herunterladen. - Obwohl das Programm nun ziemlich ausgereift
ist, bleibt es nicht aus, dass einem früher oder später doch noch die eine
oder andere Verbesserung einfällt. So hat es sich z.B. herausgestellt, dass
man ab und an einen „Reset“-Taster vermisst, um einen bereits eingestellten
Startzählwert einfach wieder auf null setzen zu können, sodass man mit der
Einstellung eines neuen Startzählwertes wieder von vorn
anfangen kann. Ähnlich verhält es sich, wenn einen bereits gestarteten
„Count down“-Zählvorgang abbrechen möchte, sodass der
Startzählwert wieder auf den Anfangswert null zurück gesetzt wird und sich
neu einstellen lässt. Zwar gibt es auf der Rückseite der Platine des „micro:bit“-Rechners einen kleinen Reset-Knopf mit dem sich der Rechner neu starten
lässt, aber wenn man den Rechner später einmal in ein Gehäuse einbauen will,
dann kann es sein, dass sich der Reset-Knopf wegen der Rückwand
nicht mehr erreichen lässt. Dann müsste man ihn auslöten und mittels
Verbindungskabel an einer anderen Stelle des Gehäuses anbringen, sodass sich
dieser von vorn bedienen lässt. Wozu dann aber der Aufwand, wenn es im
vorliegenden Fall doch nur darum geht, den Startzählwert zwischendrin einfach mal auf null
zu setzen. Demzufolge ist es also einfacher, wenn man sich einen „Reset“-Taster selbst programmiert!
Aber nur zum Zurücksetzen des Startzählwertes auf null:
(Zum Vergrößern bitte
auf das Bild klicken!) In diesem Zusammenhang bleibt festzustellen,
dass der kleine „micro:bit“-Rechner auf der Vorderseite rechts und links neben
dem „5 x 5 LED-Matrix“-Display physisch nur über die beiden Taster A und B
verfügt, die sich schaltungstechnisch auch in Kombination mittels der Tastenfolge <Taster
A> + <Taster B> bedienen, d.h. abfragen lassen. Aber auch wenn man die
beiden Taster A und B wie gefordert gleichzeitig betätigt, so ist
es elektrotechnisch seitens des Stromflusses praktisch unmöglich, zwei Tasten gleichzeitig
zu drücken, d.h. quasi parallel abzufragen und darauf zu reagieren.
Zwar könnte man die beiden Taster A und B mittels gemeinsamer Taktung zeitgleich synchron abfragen
und deren zeitabhängigen Tastendruck auch in einem Speicher abspeichern, das Auslesen und Auswerten der gespeicherten Werte wäre dann aber
trotzdem nur der Reihe
nach
möglich. Da der kleine „micro:bit“-Rechner in seiner Rechenleistung
nicht so schnell ist, fällt es in der Praxis tatsächlich schwer, die beiden Taster A und B
gleichzeitig zu drücken, sodass diese auf den gemeinsamen Tastendruck unverzüglich reagieren. Aber
mit einem kleinen Trick kann man sich leicht helfen. Man muss nämlich dem
kleinen „micro:bit“-Rechner mit seiner geringen Rechenleistung nebst
Reaktionsvermögen einfach nur mehr Zeit
geben, um auf die beiden Tastendrücke der Taster A und B zu reagieren, indem man diese einfach ein bis
zwei Sekunden lang gedrückt hält! Das Zeitfenster für den Tastendruck
ist dann nämlich groß genug, um dieses durch den „micro:bit“-Rechner zeitunkritisch abfragen zu lassen. - Da also der „micro:bit“-Rechner nur über eine
einfache „Tastatur“ in Form der Taster A und B und die Kombination der beiden in Form des Tasters A+B sowie über ein einfaches „5 x 5 LED-Matrix“-Display verfügt, sind wir von den
Eingabemöglichkeiten und des Eingabekomforts eines PCs, Tablet-PCs oder
Smartphones meilenweit entfernt. Damit dieser Nachteil nicht zu Lasten des
Anwenders geht, zu Kommunikationsproblemen und Bedienungsfehlern führt, sind
wir als Programmierer gefordert. Aber auch, wenn es uns gelingt, die Bedienung so zu programmieren, dass
sie sich intuitiv bedienen lässt, sieht
man es dem „micro:bit“-Rechner nicht an, ob und wenn ja, welche Taster mit welchen Funktionen belegt sind. Deshalb wird
man nicht umhin kommen, beizeiten eine entsprechende Bedienungsanleitung zu erarbeiten, da man
die Bedienung und Handhabung von Programmen meistens schon nach wenigen
Monaten vergessen hat, insbesondere dann, wenn man dieses nicht
täglich benutzt und die Bedienung in Fleisch und Blut übergeht. - Bedienungsanleitung zum Programm
„microbit_teil_01_prog_18.hex“
und dem Quelltext „microbit_teil_01_prog_18.js“ 1.
Kabelverbindung
herstellen Um mit dem „micro:bit“-Rechner kommunizieren und das
gewünschte Programm auf den Rechner
einspielen zu können, muss man zunächst eine entsprechende Verbindung
herstellen. Dabei ist es am einfachsten, wenn man ein entsprechendes USB-Kabel
verwendet, das mit seinem kleinen „USB-2.0-Micro-B-Stecker“
direkt an den „micro:bit“-Rechner zwecks Stromversorgung
über USB und zum Datenaustausch
angeschlossen wird. Der größere „USB-2.0-Typ-A-Stecker“
am anderen Ende des Kabels wird an die USB-2.0-Buchse
des heimischen Windows-PCs
angesteckt. Sobald das USB-Kabel mit dem Windows-PC verbunden wird, erkennt Windows von sich aus, dass
ein USB-Gerät angeschlossen wurde,
lädt im Hintergrund die entsprechenden Treiber und bindet das USB-Gerät automatisch in das Windows-Dateisystem ein, sodass man ab
sofort auf dieses zugreifen kann. ACHTUNG In das
Windows-Dateisystem eingebundene USB-Geräte wie z.B. USB-Speichersticks,
externe USB-Festplatten oder auch der „micro:bit“-Rechner als USB-Gerät müssen
nach Gebrauch, d.h. beim Beenden der
Arbeit,
unter Windows (oder auch Linux oder Android) ordnungsgemäß manuell vom Windows-Dateisystem abgemeldet werden, da es ansonsten beim spontanen
Abziehen des USB-Kabels zum Datenverlust kommen kann! - 2.
Aufspielen des
Programms Damit sich
das für den „micro:bit“-Rechner entwickelte Programm auf diesem nutzen lässt,
muss es zuvor auf das Dateisystem
des Rechners aufgespielt werden. Dazu muss zuvor eine entsprechende Verbindung z.B. über das USB-Kabel erfolgreich hergestellt worden sein! Nachdem
das gewünschte Programm in das Hauptverzeichnis
des „micro:bit“-Dateisystems aufgespielt, d.h. kopiert wurde, kann es bis
zu 20 Sekunden dauern, bis dieses
vom Dateisystem in den Arbeitsspeichers des „micro:bit“-Rechners „geflasht“, d.h.
geladen wurde. Während des „Flashens“ (= Laden in den
Arbeitsspeicher) blickt die rückwärtige, gelbe Status-LED des „micro:bit“-Rechners. Dabei darf die Datenverbindung und Stromversorung
des „micro:bit“-Rechner nicht
unterbrochen werden, da es ansonsten zu unvorhersehbarem Verhalten bis hin zur Zerstörung des Rechners kommen kann! 3.
Starten und Ausführen
des Programms Das in den Arbeitsspeichers des „micro:bit“-Rechners geflashte Programm
wird vom System automatisch gestartet und ausgeführt! Wenn bei dem in den
Arbeitsspeicher geladenen Programm nichts anderweitiges programmiert wurde,
wie z.B. ein kleiner Begrüßungstext als Laufschrift auf dem „5 x 5 LED-Matrix“-Display, dann bleibt das Display dunkel, sieht man nicht,
dass das geladene Programm gestartet wurde! Dies ist auch der Fall,
wenn die Laufschrift
durchgelaufen ist!
Im vorliegenden Fall,
d.h. beim Programm „microbit_teil_01_prog_18.hex“
wird der Anfangszählerstand
„0“
auf dem „5 x 5 LED-Matrix“-Display angezeigt, da es sich beim Programm ja um
einen „Count-down“-Timer, d.h. ein Programm zum Herunterzählen eines eingestellten Startzählwertes handelt. 4.
Einstellen des Startzählwertes Ein „Count-down“-Timer, der vom Startzählwert „0“ aus herunter zählt,
macht natürlich keinen Sinn. Deshalb muss man mittels Tastendruck auf den Taster A erst vom Startzählwert „0“ aus diesen auf den gewünschten
Startzählwert „420“ (z.B. zum Kochen
eines 7-Minuten-Eies) hoch zählen! Damit das Hochzählen
nicht zu lange dauert, wird beim Programm standardmäßig in 5er Schritten hoch gezählt! Hält man den Taster A beim Hochzählen länger als fünf Sekunden lang gedrückt, dann springt der Zählalgorithmus auf 50er Schritte um, sodass jetzt deutlich schneller
hoch gezählt wird, so lange der Taster A gedrückt
bleibt! Lässt
man den gedrückten Taster A beim
Hochzählen in 50er
Schritte wieder los, dann springt der Zählalgorithmus wieder auf 5er Schritte zurück, sodass wieder
langsamer hoch gezählt wird! Da
sich mit dem Taster A nur
in 5er oder
50er Schritten hoch
zählen lässt, lassen sich mit diesem nur Werte wie z.B. 5, 10, 15, …, 50,
100, 150, …155, 160, 165, … einstellen. Wer aber einen Wert wie z.B. 133
einstellen will, muss nicht verzweifeln, weil er mit dem Taster A nur den Wert 130 oder 135 einstellen kann. Mit dem Taster B lässt sich nämlich
auch rückwärts nach unten zählen! Und zwar wahlweise in 1er oder 50er Schritten, wenn’s schneller
gehen soll. [ Video 12 ] 5.
Starten, Anhalten und
Fortsetzen des „Count down“-Timers Nachdem man mit den Tastern A und B
den gewünschten Startzählwert eingestellt hat, muss
man den Rückwärtszähler, engl. „count down“, noch starten, damit
dieser los legt und vom zuvor eingestellten Startzählerwert aus rückwärts bis auf null zählt. Da es aber für das
Starten und Anhalten des „Count down“-Timers wider Erwarten keinen Taster gibt,
muss man den „micro:bit“-Rechner einfach nur schütteln oder um die
eigene Achse drehen, damit dieser startet und anfängt vom zuvor
eingestellten Startzählerwert aus herunterzuzählen.
Auf die gleiche Weise
lässt sich das Herunterzählen des „Count down“-Timers auch jederzeit wieder
anhalten, zwischendurch unterbrechen oder wieder fortsetzen. Dabei ist das Herunterzählen erst dann definitiv beendet, wenn im „5 x 5 LED-Matrix“-Display der Wert null
erscheint! 6.
„Reset“ des
Startzählwertes während des Herunterzählens Das Zählwerk des „Count down“-Timers lässt sich jederzeit,
d.h. auch während des Herunterzählens, auf den Anfangszählwert null „resetten“, d.h. zurücksetzen. Dazu muss man
nur die beiden Taster A und B gleichzeitig gedrückt halten. Weil sich diese
aus technischen Gründen nicht so ohne Weiteres in Echtzeit umsetzen lässt,
muss man dem kleinen „micro:bit“-Rechner mit seiner geringen Rechenleistung nebst
Reaktionsvermögen etwas mehr Zeit
geben, um auf die beiden Tastendrücke der Taster A und B zu reagieren, indem man diese einfach ein bis
drei Sekunden lang gedrückt hält! Das Zeitfenster für den Tastendruck
ist dann nämlich groß genug, um dieses durch den „micro:bit“-Rechner zeitunkritisch abfragen und auswerten zu
lassen. – 7.
Zwischenzeitliches
Anzeigen des Zählwertes Nachdem
Einstellen des Startzählwertes
durch Hochzählen (= Taster A) und/oder Runterzählen
(= Taster B) erlischt die
Laufschriftanzeige im „5 x 5
LED-Matrix“-Display,
sodass man später nicht mehr weiß, welcher Zählwert momentan aktuell gültig ist. Ebenso
verhält es sich, wenn das Herunterzählen des „Count down“-Timers
zwischenzeitlich durch Schütteln oder Drehen des „micro:bit“-Rechners
angehalten wurde! Auch dabei erlischt die Anzeige, weiß man später nicht
mehr, welcher Zählwert momentan
aktuell gültig ist. Wenn,
wie weiter oben beschrieben, ein externer
Taster an
die Kontakte „Pin P0“ und „GND“ (= engl. „ground“, d.h.
Masse) angeschlossen ist, dann lässt sich mit diesem durch Tastendruck der aktuelle Zählwert im „5 x 5 LED-Matrix“-Display
anzeigen! Softwaremäßig, d.h. im Programm selbst lässt sich der Kontakt „Pin P0“ als Taster
mittels Mausklick direkt anklicken, sodass kein externer Taster erforderlich ist! - Wie man unschwer sieht, ist der „Count down“-Timer sehr leistungsfähig
und trotz intuitiver Zwei-Tasten- und Schüttel-Bedienung ziemlich komplex,
sodass die obenstehende Bedienungsanleitung
absolut sinnvoll ist und die Dokumentation des Programms abrundet! [ Video
13 ] Hier geht’s dann weiter zum „micro:bit“-Programmieren,
Teil 2“ |
||||
|
|
[ Home ] [ zurück ] [ Seitenanfang ] [ Teil 2 ] |
|
