Inhalt

Cover

Über den Autor

Titel

Impressum

Inhaltsverzeichnis

1 Einleitung

2 Willkommen in der Powered-Up-Welt

Electric System – wie alles begann

Power Functions

WeDo 2.0

Boost

Powered Up

Spike Prime

Control+

Mindstorms

3 Die Powered-Up-App

Eine kleine Einführung

Spielen

Erschaffen

Weitere Powered-Up-Apps

4 Programmierung

Aller Anfang ist leicht!

Das erste Programm

Besondere Befehle und Programmiertechniken

Mehrere Hubs ansteuern

Übersicht über die Befehle

5 Powered Up mit anderen Programmiersprachen programmieren

Scratch

Weitere Möglichkeiten

6 Flugsimulator

Beschreibung

Simulator-Plattform

Stücklisten und Bauanleitungen

Space-Jet

Labyrinth

Software

Variationen

7 Tresor

Beschreibung

Tresor

Stückliste und Bauanleitung

Software

Variationen

8 Bahnübergang

Beschreibung

Bahnübergang

Stücklisten und Bauanleitungen

Sensor im Personenzug

Sensor im Güterzug

Software

Variationen

9 Danksagungen

Fußnoten

Christoph Ruge automatisierte schon als Kind seine Modelleisenbahn oder die Beleuchtung seines Zimmers. Nach einem Studium der Ingenieurinformatik hat er die Steuerung echter Eisenbahnen programmiert und letztlich seine Wohnung komplett automatisiert. Seit 2014 baut er Modelle aus LEGO. 2020 ist das von ihm bei LEGO Ideas eingereichte Modell der Internationalen Raumstation in den Handel gekommen. Wenn er nicht gerade mit LEGO baut, fährt er Rad, singt im Chor oder komponiert Musik (christophruge.de).

Henry Krasemann ist Jurist im öffentlichen Dienst und betreibt seit 2011 den You-Tube-Kanal »Klemmbausteinlyrik« und die Webseite klemmbausteinlyrik.de für LEGO-Begeisterte. Er stellt dort regelmäßig Sets vor, berichtet von Veranstaltungen und führt Interviews. Seine Frau Hilke Krasemann (»Blümchen«) ist ab und an mit dabei. Sie hat viele nervenaufreibende Abende und Nächte damit verbracht, die Anleitungen umzusetzen.

Michael Friedrichs ist Gründer und Betreiber der Webseite promobricks.de, der LEGO-News-Seite von Fans für Fans. Mit über zwei Millionen Zugriffen im Monat gehört sie zu den größten und reichweitenstärksten Blogs im gesamten deutschsprachigen Raum. Heute arbeitet ein ganzes Team daran, Fans täglich mit aktuellen News, Gerüchten und interessanten Reviews zu versorgen.

Gemeinsam mit Henry Krasemann lädt Michael Friedrichs in regelmäßigen Abständen zum LEGO Fan Talk ein, einem Live-Gesprächsformat auf YouTube.

Zu diesem Buch – sowie zu vielen weiteren dpunkt.büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei dpunkt.plus⁺:

www.dpunkt.plus

Ruge · Krasemann · Krasemann · Friedrichs

Eigene LEGO®-Modelle
programmieren

Mit Bauanleitungen für neue Modelle.
Für Powered Up, BOOST und Control+

Ruge · Krasemann · Krasemann · Friedrichs

Lektorat: Gabriel Neumann

Copy-Editing: Kerstin Grebenstein, www.buch-fuer-buch.de

Satz: Veronika Schnabel

Fotografien, soweit nicht anders angegeben:

Veronika Schnabel; Screenshots: die Autoren;

Fotos S. 15-17, 20: Henry Krasemann, S. 2, 6, 8-11, 13, 24: Michael Friedrichs

Herstellung: Stefanie Weidner

Umschlaggestaltung: Helmut Kraus, www.exclam.de,

unter Verwendung von Fotos von Veronika Schnabel

Bibliografische Information der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen

Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über

http://dnb.d-nb.de abrufbar.

ISBN:

Print978-3-86490-799-9

PDF978-3-96910-054-7

ePub978-3-96910-055-4

mobi978-3-96910-056-1

1. Auflage 2021

Copyright © 2021 dpunkt.verlag GmbH

Wieblinger Weg 17

69123 Heidelberg

Hinweis:

Der Umwelt zuliebe verzichten wir auf die Einschweißfolie.

Schreiben Sie uns:

Falls Sie Anregungen, Wünsche und Kommentare haben, lassen Sie es uns wissen: hallo@dpunkt.de.

LEGO, LEGO-Figuren und LEGO-Bausteine sind Warenzeichen der LEGO-Gruppe.
Dieses Buch ist von der LEGO-Gruppe weder unterstützt noch autorisiert worden.

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten.

Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar.

Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen. Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert.

Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die im Zusammenhang mit der Verwendung dieses Buches stehen.

5 4 3 2 1 0

Inhaltsverzeichnis

1Einleitung

2Willkommen in der Powered-Up-Welt

Electric System – wie alles begann

Power Functions

WeDo 2.0

Boost

Powered Up

Spike Prime

Control+

Mindstorms

3Die Powered-Up-App

Eine kleine Einführung

Spielen

Erschaffen

Weitere Powered-Up-Apps

4Programmierung

Aller Anfang ist leicht!

Das erste Programm

Besondere Befehle und Programmiertechniken

Mehrere Hubs ansteuern

Übersicht über die Befehle

5Powered Up mit anderen Programmiersprachen programmieren

Scratch

Weitere Möglichkeiten

6Flugsimulator

Beschreibung

Stücklisten und Bauanleitungen

Simulator-Plattform

Space-Jet

Labyrinth

Software

Variationen

7Tresor

Beschreibung

Stückliste und Bauanleitung

Tresor

Software

Variationen

8Bahnübergang

Beschreibung

Stücklisten und Bauanleitungen

Bahnübergang

Sensor im Personenzug

Sensor im Güterzug

Software

Variationen

9Danksagungen

1
Einleitung

Power Functions, WeDo, Boost oder Control+? Der dänische Spielwarenhersteller hat seine Fans in den vergangenen Jahren mit so einigen technischen Erweiterungen versorgt, damit sie ihre LEGO-Modelle immer besser und realistischer umsetzen können. Mit einer Vielzahl von Steuerungseinheiten, Motoren und Sensoren eröffnet LEGO ihnen dabei viele Möglichkeiten.

Was früher die praktische Fernsteuerung war, ist heute das Smartphone oder das Tablet. Mit ihnen können motorisierte Modelle beispielsweise via Bluetooth-Verbindung und Touchscreen gesteuert werden. So ist nicht nur für Spaß beim Entwerfen und Bauen gesorgt, sondern auch später beim Spielen mit Freunden und der Familie.

Doch es ist nicht einfach, bei dieser ganzen Fülle von Erweiterungen den Überblick zu behalten, denn nicht jeder Motor ist mit jeder Steuerungseinheit kompatibel. Gerade in den vergangenen zwei Jahren hat die LEGO-Gruppe viel unternommen, um das Thema Powered Up bei kleinen und großen Fans stärker zu positionieren und unter anderem durch die Weiterentwicklung von Komponenten und der entsprechenden Software voranzubringen.

Das Batmobil war 2018 das erste Kaufset mit Powered Up.

Auch aktuell gibt es ein paar interessante technische Veränderungen, die nicht nur das Spielen künftig beeinflussen werden, sondern auch die Programmierung der Modelle.

Und genau hier kommt dieses Buch ins Spiel: Wir nehmen dich mit in die Welt von Powered Up, stellen dir die Gemeinsamkeiten und Unterschiede der einzelnen Systeme vor und helfen dir dabei, deine selbst gebauten Modelle mithilfe der offiziellen App und einfacher Programmierung eindrucksvoll zum Leben zu erwecken. Ein Ausblick auf die künftige Entwicklung sowie drei spannende Powered-Up-Modelle zum Nachbauen sorgen für noch mehr Spielspaß und Abwechslung.

Du kannst unsere Modelle oder Programmbeispiele gerne nach Belieben erweitern und verbessern. Die Grenzen deiner Kreativität bestimmen alleine du und dein Vorrat an LEGO-Steinen, LEGO-Teilen und Powered-Up-Komponenten zu Hause. Ganz viel Spaß dabei!

2
Willkommen in der Powered-Up-Welt

Um dir den Einstieg in die Welt von LEGO Powered Up zu erleichtern und dir einen guten Überblick über die verschiedenen Systeme und entsprechenden Sets zu verschaffen, beginnen wir mit einem kurzen Rückblick in die 70er-Jahre und schauen uns gemeinsam die Entwicklung vom einfachen LEGO-Motor bis hin zum neuesten Powered Up Hub mit seinen vielfältigen Funktionen und Anschlussmöglichkeiten an.

Electric System – wie alles begann

Ok, legen wir los und beginnen mit unserer kleinen Zeitreise durch die LEGO-Geschichte. 1977 erschien mit dem Expert Builder 4,5 Volt Power Pack (Set-Nummer 960) der erste Technic-Motor. Bei der Expert-Builder-Reihe handelt es sich um die heutige LEGO-Technic-Reihe, die aber erst seit 1984 so heißt und insbesondere in Deutschland zu den beliebtesten und meistverkauften Themenwelten gehört. Zumindest betonen das die Marketing-Leute von LEGO immer wieder gerne. Expert-Builder-Sets waren in der Regel anspruchsvolle Modelle, bei denen nicht das Aussehen im Vordergrund stand, sondern deren durchaus komplexe Funktionsweise. Nicht ohne Grund vermarkteten die Dänen diese Sets damals mit dem Slogan »Technik wie in Wirklichkeit«. Und so war es in der Regel auch.

Doch zurück zu unserem ersten »Technic«-Motor aus dem Expert Builder Power Pack. Sobald dieser mit der Batterie-Box verbunden und der Kippschalter betätigt wurde, drehte sich die vorstehende Achse des Motors und brachte dadurch Bewegung ins Spiel. So bewegte sich zum Beispiel das Modellauto auf Knopfdruck vorwärts, ein Seilzug setzte sich in Bewegung oder ein Bagger hob seine Schaufel an. Doch viel mehr Möglichkeiten bot der Motor den Fans damals nicht. Der integrierte Kippschalter in der Batterie-Box bot eine Stopp-Funktion sowie die Möglichkeit, die Achse des Motors – je nach Stellung des Reglers – vorwärts oder rückwärts zu drehen. Da im LEGO-Motor von damals auch noch kein Getriebe verbaut war, konnte die Drehzahl des Motors auch nur mit entsprechenden Zahnrädern händisch im Modell angepasst werden.

Einem direkten Vergleich mit den heutigen Powered-Up-Motoren würden die Erweiterungen von damals nicht standhalten, auch wenn sie seitdem kontinuierlich weiterentwickelt und verbessert wurden. Erst 1997 stellten die Produktentwickler im dänischen Billund, wo die Unternehmenszentrale des Spielwarenherstellers ansässig ist, den ersten Motor mit Getriebe vor.

Neben den Motoren für Technik-Modelle gab es noch eine ganze Reihe anderer technischer Erweiterungen, die mithilfe von Strom aus der Batteriebox oder aus dem Trafo zum Leben erweckt werden konnten. Hier ist insbesondere das große Eisenbahn-Sortiment zu nennen, welches seit Anfang der 70er-Jahre bei kleinen und großen Fans immer wieder für leuchtende Augen gesorgt hat. Da gab es elektrische Weichen, motorisierte Züge oder einfach nur LEGO-Lampen zur Beleuchtung der heimischen Gleisanlage.

Fans konnten diese Erweiterungen auch an einem Emblem auf den Setverpackungen erkennen: Electric System hieß es da. Das Angebot erstreckte sich nicht nur auf Technik- und Eisenbahn-Sets, sondern fand sich auch in anderen Themenwelten wieder. Ein Highlight waren hier die zahlreichen Light-&-Sound-Modelle, die auf Knopfdruck grelle Geräusche machen konnten oder wild zu blinken begannen.

Wie ihr seht, wurde den Fans schon damals allerhand geboten.

Power Functions

Springen wir auf unserer Zeitreise in das Jahr 2007. Hier kam mit dem RC Bulldozer das erste Technic-Set in den Handel, das auf das neue Power-Functions-System setzte. Für rund 150 Euro gab es damals knapp 1.400 Teile, darunter waren auch vier Motoren, eine Batteriebox, zwei Infrarot-Empfänger sowie eine Infrarot-Fernbedienung, um den Bulldozer damit fernsteuern zu können. Eine Sensation damals, die bei vielen Fans wahre Begeisterungsstürme auslöste.

Für sie ging damit ein Traum in Erfüllung, denn die neuen Möglichkeiten, die die Power-Functions-Komponenten mit sich brachten, unterschieden sich deutlich vom Electric System. Es wurden nun statt einem Motor für alle Modelle mehrere Motoren mit unterschiedlicher Leistung angeboten. Ebenfalls wichtig: Die neuen Motoren enthielten statt der früher üblichen festen Antriebsachse ein sogenanntes Kreuzloch. Fans haben damit die Flexibilität erhalten, selbst entscheiden zu können, welche Lego-Achse sie beispielsweise für den Antrieb eines Fahrzeugs verwenden möchten.

Ein neues Highlight von Power Functions war auch die Infrarot-Fernbedienung. Der entsprechende Empfänger wurde zusammen mit der Batteriebox und den Motoren im Modell verbaut.

Zwei Power-Functions-Motoren nehmen einen Infrarotempfänger in ihre Mitte.

Auch wenn einige Komponenten aktuell nicht mehr lieferbar sind, viele Elemente erfreuen sich bei den Fans nach wie vor einer hohen Beliebtheit. Neben den Motoren, Batterieboxen und der Fernbedienung gab und gibt es auch Lampen, Farb- und Abstandssensoren. Auch nach der Ankündigung von Powered UP waren diese im LEGO-Online-Shop immer noch bestellbar. Doch wenn die entsprechenden Powered-Up-Komponenten länger im Angebot sind, dürften auch die letzten Power-Functions-Teile dort verschwinden – so zumindest kündigte es der Spielwarenhersteller schon bald nach Einführung von Powered Up an.

Ausmustern müsst ihr eure Power-Functions-Elemente deshalb aber nicht. Seit einem der letzten größeren Updates der offiziellen Powered-Up-App können beispielsweise Motoren mit wenigen Schritten in das neue System integriert und weiterverwendet werden. Da das aber je nach Modell und Funktion manchmal ein wenig trickreich sein kann, gibt es auf der Fan-Seite Promobricks.de eine ausführliche Anleitung dazu, die ihr euch bei Bedarf gerne anschauen könnt.

LEGO Power Functions mit Powered Up nutzen: https://www.promobricks.de/lego-powered-up-tutorial/97055/

WeDo 2.0

Das LEGO-WeDo-2.0-Set aus dem Education-Programm richtet sich speziell an Grundschulen und eignet sich gut für den Einsatz im Sachunterricht. Damit sollen Kinder bereits früh den Spaß am eigenständigen Erforschen von realen Themen anhand von selbst gebauten LEGO-Modellen entdecken und zum Experimentieren angeregt werden. Auch die ersten rudimentären Programmierkenntnisse sollen so spielerisch vermittelt werden.

Gesteuert werden die WeDo-Modelle über eine eigene App, die kostenlos in den jeweiligen App-Stores heruntergeladen werden kann. Hier finden die jungen Forscher auch zahlreiche Ideen für Modelle sowie Bauanleitungen, die ihnen den Einstieg erleichtern und ihnen Funktionen und Möglichkeiten schrittweise erläutern.

Die technischen Komponenten von WeDo 2.0 sind erst seit dem App-Update auf Version 3.1 mit dem Powered-Up-System kompatibel. Der Vorgängerbausatz, WeDo 1.0 von 2009, kann hingegen nicht mehr mit den aktuellen Systemen mithalten. Die Motoren und Sensoren können nicht mit Powered-Up-Komponenten kombiniert werden.

Boost

Mit LEGO Boost erschien 2017 auch der erste Roboter-Baukasten für das heimische Kinderzimmer. Das Set beinhaltete knapp 850 Teile, darunter ein Move Hub als zentrale Steuerungseinheit mit integriertem Motor und ein kombinierter Farb- und Entfernungssensor. Mithilfe einer eigenen App ließen sich fünf Basismodelle über eine objektorientierte Programmiersprache (Scratch) steuern.

Zahlreiche Updates für die App sowie einige Erweiterungssets sorgten seit dem Verkaufsstart dafür, dass es zu Hause in den Kinderzimmern nicht langweilig wurde.

Die Boost-App startet.

Und sind doch alle von LEGO angebotenen Modelle und Anleitungen durchgespielt, gibt es noch unser Buch zu LEGO-Boost-Robotern. Es bietet fünf alternative Bauvorschläge und eine ausführliche Einführung in die Programmierung der Modelle.

Seit Mitte 2019 können die technischen Komponenten von Boost übrigens in das Powered-Up-System integriert werden.

Foto: dpunkt.verlag

Powered Up

Im Mai 2018 hat die LEGO-Gruppe mit Powered Up den Nachfolger von Power Functions vorgestellt. Mit der neuen Plattform und den überarbeiteten technischen Komponenten sollen Fans noch mehr Spielspaß und Interaktionsmöglichkeiten erhalten, so zumindest das Versprechen des Spielwarenherstellers. LEGO Powered Up basiert auf dem ein Jahr früher vorgestellten LEGO Boost und erweitert die bekannten Power Functions um zusätzliche Soundeffekte und spezielle Bewegungs-Modi.

Zum Start der neuen Plattform gab es für die Fans drei Powered-Up-Sets: Das per App gesteuerte Batmobil sowie zwei Züge aus der LEGO-City-Themenreihe. Diesen lag erstmals die neue Fernbedienung bei.

Power Functions hatte zur Fernsteuerung noch die vergleichsweise störanfällige Infrarot-Technik verwendet. Die Powered-Up-Plattform setzt auf die wesentlich vielseitigere und modernere Bluetooth-Schnittstelle zur Übertragung der Steuerungsdaten. Der Sensor bzw. der Empfänger ist fest in der neuen Batteriebox verbaut, so wie es beispielsweise auch beim Move Hub von Boost der Fall ist.

Der Smart Hub, so der Name der Powered-Up-Steuereinheit, verfügt über zwei Anschlussmöglichkeiten. Hier können zum Beispiel ein Motor sowie ein LED-Licht (Ja, das gibt es jetzt auch!) angeschlossen werden. Bei den Steckern haben sich die Designer für das neuere System von Boost und WeDo 2.0 entschieden.

Zum Start von Powered Up war es übrigens nicht möglich, über den Hub bzw. über die App die bisherigen Power-Functions-Komponenten zu steuern. Auch das eigene Programmieren von Bewegungsabläufen war anfangs noch nicht möglich. Beides wurde später nach und nach erst möglich.

Powered-Up-Stecker

Spike Prime

Im April 2019 hat LEGO mit Spike Prime ein neues praxisorientiertes Lernkonzept für den MINT-Unterricht an weiterführenden Schulen vorgestellt. Im Fokus stehen dabei Schülerinnen und Schüler der fünften bis achten Jahrgangsstufe.

Spike Prime gehört wie Mindstorms zur LEGO-Education-Reihe und besteht aus verschiedenen Bauelementen, einem programmierbaren Hub, Motoren und Sensoren sowie einer kindgerechten Programmiersprache, die auf Scratch basiert. Die Programmierung selbst erfolgt über eine eigene App.

Foto: LEGO

Control+

Im Sommer 2019 haben die Dänen mit Control+ ein weiteres Steuerungssystem an den Start gebracht. Technic-Modelle sollen damit auf ein neues Realitäts-Level gehoben werden, so das Versprechen des Spielzeugherstellers. Das erste Set mit Control+-Elementen war der 4x4 X-treme Off-Roader (Setnummer 42099) aus der Technic-Reihe. Damit konnten sich Fans ein erstes Bild von neuen Funktionen machen. Neben einem Multifunktions-Steuermodus per Touchscreen konnten sich Fans über Echtzeit-Angaben über den Neigungswinkel des Fahrzeugs, zur Geschwindigkeit und Motorleistung freuen. Dazu kamen über die gleichnamige App passende Fahrgeräusche und diverse Aufgaben, um das neue System besser kennenzulernen und die Kreativität voranzubringen.

Die Control+-App im Einsatz mit dem Liebherr-Bagger (42100).

Mindstorms

Den ersten LEGO-Mindstorms-Programmier-Baukasten veröffentlichte der dänische Spielwarenhändler im Jahr 1998. Bei der Hauptzielgruppe, Schüler der Oberstufe und Studierende von MINT-Fächern, kam das neue Set gut an und fand weltweit viele Fans. Besonders beliebt ist die Programmierung von Robotern, die komplizierte Aufgaben selbstständig erledigen müssen. Aufgrund der hohen Resonanz vonseiten der Schulen und Bildungseinrichtungen wurde Mindstorms stetig weiterentwickelt und verbessert. Nach den Produkt-Updates in den Jahren 2006 und 2013 stellte LEGO mit dem Robot Inventor kürzlich die neueste Mindstorms-Generation vor.

Als Begleitung zum Set haben die Dänen auch eine eigene App veröffentlicht, die sowohl Mindstorms-Anfänger als auch fortgeschrittene Nutzer dabei unterstützt, Programmierkenntnisse aufzubauen und weiter zu vertiefen. Die App verwendet eine sogenannte Drag-and-Drop-Programmiersprache, die auf Scratch basiert, sowie Python für Fans, die bereits über ausreichende Programmierkenntnisse verfügen.

Das Set Mindstorms Robot Inventor (51515)

Auch die Auswahl an Motoren und Sensoren kann sich sehen lassen. Die neuen Mindstorms-Motoren haben beispielsweise einen integrierten Rotationssensor und bieten so eine präzise Ansteuerung. Interessant ist auch der Farbsensor. Er kann zwischen acht Farben unterscheiden, kann Lichtreflexionen messen und funktioniert problemlos bei allen Lichtverhältnissen.

Inwieweit sich die Motoren und Sensoren auch in das Powered-Up-System integrieren lassen, wird sich noch zeigen.

3
Die Powered-Up-App

In diesem Kapitel schauen wir uns die LEGO-Powered-Up-App etwas genauer an. Sie ist im Apple App Store (iOS), im Google Play Store (Android) sowie im Amazon App Store (Fire OS) zu finden und kann von dort aus kostenlos heruntergeladen werden. Je nach Internetverbindung ist die Installation in wenigen Minuten erfolgt. Die App lässt sich sowohl auf dem Smartphone als auch auf dem Tablet installieren – ganz wie ihr mögt und welche Geräte euch zu Hause dafür zur Verfügung stehen.

Fragt ihr euch jetzt, warum ihr die Powered-Up-App installieren sollt, wenn sich doch manche der motorisierten Modelle auch ganz bequem ohne App via Fernsteuerung in Bewegung setzen lassen? Dann ist die Antwort ganz einfach: Weil euch durch die App viel mehr Möglichkeiten zur Verfügung stehen, eure Modelle zu steuern. Kurzum: Ohne App macht LEGO Powered Up nur halb so viel Spaß.

Ist dein Gerät kompatibel? Auf LEGO.com/devicecheck kannst du prüfen, ob dein Gerät geeignet ist. Bitte fragt eure Eltern um Erlaubnis, bevor ihr online geht.

Eine kleine Einführung

Die App steht seit Juni 2018 für die verschiedenen Plattformen zum Download zur Verfügung. Seitdem wurde sie fortwährend weiterentwickelt und mit jedem Update um neue Funktionen und Möglichkeiten erweitert. So konntet ihr anfangs über die App (Version 1.0) beispielsweise nur das Super Heroes Batmobil durch die Gegend fahren und passend dazu Fahrgeräusche und Soundeffekte abspielen lassen. Gleiches galt für den LEGO City Güter- und Personenzug.

Die von vielen Fans erhoffte und auch erwartete Programmierfunktion, wie wir sie heute kennen, wurde erst im April 2019 im Rahmen eines großen Software-Updates (Version 2.1) freigeschaltet. Damit war es nun möglich, eigene Steuerungsprogramme für die selbst gebauten Modelle zu erstellen, Soundeffekte auszuwählen oder die Touchscreen-Steuerung auf dem Smartphone oder Tablet ganz nach seinen Vorstellungen anzupassen.

Für manche Modelle – hier das Creator-Expert-Geisterhaus (10273) – bietet LEGO eine optionale Erweiterung mit Powered-Up-Komponenten an.

Im Januar 2020 folgte dann ein weiteres großes Update der App (Version 3.1). Damit war es nun möglich, nicht nur Powered-Up-Motoren und -Sensoren zu programmieren, sondern auch einige ältere Power-Functions-Komponenten über die App einzubinden und diese mit dem neueren System zu nutzen. Zudem konnte die Powered-Up-Fernbedienung über die App neu konfiguriert werden. Und im Oktober 2020 erschien das Update auf Version 3.5 und damit die freie Programmierung der Controller sowie die Möglichkeit, Modelle ohne Zeitbeschränkung anzusteuern.

Spielen

Sobald ihr die App heruntergeladen, installiert und gestartet habt, geht es auch schon los. Der Einstieg ist denkbar einfach. Auf dem Start-Bildschirm erwartet euch eine Reihe von Kauf-Sets, für die werkseitig schon Steuerungsprogramme von den Entwicklern bereitgestellt wurden.

Falls ihr eines oder mehrere der dort abgebildeten Sets schon haben solltet, wisst ihr eventuell bereits, was euch hier erwartet. Für jedes dieser Sets haben die Entwickler schon die grundlegenden Steuerungsabläufe programmiert, dazu passende Soundeffekte hinzugefügt und ein schickes Layout für die Touchscreen-Steuerung erstellt. Das ist insofern ganz praktisch, weil ihr nach Auswahl des Modells direkt loslegen und Spaß haben könnt.

Die vorgegebenen Steuerungsprogramme und Soundeffekte der Kauf-Sets lassen sich leider nicht ändern. Die einzige Ausnahme ist das per App gesteuerte Batmobil. Die beiden vorhandenen Beispiel-Programme können nach Belieben geändert und individuell angepasst werden. Dafür stehen euch eine Vielzahl von Funktionen und Steuerungselementen zur Verfügung. Was euch da alles erwartet und wie das funktioniert, erfahrt ihr im Kapitel »Programmierung«.

Erschaffen

Mit der offiziellen Powered-Up-App könnt ihr nicht nur die vorgegebenen Kauf-Modelle steuern, sondern sie bietet euch auch die Grundlage für die Entwicklung eigener Programme – und genau das macht sie auch so interessant und vielseitig. Um vom Bereich Spielen in den Programmier-Modus zu wechseln, bewegt ihr im Start-Bildschirm der App den Schieber oben rechts auf Erschaffen.

Dort befindet sich ein leerer Projektordner, der nur darauf wartet, von euch mit eigenen Steuerungsprogrammen gefüllt zu werden.

Los geht es mit dem Namen eures Projektes. Worum geht es? Wie soll euer Programm später heißen? Welches Modell wird programmiert? Habt ihr euch für eine Bezeichnung entschieden, folgt der nächste Schritt: die Auswahl des Projekttyps. In diesem Fall müsst ihr euch zwischen dem Controller und Programmieren entscheiden.

Der Unterschied ist schnell erklärt. Bei Controller geht es um die Steuerung, beziehungsweise um die Steuerungsart eures Modells, um genau zu sein. Beispielsweise erfolgt auf dem linken Bild die Steuerung eines Fahrzeugs über das Steuerkreuz, auf dem rechten Bild über die beiden Schieberegler.

Auswahl verschiedener Steuerungsarten in der App von Powered Up

Habt ihr euch für die Steuerungsart entschieden, wechselt die Ansicht und ihr könnt fortfahren. Oben rechts wird neben dem Stopp-Icon auch das Programmier-Symbol angezeigt. Hier könnt ihr Anpassungen vornehmen und eurer Kreativität freien Lauf lassen.

Wählt ihr Programmieren, gelangt ihr direkt auf die Oberfläche mit einer Vielzahl von Befehlen und Funktionen zur Steuerung der verschiedenen Powered-Up-Komponenten. Wie diese programmiert werden können, erfahrt ihr im nächsten Kapitel.

Weitere Powered-Up-Apps

Neben der eben beschriebenen App gibt es noch drei weitere offizielle Programmier- und Steuerungs-Tools für eure Smartphones und Tablets, die zur großen Powered-Up-Familie gehören. Da wären die beiden BoostApps für programmierbare Roboter (2017) und Star-Wars-Droiden (2019) sowie die Technic-Control+-App (2019). Alle drei Apps sind vom Konzept her ähnlich aufgebaut und sind speziell auf die Anforderungen der jeweiligen Sets zugeschnitten.

Für Technik-Begeisterte dürfte insbesondere die Control+-App von Interesse sein. Hier stehen derzeit vier Kauf-Modelle zur Verfügung, die über die App gesteuert werden können.

Auf euch warten realitätsnahe Soundeffekte, eine möglichst authentische Steuerung, Rückmeldungen von Sensoren in Echtzeit (beispielsweise zum Neigungswinkel eures Geländewagen-Modells) und ein sogenannter Multifunktions-Steuerungsmodus via Touchscreen.

Eine Programmier-Funktion wie die Powered-Up-App hat die Control+-App aber bislang nicht. Sie wird hier aber auch nicht benötigt, denn sowohl die Motoren als auch der neue der neue Control+-Hub lassen sich seit dem letzten Update der Powered-Up-App problemlos ansteuern.

4
Programmierung

Damit solltest du sehr schnell in der Lage sein, erste eigene Programme zu schreiben oder deinen eigenen Controller zusammenzustellen. Probiere ruhig alles aus, kaputt gehen kann nichts … oder du kannst es zumindest schnell wieder zusammenstecken.

Aller Anfang ist leicht!

Der Start

Programmieren klingt kompliziert. Dabei ist es etwas, das wir alle tagtäglich machen. Und damit meine ich nicht nur, dass wir Geräten wie Waschmaschinen, Videorekordern und Smartphones Befehle erteilen. Mit mehr oder minder großem Erfolg versuche ich zum Beispiel meinem Sohn bestimmte Abläufe klar zu machen: erst Abendessen, dann Zähne putzen, dann Zimmer aufräumen und dann gibt es erst die Gute-Nacht-Geschichte im Bett. Würde das klappen, hätte ich ihn gut programmiert. Auch LEGO hat uns alle schon programmiert. Ist doch jede Bauanleitung nichts anderes als ein Programm, dem wir freudestrahlend folgen: Starte hier, nimm diese Steine, setze sie hier hin, drehe das Modell, öffne Tüte 2 … Denn nichts anderes ist Programmieren, als eine Liste mit einigen oder vielen aneinandergereihten Befehlen zu erstellen, die dann ein Computer nach strengen Regeln abarbeitet.

Bei Powered Up ist dieser Computer der Hub in Zusammenarbeit mit dem Smartphone. Und die Befehle werden hier nicht untereinandergeschrieben, sondern mit einigen Bildchen in eine Reihe hintereinander gesetzt. Das geschieht in der Powered-Up-App, wenn man nach dem Start oben rechts auf »Erschaffen« klickt. Ein roter Kreis mit einem weißen Kreuz darin wartet dort darauf, dass jemand das erste Programm erstellt.

Drückt man auf den roten Kreis, so darf man als Erstes dem Programm einen Namen geben. Danach hat man die Wahl, sich entweder seinen eigenen Controller zusammenzuklicken (links) oder frei zu »programmieren« (rechts).

Die Controller-Variante hat den Vorteil, dass dort für die Fernsteuerung von Powered-Up-Modellen schon einige erste Ideen und Vorgaben vorhanden sind und diese nur noch an die eigenen Wünsche angepasst werden müssen. Bei unserem Flugsimulator und dem Bahnübergang nutzen wir dieses.

Zunächst schauen wir uns jedoch das freie »Programmieren« (rechts) an. Drückt man auf diesen Button, so ist man mitten drin in der Programmieroberfläche.

Ein grüner Pfeil auf gelben Grund signalisiert, dass hier das Programm starten kann.

Du wirst im weiteren Verlauf des Buches sehen, dass ein Programm aus mehreren Befehlsketten bestehen kann, die parallel zueinander abgearbeitet werden können. Was das bedeutet, erklären wir dir gleich. Der Einfachheit halber reden wir zunächst nur von Programmen. Wenn es etwas komplizierter wird, dann werden wir dir auch die Befehlsketten erklären.

Übersicht

Alles beginnt mit dem grünen Pfeil. Er besagt: Hier geht das Programm los. Alles, was rechts davon angehängt wird, wird nacheinander abgearbeitet, bis entweder ein Stopp-Befehl kommt oder nichts mehr folgt. Wie bei einem virtuellen Puzzle werden die weiteren Befehle einfach von unten aus der Zeile mit dem Finger hochgezogen und an den vorherigen Befehl angelegt. Die App sorgt dafür, dass diese formschön zusammengezogen werden. Lässt man genügend Abstand, so kann man auch Befehle einfach so ablegen, um sie zum Beispiel für Tests bereitzulegen.

Wie beim Betrachten von Fotos auf dem Smartphone kann die Oberfläche durch Auseinanderziehen von zwei Fingern vergrößert werden oder durch Zusammenziehen wieder verkleinert werden.

Die Befehle sind unter verschiedenfarbigen Reitern unten links gruppiert. Beim Starten der Ebene ist die gelbe Gruppe aktiviert, wo sich die grundlegenden Befehle für die Steuerung des Programms befinden. Hier finden sich verschiedene Möglichkeiten: Programme zu starten, Programme pausieren zu lassen, Wiederholungen einzubauen (Schleifen), Entscheidungen abzufragen und das Programm zu beenden. Diese Befehle sind allesamt in der untersten Reihe zu finden. Gegebenenfalls passen nicht alle dort hin, sodass einige Befehle durch das Wischen in der Zeile nach links erst sichtbar werden.

Drückt man auf den orangen Reiter, kommen die Befehle rund um die Sensoren zum Vorschein. Sie steuern insbesondere den Umgang mit dem Farbsensor, dem Abstandssensor, den Neigungssensoren und der (Zug-)Fernbedienung. Sogar die Neigung des eigenen Smartphones kann in die Programmierung eingebunden werden. Das nutzen wir zum Beispiel bei dem Flugsimulator-Modell.

Beim grünen Reiter dreht sich im wahrsten Sinne des Wortes alles um die Motoren. In verschiedensten Varianten können diese angesteuert werden.

Unter dem türkisen Reiter findest du die Befehle zum Programmieren des eigenen Controllers. Die dort angezeigten Befehle unterscheiden sich je nach Art des Controllers.

Hinter dem lila Reiter verbergen sich Licht und Sound. Sowohl das externe Licht-Modul, als auch die LEDs der Hubs können angesteuert werden. Daneben finden sich zahlreiche Geräusche und Töne, die mit entsprechenden Symbolen gekennzeichnet sind. Der Sound kommt jedoch (bisher) ausschließlich aus dem Smartphone und (noch) nicht aus dem Hub. Das kann sich ändern, sollte LEGO irgendwann ein Sound-Modul herausbringen.

Hinter dem weißen Reiter verbergen sich Befehle, die schon etwas aufwändigere Programme ermöglichen. So können Variablen in »Kartons« abgelegt werden, um Daten über Programmteile hinweg auszutauschen. Es können mehrere Hubs verbunden werden. Und wichtig sind auch die Operatoren, die aussehen wie schwarze Kleiderbügel. Hierüber sind nicht nur Berechnungen möglich, sondern es können zum Beispiel Entscheidungen gefällt werden. So kann hierüber realisiert werden, dass ein Programm erst dann aktiv wird, wenn ein bestimmter Wert an einem Sensor erreicht wurde. Das schauen wir uns aber später noch ausführlich an.

Hinter dem grauen Reiter mit dem »+«-Zeichen verbirgt sich die Möglichkeit, Programme durch eigene Blöcke etwas eleganter und übersichtlicher zu gestalten. Aber auch dazu später mehr.

Steuerung

Unten rechts siehst du ein Feld mit drei Punkten übereinander. Wenn du darauf drückst, erscheinen ein paar weitere weiße Felder mit Symbolen. Diese können dir die Nutzung der Programmieroberfläche erleichtern.

Da wäre ganz rechts das Fragezeichen. Darüber kannst du ein paar Hinweise erhalten, was du da gerade auf der Bildschirmoberfläche siehst. Wenn du eine orangene Kugel anklickst, siehst du ein paar kurze Hinweise, was sich dahinter verbirgt. Wenn du davon genug hast, klicke einfach auf den Pfeil oben links.

Das Symbol mit den drei Kisten daneben ermöglicht dir, die Komplexität der Oberfläche zu steuern. Die Idee dabei ist, dass du am Anfang bei deinen ersten Versuchen mit der App nur wenige Befehle sehen kannst, um nicht verwirrt zu werden. Insgesamt drei Stufen kannst du dort einstellen. Für das Verständnis der folgenden Seiten in unserem Buch solltest du jedoch das untere Symbol mit den drei Kisten auswählen, sodass du alle Befehle sehen kannst. Solltest du beim weiteren Lesen mal einen Befehl nicht finden, dann sieh am besten hier nach, ob aus Versehen nur das Symbol mit den zwei Kisten bzw. das mit einer einzelnen Kiste ausgewählt ist. Es ist gut möglich, dass dein gesuchter Befehl deswegen nicht angezeigt wird.

Das Viereck daneben ist dafür da, dein Programm wieder auf dem Bildschirm zu zentrieren und so weit zu verkleinern, dass du alles wieder im Blick hast. Das ist sehr nützlich, wenn man mal die Übersicht verliert und nicht mehr genau weiß, wo oben und wo unten ist …

Wenn du dich beim Programmieren mal vertan hast, machst du mit dem gekrümmten Pfeil, der nach links zeigt, den letzten Schritt wieder rückgängig. Das klappt sogar mehrfach, wenn du öfters auf den Pfeil drückst. Hast du es dir zwischenzeitlich wieder anders überlegt, kannst du das Rückgängigmachen auch wieder Schritt für Schritt zurücknehmen. Dafür ist der gebogene Pfeil nach rechts gedacht.

Und schließlich kannst du mit dem Kreis ganz links, der zwei übereinander liegende Befehlssymbole hat, einen Befehl kopieren. Dazu drückst du einmal darauf, was den Kreis orange verfärbt. Dann drückst du auf deine Befehlskette. Alles, was rechts von dem Punkt ist, wo du hingedrückt hast, wird kopiert und steht für die weitere Verwendung zur Verfügung.

Das erste Programm

Starten wir mit unserem ersten kleinen Programm: tuten, Motor laufen lassen und fertig. Das klingt simpel und ist es auch. Den Anfang des Programms haben wir schließlich schon vor uns: den grünen Pfeil auf gelbem Grund. Nun soll als Nächstes ein Tuten ausgegeben werden. Dazu wählen wir den lila Reiter aus und können uns irgendetwas aus den Symbolen auswählen, die einen kleinen Lautsprecher in der linken unteren Ecke haben. Für ein Tuten ziehen wir das Symbol mit der Pfeife (es sieht aus wie ein Turm, aus dem Dampf ausgeblasen wird) direkt hinter unseren Pfeil. Damit erscheint unter dem Befehl eine Zahl. Auf die können wir drücken und dann eine der nun erscheinenden Zahlen auswählen. Wenn du auf die einzelnen Zahlen drückst, hörst Du, welches Pfeifen sich jeweils hinter dieser Zahl verbirgt. Damit haben wir unser Pfeifen, nun fehlt noch der Motor.

Die Motorbefehle finden wir unter dem grünen Reiter. Für den Anfang wählen wir das grüne Motorsymbol, um das ein gelber Pfeil gemalt ist und das zwei kleine Einbuchtungen unten drunter hat. Es hat zudem rechts unten einen Pfeil, der nach oben weist. Dieses Symbol ziehen wir hinter die Pfeife. Während wir bei der Pfeife eine Einstellung unter dem Befehl machen konnten, können wir hier zwei machen. Die erste Auswahl betrifft einen Buchstaben. Diesen finden wir auch auf dem Hub wieder. Er gibt an, an welchen Anschluss wir den Motor angeschlossen haben. Steckt dieser in der Buchse »A«, so wählen wir hier auch »A« an. Wählt man »AB« an, so werden sogar zwei Motoren in den Buchsen »A« und »B« angesteuert.

Der zweite Wert betrifft die Geschwindigkeit. Dabei ist »100« die höchste Geschwindigkeit und der Motor dreht nach rechts. Bei Minuszahlen dreht der Motor in die Gegenrichtung, also nach links. Die Geschwindigkeit kann man entweder durch Ziehen des kleinen Knopfes nach oben und unten einstellen, oder direkt als Zahl eingeben. Dazu drückt man auf den kleinen Knopf oben links vor der grauen Auswahlbox und die Eingabemöglichkeit wechselt.

Damit ist eigentlich unser erstes Programm fertig und wir können es ausprobieren. Wenn das Smartphone bzw. Tablet mit dem Hub verbunden ist, dann sieht man dies an einem kleinen grünen Pfeil an dem Bluetooth-Symbol (das aussieht wie ein seltsam eckiges »B«). Ist das noch nicht der Fall, dann muss man auf dieses »B« drücken und den Anweisungen auf dem Bildschirm folgen.

Steht die Verbindung und ist der Motor an der richtigen (also beim Motorbefehl ausgewählten) Buchse angeschlossen? Dann drück entweder auf den grünen Pfeil am Anfang des Programms oder den in der rechten oberen Ecke. Du solltest nun dein Pfeifen hören und danach startet der Motor. Und der Motor läuft und läuft und läuft … Solange, bis du oben rechts auf das rote Quadrat gedrückt hast (oder die Batterien alle sind).

Dass das Laufen des Motors so gewaltsam beendet wird, muss aber nicht sein. Man könnte stattdessen einen Programm-Ende-Befehl an das Ende des Programms ziehen. Mach das ruhig mal! Du findest den Befehl unter dem gelben Reiter ganz rechts. Es ist ein rotes Quadrat auf gelbem Grund. Schon die Form des Befehls zeigt, dass damit das Programm beendet wird. Mach es so und starte das Programm. Es pfeift, der Motor läuft, aber das Programm endet erstaunlicherweise sofort nach dem Start des Motors. Zum Glück können wir das auf verschiedene Arten ändern.

Eine Möglichkeit ist, den Sanduhr-Befehl (blaue Sanduhr auf gelbem Grund) hinter den Motor-Befehl zu ziehen. Dort können wir dann auswählen, wie viele Sekunden das Programm warten soll (und wie lange der Motor laufen soll), bis das Programm beendet wird¹. Eine Alternative ist, den Motorbefehl auszutauschen. Dazu ziehen wir den bisher genutzten Befehl einfach wieder nach unten über die Befehlsleiste, sodass er verschwindet. Stattdessen nehmen wir den Befehl daneben, der eine Einbuchtung (man nennt das auch »Argument«) neben einer kleinen Sanduhr hat. Bei diesem Befehl können wir wieder den Anschluss und die Geschwindigkeit auswählen. Hinzugekommen ist nun die Angabe der Zeit, wie lange der Motor laufen soll. Wählen wir hier z. B. die »5«, läuft der Motor ca. 5 Sekunden.

Herzlichen Glückwunsch zu Deinem ersten Programm! Spiele ruhig ein wenig mit den Befehlen herum! Du kannst nichts kaputt machen. Das Schlimmste, was passieren kann, ist, dass nichts passiert. Einige der Symbole erklären sich von selbst. Einige jedoch können dich noch etwas ratlos lassen. Deshalb schauen wir uns jetzt einige der besonderen Programmiertechniken an.

Besondere Befehle und Programmiertechniken

Bedingungen

Fragezeichen

Starten wir mit den Bedingungen oder auch »Wenn-Dann«-Befehlen. Das klingt trocken, aber hier passiert Spannendes. Denn Bedingungen sind auch Entscheidungen und damit kann dein Modell schon fast intelligent wirken.

Die Grundidee ist ganz einfach. Das Programm kommt irgendwann an eine Stelle, an der es nicht sofort weiterweiß. Dann muss es sich entscheiden. Ist zum Beispiel ein Knopf gedrückt worden oder hat sich etwas einem Sensor genähert, dann macht es das eine. Ist das nicht der Fall, dann macht das Programm etwas anderes (z. B. warten oder ein kleines Lied pfeifen …).

Eine Möglichkeit, das im Programm umzusetzen, ist der Befehl mit dem großen blauen Fragezeichen und den beiden Pfeilen, die davon abgehen. Zieh ihn mal in dein Programm! Du siehst nun rechts von dem Fragezeichen zwei Felder, in die du weitere Befehle hineinziehen kannst. Du ahnst es wahrscheinlich schon: In einem Fall werden die oberen Befehle ausgeführt, im anderen Fall die unteren. Doch was verursacht diese Entscheidung? Aktuell kann man unter dem Fragezeichen entweder ein »x« oder einen Haken einstellen. Steht dort der Haken, dann werden die oberen Befehle ausgeführt. Wählt man das »x«, kommen die unteren Befehle an die Reihe. So allerdings ist diese Konstruktion ziemlich sinnlos. Schließlich könnte man sich beim Programmieren von vornherein für den oberen oder unteren Teil entscheiden, da muss man es nicht so unnötig kompliziert machen. Und intelligent ist es erst recht nicht.

Deshalb ersetzen wir den Teil unter dem Fragezeichen durch etwas anderes. Dir ist vielleicht schon aufgefallen, dass es insbesondere unter dem weißen Reiter (aber nicht nur) Befehle gibt, die am oberen Rand eine Kerbe haben. Diese sind nicht zu verwechseln mit denen, die dort einen kleinen runden Bogen haben. Aber zu denen kommen wir später. Erst einmal interessieren uns nur die spitzen Kerben. Das sind nämlich unsere Entscheidungshilfen, die irgendetwas vergleichen oder auf sonstige Art eine Entscheidung vorbereiten.

Nehmen wir zum Beispiel den schwarzen Befehl mit dem Gleichheitszeichen zwischen den Lücken. Zieh ihn einfach dahin, wo auch der Fragezeichen-Befehl die passende Einkerbung aufweist. Und schon steht da: 0 = 0. Das ist jetzt nicht überraschend, hilft uns dennoch erst einmal nicht weiter. Aber nach dem Eckigen kommt nun das Runde.

Um das zu verstehen, öffnen wir die Sensoren-Befehle. Unser Ziel ist, dass etwas passieren soll, wenn sich ein Gegenstand auf eine mittlere Entfernung dem Abstandssensor genähert hat. Deshalb greifen wir uns den kleinen Befehl mit dem Abstandssensor (Sensor mit Hand davor), der oben einen Bogen nach außen hat. Den ziehen wir vor das Gleichheitszeichen. Darunter müssen wir noch auswählen, an welchem Anschluss der Sensor angeschlossen ist. Damit haben wir nun etwas, das uns den aktuellen Wert des Sensors nutzbar macht. Rechts von dem Gleichheitszeichen tragen wir nun den Wert ein, auf den der Sensor reagieren soll (z. B. 5). Dieser Befehl prüft, ob sich ein Gegenstand mindestens in einer bestimmten Entfernung zum Sensor befindet. Wenn das so ist, dann werden die Befehle nach dem Haken-Symbol ausgeführt, andernfalls die Befehle hinter dem x. Zum Testen könnten wir einfach verschiedene Töne abspielen lassen.

Probiere es aus! Aber … irgendwie wird immer nur der Ton-Befehl hinter dem »x« ausgeführt? Das ist ganz einfach zu erklären: Der Befehl hinter dem Haken (was bedeutet, dass das unter dem Fragezeichen »erfüllt« ist) würde ja nur abgespielt werden, wenn sich genau in dem Moment, in dem der Fragezeichen-Befehl ausgeführt wird, etwas in exakt dieser Entfernung zum Sensor befindet. Das ist sehr unwahrscheinlich und beim Ausprobieren auch ein kleines Geduldsspiel.

Interessanter wird es schon, wenn wir nicht den schwarzen Befehl mit dem Gleichheitszeichen nehmen, sondern den mit dem Größer- oder Kleinerzeichen. Dann wäre der Bereich, in dem sich das Hindernis befindet, schon größer. Beim Bahnübergang nutzen wir diese Bedingungsblock auch, dort jedoch mit einer Variablen als Auslöser. Wir kommen aber später noch dazu, was das bedeutet.

Viel wahrscheinlicher ist es, dass man möchte, dass das Programm wartet, bis etwas passiert und dann, wenn es endlich passiert ist (z. B. die Hand endlich ganz nah am Sensor ist), mit dem gewünschten Befehl fortsetzt. Das können wir kompliziert mit z. B. einer Schleife machen (kommt später), oder ganz einfach. Doch dafür brauchen wir den Fragezeichenbefehl nicht mehr und wir müssen uns etwas anderem zuwenden.

Abwarten und Befehle ausführen

Wie du vielleicht schon gesehen hast, gibt es nicht nur den grünen Pfeil auf gelbem Grund, um den Anfang eines Programms zu bilden. Insbesondere unter dem gelben und dem orangenen Reiter befinden sich noch mehr Befehle. Sie haben an der linken Seite eine Rundung. Diese Befehle sind alle dafür da, ein Programm zu starten. Während der bisher von uns verwendete einfache grüne Pfeil das immer macht, wenn man auf ihn drückt (oder oben rechts den Pfeil betätigt), brauchen alle anderen Startbefehle noch eine besondere Bedingung, die hierfür eingetreten sein muss.

Da wäre etwa der grüne Pfeil-Befehl, der unten noch eine kleine Kerbe hat. Du ahnst es sicherlich schon: Das ist das gleiche Prinzip, das wir schon bei der Einkerbung vom Fragezeichen kennengelernt haben. Auch hier können wir zum Beispiel einen von den Befehlen unter dem schwarzen Reiter mit den Vergleichen heranschieben. Das bedeutet, dass das Programm startet, sobald diese Bedingung erfüllt ist. Nehmen wir wieder unser Beispiel von oben: Das Programm startet, wenn der Sensor etwas in der Entfernung »5« feststellt (wenn links der Sensorbefehl und rechts neben dem »=« die »5« eingetragen wird). Wenn das (noch) nicht der Fall ist, dann passiert einfach gar nichts. Das Programm wartet so lange, bis genau diese Bedingung eingetreten ist.

Daneben gibt es noch einen sehr ähnlichen Befehl, bei dem noch eine Art Blitz in den grünen Pfeil gezeichnet ist. Dieser Befehl ist etwas knifflig. Im Prinzip startet auch hier das Programm, wenn die Bedingung unter der Einkerbung eingetreten ist. Allerdings passiert das nur, wenn vorher mal NICHT diese Bedingung eingetreten war. Das bedeutet, dass das Programm in unserem Beispiel nicht starten würde, wenn schon gleich am Anfang etwas in der Mindestentfernung 5 vor dem Sensor ist. Erst wenn kurz mal etwas nicht da war und dann wiederkommt, dann startet das Programm. Klingt sinnlos? Ja, für dieses Beispiel stimmt das. Aber für eine Motorsteuerung kann das nützlich sein, z. B. wenn man möchte, dass zunächst ein Schalter oder Sensor komplett auf Anfang gestellt wird und es erst dann losgehen kann.

Bei der grünen Flagge wird es auch etwas kompliziert. Für sich allein funktioniert diese nämlich nicht. Es muss irgendwo vorher mal die andere (oder zweite?) grüne Flagge eingebunden sein, die bei der Befehlsdarstellung direkt rechts daneben ist. Mehr dazu schauen wir uns in dem Abschnitt »Programme parallel laufen lassen« auf Seite 44 an.

Anstatt umständlich mit den schwarzen Vergleichsbefehlen zu arbeiten, die man extra an andere Befehle andocken muss, kann man unter dem orangen Reiter auch gleich die Befehle nehmen, die auf eine Reaktion eines Sensors warten. Drei Startbefehle gibt es da: einen für den Farbsensor (mit der rot-grün-blauen Blume), einen für den Abstandssensor (mit der kleinen Hand) und einen für die Neigung des Hubs (mit dem Doppelpfeil).

Die ersten beiden funktionieren sehr ähnlich. An erster Stelle muss man einstellen, an welchem Anschluss der Sensor am Hub angeschlossen ist. Der zweite Eintrag bestimmt, auf was das Programm warten soll, damit es starten kann. Beim Farbsensor ist es eine Farbe, beim Abstandssensor ein Wert für den Abstand vom Sensor zwischen 0 und 10. Wobei es beim Abstandssensor nicht auf den genauen Wert ankommt, sondern das Programm startet immer, wenn der Abstand kleiner als der eingestellte Wert ist.

Der Befehl, der auf eine bestimmte Ausrichtung bzw. Neigung des Sensors wartet, kann nur mit Sensoren eingesetzt werden, die dies auch unterstützen. Das ist z. B. beim Boost Hub der Fall. Beim ersten Teil des Befehls kann aktuell nichts eingestellt werden, außer die Bestätigung, dass der Hub Strom braucht, um zu funktionieren. In der zweiten Einstellung wählt man die Neigung des Hubs aus, der das Programm starten soll.

Eine Besonderheit sind die beiden Motorbefehle unter dem grünen Reiter, die den Bogen sowohl links als auch rechts haben. Das sind einzelne Befehle, die für sich ein ganzes abgeschlossenes Programm darstellen. Werden sie (mit) gestartet, indem oben rechts auf den grünen Pfeil gedrückt wird, so laufen sie einfach los und stoppen erst, wenn irgendwoher ein Stoppbefehl kommt (entweder durch den Nutzer durch Drücken auf das rote Viereck oder den ebenso aussehenden Endbefehl). Eine Bedingung ist hier also nicht erforderlich, aber der Vollständigkeit halber seien sie hier auch erwähnt. Der eine der beiden Befehle (bei dem zwei Pfeile auf eine rote Linie zeigen), kann dazu genutzt werden, einen passenden Motor um einen entsprechend eingestellten Grad zu drehen. Der andere (mit dem umspannenden Pfeil), lässt den ausgewählten Motor konstant mit der eingestellten Geschwindigkeit laufen.

Apropos Laufen lassen: Kommen wir nun zu den Schleifen.

Schleifen

Geht es darum, Programmteile immer und immer wieder zu wiederholen, dann sind die Schleifen das Mittel der Wahl. Mit ihnen kann zum Beispiel ein Blinklicht realisiert werden oder die dauerhafte Steuerung der Motoren beim Flugsimulator. Die Schleifenbefehle erkennt man unter den gelben Reitern an den beiden blauen Pfeilen, die gemeinsam einen Kreis bilden.

Der erste Befehl davon (ohne Fragezeichen) ist sehr einfach gestaltet. Den einzigen Wert, den man hier angeben kann, ist die Anzahl der Wiederholungen. Was wiederholt werden soll, das kommt in das große Feld neben den Pfeilen. Da kann auch nicht nur ein Befehl hinein, auch lange Befehlsketten sind möglich. Das Feld weitet sich dann automatisch aus. Wenn die Anzahl der Durchgänge abgearbeitet wurde, wird das Programm mit dem Befehl nach der Schleife fortgesetzt, als wäre nichts passiert …

Der zweite Schleifenbefehl (mit dem Fragezeichen am Kreis der Pfeile) bringt noch eine Bedingung mit ins Spiel. Die eingefügten Befehle werden hier so lange immer wieder ausgeführt, bis die Bedingung darunter eingetreten ist. Nehmen wir wieder einen der schwarzen Vergleichsbefehle (die mit dem Dreieck obendrauf) und schieben ihn hier an passender Stelle hinein. Das könnte z. B. der Vergleich sein, ob ein Sensor die Farbe Rot sieht. Solange dies der Fall ist, werden die Befehle immer wieder aufs Neue ausgeführt. Stimmt dieser Vergleich plötzlich nicht mehr (er ist »falsch«), so endet die Schleife und das Programm läuft mit dem Befehl dahinter weiter. Wer es simpel mag: Trägt man etwa die Bedingung »0 = 0« ein (was richtig wäre), würde die Schleife ohne Unterlass durchlaufen. Stünde da »0 = 1«, würde die Schleife gar nicht erst einsetzen.

Apropos »ohne Unterlass«: Der dritte Schleifenbefehl macht genau das. Hier kann nichts weiter eingestellt werden als die Befehle, die ständig aufs Neue abgearbeitet werden sollen. Ein Ende würde diese Schleife erst finden, wenn sich der Nutzer erbarmt, den Stopp-Knopf zu drücken, oder irgendwo in dem Programm der Befehl mit dem roten Quadrat an die Reihe kommt.

Programme parallel laufen lassen

Ein großer Vorteil von Powered Up ist, dass nunmehr mehrere Aktionen gleichzeitig ablaufen können. Das alte Power Functions war nicht nur in der LEGO-Variante nicht so einfach programmierbar, es erlaubte auch nicht, dass z. B. mehrere Motoren gleichzeitig liefen. So etwas wie der Liebherr Bagger R 9800 aus der LEGO-Technic-Reihe (Set 42100), bei dem durch Control+ bis zu sieben Motoren koordiniert gleichzeitig arbeiten können, wäre mit der alten Technik nicht denkbar gewesen.

Das Programmieren von gleichzeitig ablaufenden Programmteilen (ab jetzt Befehlsketten genannt) ist denkbar einfach: Man legt einfach mehrere Befehlsketten nebeneinander oder untereinander auf der Oberfläche an. Jede Befehlskette kann individuell gestaltet werden, und wenn man dann oben rechts auf den grünen Pfeil drückt, starten auch alle Befehlsketten des Programms zur selben Zeit. Bei unserem Modell vom Tresor machen wir ausgiebig Gebrauch von unterschiedlichen Befehlsketten.

Sollen nur zwei Motoren an einem Hub gleichzeitig und synchron gedreht werden, müssen nicht extra mehrere Befehlsketten programmiert werden. So kann man bei den Motorbefehlen auch auswählen, dass z. B. sowohl Port A und B oder C und D angesprochen werden, an denen dann z. B. die Motoren für die Vorder- und Hinterachse hängen. Dies nützt jedoch dann nichts mehr, wenn Verschiedenes gleichzeitig geschehen soll. So könnte eine Befehlskette für die Bewegung des Modells zuständig sein und eine andere daneben für das Reagieren auf Sensoren. Die Möglichkeiten sind unendlich, allerdings kann es dann auch schnell etwas unübersichtlich werden. Dafür gibt es jedoch Lösungen, auf die wir aber erst später eingehen.

Möchte man zwei Befehlsketten zur gleichen Zeit parallel ablaufen lassen, dann kann man auch den Befehl nutzen, bei dem zwei blaue Pfeile aus einem einzelnen Strich erwachsen.

Hier kann man in den oberen und unteren Teil eigene Befehlsketten hineinziehen, die dann parallel ablaufen. Wie das funktioniert, siehst du z. B. bei den Modellen vom Bahnübergang und vom Flugsimulator.

Was man auch oft braucht ist, dass die parallel ablaufenden Befehlsketten Daten austauschen können oder zumindest Einfluss auf den Ablauf des jeweils anderen nehmen können. Das geht! Zum einen können Variablen zum Datenaustausch eingesetzt werden (dazu im folgenden Kapitel mehr), zum anderen können Signale an einzelne oder alle Befehlsketten übermittelt werden. Einen derartigen Befehl kennst du schon: das rote Quadrat auf gelbem Grund. Wenn eine der Befehlsketten auf diesen Endebefehl stößt, dann werden alle Befehlsketten des Programms sofort beendet, ungeachtet dessen, was sie gerade machen.

Interessante Möglichkeiten eröffnet auch die grüne Flagge unter dem gelben Reiter. Davon gibt es zwei und sie ergeben vor allem im Zusammenspiel Sinn.

Zum einen ist da der Startbefehl mit der grünen Flagge (der mit dem Rundbogen auf der linken Seite). Der wartet auf ein Signal, damit er starten kann. Dieses Signal ist zunächst nur eine Zahl, die man hier einstellen kann. Doch wer sendet dieses Signal bzw. die Zahl, damit der Befehl sein Go bekommt?

Hier kommt der andere Befehl mit der grünen Flagge als Sprungmarke ins Spiel. Den kann man irgendwo in einer seiner Befehlsketten einbinden. Auch hier kann eine Zahl eingestellt werden, die der Zahl bei dem Startbefehl entsprechen sollte. Stößt das Programm auf diese Flagge, so hisst der Befehl quasi diese Flagge mit dieser Zahl und alle anderen unserer Befehlsketten können das sehen. So auch unser noch immer vor sich hin wartender Startbefehl. Wenn er nun die bei uns eingestellte Zahl sieht, dann rennt er los … bzw. startet seine Befehlskette.

Wer möchte, kann damit recht komplexe Programme realisieren, bei denen mehrere Flaggen mit unterschiedlichen Nummern genutzt werden, die dann wiederum zum rechten Zeitpunkt neue Befehlsketten starten. Das kann auch mit Bedingungen und Schleifen verbunden werden. Also viele Möglichkeiten, aber auch die Herausforderung, da dann noch den Überblick zu bewahren. Den Einsatz dieser Sprungmarken kannst du z. B. bei unserem Tresor-Modell sehen.

Variablen

Mit den bisher gezeigten Befehlen lässt sich schon sehr viel machen. Doch jetzt wird es variabel.

Variablen sind Platzhalter für irgendwelche Werte. Man kann sich das wie eine Schublade vorstellen, in die man irgendwo im Programm etwas hineintut. An einer anderen Stelle im Programm guckt ein Befehl in diese Schublade und holt es wieder heraus und verwendet es weiter.

So könnte etwa in einer Befehlskette ein Befehl das Ergebnis des Farbsensors in diese Schublade packen. Eine andere Befehlskette des Programms holt diesen Farbwert heraus und macht damit etwas (z. B. einen Motor bei Rot stoppen oder bei Grün starten).

Die Einbuchtungen

Bevor wir uns die Variablen genauer ansehen, müssen wir dir noch eine Besonderheit bei der Nutzung von Befehlen in Powered Up erklären. Dir ist sicherlich aufgefallen, dass bei den meisten Befehlen die Einstellung eines Wertes (z. B. der Geschwindigkeit eines Motors) unterhalb einer runden Einbuchtung erfolgt. Gleichzeitig gibt es kleine Befehle, die eine passende Ausbuchtung am oberen Rand haben (sie werden »Reporter-Block« genannt). Tatsächlich kann man diese Befehle miteinander verbinden. Schiebt man die Ausbuchtung in die Einbuchtung, dann steht da plötzlich nicht mehr der eingestellte Wert (etwa die Geschwindigkeit des Motors). Diesen ersetzt nun der kleine Zusatzbefehl.

Besonders gut kann man das bei den Sensoren sehen. Jeder Sensor hat einen solchen kleinen Zusatzbefehl. Zum Beispiel der Abstandssensor. Dieser Zusatzbefehl gibt dann seinen Wert (hier also etwa den gerade gemessenen Abstand) an den »größeren« Befehl weiter, an dem er angedockt ist. Würde also der kleine Abstandssensorbefehl an den Motorbefehl bei der Geschwindigkeit angedockt werden, würde dieser größere Werte liefern, je weiter z. B. meine Hand von dem Sensor entfernt ist. Das würde dazu führen, dass auch der Motor entsprechend schneller läuft, da der Motorbefehl genau diesen Wert des Sensors automatisch als seinen Geschwindigkeitswert übernehmen würde.

Aber es kann sogar noch komplizierter gemacht werden: Diese kleinen Befehle haben in der Regel wiederum kleine Einbuchtungen am unteren Ende, wo wiederum ein anderer kleiner Befehl seinen Wert übergeben kann. Damit kann das Programm ziemlich komplex werden. Das Gute ist aber, dass du nichts kaputt machen kannst (wenn du nicht gerade dein Modell aus Versehen über die Tischkante fahren lässt).

Interessant ist, dass diese Reporter-Blocks schon vor dem Andocken den aktuellen Wert zeigen, den sie an den Befehl weitergeben würden. Dazu muss man diesen Block nur einzeln auf die Programmieroberfläche legen und dann wird der Wert klein über der Ausbuchtung angezeigt. So kann z. B. auch ein Sensor getestet werden.

Ein interessanter derartiger Block befindet sich unter dem weißen Reiter und zeigt in der Mitte zwei Würfel. Damit kann eine Zufallszahl an den angedockten Befehl weitergegeben werden. Einstellen kann man dabei, zwischen welchen Zahlen die ausgeworfene Zufallszahl sein soll (z. B. zwischen 1 und 10). Das ist interessant, wenn man z. B. ein kleines Spiel programmieren möchte, bei dem nicht alles vorhersehbar ist.

Du hast sicherlich auch schon gesehen, was der Unterschied zwischen den runden und den dreieckigen Ein- bzw. Ausbuchtungen ist. Die Befehle mit den runden Ausbuchtungen liefern verschiedene Zahlen zurück wie den Wert eines Sensors oder eine Zufallszahl. Die Befehle mit der Spitze treiben sozusagen das Ergebnis »auf die Spitze« und liefern einen sogenannten »logischen Wert«. Das ist nicht eine bestimmte Zahl, sondern hopp oder topp (wir haben das bereits bei den Entscheidungen und dem Fragezeichenbefehl besprochen): Ein Wert ist z. B. größer als ein anderer oder nicht. Ein bisschen größer gibt es hier nicht. Merke dir also: rund = gleich viele mögliche Werte, spitz = gleich hopp oder topp.

Übrigens können sich einige der Powered-Up-Motoren nicht nur bewegen, sondern auch Bewegungen bzw. Drehungen erkennen und somit als Sensor fungieren. Das machen wir uns beim Tresor zu Nutze, bei dem die Drehungen per Hand an dem Rad als Wert eingestellt und an das Programm weitergegeben werden.

Jetzt endlich die Variablen

Jetzt kommen wir endlich tatsächlich zu den Variablen. Die Befehle dazu findest du unter dem weißen Reiter.

Sie sehen aus wie Pappkartons und dieses Bild passt auch ganz gut. Schließlich sollen Daten hineingepackt und wieder herausgeholt werden. Der große Befehl dient zum Reinpacken der Information, der kleine Befehl zum Rausholen. Dabei gibt es Kartons mit Weltkugel und ohne.

Die Kartons mit Weltkugel funktionieren über alle Programmteile und Befehlsketten hinweg. Diese »globalen« Variablen kannst du nutzen, um Daten auch zwischen allen Blocks und Befehlsketten auszutauschen, egal wo sie in deinem Programm anfallen und wo sie gebraucht werden.

Die Kartons ohne Weltkugel hingegen nützen nur etwas innerhalb eines eigenen Blocks oder innerhalb des Hauptprogramms. Andere parallele Programmteile mit anderen Befehlsketten sehen von diesen Kartons (bzw. Variablen) nichts.

Der große Befehl weist einer Kiste (der Variablen) einen Inhalt (also einen Wert bzw. eine Zahl) zu. Damit diese Kiste später wiedergefunden werden kann, muss sie einen Namen haben. Das ist die erste Einstellung des Befehls. Das kann ein Buchstabe oder auch ein anderes Zeichen sein. Rechts davon trägt man den Wert ein, den die Variable haben soll (also die Zahl, die wir in die Kiste für später packen). Somit könnte man der Variablen »a« den Wert »44« zuweisen. Kommt an anderer Stelle im Programm dann der kleine Befehl vor, der irgendwo an einen anderen Befehl angedockt ist, und dieser Befehl mit der kleinen Kiste hat den gleichen Buchstaben (hier also das »a«), so verwendet der angedockte Befehl das, was es in der Variablen/Kiste findet, also in unserem Beispiel die »44«.

Das klingt zunächst kompliziert und sinnlos. Schließlich könnte man statt des ganzen Aufwands mit der Variablen bzw. den Kisten auch einfach gleich die Zahl »44« bei dem auslesenden Befehl eintragen. Richtig! Aber in der Regel wird man gerade keine feste Zahl in die Variable bzw. Kiste packen. Du siehst dort ja, dass das auch eine Einbuchtung ist. Dort wird man also in der Regel z. B. einen der kleinen Sensorbefehle anfügen, der dann einen gemessenen Wert der Variablen übergibt. Auch bei diesem Beispiel wirst du sagen, dass man dann doch den kleinen Sensorbefehl gleich ohne Umwege über Variablen einsetzen könnte. Spannend wird es jedoch, wenn etwa dieser Wert mehrfach genutzt wird, z. B. in unterschiedlichen Befehlsketten. Auch kann die Nutzung einer Variablen sinnvoll sein, wenn nicht nur der aktuelle Wert eines Sensors genutzt werden soll, sondern auch vorherige Werte, die dann in Variablen gespeichert wurden. Beim Flugsimulator nutzen wir die Variablen, um einfach mit Werten zu experimentieren und Änderungen vorzunehmen. Und bei dem Bahnübergang signalisieren wir über bestimmte Werte in einer Variablen, dass der Zug am Bahnübergang angekommen ist.

Mit den Einträgen in den Variablen kann sogar gerechnet werden. Diese Rechenfunktionen findest du unter dem weißen Reiter. Es sind die schwarzen Blöcke mit den runden Ausbuchtungen, die in der Mitte Rechenzeichen haben. Nimmst du z. B. den Block mit dem »+«-Zeichen für Addieren, so kannst du zwar links und rechts Zahlen eintragen – doch das wäre langweilig. Interessanter ist es, einen oder beide Werte durch Variablen oder einen anderen Block (etwa einem Sensorwert) zu ersetzen. So könntest du etwa den Wert eines Sensors mit dem »x«-Block verzehnfachen, um so einen höheren Wert etwa für die Geschwindigkeit eines Motors an den entsprechenden Befehl zu übergeben. Auch beim Flugsimulator rechnen wir so die Ausgaben des Kippsensors um in sinnvolle Geschwindigkeitswerte.

Wie du siehst, gibt es mehrere Rechenbefehle. Wenn dir nicht ganz klar ist, was diese machen, dann probiere sie einfach aus. Wie oben beschrieben, kannst du jeweils einen Rechenbefehl einzeln auf die Programmieroberfläche ziehen und dann jeweils das Ergebnis der Rechnung oberhalb des Blocks ablesen. Bei unserem Modell vom Tresor nutzen wir z. B. die Funktion »Mudolo« bzw. »mod«, bei der eine Zahl von der anderen abgezogen wird und nur der Rest als Wert an das Programm weitergegeben wird.

Eigene Blöcke

Kommen wir schließlich noch zum letzten Reiter, dem grauen mit dem Pluszeichen. Hiermit kannst du eigene Blöcke (auch »Routinen«, »Module« oder »Blocksequenzen« genannt) erstellen. Damit ergeben sich keine neuen Funktionen für deine Programme. Aber sie können helfen, umfangreiche Programme etwas übersichtlicher zu gestalten. Unsere Modelle im hinteren Teil des Buches machen ausgiebig davon Gebrauch.

Drückst du nach Auswahl dieses Reiters auf das weiße Pluszeichen unten links, so erscheint ein Symbol daneben. Dieses kannst du anwählen und es öffnet sich ein kleines Fenster ohne Inhalt. Jetzt hast du mehrere Möglichkeiten.

Zum einen kannst du Befehle aus deinem Hauptprogramm einfach hier hinziehen. Oder du kannst nochmal auf dieses Fenster klicken und plötzlich sieht es so aus, als wenn du ganz von vorne wieder mit deinem Programm beginnen würdest. Das stimmt auch, allerdings schreibst du hierin ein Unterprogramm. Das bedeutet, du baust dir aus den schon bekannten Befehlen einen eigenen neuen Befehl. Du kannst diesem Befehl sogar eigene Felder zum Andocken von anderen Befehlen geben. Dafür stehen neue blaue Kästchen mit Zahlen darin zur Verfügung. Zieh sie einfach mal in deinen eigenen Block bzw. das Unterprogramm und drücke dann auf den Pfeil oben links. Damit gehst du aus der Programmierung dieses eigenen Blocks heraus und siehst, wie sich das Symbol gewandelt hat und nun dazu bereit ist, mit anderen Programmen zusammen zu arbeiten.

Stell dir diese eigenen Blöcke wie kleine Maschinen vor, die du vorab selbst zusammenbastelst. Wenn du sie fertig hast, kannst du sie wie jeden anderen Befehl einfach in dein Programm einfügen. Dann kann es aussehen, als würde dein Programm nur aus ganz wenigen Befehlen bestehen. In Wirklichkeit hast du aber komplexe Ideen in diese eigenen Blöcke geschrieben.

Natürlich kannst du statt der eigenen Blöcke auch einfach den darin befindlichen Programmcode in dein Programm schreiben. Aber wenn du mehrfach dasselbe machen willst, machen diese eigenen Blöcke das Programm besser lesbar und es ist eleganter.

Das Symbol deines eigenen Blocks kannst du durch Klick auf das Symbol oben in der Mitte des Bildschirms einstellen. Durch Klick auf das angehängte Schraubenschlüsselsymbol beeinflusst du zusätzlich die Farbe und die Art des Befehls. So kannst du insbesondere auch festlegen, ob es sich um einen Start-Befehl, einen normalen Programmierbefehl oder einen Reporter-Block handeln soll.

Mehrere Hubs ansteuern

Du kannst bis zu vier Hubs mit deinem Programm gleichzeitig steuern. Dies ist z. B. bei unserem Bahnübergang notwendig, da sich dort ein Hub im Zug und einer im Bahnwärterhäuschen befindet. Dabei können sogar verschiedene Arten von Hubs zusammen arbeiten (also etwa der Hub mit den zwei Anschlüssen als auch der Technic Hub mit den vier Anschlüssen).

Dazu wird der kleine Befehl bzw. »Reporter-Block« unter dem weißen Reiter benötigt, auf dem zwei Hubs abgebildet sind. Diesen kann man z. B. beim Motor an die Einbuchtung andocken, wo normalerweise der Port ausgewählt wird, an dem der Motor am Hub angeschlossen ist.

Links von diesem Hub-Reporter-Block wählen wir den Hub aus, der z. B. den Motor steuern soll. Das ist eine Zahl zwischen 1 und 4, passend zu den vier Hubs, die wir ansteuern können. Doch woher weiß ich, welcher Hub welche Nummer hat?

Dazu musst du die Hubs zunächst einmal mit dem Smartphone bzw. Tablet verbinden, das du zum Programmieren gerade nutzt. Das funktioniert, wie wir ganz am Anfang schon gesehen haben, über das Bluetooth-Symbol oben links: Darauf klicken und dann den ersten Hub durch Drücken auf dessen Knopf einschalten. Er wird dann mit dem Smartphone oder Handy verbunden. Drückt man nochmal auf das Bluetooth-Symbol, sollte der erste Hub nun grün erscheinen und auch einen Namen haben. Diesen Namen kannst du auch mit Klick auf das Bleistiftsymbol ändern, um die Hubs ggf. besser unterscheiden zu können. Nun schaltest du auch den zweiten Hub ein, der dann auch wieder verbunden wird. Gegebenenfalls musst du dabei einmal auf das Feld drücken, das beim Verbinden unterhalb des schon verbundenen Hubs erscheint. Interessant ist nun, dass links von den Einträgen Zahlen stehen. Das sind die Nummern, die wir bei dem Befehl in der Hub-Auswahl eintragen. Tragen wir dort die »1« ein, so wird der 1. Hub angesprochen und so weiter.

Je nach Ausstattung kannst du nun noch bis zu vier Hubs so anmelden und dann in deinem Programm auswählen. Bei der Auswahl rechts stellst du dann den Anschluss ein, der an dem Hub angesprochen werden soll, so wie du es schon vom Anfang kennst. Zur Erinnerung: Den Buchstaben findest du jeweils bei den Anschlüssen auf dem Hub aufgedruckt. Stellst du also bei dem Hub-Befehl »2« und »B« ein, so wird der Motor (oder Sensor, oder …) an Anschluss »B« von Hub »02« angesprochen.

Ein kleines Problem gibt es leider noch bei der Nutzung mehrerer Hubs. Die Powered-Up-App merkt sich nicht, in welcher Reihenfolge die Hubs von dir im Programm genutzt werden. Das bedeutet, wenn du beim nächsten Mal die Powered-Up-App neu startest und die Hubs in einer anderen Reihenfolge nacheinander anmeldest, so ist dann auch die Zuordnung der Zahlen zu den Hubs anders. Was vorher Hub »01« war, könnte dann Hub »03« sein und damit würde das Programm den falschen Hub ansprechen.

Das Problem lässt sich jedoch leicht beheben. Wenn du bei der Auflistung der Hubs unter dem Bluetooth-Zeichen die Reihenfolge der Hubs ändern möchtest, dann musst du mit dem Finger auf die drei waagerechten Striche an der jeweiligen rechte Seite des Eintrags drücken und sie gedrückt halten. So kannst du den Eintrag nach oben oder unten schieben und deine alte Reihenfolge wiederherstellen. Der oberste Eintrag hat dabei immer den Wert 01 und so weiter. Um dir zu merken, welche Reihenfolge die Hubs haben müssen, kannst du sie entsprechend mit dem Bleistift-Symbol betiteln. Diesen Namen merkt der Hub sich und er wird auch beim nächsten Start wieder angezeigt. So könntest du sie einfach mit »01«, »02«, »03« und »04« benennen.

Wenn du einen Hub in der Liste löschen willst, so kannst du einfach seinen Eintrag nach links wischen und dann auf das »x« drücken. Und wenn du sicher gehen willst, dass die Anzeige aktuell ist, ziehst du sie nach unten und die App aktualisiert alles. So hast du auch stets im Blick, ob bei einem der Hubs die Batterien schwach werden.

Übersicht über die Befehle

Damit kennst du nun die grundlegenden Befehle und Programmiertechniken von Powered Up. Es gibt noch viele weitere Befehle, wie du sicherlich bei der Durchsicht der Reiter gesehen hast. Insbesondere bei den Motorbefehlen gibt es zahlreiche Varianten und Möglichkeiten. Damit du den Überblick behältst, haben wir in diesem Kapitel Tabellen mit Kurzbeschreibungen aller Befehle aufgeführt. Wenn dir dabei noch etwas unklar ist, dann probiere es einfach aus. Du kannst nichts kaputt machen – außer dein Modell fährt unkontrolliert über den Balkon und fällt aus dem 5. Stock. Aber dass man beim Ausprobieren auf dem Balkon im 5. Stock etwas vorsichtiger sein sollte als im Wohnzimmer, das war dir wahrscheinlich auch schon vorher klar.

Insbesondere bei den Hubs und Motoren gibt es einige Unterschiede bei der Ausstattung. So können z. B. die einfachen Hubs mit zwei Anschlüssen nicht ihre Neigung übermitteln und nicht alle Motoren können genaue Winkel einstellen.

Gelb: Ablaufblöcke

Die Ablaufblöcke sind die Grundfunktionen für die Programmierung. Irgendetwas hiervon braucht jedes Programm.

Der einfache Startbefehl. Praktisch und (fast) unverzichtbar. Einmal Drücken und das Programm startet.

Die Befehlskette startet erst, wenn eine Bedingung erfüllt ist, die unten rangeschoben wird.

Die Befehlskette startet, wenn sich die Bedingung von »nicht-erfüllt« in »erfüllt« ändert.

Die Befehlsfolge wird gestartet, sobald der andere Befehl mit der Fahne sie auslöst.

Dieser Befehl startet andere Befehlsfolgen, die mit dem oberen Fahnensymbol beginnen.

Wartet so viele Sekunden, wie eingestellt wurde (maximal 9999).

Wartet bis die angedockte Bedingung erfüllt ist.

Die eingefügten Befehle werden so oft wiederholt, wie es eingestellt wurde (oder der angedockte Befehl vorgibt).

Die eingefügten Befehle werden so lange wiederholen, bis die vorab festgelegte Bedingung erfüllt ist.

Führt die eingefügten Befehle immer wieder aufs Neue aus.

Wenn die angedockte Bedingung zutrifft, wird mit der oberen Befehlsfolge fortgefahren. Falls nicht, wird mit der unteren Befehlsfolge weitergemacht.

Beide eingefügten Befehlsketten werden gleichzeitig ausgeführt. Erst wenn beide einmal abgearbeitet wurden, geht es mit dem nächsten Befehl nach diesem Block weiter.

Beendet alle anderen Befehlsketten. Dann wird mit dem Block dahinter weiter gemacht.

Alle Befehlsketten werden angehalten und das Programm ist beendet.

Orange: Sensorblöcke

Die Sensorblöcke sind dafür da, die verschiedenen Powered-Up-Sensoren in das Programm zu integrieren. So können etwa ein Abstandssensor, Farbsensor, Neigungssensor, der Controller und sogar die Bewegung des Smartphones zur Steuerung des Programms verwendet werden.

Der Farbsensor an dem eingestellten Anschluss wartet auf eine bestimmte Farbe und startet dann diese Befehlskette.

Der Farbsensor an dem eingestellten Anschluss wartet auf eine bestimmte Farbe. Dann wird die Befehlskette fortgesetzt.

Gibt den Farbwert des Farbsensors an den eingestellten Anschluss weiter.

Die Befehlskette startet, wenn etwas näher an dem Sensor (an dem eingestellten Anschluss) ist als der eingestellte Wert.

Die Befehlskette wird fortgesetzt, wenn etwas näher an dem Sensor (an dem eingestellten Anschluss) ist als der eingestellte Wert.

Gibt den Abstandswert weiter.

Gibt den Lichtwert (also wie hell bzw. dunkel es ist) weiter.

Die Befehlskette wird gestartet, wenn sich der Boost Hub in der eingestellten Position befindet.

Die Befehlskette wird fortgesetzt, wenn sich der Boost Hub in der eingestellten Position befindet.

Gibt die Lage des Boost Hubs weiter.

Gibt die Neigung des Boost Hubs auf der X-Achse (Horizontale) weiter.

Gibt die Neigung des Boost Hubs auf der Y-Achse (Vertikale) weiter.

Gibt den X-, Y- oder Z-Wert des Geräts an den jeweils angeschlossenen Eingang weiter, sofern er von dem Gerät unterstützt wird. Wenn das Steckersymbol ausgewählt wird, betrifft es den Hub selbst (Z-Wert u. a. beim Technic Hub).

Stellt die Lage des Hubs neu ein, um eine neue Synchronisation für den X- und Y-Wert zu erhalten.

Gibt den X-, Y- oder Z-Wert des Hubs in vermeintlich hoher Genauigkeit weiter.

Gibt den Entfernungswert des Abstandssensors weiter (WeDo bzw. neuer Powered-Up-Sensor)

Gibt die Neigung des (WeDo-)Sensors auf der X-Achse (Horizontale) weiter.

Gibt die Neigung des (WeDo-)Sensors auf der Y-Achse (Vertikale) weiter.

Gibt die Neigung des Smartphones/Tablets auf der X-Achse (Horizontale) weiter.

Gibt die Neigung des Smartphones/Tablets auf der Y-Achse (Vertikale) weiter.

Gibt den Wert des Knopfs des Controllers entweder auf der A- oder der B-Seite des Controllers weiter.

Grün: Bewegungs-Blöcke

Hier kommt Bewegung in die Sache. Zahlreiche Befehle zur Steuerung der Motoren warten darauf, ausprobiert zu werden.

Dreht den Motor an dem eingestellten Anschluss in der angegebenen Geschwindigkeit. Positiver Wert: mit dem Uhrzeigersinn. Negativer Wert: gegen den Uhrzeigersinn.

Schaltet die Energie für den Motor an dem eingestellten Anschluss ab. Dieser dreht ggf. noch etwas weiter im Leerlauf.

Stoppt augenblicklich den Motor an dem eingestellten Anschluss.

Gibt die aktuelle Geschwindigkeit des eingestellten Motors weiter (sofern der Motor das unterstützt – z. B. Tachomotoren).

Dreht den Tachomotor (z. B. den externen Motor bei LEGO Boost) an dem eingestellten Anschluss in der angegebenen Geschwindigkeit. Positiver Wert: mit dem Uhrzeigersinn. Negativer Wert: gegen den Uhrzeigersinn.

Dreht den (Tacho-)Motor an dem eingestellten Anschluss in der angegebenen Geschwindigkeit für die angegebene Zeit.

Gibt die aktuelle Position des eingestellten Tachomotors weiter. Dabei ist »0« die Position zum Zeitpunkt des Einschaltens.

Dreht den eingestellten (Tacho-)Motor in der eingestellten Geschwindigkeit um den angegebenen Winkel. Die Drehrichtung wird hierbei über positive bzw. negative Geschwindigkeit gesteuert.

Dreht den eingestellten (Tacho-)Motor in der eingestellten Geschwindigkeit zu der angegebenen Position.

Definiert für den (Tacho-)Motor die aktuelle Position. So kann z. B. die 0-Position neu gesetzt werden.

Stoppt den (Tacho-)Motor an dem eingestellten Anschluss.

Stellt die Höchstgeschwindigkeit des Motors an dem eingestellten Anschluss ein.

Stellt die Beschleunigung des eingestellten Motors ein. Ein Wert von »0.1« etwa würde zu einer hohen Beschleunigung führen.

Stellt die Dauer der Verlangsamung für den Motor an dem eingestellten Anschluss ein. Je kleiner der Wert ist, umso abrupter bremst der Motor ab.

Stellt die Geschwindigkeit eines Motorpaars ein.

Stellt die Geschwindigkeit eines Tachomotorpaars ein.

Stellt die Geschwindigkeit und die Dauer für ein (Tacho-)Motorpaar ein.

Stellt die Geschwindigkeit eines (Tacho-)Motorpaars ein, wobei beide zu einer bestimmten Position drehen.

Für ein Motorpaar wird eine Geschwindigkeit eingestellt. Der letzte Wert fungiert wie ein Lenkrad: Beim Wert 0 erhalten beide Motoren gleich viel Energie, bis 50 wird mehr und mehr Energie auf einen Motor übertragen und bis 100 laufen die Motoren in entgegengesetzte Richtung.

Funktioniert wie der Befehl zuvor, nur dass hier noch die Dauer angegeben werden kann.

Funktioniert wie der Befehl zuvor, nur dass statt der Zeit der Winkel angegeben wird.

Dreht als eigenständiger Befehl den Motor am eingestellten Anschluss zu der angegebenen Position.

Dreht dauerhaft den Motor an dem eingestellten Anschluss in der angegeben Geschwindigkeit.

Blaugrün/Türkis: Controller-Blöcke

Diese Blöcke gibt es in zwei Varianten, je nachdem, was du am Anfang bei dem Projekttyp ausgewählt hast.

a) Fiel deine Wahl auf »Controller« und wählst du als Vorlage die Feuerwehr oder die Stadt, so siehst du folgende Befehle, sobald du oben rechts auf das Programmiersymbol geklickt hast:

Stadt:

Feuerwehr:

Diese Befehle dienen dazu, deinen schon vorgefertigten Controller auf dem Smartphone bzw. Tablet zu programmieren. Du stellst ein, welcher dargestellte Schalter welche Funktion ausführt.

Jeder dieser Befehle (auch »Widget« genannt), den du für die Kontrolle einstellst, besteht aus zwei Blöcken: die großen, die diese Steuerung definieren, und den kleinen, die entweder den entsprechenden Wert (rund) oder einen logischen Zustand (z. B. gedrückt oder nicht gedrückt) weitergeben. Der Befehl mit der »100« und »0« steht dabei für den angezeigten Wert (z. B. die Geschwindigkeit).

Einige der Widgets haben noch eine kleine Zahl auf schwarzem Grund in der rechten unteren Ecke. Diese kann man doppelt verwenden (z. B. einen Slider für den rechten Motor und einen für den linken Motor).

b) Völlige Freiheit hast du bei der anderen Variante.

Verschiedene Varianten an Knöpfen, Hebeln, Schiebern und Anzeigen stehen dir hierbei zur Verfügung. Du kannst diesen Controller nicht nur über die Vorauswahl »Controller« programmieren, sondern auch aus jedem anderen Projekt, indem du oben rechts auf das Bild eines Controllers klickst.

Zunächst wählst du deine Elemente des Controllers einzeln aus. Rechts auf dem Bildschirm kannst du zwischen Schaltflächen, Steuerung, Anzeigen und auch Dekorationen (zum Zeitpunkt der Erstellung dieses Buches waren die Dekorationen noch nicht frei geschaltet) wählen. Mit dem Häkchen unten links fügst du das Element hinzu.

Weitere Elemente fügst du mit dem »+«-Zeichen hinzu. Die einzelnen Elemente kannst du noch frei verschieben und anordnen. Wenn du mit den Elementen deines Controllers zufrieden bist, dann klicke auf das Schlosssymbol oben rechts. Vorher solltest du dir jedoch noch notieren, welche kleine Zahl bei jedem Element dran steht. Diese Zahl brauchst du später beim Programmieren der jeweiligen Funktion.

Du kannst auch jederzeit die Elemente wieder ändern, wenn du erneut auf das Schlosssymbol klickst.

Mit dem Programmiersymbol gelangst du zur Programmieroberfläche und kannst nun Befehle einfügen, um den Controller mit Leben zu erfüllen.

Jetzt wird es wichtig, dass du dir notiert (oder gemerkt) hattest, welchem Element des Controllers welche Zahl zugeordnet war. Diese musst du unterhalb des jeweiligen Befehls einstellen. Den Zustand des Elements (z. B. wenn es gedrückt wurde oder ein Wert über Schieberegler eingestellt wurde), wird über Andocken an andere Befehle weitergegeben – wie du es schon von z. B. den Sensoren-Befehlen kennst. Typischerweise würde der Controller-Befehl etwa mit einem Motor-Befehl verbunden werden und z. B. seinen Wert an die Geschwindigkeitseinstellung weitergeben.

Bei dem Befehl für die Tacho-Anzeige stellst du links die Nummer des Elements ein und rechts den anzuzeigenden Wert (bzw. in der Regel etwa das Ergebnis eines angedockten Sensors).

Auch bei dem Joystick trägst du links unten die Nummer des Elements ein. Rechts davon kannst du einstellen, ob du die Werte für Betätigung des Sticks »Links-Rechts« oder »Oben-Unten« auswerten möchtest.

LEGO hat angekündigt, dass sie noch viele Ideen für die Programmierung von Controllern haben und auch mehr Vorlagen erstellen wollen. Also sei nicht verwundert, wenn bei dir dieser Bereich plötzlich anders aussieht.

Lila: Licht- und Tonblöcke

Unter dem lila Reiter findest du die Befehle zur Steuerung der Lichtfunktionen und zum Integrieren von Tönen. Letztere kommen jedoch nur aus dem Smartphone bzw. dem Tablet und nicht aus deinem Modell.

Stellt die Helligkeit des Licht-Moduls am angegebenen Anschluss ein.

Stellt die Farbe der LED des Hubs ein.

Stellt die Farbe der LED des Hubs ein, wobei hier die Farbe in Prozentwerten der Grundfarben Rot, Grün und Blau definiert wird.

Setzt die Farbe der LED des Farbsensors fest.

Diverse Blöcke mit voreingestellten Tönen und Geräuschen, die individuell ausgewählt werden können.

Hiermit kann über den Farb- bzw. Abstandssensor ein Infrarotsignal an einen entsprechenden Empfänger vom alten Power Functions geschickt werden. Neben dem Anschluss des Sensors kann hier der Infrarotkanal, der Farbport und die Geschwindigkeit eingestellt werden.

Hiermit kann der Farb- und Abstandssensor an dem eingestellten Anschluss in den Modus zur Übermittlung von Infrarotsignalen umgeschaltet werden. Der zweite Wert muss dann auf »7« eingestellt werden. Erst dann kann mit dem vorherigen Befehl das Infrarotsignal gesendet werden.

Weiß: Variablen und Mathematikblöcke

Hier findest du die Befehle zur Verwendung von Variablen, zum Ansteuern mehrerer Hubs und zum Durchführen diverser Rechenoperationen.

Gibt weiter, welcher Port von welchem Hub angesprochen werden soll.

Gibt den Wert der lokalen Variablen weiter.

Teilt einer lokalen Variablen einen Wert zu.

Gibt den Wert der globalen Variablen weiter.

Teilt einer globalen Variablen einen Wert zu.

Wählt einen Zufallswert zwischen den beiden eingestellten Werten.

Prüft, ob die beiden Werte gleich sind.

Prüft, ob der linke Wert kleiner als der rechte Wert ist.

Prüft, ob der linke Wert größer als der rechte Wert ist.

Prüft, ob die beiden Werte ungleich sind.

Logische Und-Verknüpfung (Haken, wenn beide Einträge Haken sind)

Logische Oder-Verknüpfung (Haken, wenn zumindest einer der Werte ein Haken ist)

Addiert die beiden Werte.

Subtrahiert die beiden Werte.

Multipliziert die beiden Werte.

Dividiert die beiden Werte.

diverse mathematische Operationen

Gibt das Ergebnis der Funktion {atan2} (y,x) oder {arctan2} (y,x) weiter.

Rechnet a hoch b.

Gibt den Maximalwert der beiden Zahlen weiter.

Gibt den Minimalwert der beiden Zahlen weiter.

Gibt den Rest nach der Division der beiden Werte weiter.

5
Powered Up mit anderen Programmiersprachen programmieren

Scratch

Die Programmiersprache von LEGO für Powered Up ist einfach und eingängig. Vielleicht hast du in der Schule schon eine andere Programmierart kennengelernt, die sich davon gar nicht so unterscheidet, wie etwa Scratch. Auch Scratch funktioniert durch das Zusammenschieben von Blöcken, bietet darüber hinaus aber noch viel mehr Möglichkeiten. So gibt es nicht nur zahllose Beispielprogramme, Tutorials und Anleitungen für Scratch, es kann auch noch mit anderen Techniken wie Micro:bit, WeDo, LEGO Boost und einigen anderen verbunden werden. Und das Gute ist, auch LEGO Powered Up wird unterstützt und kann mit Scratch 3.0 programmiert werden. Beim neuen LEGO Mindstorms Robot Inventor etwa ist Scratch sogar die Standardmethode zum Programmieren.

Das ist auch gut so, denn eine echte Windows- oder Mac-Version der PoweredUpApp gibt es leider nicht. Zwar kann man die Android-App über einen Emulator starten, doch dann kann man auch gleich direkt das Tablet oder das Smartphone nehmen.

Um mit einem PC Kontakt zu den Powered Up Hubs aufzunehmen, benötigt man eine Bluetooth-Verbindung. Die meisten neueren Laptops sollten Bluetooth serienmäßig eingebaut haben. Bei Stand-Alone-PCs ist das jedoch nicht immer der Fall. Gegebenenfalls muss man da Bluetooth nachrüsten. Allerdings kann es dabei auch zu Problemen kommen, wie etwa dass sich das nachgerüstete Bluetooth nicht mit den Hubs versteht. Da hilft manchmal nur die eigene Internetrecherche oder Ausprobieren.

Die Oberfläche von Scratch

Damit sich Scratch 3.0 mit den Hubs verständigen kann, muss zunächst Scratch Link installiert werden. Das findet man schnell und kostenlos z. B. im App-Store von Windows 10¹. Dann kann man über folgenden Link Scratch 3 im Browser starten: https://tinyurl.com/y4b5knzv².

Mit der Version von Scratch, die auf den Desktop heruntergeladen werden kann, klappt es leider (noch) nicht.

Unten links bei Scratch 3 muss man dann auf das Symbol mit den Wellen und dem »+«-Zeichen klicken und kann aus der folgenden Auswahl »Powered Up« als Ergänzung auswählen.

Ist Scratch Link gestartet, Bluetooth aktiviert und auch die Powered-Up-Erweiterung ausgewählt, kann sich der Rechner mit dem Hub verbinden. Manchmal muss man auch etwas rumprobieren. Es gab z. B. schon einmal beim Chrome-Browser Probleme mit der Verbindung, wohingegen bei Microsoft Edge sofort die Verbindung funktionierte.

Funfact: Dort ist sogar eine Erweiterung zu finden ist, die es erlaubt, den aktuellen Duplo-Zug zu programmieren. Etwas, das LEGO selbst zum Vermeiden des Vermischens von Duplo und klassischen LEGO-Steinen unterbindet, obwohl auch die aktuellen Duplo-Züge die Technik von Powered Up eingebaut haben.

Links solltest du nun einige Befehle sehen, die extra die Ansteuerung von Powered-Up-Motoren und -Sensoren erlauben. So kann das Programmieren losgehen, wobei bei Scratch die Befehle untereinander bzw. übereinander angeordnet werden.

Weitere Möglichkeiten

Da LEGO selbst viele technische Spezifikationen von Powered Up veröffentlicht hat, sind auch die Möglichkeiten des Einsatzes anderer Programmiersprachen gegeben. So ist zum Beispiel auch die Programmierung über Javascript schon beschrieben worden³.

Das Projekt »Pybricks«⁴ hat es auch schon erreicht, dass Programme direkt auf den Hubs ausgeführt werden können, ohne dass hierfür noch ein Smartphone oder Tablet in der Nähe sein muss. Pybricks baut auf dem Projekt MicroPython auf. Der Hub muss hierfür zwar mit einer neuen Firmware beschrieben werden, jedoch kann er dann per Python programmiert werden.

Ein Screenshot aus der Dokumentation von pybricks. Firmware und Programme werden per Bluetooth übertragen. Quelle: pybricks

6
Flugsimulator

Beschreibung

Ein Flugsimulator ist eine Maschine, die dazu benutzt wird, Piloten zu trainieren, ohne dass sie mit einem echten Flugzeug fliegen müssen. Damit lassen sich insbesondere Ausnahmesituationen trainieren, die mit echten Flugzeugen zu riskant wären. Nach einem solchen Training ist ein Pilot viel besser darauf vorbereitet, mit einem echten Flugzeug zu fliegen. Du kennst sicherlich einen Flugsimulator als Computerspiel auf dem Monitor. Bei einem richtigen Simulator wird zusätzlich ein komplettes Cockpit nachgebaut, in dem der trainierende Pilot sitzt. Die ganze Kabine ist auf einem Gestell montiert, mit dem sie sich in alle Richtungen kippen lässt. Zusammen mit den Bildern, die der Pilot zu sehen bekommt, entsteht so der Eindruck, wirklich zu fliegen.

Bei unserem Modell ist nicht nur ein Cockpit, sondern gleich ein ganzes Raumschiff aufgesetzt. Alternativ kannst du unser Labyrinth nachbauen und aufsetzen, oder du entwirfst gleich dein eigenes Raumschiff, Flugzeug, Schiff, Auto oder was du magst. Du wirst sehen, die wesentliche Funktion liegt in der Simulator-Plattform. Wir haben in beide Aufsätze noch zusätzliche Funktionen eingebaut, die aber nur mit dem jeweiligen Modell funktionieren.

Ein echter Flugsimulator © B.O.T. Aircraft AG

Die Simulator-Plattform ist aus Technic-Elementen gebaut und verwendet den Technic Hub (88012) sowie die beiden Technic-Motoren »Technic Großer Motor« (88013) und »Technic XL-Motor« (88014). Alle drei zusammen sind zum Beispiel in den Modellen »Top-Gear Ralleyauto mit App-Steuerung« (42109), »Allrad Xtreme-Geländewagen« (42099) oder auch »Liebherr Bagger R 9800« (42100) enthalten. Sie sind aber auch einzeln bei LEGO erhältlich. Der Space-Jet verwendet zusätzlich das Powered-Up-Licht (88005) und das Labyrinth den Farb- und Abstandssensor (88007).

Beim Flugsimulator-Modell machen wir uns zunutze, dass in deinem Handy ein sogenanntes »Gyroskop« eingebaut ist. Es ermöglicht uns, die Bewegung des Gerätes zu erkennen. Viele Handy-Spiele verwenden diese Funktion zum Beispiel, um Autos damit steuern zu können. In der Powered-Up-Programmierung bekommen wir darüber Informationen über Kippbewegungen nach rechts und links sowie nach vorne und hinten.

Simulator-Plattform

Die Simulator-Plattform ohne Aufsatz

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du für unser Modell:

1x

4x

6x

12x

54x

4x

4x

18x

6x

6x

3x

4x

2x

6x

2x

3x

1x

2x

2x

4x

7x

2x

2x

2x

1x

1x

1x

2x

3x

3x

4x

12x

2x

2x

1x

1x

1x

1x

1x

1x

4x

4x

4x

2x

2x

1x

Bauanleitung

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

So verlegst du das Kabel für den ersten Motor.

So verlegst du das Kabel für den zweiten Motor.

Space-Jet

Der Space-Jet

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du für unser Modell:

2x

1x

2x

1x

6x

4x

2x

2x

2x

1x

1x

1x

1x

1x

2x

2x

4x

2x

2x

1x

2x

2x

1x

1x

1x

1x

2x

3x

1x

1x

1x

1x

2x

1x

1x

1x

1x

2x

2x

1x

2x

1x

2x

1x

1x

1x

2x

2x

5x

2x

2x

2x

2x

3x

3x

3x

2x

2x

2x

1x

1x

1x

2x

Bauanleitung

1

2

3

4

5

8

9

6

7

10

11

12

13

So montierst du die LED-Lichter.

Der Space-Jet auf der Simulator-Plattform mit angeschlossenem Kabel

Labyrinth

Unser Vorschlag für das Labyrinth

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du für unser Modell:

1x

1x

1x

2x

12x

3x

5x

1x

6x

1x

11x

2x

4x

3x

1x

1x

4x

10x

2x

1x

1x

1x

1x

2x

1x

2x

2x

1x

1x

4x

3x

Bauanleitung

1

2

3

4

5

6

7

8

9

Das Labyrinth auf der Simulator-Plattform mit angeschlossenem Kabel

Software

Im Flugsimulator haben wir zwei Motoren verbaut: Den großen Technic-Motor für die untere Drehachse (Kippen nach vorne und hinten) am Anschluss A und den kleinen Technic-Motor für die obere Drehachse (Kippen nach rechts und links) am Anschluss B. Je nach Aufbau schließen wir am Anschluss C den Farb-/Abstandssensor oder am Anschluss D die LEDs an. Und nun geht es darum, die Software für die eigentliche Funktion zu entwickeln. Dazu stellen wir uns zunächst die Frage, was der Flugsimulator alles können soll und überlegen dann, wie wir das umsetzen können.

Was der Flugsimulator können soll

Sammeln wir mal die Anforderungen:

1. Durch die Bewegung des Handys (oder Tablets) soll die Bewegung des Simulators gesteuert werden. Dabei sollen Bewegungen nach rechts und links den oberen Motor und Bewegungen nach vorne und hinten den unteren Motor ansteuern und somit die Plattform entsprechend bewegen.

2. Ist der Space-Jet angeschlossen, so sollen auf Knopfdruck die Laserkanonen mit Licht und Ton aktiviert werden.

3. Ist das Labyrinth angeschlossen, so soll ein Jubel-Ton abgespielt werden, sobald die Kugel das Labyrinth auf dem richtigen Weg verlassen hat.

Unsere Anforderungen sind recht harmlos. Wenn du darüber hinaus noch mehr Funktionen einbauen möchtest, so kannst du das im Anschluss gerne tun!

Wie der Flugsimulator das alles können soll

Jetzt überlegen wir uns, wie wir diese Funktionen umsetzen können. Dabei fällt auf, dass wir zunächst einen Knopf brauchen werden, mit dem wir die Laserkanone aktivieren können. Wir benutzen dazu beim Anlegen unseres neuen Projekts die Auswahl »Controller« und wählen dann den Controller mit der Straßenansicht.

Da wir die Ansteuerung mit den Schiebern rechts und links nicht benutzen wollen, müssen wir den Code, der dafür vorprogrammiert ist, löschen. Dazu schalten wir zunächst in den Programmiermodus um (Knopf rechts oben neben dem Stopp-Knopf) und schieben dann die beiden Befehlsketten, die die Motoren ansteuern, nach unten auf die Auswahlliste. Damit löschen wir sie aus dem Programm.

Mit diesem Knopf wechselst du in die Programmierumgebung.

Diesen Code müssen wir zunächst löschen.

Bewegung

Als Erstes müssen wir uns darüber klar werden, was wir vom Handy an Sensordaten für die Bewegung bekommen: Für die Bewegung nach rechts und links bekommen wir +/– 100 für jeweils etwa +/– 45° Neigung. Für die Bewegung nach vorne und hinten bekommen wir ebenfalls +/– 100. Der Unterschied ist lediglich, dass der Nullpunkt so liegt, dass wir das Handy etwa 45° zu uns hingeneigt halten müssen. In die Waagerechte nach vorne gekippt ergibt sich dann +100 und in die Senkrechte nach oben liefert der Sensor –100. Spiele ruhig etwas mit den Sensorwerten herum, damit du sein Verhalten verstehen lernst.

Durch die Bewegung des Handys steuerst du den Simulator.

Prinzipiell haben wir jetzt zwei Möglichkeiten der Steuerung: Der Simulator kann entweder genau unserer Bewegung des Handys folgen, also immer die gleiche Stellung einnehmen, die das Handy auch hat, oder wir bewegen den Simulator solange, bis wir das Handy aus der jeweiligen Nulllage herausgekippt haben. Die erste Variante würde voraussetzen, dass die Motoren über ihre absolute Position Bescheid wissen. Das tun sie aber leider nicht. Wir werden daher die zweite Variante umsetzen.

Das Kippen des Handys aus der Nullposition heraus soll also den Simulator bewegen. Dabei soll er sich umso schneller bewegen, je weiter wir das Handy kippen. Kleinere Bewegungen des Handys führen folglich zu kleineren Bewegungen des Simulators. Sehr kleine Bewegungen sollen ignoriert werden, denn sonst wird die Simulator-Plattform zu zappelig.

Da die Motoren sich für unsere Zwecke zu schnell bewegen, begrenzen wir zunächst ihre Beschleunigungszeit (0,1 Sekunden) und ebenso ihre Abbremszeit (0.1 s). Außerdem begrenzen wir die Geschwindigkeit auf maximal 20. Wir führen noch die Variablen a und b als Motorparameter für die Motoren A und B ein: a = 5 und b = 7. Mit denen können wir das Verhalten des jeweiligen Motors etwas verändern und die beiden Motoren aufeinander abstimmen. Nach diesen grundsätzlichen Einstellungen begeben wir uns in eine Endlosschleife, in der wir jetzt die Bewegung des Handys auswerten und auf die Motoren geben: Zunächst teilen wir das Sensorsignal vom Handy durch den jeweiligen Motorparameter. Damit bilden wir die +/–100 vom Kippsensor ungefähr auf die +/–20 für die Bewegungsgeschwindigkeit ab. Dann prüfen wir, ob der Betrag vom Ergebnis größer ist als der Motorparameter. Damit stellen wir sicher, dass wir die Motoren nur ansteuern, wenn die Bewegung vom Handy ein gewisses Mindestmaß überschreitet. Ist diese Bedingung erfüllt, so steuern wir den Motor mit dem heruntergerechneten und aufgerundeten Bewegungswert an. Andernfalls stoppen wir den Motor. Damit wir diese Befehlskette nur einmal programmieren müssen, aber für beide Motoren verwenden können, legen wir einen eigenen Block an. Dabei benutzen wir drei Eingänge: Mit dem ersten Eingang wählen wir den Motor (A oder B) aus, an den zweiten Eingang wollen wir das Sensorsignal anschließen und der dritte Eingang soll den Motorparameter bekommen. Das klingt alles etwas abstrakt und das ist es auch. Aber schauen wir uns einmal an, wie unser Block jetzt aussieht:

Unser eigener Block zur Ansteuerung der Motoren

Diesen Block benutzen wir jetzt im Hauptprogramm jeweils einmal für den Motor A und einmal für den Motor B. Dazu schließen wir die Kippsensor-Blöcke am Eingang für die Bewegung an. Dabei müssen wir beim Motor A – wegen der Einbaulage – noch das Vorzeichen ändern (also + gegen – tauschen). Da die Motoren sich gleichzeitig drehen sollen, verpacken wir die Blöcke in eine Parallelverzweigung. Zusätzlich definieren wir jetzt noch die Motorparameter, von denen wir oben gesprochen haben. Die Befehlskette dafür sieht dann so aus:

So verwenden wir unseren neuen Block.

Laserkanonen

Für den Lichteffekt der Laserkanonen schalten wir die LED am Ausgang D zu 80 % ein und nach 0,3 Sekunden wieder aus. Zeitgleich spielen wir einen passenden Klang ab. Die ganze Befehlskette verpacken wir in einen eigenen Block, der dann so aussieht:

Unser Block für die Laserkanonen

Im Hauptprogramm schließen wir unseren Block an einen der Startblöcke an, die schon da sind. Und zwar denjenigen, an den der Knopf mit der Straße drauf angeschlossen ist. Den mit diesem Block verbundenen Straßen-Sound löschen wir dabei. Zusätzlich schalten wir gleich zu Beginn des Programms die LED am Hub aus, damit der Effekt der Laserkanone besser sichtbar ist. Diese beiden Befehlsketten sehen dann so aus:

So verwenden wir den Block für die Laserkanonen.

Labyrinth-Jubel

Jetzt fehlt nur noch der Jubel, sobald eine Kugel an der richtigen Stelle aus dem Labyrinth heraus rollt. Weil wir eine orangefarbene Kugel benutzen, verwenden wir den Farbsensor, warten allerdings nicht auf die Farbe Orange, sondern auf Rot, weil Orange vom Sensor eher als Rot erkannt wird. Wir könnten stattdessen aber auch mit dem Abstandssensor darauf warten, dass etwas nah vorbei kommt. Probiere mal aus, was bei dir besser funktioniert. Wenn die geforderte Bedingung erfüllt ist, spielen wir ein Jubelgeräusch ab. Die Befehlskette sieht dann so aus:

Hier gibt es Grund zum Jubeln!

Die Farben, die der Sensor erkennt, hängen auch von der Einbauposition und der Umgebungshelligkeit ab. Wenn du eigene Farben erkennen willst, probiere also zunächst aus, was der Sensor erkennt. Du kannst dazu den Sensoreingang einfach so auf die Programmieroberfläche ziehen. Dann bekommst du angezeigt, was der Sensor grade erkennt.

Ein Sensor sieht Rot.

Fertig

Starte jetzt dein Programm, indem du auf das kleine Controller-Icon rechts oben drückst. Probiere zunächst vorsichtig, wie sich der Simulator bewegt und gewöhne dich an die Steuerung, bevor du eines der Modelle aufsetzt. Beachte dabei besonders, dass der Simulator nicht von selber die Motoren stoppt, wenn du in einem der mechanischen Anschläge fährst. Du musst selber darauf achten, dass du in dem Bereich bleibst, in dem noch Bewegungsfreiheit herrscht. Stoppe das Programm, bevor du das Handy aus der Hand legst, da es andernfalls zu ungewollten Bewegungen am Simulator kommen kann!

Teste aus, wie gut du den Simulator bedienen kannst! Schaffst du es, die Kugel durch das Labyrinth bis zum Ausgang zu bewegen?

Variationen

Du hast dein eigenes Raumschiff entworfen? Oder ein Auto oder ein Schiff? Kein Problem, der Simulator ist eine Plattform, auf die du natürlich auch deine eigenen Kreationen setzen kannst. Beachte nur, dass die Modelle nicht zu groß und vor allem nicht zu schwer sein dürfen.

Dir ist das Labyrinth zu langweilig oder nicht cool genug? Entwerfe dein eigenes und probiere es aus!

Du kannst auch ein Auto, einen Drachen oder etwas ganz anderes montieren.

7
Tresor

Beschreibung

Tresore dienen zur Aufbewahrung wertvoller Gegenstände und es gibt sie in den unterschiedlichsten Ausführungen von so klein, dass sie in ein Schrankfach passen, bis hin zu so groß, dass sie schon selbst ein Gebäudeteil sind. Allen gemeinsam ist, dass sie einen aufwändigen Verriegelungsmechanismus haben und die Schlüssel oder die Zahlen-Codes zum Öffnen vor dem allgemeinen Zugriff geschützt sind. Sprich: Sowohl der Inhalt als auch der Schlüssel sind Geheimsache!

Meistens ist der Verriegelungsmechanismus in der Tresortür untergebracht. Da die Powered-Up-Komponenten dafür zu groß sind, hat unser Tresor den Mechanismus neben dem eigentlichen Tresorraum. Außerdem verwenden wir Farben anstelle von Zahlen für den Code.

Als Powered-Up-Komponenten benötigst du den einfachen Hub (88008) und zweimal den mittleren Linearmotor (88009). Zusätzlich benötigst du noch etwas, das du in den Tresor einschließen kannst. Das auszuwählen, überlassen wir dir …

Bei dem Tresor-Modell machen wir uns zunutze, dass wir die Motoren nicht nur zu einer Drehbewegung ansteuern können, sondern dass sie uns umgekehrt auch über ihre Bewegung informieren können. Wir benutzen einen der Motoren also nur als Sensor und nicht als Motor.

Ein echter Tresor © Franz Jäger Berlin

Tresor

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du für unser Modell:

2x

2x

2x

5x

1x

2x

1x

3x

1x

5x

3x

3x

1x

1x

2x

1x

1x

2x

2x

2x

1x

7x

1x

1x

3x

2x

2x

1x

1x

1x

1x

1x

2x

1x

2x

7x

2x

1x

1x

1x

1x

1x

1x

3x

2x

2x

1x

1x

1x

1x

1x

1x

1x

1x

1x

1x

4x

1x

1x

14x

6x

2x

12x

2x

1x

5x

2x

10x

19x

52x

8x

8x

1x

3x

11x

4x

1x

1x

29x

2x

3x

3x

2x

4x

2x

3x

3x

2x

4x

4x

6x

1x

1x

1x

2x

2x

4x

2x

4x

Bauanleitung

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

Der Einbauraum für die Kabel im Tresor

Software

Im Tresor haben wir zwei Motoren verbaut: Einen für das Farbrad am Anschluss A und einen für den Verriegelungsmechanismus am Anschluss B. Jetzt geht es darum, die Software für die eigentliche Funktion zu entwickeln. Dazu stellen wir uns zunächst die Frage, was der Tresor können soll und überlegen dann, wie wir das umsetzen können.

Was der Tresor können soll

Prinzipiell soll der Tresor »wie ein Tresor funktionieren«. Doch was heißt das konkret? Sammeln wir mal die Anforderungen:

1. Mit dem Farbrad soll ein Farb-Code eingestellt werden können. Der Code soll aus vier Farben in einer vorprogrammierten Reihenfolge bestehen.

2. Wird der richtige Code eingestellt, so soll sich der Verriegelungsmechanismus des Tresors öffnen. Wird er falsch eingegeben, bleibt der Tresor verschlossen. Der Code muss dann von Neuem eingegeben werden.

3. Richtige und falsche Eingaben sollen durch unterschiedliche Töne erkennbar sein.

4. Ob der Tresor verriegelt oder nicht verriegelt ist, soll über eine farbige LED angezeigt werden (rot = verriegelt, grün = nicht verriegelt, gelb = Mechanismus ist in Bewegung).

5. Ist der Tresor nicht verriegelt, so soll durch ein schnelles Drehen des Farbrades der Tresor verriegelt werden.

6. Beim Start des Programms soll der Tresor zunächst verriegelt werden, damit er nicht unbeabsichtigt offen steht!

Wir sehen, wenn man genauer darüber nachdenkt, kommt doch schnell einiges an Anforderungen zusammen.

Wie der Tresor das alles können soll

Jetzt überlegen wir uns, wie wir diese Funktionen umsetzen können. Nehmen wir uns zunächst die Verriegelung vor, dann können wir sie im Anschluss direkt ausprobieren. Da wir alle Bedienelemente am Tresor selber haben, starten wir unser neues Programm im Modus »Programmieren«.

Verriegelung

Unsere Verriegelung besteht aus einer Technik-Achse, die wir durch eine Zahnstange seitlich verschieben können, indem wir den Motor entsprechend drehen lassen. Dabei fällt sofort auf, dass der Mechanismus in beiden Richtungen einen Anschlag hat. Wir müssen also aufpassen, dass wir den Motor nicht zu viel und nicht zu schnell drehen lassen.

Zum Verriegeln stellen wir die LED zunächst auf Gelb, um zu zeigen, dass der Mechanismus sich jetzt bewegen wird. Dann drehen wir den Motor mit langsamer Geschwindigkeit (6) und geben ihm 0,5 Sekunden Zeit zum Anlaufen. Anschließend warten wir darauf, dass der Mechanismus in den Anschlag gelaufen ist. Das erkennen wir daran, dass der Sensorwert vom Motor keine Bewegung mehr anzeigt (der Wert ist < 1). Ist der Mechanismus im Anschlag, so stoppen wir den Motor. Um anzuzeigen, dass die Verriegelung abgeschlossen ist, setzen wir die globale Variable v (»verriegelt«) auf den Wert 1 (wir werden sie später noch benötigen), die LED des Hubs auf Rot und spielen einen passenden Ton ab.

Da wir die Verriegelung öfters benötigen und weil es übersichtlicher ist, legen wir die Befehlskette in einen eigenen Block und geben ihm ein passendes Icon. Die fertige Befehlskette zur Verriegelung sieht dann so aus:

Die Befehlskette zur Verriegelung

Du kannst einzelne Befehlsketten ausprobieren, indem du auf ihren Startknopf drückst. Das geht sowohl innerhalb, als auch außerhalb von deinen eigenen Blöcken.

Entriegelung

Die Entriegelung funktioniert ähnlich: Wir drehen lediglich den Motor in die andere Richtung (-6). Daher müssen wir auch anschließend darauf warten, dass der Wert der Bewegung > -1 wird. Außerdem setzen wir die globale Variable v auf 0 (»nicht verriegelt«) und die LED auf Grün. Auch für die Entriegelung legen wir einen eigenen Block an und geben ihm ein passendes Icon. Unser neuer Block sieht dann so aus:

Die Befehlskette zur Entriegelung

Das Farbrad

Jetzt haben wir also die Möglichkeit, den Tresor zu verriegeln und zu entriegeln. Als Nächstes brauchen wir einige Funktionen für das Farbrad. Um einen Code einstellen zu können, müssen wir erkennen können, an welcher Stelle sich das Rad gerade befindet, also welche Farbe ausgewählt ist. Außerdem müssen wir feststellen, ob sich das Rad gerade in Bewegung befindet, weil wir daran drehen, oder ob es still steht. Aus der Kombination dieser Beobachtungen können wir schließen, ob wir der Reihe nach die richtigen Farben eingestellt haben, also das Rad auf die richtigen Positionen gedreht und es dort kurz haben stehen lassen. Fangen wir zum Einstieg mit der Bewegungserkennung an.

Bewegungserkennung

Zur Bewegungserkennung führen wir die globale Variable b (»Bewegung«) ein. Wir setzen sie auf »1«, wenn sich das Rad bewegt und auf »0«, wenn es still steht. Zur Erkennung des Stillstands verwenden wir einen Startblock mit der Bedingung »Bewegung des Motors = 0«. Danach warten wir zunächst 0,2 Sekunden und dann prüfen wir erneut, ob der Motor immer noch steht. Damit erkennen wir, dass das Rad auch wirklich still steht. In einer zweiten Befehlskette setzen wir die Variable b auf »1« , sobald sich der Motor bewegt (»Bewegung des Motors = 0«). Unser Programm sieht jetzt also so aus (hierfür haben wir keinen eigenen Block angelegt):

Die Befehlsketten zur Bewegungserkennung

Positionserkennung

Die Positionserkennung wird etwas aufwändiger. Dafür müssen wir uns zunächst darüber klar werden, welche Signale der Motor uns liefert. Die Powered-Up-Motoren haben keine absolute Positionserkennung (gegenüber ihrem mechanischen Aufbau), sondern nur eine relative Positionserkennung. Das bedeutet: Nach dem Starten des Programms sendet jeder Motor immer die Positionsangabe »0«, unabhängig davon, wo der Motor mechanisch steht. Das ist für unsere Zwecke unpraktisch, denn wir wollen ja die absolute Position erkennen können, die in Form der bunten Steine auf dem Stellrad aufgebaut sind.

Die Lösung dafür besteht darin, dass wir vor dem Starten des Programms drauf achten, dass das Rad in der Stellung »Gold« steht (das goldene Viertelplättchen zeigt zum goldenen Mikrofon). Das beachten wir auch vor der Eingabe des Codes und ebenfalls zum Abschluss des Codes. Auch nach dem Drehen zur Verriegelung soll das Rad wieder in diese Stellung gebracht werden. Durch die goldene Markierung haben wir uns eine »Nullposition« geschaffen und durch die zusätzliche Bedingung im Programm zwingen wir uns selber dazu, das Rad immer wieder in diese Stellung zurückzubringen. Probiere es später mal aus: Steht das Rad beim Programmstart anders, wird unser Programm nicht mehr richtig funktionieren.

Wir haben jetzt also eine Position »0«. Wir brauchen dann noch die Positionen »1« bis »4« für die vier Farben. Im Programm können wir nicht mit Farben rechnen, sondern nur mit Zahlen. Wir ordnen also intern den vier Farben vier Zahlen zu: Grün = 1, Rot = 2, Gelb = 3 und Blau = 4. Zurück zu den Werten, die der Motor uns liefert: Von Null aus startend bekommen wir in die eine Richtung positiv aufsteigende Gradzahlen, in die andere Richtung negative. Bewegen wir den Motor also um genau 90°, bekommen wir den Wert 90. Bewegen wir ihn in die andere Richtung um 90°, bekommen wir den Wert –90. Bewegen wir den Motor mehr als einmal herum, also über die 360° eines Kreises hinaus, zählt er weiter: Drehen wir den Motor zweimal herum, bekommen wir also 720 gemeldet. Das ist für unseren Bedarf unpraktisch, denn wir haben ja genau die vier Farben, die wir erkennen wollen, egal, wie oft wir das Rad herumdrehen: Nach einmal Drehen geht es bei uns ja wieder von vorne los. Wir wollen also, dass die Werte bis maximal 360 ansteigen und dann wieder bei 0 anfangen. Für diesen Zweck gibt es die mathematische Funktion »Modulo« (kurz »mod«). Sie dividiert zwei Zahlen und liefert nur den Rest zurück. Teilen wir unseren Motorwert durch 360 und schauen uns nur den Rest an, sehen wir:

0 : 360 = 0 Rest 0

90 : 360 = 0 Rest 90

180 : 360 = 0 Rest 180

360 : 360 = 1 Rest 0

450 : 360 = 1 Rest 90

540 : 360 = 1 Rest 180

und so weiter.

Der Restwert ist genau das, was wir brauchen. Wir haben jetzt aber immer noch 360 Werte, wir wollen aber nur vier. Daher teilen wir den Wert noch durch 90 und runden das Ergebnis. Jetzt bekommen wir für die ersten 45° den Wert 0, dann bis zum Winkel von 135° den Wert 1, bis 225° den Wert 2, bis 315° den Wert 3 und danach den Wert 4. Damit sind wir fast fertig. Noch fängt unser Nullpunkt (Wert 0) bei 0° an und geht bis 45°. Wir wollen aber, dass er symmetrisch über die goldene Viertelplatte verteilt liegt. Dazu verschieben wir als Erstes den Sensorwert um 22.5 (die Hälfte von 45°). Jetzt bekommen wir das Ergebnis, das wir benötigen. Da diese Berechnung zu kompliziert ist, um sie bei jeder Gelegenheit, bei der wir die Position des Rades benötigen, erneut auszurechnen, führen wir die globale Variable p (»Position«) ein, die wir in einer Dauerschleife mit der aktuellen Position des Farbrades belegen. Diese Befehlskette sieht dann jetzt so aus:

Die Befehlskette zur Bewegungserkennung

Jetzt haben wir nur noch ein Problem: Drehen wir das Rad nach rechts, funktioniert alles, wie gewünscht. Drehen wir vom Start weg nach links, funktioniert es nicht mehr. Das liegt daran, dass wir uns dort in die negativen Zahlen begeben und somit alle Winkelangaben spiegelverkehrt sind und damit auch die Zahlen unserer Positionen gespiegelt sind. Um dem zu entgehen, retten wir uns weit in den positiven Bereich und setzen die Motorposition zu Beginn des Programms auf 3600 (wie das dann aussieht, zeige ich später). Das ist so, als hätten wir das Rad zehnmal nach rechts gedreht. Das bedeutet allerdings auch, dass unser Tresor nicht mehr richtig funktioniert, wenn du das Rad nach dem Start zehnmal (oder mehr) nach links drehst. Probiere das ruhig mal aus!

Nullpunkterkennung

Weil wir ja vor und nach der Code-Eingabe das Rad in der Nullposition (»Gold«) stehen haben wollen, brauchen wir noch eine entsprechende Erkennung. Dazu warten wir zunächst darauf, dass wir das Rad bewegt haben (b ≠ 0). Und dann darauf, dass das Rad stillsteht (b = 0) und zwar in der Position »Gold« (p = 0). Diese Befehlskette legen wir wiederum als eigenen Block mit passendem Icon an. Das Ergebnis sieht dann so aus:

Unser Block zur Nullpunkterkennung

Jetzt wissen wir also immer, auf welcher Position das Farbrad gerade steht und ob es überhaupt steht oder sich bewegt. Probiere es aus, indem du die Variablen p und b einfach so in das Programm ziehst, ohne sie irgendwo anzuschließen. Du kannst dann das Farbrad bewegen und die Ergebnisse beobachten.

Farb-Eingabe

Kommen wir also langsam zur Eingabe des Codes. Für diesen Teil machen wir uns zunächst klar, was genau passieren soll, wenn wir den Code eingeben: Zunächst wollen wir das Rad bewegen und in die Gold-Stellung bringen. Dazu haben wir uns gerade einen Block erstellt, den wir benutzen können. Dann möchten wir, dass das Rad erneut bewegt wird und auf der ersten richtigen Farbe des Codes stehenbleibt. Dann wollen wir wiederum eine Bewegung und ein Stehenbleiben auf der zweiten richtigen Farbe und so weiter. Nach der vierten richtigen Farbe soll das Rad wieder auf »Gold« gedreht werden. Dann erst soll der Tresor entriegelt werden.

Wir sehen, dass es sich bei der Eingabe der Farben um eine sich wiederholende Abfolge handelt. Um das übersichtlicher zu gestalten, legen wir die folgende Befehlskette in einem eigenen Block an: Wir warten zunächst darauf, dass sich das Rad bewegt hat. Dann warten wir darauf, dass es stillsteht und zwar auf einer Farbe und nicht auf Gold. Dann fragen wir ab, ob das Rad auf der Position steht, die wir haben wollen, also auf der richtigen Farbe. Dafür belegen wir einen Eingang des Moduls mit der Zahl, mit der wir die Position hier vergleichen wollen. Wir werden sehen, dass wir damit unseren neuen Block universell für alle vier Code-Farben verwenden können. Hat der Vergleich gestimmt, stand das Rad also auf der richtigen Farbe und es soll ein positives akustisches Signal ausgegeben werden. Und dann geht es weiter mit der nächsten Code-Farbe. Haben wir eine falsche Farbe eingegeben, soll ein negatives Signal ausgegeben werden und die ganze Code-Abfrage von vorne starten. Dazu setzen wir die globale Variable f (»falsche Eingabe«) auf »1«. Inwiefern uns das die Eingabe neu startet, werden wir im Anschluss sehen. Zunächst einmal sieht unsere Befehlskette jetzt so aus:

Unser Block für die Farbeingabe

Code-Eingabe

Jetzt haben wir alles, was wir brauchen, um die Code-Eingabe umzusetzen: Zunächst warten wir darauf, dass der Tresor verriegelt ist (v = 1), denn bei offenem Schloss brauchen wir keinen Code einzugeben. Dann setzen wir die globale Variable f, die wir gerade eingeführt hatten auf 0, weil wir ja noch keine falsche Farbe eingegeben haben. Dann warten wir darauf, dass wir das Rad in die Gold-Stellung gebracht haben und quittieren dies mit einem freudigen Signal. Jetzt benutzen wir den Farb-Eingabe-Block viermal für unseren vierstelligen Code. Die vier Zahlen, die du hier einstellst, bestimmen, welcher Farb-Code den Tresor öffnen kann. Dir sind vier Farben zu wenig? Dann kannst du gerne auch mehr einbauen, indem du unseren Block öfters einsetzt. Nach dem Code warten wir wieder auf die Nullstellung. Wenn das alles erfolgreich war, geben wir ein positives Signal aus und rufen die Entriegelungssequenz auf. Zu guter Letzt springen wir wieder zum Anfang dieser Funktion. Das Spiel kann somit wieder von vorne beginnen.

Aber Moment, haben wir nicht etwas vergessen? Was sollte noch passieren, wenn eine falsche Farbe eingegeben wurde? Richtig, wir wollten wieder zum Anfang der Code-Eingabe springen. Bisher haben wir aber bisher lediglich die Variable f auf »1« gesetzt. Für solche Sprünge im Programm bieten sich Sprungmarken an. Wir beginnen daher die gesamte Code-Eingabe-Funktion mit einer Sprungmarke (grüne Fahne) und springen am Ende wieder zu dieser Marke hin. Zugleich führen wir noch eine Befehlskette ein, die den Ablauf immer dann, wenn wir eine falsche Farbe eingegeben haben (f = 1) ebenfalls zu dieser Sprungmarke führt. Klingt kompliziert? Dann gucken wir uns schnell an, wie unsere beiden neuen Befehlsketten jetzt aussehen.

So sieht die Befehlskette zur Code-Eingabe aus. In diesem Beispiel lautet der Code: 1 – 2 – 1 – 4, also: Grün, Rot, Grün, Blau.

Der Rücksprung zum Anfang der Code-Eingabe

Warum gehen wir den Umweg über die globale Variable f und springen nicht direkt aus den Code-Modulen zurück zur Sprungmarke 1? Sprungmarken können nur innerhalb eines Moduls angesprungen werden. Wir können also nicht aus einem eigenen Block heraus an eine andere Stelle in das Hauptprogramm springen.

Schließen

Wir haben jetzt alle Module zusammen, die wir benötigen, um die Anforderung zum Schließen des Tresors umzusetzen:

Wir benutzen dazu einen Startblock mit der Bedingung, dass der Tresor nicht verriegelt ist (v = 0) und gleichzeitig das Rad schnell bewegt wird (Bewegung > 30). Anschließend warten wir darauf, dass das Rad wieder in die Stellung »Gold« zurückkommt. Dann geben wir einen Ton zur Bestätigung aus, rufen unseren Block zur Verriegelung auf und springen im Anschluss wieder zur Sprungmarke für die Code-Eingabe, damit der Tresor auch wieder geöffnet werden kann. Diese Befehlskette sieht dann so aus:

So verschließen wir den Tresor.

Ist dir etwas aufgefallen? Wir fragen den Motor auf eine Bewegung > 30 ab. Das bedeutet, wir müssen das Rad rechts herum drehen, damit das funktioniert. Drehen wir es links herum, wird diese Bedingung nicht erfüllt werden und der Tresor bleibt offen.

Start

Jetzt fehlt uns nur noch die Befehlskette zum Start, also der Teil vom Programm, der gleich zu Beginn ausgeführt werden soll: Wir wollen den Startwert für das Stellrad »weit in den positiven Bereich« verschieben, außerdem setzen wir den Motor stromlos (»Leerlauf«), damit wir ihn leichter von Hand drehen können. Teste aus, was passiert, wenn dieser Block fehlt. Du wirst es merken! Dann wollen wir, dass der Tresor zu Beginn des Programms erst mal geschlossen wird. Zu guter Letzt springen wir zur Sprungmarke 1. Die Befehlskette zum Start sieht dann wie folgt aus:

Zu guter Letzt: der Anfang unseres Programms

Fertig

Das war’s: Der Tresor ist jetzt bereit, von dir geöffnet zu werden! Bleibt nur noch die Frage, was wirst du hinein tun?

Zum Ein- und Ausschalten des Hubs drückst du die rechte runde goldene Fliese auf dem Deckel des Tresors.

Variationen

Ändere den Code.

Verlängere oder verkürze den Code.

Bitte eines deiner Geschwister oder einen Elternteil, einen Code einzustellen, den du nicht kennst. Kannst du herausfinden, welcher es war, ohne in das Programm zu schauen?

8
Bahnübergang

Beschreibung

Ein Bahnübergang ist eine Stelle, an der eine Straße oder ein Weg die Gleise der Eisenbahn kreuzt. Da Züge sehr viel längere Bremswege haben und in der Regel auch schneller fahren als Autos, wird ihnen im Straßenverkehr Vorfahrt gewährt. Damit das reibungslos funktioniert, werden moderne Bahnübergänge meistens mit automatischen Schranken und Lichtsignalen gesichert. Ein im passenden Abstand zum Bahnübergang montierter Kontakt im Gleis bewirkt, dass ein herannahender Zug die Schranken per Fernsteuerung schließen kann. Am Bahnübergang selber sind wiederum Kontakte im Gleis, die melden, wenn der Zug vollständig vorbeigefahren ist. Dann öffnen die Schranken sich wieder.

Unser Bahnübergang passt zur LEGO-City-Eisenbahn, du kannst ihn also in deine bisherige Anlage integrieren. Als Powered-Up-Komponenten benötigst du den Boost-Hub, den Motor und den Abstandssensor (alle drei sind z. B. im Boost-Set (17101) enthalten). Zusätzlich brauchst du noch einen weiteren Abstandssensor und zwei rote Fliesen in der Größe 2×4. Damit das Ganze auch im Zusammenspiel funktioniert, benötigst du so viele Gleise, um mindestens ein einfaches Oval aufbauen zu können, und einen Zug, den du per Powered Up steuern kannst. Dafür kommen zum Beispiel der Personenzug (60197) und der Güterzug (60198) infrage. Für beide zeigen wir Dir, wie du den zusätzlichen Sensor einbauen kannst.

Bei diesem Modell machen wir uns zunutze, dass ein Powered-Up-Programm mehrere Smart Hubs gleichzeitig ansteuern kann. So können wir den Zug und den Bahnübergang gleichzeitig verwenden und die Informationen vom einen zur Steuerung des anderen verwenden.

Ein echter Bahnübergang
Foto: Kai Michael Neuhold © Deutsche Bahn AG

Bahnübergang

Der Bahnübergang

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du für unser Modell:

2x

4x

16x

1x

14x

4x

4x

2x

1x

3x

4x

1x

1x

2x

2x

2x

4x

4x

1x

4x

6x

2x

5x

5x

9x

18x

6x

1x

2x

2x

4x

2x

5x

7x

5x

4x

7x

1x

6x

3x

4x

3x

5x

16x

4x

1x

2x

2x

10x

4x

8x

1x

1x

15x

9x

8x

2x

4x

4x

2x

1x

2x

2x

2x

5x

9x

7x

1x

1x

2x

2x

4x

10x

16x

1x

10x

1x

1x

8x

8x

8x

2x

1x

18x

4x

42x

8x

1x

2x

2x

Bauanleitung

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

Der Einbauraum für die Kabel im Bahnübergang

Sensor im Personenzug

Wenn du den Powered-Up-Personenzug (60197) hast, dann zeigen wir dir hier, wie du den zusätzlichen Farbsensor in die Lok einbauen kannst:

Stückliste

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Diese Teile benötigst du:

1x

1x

1x

2x

1x

1x

2x

2x

2x

2x

2x

4x

Bauanleitung

1

2

3

4

5

So sieht der finale Einbau des Sensors in die Lok aus.

Sensor im Güterzug

Stücklisten mit Teilenummern

Stücklisten mit Teilenummern der benötigten Bauteile können unter dpunkt.de/produkt/eigene-lego-modelle-programmieren/ bei »Zusatzmaterial« heruntergeladen werden.

Wenn du den Powered-Up-Güterzug (60198) hast, dann zeigen wir dir hier, wie du den zusätzlichen Farbsensor in die Lok einbauen kannst:

Stückliste

Diese Teile benötigst du:

4x

4x

2x

1x

1x

2x

2x

1x

2x

2x

2x

1x

2x

Bauanleitung

1

2

3

4

Um das Kabel in der Lok verlegen zu können, musst du den Batterieblock noch soweit verschieben, bis er an den Rand des vorderen Führerstandes stößt.

Software

Wir haben soeben mehrere Motoren und Sensoren verbaut: Im Bahnübergang selber benutzten wir einen internen Motor des Move Hubs (den Motor B), einen angeschlossenen Motor am Anschluss D und einen externen Farb-/Abstandssensor am Anschluss C. Im Zug haben wir einen Farb-/Abstandssensor am Anschluss B des Train Hubs verbaut. Im Abstand von etwa zehn Schienenelementen vor der Schranke stecken wir zwei rote Fliesen (2 × 4) der Länge nach in das Gleisbett. Sie benötigt der ankommende Zug, um den Bahnübergang »zu erkennen«. Den Abstand kannst du variieren, je nachdem, wie es bei dir am besten passt. Spiele später ruhig etwas damit herum.

Jetzt geht es darum, die Software für die eigentliche Funktion zu entwickeln. Dazu stellen wir uns zunächst die Frage, was der Bahnübergang können soll und überlegen dann, wie wir das umsetzen können.

Was der Bahnübergang können soll

Prinzipiell soll der Bahnübergang »wie ein Bahnübergang funktionieren«. Doch was heißt das konkret? Sammeln wir einmal die Anforderungen:

1. Von sich aus sollen die Schranken des Bahnübergangs offen stehen und der Farbsensor soll grünes Licht zeigen.

2. Sobald sich ein Zug nähert, sollen die Schranken schließen und das Licht soll auf »Rot blinkend« wechseln.

3. Die Schranken sollen erst wieder öffnen, wenn der Zug vollständig über den Bahnübergang gefahren ist. Damit soll auch das Licht wieder auf Grün wechseln.

4. Anschließend ist der Bahnübergang bereit für die nächste Zugdurchfahrt.

Wir sehen also, wenn man genauer darüber nachdenkt, kommt doch schnell einiges an Anforderungen zusammen.

Erreicht der Zug den Bahnübergang, müssen die Schranken geschlossen sein.

Wie der Bahnübergang das alles können soll

Jetzt überlegen wir uns, wie wir diese Funktionen umsetzen können. Nehmen wir uns zunächst die Bewegung der Schranke vor, dann können wir sie im Anschluss direkt ausprobieren. Wir legen mit der Auswahl des Controllers ein neues Projekt an und wählen den Controller mit der Straße aus. Dadurch haben wir zugleich einen Schieberegler, mit dem wir unseren Zug steuern können. Beim Anmelden der beiden Hubs achten wir darauf, dass der Move Hub im Bahnübergang der erste Hub in der Liste ist und der Train Hub des Zuges der zweite. Sollten sie andersherum angemeldet sein, so kannst du die Reihenfolge in der Liste durch Schieben noch verändern.

Zwei Hubs sind angemeldet.

Ein Hub ist erst korrekt angemeldet, wenn er in der Liste der Hubs grün dargestellt wird. Ist er orange oder weiß, so wurde er erkannt, ist aber noch nicht angemeldet. Durch Tippen auf den Listeneintrag, kannst du das ändern.

Schranke initialisieren

Zunächst fällt uns auf, dass die Schranke nur einen relativ kleinen Bewegungsspielraum hat: von senkrecht nach oben stehend bis waagerecht über der Straße liegend. In beiden Positionen gibt es jeweils mechanische Anschläge, weswegen wir vorsichtig mit der Bewegung der Schranke sein müssen, damit wir nichts kaputt machen. Auch hier ist es wieder unpraktisch, dass die Powered-Up-Motoren nichts über ihre absolute mechanische Position wissen: Nach jedem Starten des Programms zeigen sie wieder die Position 0 an, unabhängig davon, in welcher Stellung sich der Motor wirklich befindet. Wir müssen uns also eine Referenzposition schaffen und diese bei jedem Starten des Programms zuerst anfahren.

Dazu starten wir die Schrankenmotoren zunächst mit langsamer Geschwindigkeit (6 für den Motor D und -6 für den Motor B) und geben ihnen 0,5 Sekunden Zeit zum Anlauf. Dann warten wir darauf, dass der Motor sich nicht mehr bewegt, weil er in den oberen mechanischen Anschlag der Schranke gelaufen ist (sie steht jetzt sogar etwas mehr als senkrecht). Dann bewegen wir den Motor langsam um 35° zurück, sodass die Schranke nicht mehr ganz senkrecht, sondern leicht schräg steht (ungefähr bei 75°). Dann setzen wir die Motorposition auf 0 und stoppen den Motor im Leerlauf (stromlos). Die so erreichte Position ist jetzt unsere »Schranke offen«-Position. Für diese Befehlskette legen wir einen eigenen Block an, der dann so aussieht:

Unser Block zum Initialisieren der Schranke

Diesen Block rufen wir gleich zum Programmstart auf. Da die Erkennung manchmal etwas hakt, rufen wir sie zweimal nacheinander auf. Außerdem stellen wir das Licht des Farbsensors des Zuges auf Weiß ein. Das verbessert die Farberkennung unter dem Zug, wo es sonst ja sehr dunkel ist. Die Befehlskette sieht dann so aus:

Abbildung: So verwenden wir unseren neuen Block.

Schranke schließen

Als nächstes wollen wir die Schranke schließen können. Das geht am einfachsten, indem wir die Schranke bis in die waagerechte Position bewegen. Doch wie machen wir das genau? Von einer senkrecht stehenden Schranke zu einer waagerechten sind es genau 90°, wir könnten den Motor also um 90° drehen lassen. Da die Schranke nicht ganz senkrecht steht, bleiben uns etwa 75° übrig. Wenn du ausprobierst, den Motor um 75° zu drehen, wirst du feststellen, dass die Schranke nicht ganz schließt. Warum ist das so? Die beiden Zahnräder, die wir eingebaut haben, ergeben zusammen eine Untersetzung (das Gegenteil von einer Übersetzung) von 16:24 Zähnen, also einem Faktor von 2/3. Das heißt, wenn wir das kleine Zahnrad einmal komplett herumdrehen lassen, dreht sich das größere nur 2/3 rum. Da wir das kleinere Zahnrad am Motor angebaut haben, müssen wir dieses also 3/2 (1,5-mal) soweit drehen, wie wir die Schranke bewegen wollen.

Wir bewegen die Motoren daher also um 115° (75° × 1,5 und das Ergebnis dann aufgerundet). Den B-Motor mit der Geschwindigkeit 3 und den D-Motor mit -8. Damit erreichen wir eine gleichmäßige und gleichzeitige Bewegung beider Schrankenbäume. Da die Motoren alle etwas anders ausfallen können, musst du diese Werte eventuell auf deine Motoren anpassen. Probiere aus, welche Werte bei dir am besten passen. Anschließend stoppen wir die Motoren wiederum im Leerlauf. Auch für diese Befehlskette legen wir einen eigenen Block an mit einem passenden Icon. Der fertige Block sieht dann so aus:

Unser Block zum Schließen der Schranke

Schranke öffnen

Zum Öffnen der Schranke könnten wir nun einen sehr einfachen eigenen Block erstellen, der lediglich die beiden Motoren zurück in ihre Nullposition fahren lässt. Auch hier sehen wir, dass die Motoren sich sehr unterschiedlich verhalten, wir also unterschiedliche Geschwindigkeiten verwenden müssen, damit sich die Schrankenbäume gleichzeitig und gleich schnell heben: Den B-Motor mit der Geschwindigkeit 4 und den D-Motor mit der Geschwindigkeit 10. Unser fertiger Block sieht dann so aus:

Unser Block zum Öffnen der Schranke

Sollten sich deine Motoren anders verhalten – was wir nicht ausschließen können – musst du die Werte entsprechend für dich anpassen.

Zugerkennung

Um die Steuerung der Schranke zu automatisieren, müssen wir noch erkennen, wann sich ein Zug nähert und wann er an der Schranke vorbei ist.

Die Näherungserkennung machen wir über eine »Vormeldung« durch den Zug: Sobald der Sensor im Zug die roten Fliesen im Gleisbett erkennt, setzen wir die Variable a (»Zug angemeldet«) auf 1 und geben einen Pfeifton aus. Gleichzeitig rufen wir unseren Block zum Schließen der Schranke auf. Beides tun wir aber nur, wenn die Variable a noch auf 0 steht, sobald der Sensor Rot meldet. Dadurch vermeiden wir, dass die roten Fliesen im Gleis mehrfach erkannt werden. Die fertige Befehlskette sieht dann so aus:

So erkennen wir einen ankommenden Zug.

Jetzt müssen wir noch erkennen, dass der Zug am Bahnübergang vollständig vorbeigefahren ist. Dazu benutzen wir den Näherungssensor, der im Bahnübergangshäuschen eingebaut ist und eine Hilfsvariable b (»Zug am Bahnübergang erkannt«). Die Variable b setzen wir auf 1, sobald der Zug angemeldet ist (a = 1) und der Sensor den Zug sieht (Wert < 4), er also auch am Bahnübergang angekommen ist. Wir wissen jetzt also, dass der Zug da ist. Doch wie erkennen wir, dass er vorbeigefahren ist? Dazu verwenden wir eine Befehlskette, die wir mit der Bedingung starten, dass der Zug am Bahnübergang angekommen ist (b = 1), der Sensor aber keinen Zug mehr sieht (Wert > 4). Zur Sicherheit warten wir 0,5 Sekunden und warten erneut darauf, dass der Sensor keinen Zug mehr sieht. Das brauchen wir, weil der Sensor zwischen zwei Wagen »durchgucken« kann und dann würde sich die Schranke schon nach der Lok wieder öffnen. Jetzt, wo wir uns also sicher sind, dass der Zug vorbeigefahren ist, setzen wir die beiden Variablen a und b wieder zurück auf 0 und rufen unseren Block zum Öffnen der Schranke auf. Die beiden Befehlsketten sehen dann so aus:

Nach der Vorbeifahrt des Zuges öffnet die Schranke wieder.

Signalanlage

Moderne Bahnübergänge haben grundsätzlich eine »Signalanlage«, also eine optische und akustische Warnung. Zumindest die optische Warnung wollen wir hier auch haben. Leider können wir die Signalanlage in unserem Modell nicht beleuchten, da die Kabellängen der Powered-Up-LEDs das nicht hergeben. Aber wir können den Abstandssensor im Bahnübergang und auch die Hub-LEDs des Bahnübergangs und des Zuges dafür benutzen: Solange ein Zug angemeldet ist (a = 1) lassen wir die drei LEDs (Farbsensor, Move Hub und Train Hub) rot blinken. Wir schalten die Lichter für 0,2 Sekunden auf Rot und dann für 0,3 Sekunden aus und immer so weiter. Ist kein Zug gemeldet (a = 0), setzen wir alle drei LEDs auf grünes Licht. Für unser Programm legen wir je einen eigenen Block für das rote Blinken und einen für das grüne Leuchten an. Das rote Blinken sieht dann so aus:

Unser Block für das rote Signal

Das grüne Leuchten ist entsprechend einfacher:

Unser Block für das grüne Signal

Aus dem Hauptprogramm rufen wir die beiden Module auf unterschiedliche Weise auf. Unseren Block für das grüne Signal starten wir direkt, wenn die Bedingung a = 0 erfüllt ist. Den Block für das rote Blinksignal starten wir entsprechend wenn die Bedingung a = 1 erfüllt ist jedoch in einer Dauerschleife. Das Ergebnis sieht dann folgendermaßen aus:

So verwenden wir unsere Blöcke für die Signale.

Zugsteuerung

Zu guter Letzt wollen wir den Zug selber noch steuern können. Zunächst löschen wir wieder die beiden Befehlsketten, die für die Schieberegler schon vorgegeben sind, wie beim Simulator schon. Dann benutzen wir den rechten Schieberegler (Nummer 2) der Controller-Oberfläche unseres Programms und geben die Werte direkt an den Zug-Motor weiter. Beachte hierbei, dass der Train Hub als zweiter Hub mit unserem Handy verbunden ist, wir müssen also die Motorwahl entsprechend einstellen. Die Befehlskette sieht dann folgendermaßen aus:

Zu guter Letzt wollen wir den Zug auch fahren lassen können.

Fertig

Starte jetzt dein Programm, indem du auf das kleine Controller-Icon rechts oben drückst. Mit dem rechten Schieber kannst du den Zug fahren lassen. Dabei wird sich die Schranke jedes Mal schließen, wenn der Zug über die roten Fliesen fährt, und öffnen, nachdem er an der Schranke vorbeigefahren ist.

Zum Ein- und Ausschalten des Hubs im Bahnübergang drückst du einfach auf die Sirene.

Variationen

Variiere die Lage der Platten im Gleis und beobachte, was sich ändert. Welchen Einfluss hat das auf die Geschwindigkeiten, mit denen du mit deinem Zug fahren kannst?

Was passiert, wenn du den Zug in die andere Richtung auf deinen Gleisen fahren lässt? Was kannst du tun, um das beobachtete Verhalten zu verbessern?

Du kannst noch grüne Fliesen im Gleis verlegen und damit z. B. ein weiteres Pfeifen des Zuges an einer passenden Stelle auslösen.

Falls du einen weiteren Train Hub und einen Abstandssensor hast, kannst du einen Sensor am Gleis aufstellen, der vorbeifahrende Züge erkennt, anstatt den Sensor im Zug zu nutzen. Dann könnte jeder deiner Züge die Schranke steuern.

Solltest du noch mehr Sensoren und Hubs haben, kannst du noch einen zweiten Sensor auf der anderen Seite des Bahnübergangs aufstellen. Dann könntest du Züge aus beiden Richtungen erkennen.

Du kannst das Modell beliebig erweitern und ergänzen.

Danksagungen

Vielen Dank an Trixi und Steffi für Inspiration und moralische Unterstützung, sowie Henry, Hilke und Michael dafür, dass sie mich auf diese großartige Reise eingeladen haben. Außerdem danke ich Tilly und Tiki dafür, dass sie keine meiner LEGO-Steine versteckt haben.

– Christoph Ruge

Wir danken unserem dreijährigen Sohn, dass er uns teilweise minutenlang Ruhe zum Arbeiten an diesem Buch gelassen hat. Vielen Dank auch an Oma und Opa, die ihn in der übrigen Zeit mehrfach bei Laune gehalten haben …

– Hilke und Henry Krasemann

Ein besonderes Dankeschön geht an meine beiden Kinder, die mich immer wieder aufs Neue daran erinnern, wie schön und entspannend das gemeinsame Spiel mit den bunten Klemmbausteinen aus Dänemark doch sein kann. Auch wenn sie für das selbstständige Programmieren ihrer LEGO-Modelle noch zu jung sind, das Bespielen und Ausprobieren der zusammengebauten Powered-Up-Kreationen macht ihnen dafür umso mehr Spaß.

– Michael Friedrichs

Fußnoten

4 Programmierung

1Die Sanduhr nutzen wir auch beim Bahnübergang zur Erkennung des durchfahrenden Zuges.

5 Powered Up mit anderen Programmiersprachen programmieren

1https://www.microsoft.com/store/productId/9N48XLLCZH0X

2Langversion: https://bricklife.github.io/scratch-gui/?fbclid=IwAR2x86zwPLI_OZGRNbBTL0GtmLfPbZMNmYeI9QNQ8nMou-cPJsIJ-pYzuwQ.

3https://github.com/nathankellenicki/node-poweredup

4www.pybricks.com