[ electronic 159 ] [ Seitenende ] [ zurück ]

 

 

 

electronic 159 – Programmieren 1

 

 

Blitz und Donner programmieren

 

Selbstverständlich lassen sich in der Natur Blitz und Donner (noch) nicht programmieren, d.h. mittels eines Computerprogramms fernsteuern, sodass man in der Nähe eines Gewitters per Programmbefehl ein Blitz auslöst, dessen Blitzenergie auffängt und für die Stromerzeugung und Stromspeicherung nutzt.

 

Zwar hat ein Blitz im Moment des Blitzeinschlags eine sehr hohe Spannung von einigen Millionen Volt, zum Vergleich: der Haushaltsstrom hat eine (Wechsel-) Spannung von U = 230 V, die im Falle einer Berührung mit dem Stromkabel tödlich(!) sein kann, und auch eine sehr hohe Stromstärke von einigen Tausend Ampere, leider aber nur für eine sehr, sehr kleine Zeitspanne von wenigen Millisekunden!

 

Demzufolge berechnet sich die Leistung PBlitz eines Blitzes wie folgt:

 

PBlitz = UBlitz * IBlitz = 2 500 000 V * 5 000 A = 12 500 000 000 VA = 12 500 000 000 W = 12 500 000 kW = 12 500 MW

 

Die Maßeinheit für die Leistung P, englisch “power” (= Kraft, Leistung), ist übrigens das Watt [W].

 

Weitere, d.h. abgeleitete Maßeinheiten für die Leistung, sind dann [ Kilowatt ] = [kW] oder [ Megawatt ] = [MW].

 

Dabei steht das „Kilo“ für den Faktor 1 000 und „Mega“ für eine Million, d.h. den Faktor 1 000 000; das ist eine 1 mit sechs Nullen!

 

Die Leistung von PBlitz = 12 500 MW ist extrem viel und lässt sich nur mit der Jahresproduktion von Strom bzw. elektrischer Energie eines großen Erdgas-Kraftwerkes vergleichen! Wirklich?

 

Nehmen wir mal ein Kraftwerk mit der monatlichen Leistung von 5 000 MW * 12 Monate = 60.000 MW/Jahr

 

Diesbezüglich berechnet sich die elektrische Energie WBlitz dann wie folgt:

 

WBlitz  = PBlitz * tBlitz

 

          = 12 500 MW * 0,1 s = 1 250 MWs

 

          = 1 250 MWs = 1 250 MW * 1/3600 h = 0,347 MWh = 0,347 kWh

 

Anstelle mit den vielen Nullen lässt sich auch mit den sogenannten Zehner-Potenzen, d.h. zur Basis 10 wie z.B. 100 = 1, 101 = 10, rechnen:

 

WBlitz  = PBlitz * tBlitz

 

          = 12 500 * 109 W * 0,1 s = 1 250 MWs

 

          = 1 250 MWs = 1,25 * 103 * 109 W * 1/3600 h = 0,347 MWh = 347 kWh = 347 * 103 Wh

 

          = 347 * 103 Wh = 347 * 103 W * 1 h  = 347 * 103 W * 3600 s = 347 * 103 W * 3,6 * 103 s

 

          = 347 * 103 W * 3,6 * 103 s = 347 W * 3,6 * 106 s = 0,347 W * 103 * 3,6 * 106 s = 0,347 W * 3,6 * 109 s

 

          = 0,347 W * 3,6 * 109 s = 1,249 109 Ws = 1 249 106 Ws = 0,347 103 Wh = 0,347 kWh

 

Zum Vergleich: ein drei Personen Haushalt hat einen durchschnittlichen Energieverbrauch von 4 200 kWh pro Jahr! Demzufolge bräuchte man n = 4 200 kWh / 0,347 kWh = 12 104 Blitze pro Jahr, um diesen einen Haushalt ein Jahr lang mit elektrischer Energie zu versorgen! Wahnsinn!

 

Zwar ließe sich eine solch große Energiemenge mit einer speziellen, noch zu erfindenden „Blitz-Antenne“ „einfangen“, aber in der kurzen Zeit nicht auf einmal in einem elektrischen Speicher wie z.B. einem Kondensator speichern. -

 

Da aber das Einfangen von Blitzen und das Speichern von elektrischer Blitzenergie ziemlich illusorisch ist, wenden wir uns einfacheren Dingen zu. Wenn sich im Sommer ein Gewitter nähert, dann möchte man schon wissen, ob und wann es unter Umständen gefährlich wird, von einem Blitz getroffen zu werden. Zwar sagt man, dass man eher vom Blitz getroffen wird als im Lotto mit einem Sechser mehreren Millionen zu gewinnen!

 

Wir wissen ja, dass es zwischen Blitz, dessen Lichtblitz sich mit Lichtgeschwindigkeit c = vLicht = 300 000 km/h ausbreitet, und Donner, wegen der Schallgeschwindigkeit cS = vSchall = 340 m/s, einen entsprechenden Laufzeitunterschied t gibt, der sich recht einfach berechnen und programmieren lässt:

 

sEntfernung = vDonner / tDonner      sEntfernung= vDonner / t = 340 m/s * 4 s = 1 020 m 1,0 km

 

Wenn also zwischen Blitz und dem zeitlich nachfolgenden Donner eine Zeitdifferenz von ∆t = 4 s verstreicht, dann befindet sich das Gewitter mit nur einem Abstand von sEntfernung= 1,0 km unmittelbar über den Bewohnern! Höchste Zeit also, sich in Sicherheit zu bringen und das Haus, eine mit Blitzschutz versehene Schutzhütte oder das Auto als Faradayscher Käfig aufzusuchen!

 

Zum Programmieren verwenden wir den sogenannten „Calliope mini 2.0“ als Hardware, einen Mikrocontroller mit ARM Cortex M0 Prozessor.

 

>> 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)

 

Wir legen gleich los und steigen in die Programmierung des „Calliope mini“ ein. Und zwar direkt in der online Entwicklungsumgebung deines Browsers:

 

 

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

 

Die im obenstehenden Bild zu sehende Entwicklungsumgebung teilt sich in drei Bereiche (Spalten) auf:

 

1.    die Simulation des „Calliope mini“,

das ist der
blaugrüne Hardware-„Stern“ des „Calliope mini“ (oben links) mit seinen sechs kreisrunden elektrischen Kontaktflächen „Pins“ in den Ecken des Sechsecks in die sich später Verbindungskabel mit einem „Bananenstecker“ einstecken lassen.

2.    die Programm-Bibliothek des „Calliope mini“,

die sich in mehrere Teile unterteilen, wie z.B.
„Grundlagen“ mit grundlegenden (Block-) Befehlen,
„Eingabe“ mittels Tastendruck auf den Taster „A“ oder „B“ oder Berühren des Pins „0“,
„Variablen“ zum Deklarieren (Definieren) und Initialieren (Zuweisen) von textlichen oder numerischen Inhalten.

3.    die Programmier-Oberfläche des „Calliope mini“,

zum Anordnen und Aufnehmen von Block-Befehlen, Programmblöcken wie z.B. „beim Start“ ausführen.

Unser erstes Programm „programm_01_01.hex lässt sich direkt aus dem Browser heraus mittels rechter Maustaste und im Untermenü <Link speichern unter> auf die lokale Festplatte des heimischen Desktop-PCs herunterladen und von dort aus auf den „Calliope mini“ über das angesteckte Mikro-USB-Kabel aufspielen!

 

Beim Programmieren mit den sogenannten (Programm-) „Blöcken“ gibt es im Wesentlichen zwei Programmblöcke und zwar

 

·       den Programmblock „beim Start“ sowie „dauerhaft“.

 

Dabei wird der Programmblock „beim Start“ gleich als erstes zu Beginn beim Starten des Programms ausgeführt.

 

Im Programmblock „beim Start“ stehen deshalb nur Befehle, d.h. engl. „statements“, die nur beim Programmstart ausgeführt werden sollen und später beim weiteren Programmablauf keine Rolle mehr spielen! Im vorliegenden Fall sind das nur zwei Statements, und zwar

 

·       das Statement <Bildschirminhalt löschen> sowie

·       das Statement <zeige Text „Blitz & Donner“>.

 

Dabei ist mit „Bildschirm“ die 9 x 9 Matrix (= Tabelle) in Form von sehr kleinen, rechteckigen LEDs gemeint, wobei jede der 9 x 9 = 81 LEDs einen, wenn auch großen Bildpunkt darstellt.

 

Damit man den Schriftzug „Blitz & Donner“ trotzdem einigermaßen gut lesen kann, wird dieser in einer roten Laufschrift angezeigt. Rot deshalb, weil die LEDs rotes Licht abstrahlen, sozusagen in „schwarzweiß“ in roter Farbe. Später werden wir noch einen Befehl kennenlernen mit dem sich die Helligkeit der LEDs „dimmen“, d.h. heller oder dunkler stellen lässt.

 

Bevor man das Programm „programm_01_01“,

 

·       das übrigens mit dem Dateinamen „mini-programm_01_01.hex“ heruntergeladen
und im (Windows-) Ordner
„Downloads“ abgespeichert wird,

startet,

·       indem man auf das kleine, weiße Quadrat „Stop“ (-Taste)
mit der
blau-grünen Umrandung (links unter dem blau-grünen Calliope-Stern)

 

klickt, sollte man dieses durch Mausklick ganz unten in der Mitte auf das Symbol „Diskette“ abspeichern!

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis programm_01-01.hex)

 

Früher oder später könnte es nämlich mal passieren, dass sich der „Calliope mini“ wider Erwarten aufhängt und einfriert, sodass nichts mehr geht, man das Gerät von der Stromversorgung abkoppeln und neu starten muss, indem man die Stromzufuhr wieder herstellt. Wohl dem, der sein mehr oder weniger umfangreiches Programm zuvor abgespeichert hatte!

 

Wenn man das Programm nach der Programmierung auch auf der Hardware des „Calliope mini“ ausprobieren möchte, dann muss man nur auf die Schaltfläche <Herunterladen> klicken, sodass sich das Dateifenster vom Windows Explorer (= Dateimanager von Windows) öffnet.

 

Nun muss man sich entscheiden, ob man „Calliope mini“-Programm auf der lokalen Festplatte C:\ des (Windows-) Desktop-PCs oder direkt in den Flashspeicher des „Calliope mini“ speichern will, das dann anschließend automatisch ausgeführt wird.

 

Wenn man den „Calliope mini“ über das Mikro-USB-Kabel an einen (Windows-) Desktop-PC anschließt, dann wird dieser nicht nur vom Desktop-PC mit Strom versorgt, sondern auch automatisch in das Windows-Dateisystem eingebunden! Und zwar in der Form, dass im Dateisystem ein weiteres Laufwerk ähnlich dem einer Festplatte, eines CD-/DVD-Laufwerks oder eben eines USB-Laufwerks mit der Bezeichnung „MBED VFS USB Device …“ eingerichtet wird.

 

Dabei steht die Angabe „MBED“ für „embedded“, d.h. „eingebettet“ im Sinne von „in das Windows-Dateisystem integriert“, die Angabe „VFS“ steht für engl. „virtual file system“, d.h. virtuelles Dateisystem, im Sinne von „nicht wirklich physisch vorhandenes Dateisystem“. Im Gegensatz zu einer tatsächlich physisch vorhandenen Festplatte als Hardware, die im Desktop-PC verbaut ist.

 

Da der „Calliope mini“ über einen sogenannten Flashspeicher wie ein USB-Speicherstick verfügt, müssen alle selbst programmierten Programme zunächst in einen hexadezimalen (digital zur Basis 16) Prozessor-/ Maschinenkode übersetzt, d.h. kompiliert werden und anschließend auf den Flashspeicher des „Calliope mini“ geflasht werden.

 

Da der Flashspeicher des „Calliope mini“ nicht über ein Dateisystem, engl. „file system“, ähnlich dem von Windows, Linux oder Google Android verfügt, muss man dem Flashspeicher von außen ein virtuelles, d.h. scheinbares (Windows-) Dateisystem quasi überstülpen. Aus diesem Grund müssen USB-Speichersticks und der „Calliope mini“ an das (Windows-) Dateisystem angebunden, engl. „mounted“, d.h. „montiert“ werden. Dies geschieht automatisch in dem Moment, wo man den Flashspeicher des USB-Speichersticks oder des „Calliope mini“ an die USB-Buchse des (Windows-) Desktop-PCs oder Notebooks ansteckt.

 

Der umgekehrte Prozess, d.h. das Abkoppeln, engl. „dismounted“, und Abmelden des Flashspeichers des USB-Speichersticks oder des „Calliope mini“ vom Windows-Dateisystem muss manuell, d.h. händisch durch Mausklick auf das kleine USB-Speicherstick-Symbol  ganz unten rechts in der System Tray (Systemleiste) veranlasst werden, damit es beim Abziehen des Mikro-USB-Kabels mit dem „Calliope mini“ nicht zum Datenverlust oder einer Beschädigung des Flashspeichers kommt!

 

 

Wenden wir uns wieder dem Block-Programm „progamm_01_01“ zu:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis programm_01-01.hex)

 

Der Programmblock „beim Start“ wird direkt beim Programmstart, d.h. beim Ausführen des Programms auf dem „Calliope mini“ ausgeführt. Und zwar nur beim Programmstart und später nie wieder!

 

Dabei werden im Programmblock „beim Start“ zwei Statements (= Befehle) ausgeführt und zwar das Löschen des „Bildschirms“ mit der 9 x 9 LED-Matrix-Anzeige und anschließend die Anzeige des konstanten Textstrings (= Zeichenkette) „Blitz & Donner“.

 

Dass es sich dabei um einen konstanten Textstring handelt, bedeutet nichts anderes, als dass es sich um einen konstanten, d.h. während des Programmablaufs nicht veränderlichen Text unter Verwendung einer Text-Variablen handelt.

 

Früher oder später werden Block-Programme (siehe oben) ziemlich umfangreich und dabei gleichzeitig nicht nur bunter, sondern auch unübersichtlicher!

 

Deshalb gewöhnen wir es uns von Anfang an, auch Statements (= Befehle) in der JavaScript“-Programmiersprache zu programmieren, die sich besser „lesen“, aber wegen der Syntax (= Satzbau eines Statements/Befehls) etwas schwerer verstehen lässt:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis programm_01-01.js)

 

Wie man im obenstehenden Programmkode sieht, gibt es sogenannte „Basis“-Befehle, engl. „basic“. Dabei handelt es sich um eine sogenannte Klasse von „Basis“-Befehlen.

 

 

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

 

Was aber hat es im obenstehenden „JavaScript“-Programm mit dem Statement

 

basic.forever(function () {

         

})

 

Wie man sieht, handelt es sich um den „Basis“-Befehl „forever“, deutsch „für ewig“ im Sinne von dauerhaft, fortwährend, der übrigens eine namentlich unbestimmte Funktion „function() { … }“ enthält bzw. ausführt!

 

Was aber ist eine „Funktion“? Eine Funktion, engl. „function“, nimmt zwischen den geschweiften Klammern { … } mehrere Statements auf, die z.B. Daten einlesen, verarbeiten, ausgeben/anzeigen usw.

 

Demzufolge kann eine Funktion etwas, bewirkt eine Funktion etwas, tut eine Funktion etwas.

 

Nehmen wir als Beispiel das Objekt „Fahrrad“, das über eine funktionierende Kettenschaltung vorn an der Tretkurbel und hinten am Hinterrad verfügt.

 

Dabei funktioniert aber die Funktion „Kettenschaltung“ nur ordnungsgemäß, wenn die Kette nicht verrostet ist, mit Kettenöl eingeölt wurde, damit sie leichtgängig ist und sich geschmeidig schalten lässt. Außerdem muss die Kettenschaltung in Form der Seilzüge richtig eingestellt und entsprechend justiert sein, damit die Kette beim Schalten nicht abspringt oder sich verhakt.

 

Schauen wir uns zur besseren Veranschaulichung noch das „Block“-Programm dazu an:

 

 

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

 

Webdesigner entwickeln Webseiten hauptsächlich in HTML 5, Cascading Style Sheets (CSS), JavaScript, während Webdeveloper (= Webentwickler) und professionelle Softwareentwickler (= Programmierer) u.a. auch in der Programmiersprache „Python programmieren, die es zwar in der Version 1.0 schon seit 1994 gibt, aber erst ab der Version 3.0 seit 2008 in Mode gekommen ist. So wurde beispielsweise der Google Assistant als Google Android App in Python programmiert.

 

Obwohl die Entwicklungsumgebung des „Calliope mini“ von Microsoft programmiert wurde, gibt es diese noch nicht für die „Python“-Programmiersprache.

 

Bei dem EC-Karten großen micro:bit“-Rechner, der u.a von der BBC London für Grundschulen entwickelt und herausgegeben wurde, gibt es die ansonsten gleiche Entwicklungsumgebung von Microsoft auch für die höhere Programmiersprache „Python“:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis programm_01-01.py)

 

Besonders interessant ist an dem obenstehenden „Python“-Programm programm_01_01_microbit.py

 

·       die Definition der Funktion „on_forever()“,

die vom Hauptprogramm aus mittels

·       des Statements „basic.forever(on_forever)

 

aufgerufen und ausgeführt wird.

 

Das Statement “pass” in der Funktion „on_forever()“ bedeutet, dass hier der Programmkode der Funktion endet.

 

Ferner ist interessant, dass der Funktion „on_forever()“ mit dem Funktionsaufruf „basic.forever(on_forever) keine Parameter mit übergeben werden! -

 

Wir fahren fort mit dem „Blitz & Donner“-Programm bei dem es darum geht, dass wir mittels des Laufzeitunterschieds t = 4 s zwischen Blitz und Donner die Entfernung des Gewitters zu unserem Standort hin berechnen:

 

sEntfernung = vDonner / tDonner      sEntfernung= vDonner / t = 340 m/s * 4 s = 1.360 m 1,4 km

 

 

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

 

Zu diesem Zweck deklarieren wir erstmalig eine Variable „time_sekunden“, die wir dann mit dem Wert „0“ initialisieren, d.h. der wir den Wert „0“ wie folgt zuweisen:

 

Statement setze time_sekunden auf 0

 

Anschließend fordern wir den Anwender durch mehrmaliges Drücken der Taste „A“ auf, die zwischen Blitz und Donner verstrichene Zeit t = 4 s einzutasten:

 

Statement zeige Text „Taste mit A Sekunden ein!“

 

Dabei wird dann später bei jedem Tastendruck auf die Taste „A“ der entsprechende Wert um +1 erhöht und im Display angezeigt:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis mini-programm_01_02.hex)

 

Dabei nennt man das Erhöhen des Wertes der Variablen „time-sekunden“ um +1 inkrementieren und das Verringern des Wertes der Variablen „time-sekunden“ um -1 dekrementieren (siehe Wikipedia):

 

Statement setze time_sekunden auf time_sekunden + 1

 

Mit dem

 

Statement zeige Text verbinde „ “ time_sekunden

 

wird dann der um +1 erhöhte Wert der Variablen „time_sekunden“ im Display angezeigt.

 

Dabei gilt es zu beachten, dass es sich bei der Variablen „time_sekunden“ wegen der anfänglichen Zuweisung mit dem Wert „0“ und der späteren Inkrementierung (= Erhöhung um +1) um eine ganzzahlige Variable vom Typ „integer“ handelt.

 

Ferner muss man wissen, dass es sich bei der Textanzeige um die Anzeige im Display von alphanumerischen Werten im Sinne von Ziffern, einzelnen Buchstaben, engl. „characters“ oder einer Zeichenkette, engl. „string“, handelt.

 

Dabei gilt es zu beachten, dass sich Ziffern nur anzeigen lassen und zwar im Sinne einzelner Symbole mit denen man nicht rechnen kann! Deswegen handelt es sich bei den Zahlen auf dem Zifferblatt einer Uhr um Ziffern und eben nicht um Zahlen, weil Zahlen dem Rechnen und Berechnen vorbehalten sind!

 

Demzufolge muss der jeweilige Zahlenwert der numerischen „Integer“-Variablen time_sekunden bereits vor der Anzeige im Display in einen sogenannten „String“, d.h. in eine alphanumerische Zeichenkette umgewandelt werden!

 

Das ist dann auch der Grund dafür, dass das Statement zeige Text verbinde „ “ time_sekunden etwas komplizierter aussieht!

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis mini-programm_01_02.js)

 

Im obenstehenden „JavaScript“-Programm „mini-programm_01_02.js“ ist beispielsweise interessant, wie die Umwandlung des Inhalts der numerischen Variable „time_sekunden“ vom Typ „integer“ bei der Anzeige im Display erfolgt:

 

Statement basic.showString(““ + time_sekunden)

 

Nämlich durch die vorangestellten ““ wird die Displayanzeige wenn auch als leerer Textstring eingeleitet, sodass die Umwandlung der nachfolgenden numerischen Variable „time_sekunden“ vom Typ „integer“ in einen Textstring, d.h. Zeichenkette, quasi automatisch erfolgt.

 

Als nächstes wechseln wir zum „micro:bit“-Rechner mit dem „Block“-Befehl-Programm „microbit-programm_01_02.hex“:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis microbit-programm_01_02.hex)

 

Dabei fällt im Programmblock „wenn Knopf A gedrückt“ auf, dass bei der Anzeige im Display praktisch keine Umwandlung des numerischen Inhalts der Variable „time_sekunden“ vom Type „integer“, d.h. ganzzahlig, in einen entsprechenden Textstring, d.h. Zeichenkette, erfolgt. Jedenfalls wird das nach außen nicht sichbar offeriert!

 

Interessant ist auch das „Python“-Programm „microbit-programm_01_02.py“ beim „micro:bit“-Rechner bei dem der numerische Inhalt die numerischen Variable „time_sekunden“ explizit mittels des

 

Statements str(time_sekunden)

 

innerhalb des

 

Statements basic.show_string("" + str(time_sekunden))

 

in einen Textstring bzw. eine Zeichenkette umgewandelt wird:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis microbit-programm_01_02.py)

 

In diesem Zusammenhang kann man im obenstehenden

 

Statement basic.show_string("" + str(time_sekunden))

 

auch die beiden Anführungszeichen “”, die für einen Leerstring stehen, wie folgt weglassen:

 

Statement basic.show_string(str(time_sekunden))

 

Wir bleiben auf dem “micro:bit”-Rechner mit Python und programmieren als nächstes die Berechnung der Entfernung zwischen Blitz und Donner:

 

Statement entfernung = time_sekunden * 340

 

Wie man sieht, wird die Entfernung mittels der Schallgeschwindigkeit von 340 m/s berechnet:

 

sEntfernung = vDonner / tDonner      sEntfernung= vDonner / t = 340 m/s * 4 s = 1.360 m 1,4 km

 

Das Berechnen der Entfernung soll aber erst dann erfolgen, wenn der Anwender zuvor mittels des Tasteres „A“ die zwischen Blitz und Donner verstrichene Zeit t = 4 s eingetastet hat! Demzufolge soll das obenstehende Statement mit der Entfernungsberechnung erst nach dem Tastendruck auf die Taste „B“ erfolgen, sodass wir jetzt die Abfrage des Tasters „B“ programmieren müssen.

 

Zu diesem Zweck kopieren wir den Programmblock „def on_button_pressed_a()“ des Tasters „A“ nebst Funktionsaufruf „input.on_button_pressed(…)“:

 

def on_button_pressed_a():

    global time_sekunden

    time_sekunden = time_sekunden + 1

    basic.show_string(str(time_sekunden))

 

input.on_button_pressed(Button.A, on_button_pressed_a)

 

und benennen diese nach Taster „B“ um, entfernen die Statements des Tasters „A“ und fügen stattdessen das Statement zum Berechnen der Entfernung wie folgt ein:

 

def on_button_pressed_b():

    entfernung = time_sekunden * 340

    basic.showString(str(entfernung))

 

input.on_button_pressed(Button.B, on_button_pressed_b)

 

Als nächstes stellt sich die Frage, wie wir den erweiterten Quellkode in den (Programmier-) Editor des „micro:bit“-Rechners übertragen bekommen. Das aber geht einfacher als erwartet, nämlich mittels Copy & Paste:

 

 

(Bild vergrößern: auf Bild klicken! Webverzeichnis microbit-programm_01_03.py)

 

Als nächstes betreiben wir noch etwas (Programm-) Kosmetik, indem wir das Programm noch anwenderfreudlicher, d.h. mitteilsamer programmieren, damit der Anwender besser weiß, warum und weshalb er etwas eintasten (im sprichtwörtlichen Sinne mittels Taster „A“ und „B“) soll:

 

 

(Bild vergrößern: auf Bild klicken! Quellkode im Browser: microbit-programm_01_04.py)

 

Selbstverständlich geht Copy & Paste nicht nur in eine Richtung, sondern auch in die andere, d.h. hin zu unserem (Text-/Programmier-) Editor „Notepad ++ (siehe obenstehendes Bild mit dem „Python“-Quellkode des „micro:bit“-Rechners). -

 

Mittels „Copy & Paste“ sind wir nun auch in der Lage, den Quellkode eines „JavaScript“- oder „Python“-Programms in den „Notepad++“-Editor zu kopieren und von dort aus auf den heimischen Rechner zu speichern!

 

Mittels „Copy & Paste“ sind wir ferner in der Lage, den Quellkode eines „JavaScript“-Programms vom „micro:bit“-Editor in den „Calliope mini“-Editor zu kopieren und von dort aus zu starten.

 

Dabei sollten wir uns aber daran erinnern, dass sich zwar „Python“-Programme als Quellkode in den „Calliope mini“-Editor kopieren, aber eben nicht ausführen bzw. simulieren lassen. Und das, obwohl beide Rechner über denselben Prozessor vom Typ „AMD Cortex M0“ verfügen! Aber bei dem Simulationsprogramm geht es eben nicht um die Hardware als solche, sondern um die Software, d.h. die Simulation für „Block“- und „JavaScript“-Programmen, jedenfalls, wenn es um den „Calliope mini“-Rechner geht.

 

Beide Simulationsprogramme, d.h. das vom „micro:bit“-Rechner und das vom „Calliope mini“-Rechner verfügen quasi über eine gemeinsame, d.h. kompatible Schnittstelle zur „JavaScript“-Programmierung. Einer der Gründe dafür ist der, dass beide Simulationsprogramme nebst (Programmier-) Editoren von Microsoft entwickelt wurden!

 

Da es sich bei dem „Calliope mini“-Rechner aber über eine in jüngster Zeit neu entwickelte Hardware handelt, wurde die „Block“-Programm-Programmierung von Anfang an überarbeitet und verbessert, sodass die „Block“-Programme des „Calliope mini“-Rechners leider nicht zu 100 % kompatibel sind! -

 

 

„Python“-Programm vom „micro:bit“ in „Block“-Programm des „Calliope mini“ konvertieren

 

Wir wissen ja inzwischen, dass man mit dem „Calliope mini“-Rechner direkt in der Online-Simulation leider keine „Python“-Programme entwickeln kann, während das hingegen auf dem älteren „micro:bit“-Rechner nebst Online-Simulation sehr wohl möglich ist (siehe oben).

 

Und genau das lässt sich entsprechend ausnutzen, indem wir das „Python“-Programm „microbit-programm_01_04.py“ in den „micro:bit“-Rechner laden bzw. importieren:

 

 

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

 

Wie man im nachfolgenden Screenshot sieht, lässt sich das „Python“-Programm „microbit-programm_01_04.py“ in der online „micro:bit“-Simulation durch einfachen Mausklick auf <JavaScript> konvertieren, dann als Ganzes markieren und mittels „Copy & Paste“ in die online „Calliope mini“-Simulation einfügen, die aber zuvor in den „JavaScript“-Modus umgeschaltet werden muss:

 

 

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

 

Bevor man aber das neue, d.h. konvertierte „JavaScript“-Programm „mini-programm_01_04.js“ durch Mausklick auf <Blöcke> umwandelt, sollte man es zuvor getestet, d.h. testweise ausgeführt/gestartet haben:

 

 

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

 

Wie man sieht, klappt das Konvertieren eines „Python“-Programms über den Zwischenschritt von „JavaScript“ hin zum „Block“-Programm bzw. dem „Block“-Quellkode problemlos! Vorausgesetzt natürlich, dass das ursprüngliche „Python“-Programm selbst fehlerfrei war und sich in der Simulation des „mircr:bit“-Rechners fehlerfrei ausführen ließ!  

 

 

 

[ electronic 159 ] [ Seitenanfang ] [ zurück ]