THAMES and KOSMOS 620141 Kosmobits / Code Gamer User Manual 1620141 KosmoBits Manual Cover indd

Download:
Mirror Download [FCC.gov]
Document ID	3149688
Application ID	dW2Ks+4xp1Q7/5s5ro5AFQ==
Document Description	Users Manual - German version
Short Term Confidential	No
Permanent Confidential	No
Supercede	No
Document Type	User Manual
Display Format	Adobe Acrobat PDF - pdf
Filesize	271.52kB (3394035 bits)
Date Submitted	2016-09-28 00:00:00
Date Available	2016-09-28 00:00:00
Creation Date	2016-07-21 19:51:04
Producing Software	Adobe PDF Library 10.0.1
Document Lastmod	2016-09-28 15:48:03
Document Title	1620141_KosmoBits_Manual_Cover.indd
Document Creator	Adobe InDesign CS6 (Macintosh)

EXPERIMENTIERKASTEN
Anleitung
Spielend Programmieren lernen
Impressum
1. Auflage 2016
0718021 AN 300416
© 2016 Franckh-Kosmos Verlags-GmbH & Co. KG • Pfizerstraße 5–7 • 70184 Stuttgart
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen,
Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen, Netzen und Medien.
Wir übernehmen keine Garantie, dass alle Angaben in diesem Werk frei von Schutzrechten sind.
Projektleitung: Jonathan Felder, Marc Gänssler, Sebastian Martin
Text und Versuche: Felix Homann
Produktentwicklung: Steffen Rothweiler
Gestaltungskonzept Anleitung: Atelier Bea Klenk, Berlin
Layout und Satz: Michael Schlegel, komuniki, Würzburg
Illustrationen: Michael Schlegel, komuniki, Würzburg
Fotos Anleitung: picsfive (alle Pinn-Nadeln); askaja (alle Büroklammern); Jaimie Duplass (alle Klebestreifen) (alle vorigen © fotolia.com);
8vFanl (S. 61 ur); hopsalka (S. 61 o); krista (S. 2 ul, S. 21 ur); tepic (S. 20 u) (alle vorigen © iStockphoto.com); Designua (S. 38 u)
(© shutter­stock.com); leejeongsoo (S. 35 u); theSOARnet (S. 38 o); Petr Kratochvil (S. 33 o) (alle vorigen © pixabay.com); Johannes
(S. 2 mr, S. 21 or); Willi Heidelbach (S 27) (alle vorigen veröffentlicht unter CC BY-SA 2.5 einzusehen unter https://creativecommons.
org/licenses/by-sa/2.5/deed.de); Philip Steffan (S. 60 alle, © Make Magazin); Alle Screenshots des Arduino-Programms © Arduino;
Andreas Resch, argfx, St. Ulrich am Waasen (U1, S. 1 Rendering Gamepad, S. 1 und S. 32 SensorBots); Michael Flaig, proStudios,
­Stuttgart (S. 1 Zusatzmaterial); Matthias Kaiser, Stuttgart (alle anderen Fotos)
Gestaltungskonzept, Layout und Satz Verpackung: Michael Schlegel, komuniki, Würzburg
Fotos Verpackung: Andreas Resch, argfx, St. Ulrich am Waasen (alle Renderings); Michael Flaig, pro-studios, Stuttgart (Materialfoto)
Fällen ein Bildrechtinhaber nicht berücksichtigt worden sein, wird er gebeten, seine Bildrechtinhaberschaft gegenüber dem
Verlag nachzuweisen, so dass ihm ein branchenübliches Bildhonorar gezahlt werden kann.
Technische Änderungen vorbehalten. Printed in China / Imprimé en Chine
Art.-Nr.: 716032
Der Verlag hat sich bemüht, für alle verwendeten Fotos die Inhaber der Bildrechte ausfindig zu machen. Sollte in einzelnen
Franckh-Kosmos Verlags-GmbH & Co. KG · Pfizerstraße 5 – 7 · 70184 Stuttgart · Telefon +49 (0) 711 2191-343
1000 1001
1101 101 00
100 10
› › › SICHERHEITSHINWEISE
1010
Sicherheitshinweise
ACHTUNG! Nur für die Benutzung durch Kinder ab
10 Jahren oder älter. Anweisungen für Eltern oder
­andere verantwortliche Personen sind enthalten und
müssen beachtet werden. Verpackung und Anleitung
aufbewahren, da sie wichtige Informationen
enthalten!
ACHTUNG! Nicht für Kinder unter 3 Jahren geeignet.
Erstickungsgefahr, da kleine Teile verschluckt oder
eingeatmet werden können.
Liebe Eltern,
dieser Experimentierkasten macht Ihr Kind auf spielerische Weise in spannenden Experimenten mit der
Welt des Programmierens vertraut.
Bitte stehen Sie Ihrem Kind bei den Experimenten
mit Rat und Tat zur Seite, unterstützen und begleiten
Sie es.
Natürlich stellen Sie die Frage nach der Sicherheit.
Dieser Kasten entspricht den Europäischen
Sicherheitsnormen. Diese Normen enthalten Auflagen für den Hersteller, sehen aber auch vor,
dass die Eltern ihren Kindern bei den Experimenten
mit Rat und Tat zur Seite stehen.
Sagen Sie Ihrem Kind ausdrücklich, dass es alle
­relevanten Anweisungen und Sicherheitshinweise
­lesen und nachschlagebereit halten soll. Machen
Sie es auch darauf aufmerksam, dass es die Hinweise
und Regeln beim Experimentieren unbedingt ein­
halten muss.
Wir wünschen Ihrem Kind und natürlich auch Ihnen
viel Spaß und Gewinn beim Experimentieren!
Für neugierige Forscher
Hinweise zum Unweltschutz
ukts sind wiederverDie elektronischen Teile diese s Prod
Umwelt am Ende ihrer
der
tz
Schu
zum
en
wertbar und dürf
sabfall entsorgt
Verwendung nicht über den Haushalt
unkt für Elektromelp
werden. Sie müssen an einem Sam
bol
Sym
es
Dies
en.
schrott abgegeben werd
weist darauf hin:
everBitte erfragen Sie bei Ihrer Gemeind
telle .
waltung die zuständige Entsorgungss
Entdecken, verstehen, Spaß haben!
Entsorgung des Akkus
müll!
Der Akku gehört nicht in den Haus
­Jeder Verbraucher der EG ist gesetzlic
einer
bei
Akku
­verpflichtet Batterien und
im
Sammelstelle seiner Gemeinde oder
rch einer umwelt­
dadu
wird
Akku
Der
n.
gebe
abzu
Handel
­ kkus,
erien und A
Batt
t.
schonenden ­Entsorgung zugeführ
en oder
Zeich
diese
durc
sind
die Schadstoffe e­ nthalten,
= Cadmi(Cd
et
ichn
nnze
geke
bole
Sym
durch chemische
um, Hg = Quecksilber, Pb = Blei).
Hinweise zum Umgang mit dem Akku
››› F
 ür die Experimente wird ein Lithium-Polymer-­Akku
verwendet. Bitte ausschließlich den mitge­lieferten
Akku verwenden!
››› D
 er Akku darf nur unter Aufsicht von Erwachsenen
­geladen werden.
››› K
 eine Experimente mit den Steckdosen des Lichtnetzes
durchführen! Keine Drähte oder Bauteile in Steckdosen
einführen! Die Netzspannung (230 Volt!) ist
lebensgefährlich!
››› B
 eim Experimentieren einen Kurzschluss des Akkus
vermeiden, er könnte überhitzen und explodieren!
››› A
 nschlüsse des Akkus dürfen nicht kurzgeschlossen
werden!
››› D
 er Akku muss mit der richtigen Polarität eingelegt
werden.
››› V
 erformungen des Akkus vermeiden.
››› B
 ei Defekt des Akkus muss dieser aus dem Spielzeug
herausgenommen werden.
››› B
 ewahre das Set außerhalb der Reichweite von kleinen Kindern auf.
››› D
 er Zusammenbau des Geräts und das Einsetzen des
Akkus, muss entsprechend den Anweisungen
in dieser Anleitung erfolgen, um die Zerstörung
von Bauteilen zu vermeiden.
Hinweise zum Umgang mit den elektronischen Bauteilen
››› D
 en Kontakt mit metallischen Gegenständen und
Flüssigkeiten aller Art vermeiden!
››› N
 ach dem Experimentieren alle empfindlichen Bau­
teile in die vorgesehenen Tüten verpacken und zusammen mit den anderen Teilen im Experimentkasten
aufbewahren.
››› S
 ollte die KosmoBits-Hardware längere Zeit nicht
­benutzt werden, bitte das Anschlusskabel des Akkus
vom Interaction Board lösen.
››› D
 as Spielzeug darf nur an Geräte der
Schutzklasse II angeschlossen werden,
die das folgende Bildzeichen tragen:
Vereinfachte EU-Konformitätserklärung
Hiermit erklärt die Franckh-Kosmos Verlags-GmbH & Co.
KG, dass der Funkanlagentyp 620141 KosmoBits der
Richtlinie 2014/53/EU entspricht.
Der vollständige Text der EU-Konformitätserklärung ist
unter der folgenden Internetadresse verfügbar:
http://www.kosmos.de/content-943-943/
entsorgung_und_sicherheit/
 Mondkrater, Galaxien, Planeten und Gasnebel – all das rückt zum Greifen nah, wenn
du mit dem Linsenteleskop auf Entdeckungsreise gehst. Durch die hohe optische und
technische Qualität macht das Beobachten
besonders viel Spaß. Auch Vögel oder Waldtiere lassen sich mit der beiliegenden Bildumkehrlinse hervorragend beobachten.
ab 12 Jahren
ab 12 Jahren
 Mit dem KOSMOS-Qualitätsmikroskop
kannst du nicht nur klassische mikroskopische
Präparate wie das Zwiebelhäutchen im Durchlicht, sondern auch flache Objekte wie Blä‘er
oder Münzen im Auflicht betrachten. Die hohe
Qualität der optischen und mechanischen Teile
ermöglichen dir spannende Untersuchungen
in der Welt der kleinen Dinge. Mit vier Dauerpräparaten, umfangreichem Präparierzubehör sowie umfassender Anleitung mit vielen
praktischen Tipps.
kosmos.de
Kosmobit.indd 1
12.04.16 11:54
Sicherheit und Qualität:
KOSMOS Experimentierkästen werden von unserem erfahrenen Team mit
größter Sorgfalt entwickelt und in allen Entwicklungs- und Produktionsschritten geprüft.
Im Hinblick auf die Produktsicherheit entsprechen unsere Experimentierkästen den europäischen Spielzeugrichtlinien und unseren eigenen durch langjährige Erfahrung e­ ntstandenen Standards. Um höchste Sicherheit zu gewährleisten, arbeiten wir
bei unseren c­ hemischen Experimentierkästen mit zertifizierten Prüfstellen zusammen.
Durch die enge Zusammenarbeit mit unseren Partnern in der Produktion sind wir in der Lage, alle
Arbeitsschritte der Fertigung zu kontrollieren. Traditionell stellen wir die Mehrzahl unserer Produkte in Deutschland her, aber auch bei Experimentierkästen, die im Ausland produziert w
­ erden,
gewährleisten wir damit die Einhaltung aller geforderten Standards.
KosmoBits
› › › AUSSTATTUNG
Was in deinem Experimentierkasten steckt:
le des
nach­
ich
ürl
nat
du
Kastens kannst
fach
ein
daz
dir
Lad
len
bestel
er kosmos.de
­einen Bestellschein unt
her unter.
GUT ZU WISSEN ! Die Tei
10
11
15
14
16
18
19
17
13
20
12
21
Checkliste: Suchen – Anschauen – Abhaken
Nr.
Bezeichnung
Anzahl
KosmoDuino
Interaction Board
Gamepad Gehäuse-Oberseite rechts
Gamepad Gehäuse-Oberseite links
Gamepad Gehäuse-Unterseite
Rad mit Rückstellfeder
Knöpfe mit Gummistempel
Lichtsensor
Schallsensor
10
Temperatursensor
11
Bewegungssensor
12
Gehäuse für Schallsensor
13
Gehäuse für Lichtsensor
14
Gehäuse für Temperatursensor
Art.-Nr.
717 982
717 981
718 006
718 007
718 005
718 008
718 009
718 010
718 011
717 985
717 986
717 984
717 983
718 000
718 004
717 999
718 003
717 997
718 001
Nr.
Bezeichnung
Anzahl
15
Gehäuse für Bewegungssensor
16
Breadboard
17
Jumperkabel
10
		 männlich-weiblich
18
Jumperkabel
10
		 männlich-männlich
19
Widerstände: 330 Ohm
20
LEDs: gelb
je 1
grün		
blau		
rot		
21
Kabel: USB zu Micro-USB
22
Lithium-Polymer-Akku 800 mAh, 3,7 V
(ohne Bild)
Art.-Nr.
717 998
718 002
717 996
717 990
717 989
717 991
717 994
717 993
717 995
717 992
717 988
717 987
Was du zusätzlich brauchst:
Smartphone/Tablet mit Android (ab 4.3) oder iOS (ab Version 7),
das Gerät muss Bluetooth 4 oder höher unterstützen. PC mit
Internetzugang
1000 1001
1101 101 00
100 10
› › › INHALT
1010
Sicherheitshinweise .............................. Vordere Umschlaginnenseite
Ausstattung............................................................................................... 1
Inhalt........................................................................................................... 2
So startest du mit KosmoBits ...................................................................3
Das Gamepad und die Sensoren zusammenbauen
Die App
Die Welt der Mikrocontroller ..................................................................... 6
Vorbereitung .................................................................................................. 8
Installation der Arduino-Software
Projekt 1: Blink! ................................................................................................... 9
Ein Programm auf deinen KosmoDuino hochladen
Projekt 2: Ausschalter ......................................................................................14
Projekt 3: Einschalter .......................................................................................15
Das Interaction Board ...................................................................................... 17
Projekt 4: Buntes Licht ....................................................................... 18
Projekt 5: Auf Tastendruck ................................................................ 22
Projekt 6: Blink-Würfel .......................................................................26
Projekt 7: Der serielle Monitor ............................................................28
Die for-Schleife ...................................................................................... 30
Sensoren ................................................................................................... 32
Projekt 8: Thermometer .........................................................................33
Projekt 9: Finger-Disko .......................................................................... 36
Projekt 10: Piep! ....................................................................................... 38
Projekt 11: Zufallstöne! .......................................................................... 39
Projekt 12: Sirene .................................................................................... 40
Projekt 13: Tonleiter .............................................................................. 43
Projekt 14: Sensor-Orgel ...................................................................... 44
Projekt 15: Der serielle Plotter ........................................................... 46
Projekt 16: Der Klatschschalter ........................................................ 47
Projekt 17: Der Schubladenwächter ................................................ 48
Projekt 18: In den Kühlschrank geschaut ...................................... 53
Projekt 19: Geisteraugen ................................................................... 55
Häufige Fehlermeldungen .............................................................................. 62
TIPP !
Notizen ................................................................................................................64
Impressum .........................................................Hintere Umschlagaußenseite
den
en findest du auf
Zusätzliches Wiss
un
en 21, 59 – 61 d
»Nachgehakt«-Seit
25,
pakt«-Seiten 24 –
den »Wissen Kom
35, 41 – 42 und 58
KosmoBits
LOS GEHT’S
So startest du mit KosmoBits
DAS GAMEPAD ZUSAMMENBAUEN
1. Zuallererst musst du die kleine Metall-Feder in die
­richtige Stelle im linken Teil der Gehäuse-Unterseite
­stecken. Die Feder hält später das Rad und sorgt dafür,
dass es immer wieder in seine ursprüngliche Position
z­ urückspringt.
2. Als nächstes musst du den dünnen Stift des Rades in
das Loch des Dreh-Encoders stecken. Pass dabei auf,
dass der Stift nicht abbricht. Der Dreh-Encoder ist
auf dem Interaction Board befestigt und dort auch
beschriftet.
3. Verbinde den Akku mit dem Interaction Board. Der Anschluss befindet sich auf der Unterseite. Der Stecker des
Akkus ist so geformt, dass er sich nur mit der richtigen
Polung ­verbinden lässt. Wende beim Verbinden keine
­ ewalt an!
4. Der Akku hat seinen festen Platz in der Gehäuse-Unterseite. Lege ihn so hinein, dass er fest sitzt und nicht
wackelt.
5
5. Jetzt kannst du das Interaction Board in das Gehäuse
einsetzen. Achte darauf, dass das Rad richtig in der
­Feder sitzt (siehe rundes Bild).
6. Die Knöpfe müssen auf der Unter­
seite mit den grauen Gummistempeln
bestückt werden. Diese einfach mit
der dünneren Seite in die Aussparungen
auf der Unterseite der Knöpfe einstecken. Dann kannst
du die Knöpfe von unten in die rechte Gehäuse-Oberseite
einfügen.
Anschließend musst du noch die restlichen Gehäuseteile
aufstecken. Achte auf die richtige Positionierung der
Knöpfe. Die Knöpfe sitzen richtig, wenn du beim Drücken
einen klaren Druckpunkt spürst.
7. Dein Gamepad ist jetzt eigentlich fertig, es fehlt nur
noch die »Schaltzentrale«, der KosmoDuino.
Diesen kannst du einfach auf das Interaction Board aufstecken. Achte darauf, dass alle Pins passen und sich
beim Einstecken nicht verbiegen. Drücke den Kosmo­
Duino so weit rein, dass seine »Füßchen« nicht mehr zu
sehen sind.
DIE SENSORBOTS ZUSAMMENBAUEN
1. Nimm einen der Sensoren und suche dir das entsprechende Gehäuse mit der richtigen Farbe (Bewegungssensor –
blau; Temperatursensor – rot; Lichtsensor – lila; Schallsensor – gelbgrün. Siehe S. 1 »Ausstattung«). Stecke den
Sensor mit der Vorderseite voran in die Gehäusehälfte
mit den aufgedruckten Augen. Die »Füßchen« der Sensoren sind immer auf der Rückseite befestigt. Achte beim
Temperatursensor darauf, dass der kleine schwarze
Knubbel leicht aus dem Loch im Gehäuse ragt.
2. Jetzt musst du nur noch die Gehäuse-Rückseite mit der
Gehäuse-Vorderseite verbinden. Drücke sie dafür fest
zusammen.
KosmoBits
SYSTEMVORAUSSETZUNGEN:
KosmoBits unterstützt Geräte ab
den Betriebssystemen Android 4.3
und iOS 7 und neuer. Das Gerät
muss Bluetooth 4 oder höher
DIE APP
unterstützen.
Um dir den Einstieg in die Welt des Programmierens zu
­erleichtern, haben wir eine App entwickelt, mit der du
­erste Erfahrungen zu dem Thema sammeln kannst.
Kern der App ist ein Spiel, in dem du immer mal wieder kleine
Programmier-Rätsel lösen musst. Aber keine Angst – diese
sind nicht schwer, sodass du sie bestimmt alle knacken
kannst. Der Schlüssel zum Lösen der Rätsel sind die Codemonster, die du in jedem Level findest. Sammle alle ein, denn
du brauchst sie an den Computerterminals. Die Computer­
terminals enthalten lückenhaften Code. Diese Lücken füllst
du, indem du das richtige Codemonster in die passende Lücke
ziehst. Um mehr über die Monster zu erfahren, kannst du sie
in deinem Inventar einfach oder doppelt antippen - so verraten sie, welche Lücke im Code sie ausfüllen können.
Um die Figuren im Spiel zu steuern, kannst du dein Gamepad verwenden. Dafür muss Bluetooth auf deinem Tablet
oder Smartphone aktiviert sein. Starte einfach die App und
schalte dein Gamepad ein, indem du den Schalter am oberen Rand auf die Position »ON« schiebst. Die Verbindung
erfolgt dann automatisch. Ist die Verbindung aktiv, verschwinden die Steuerelemente auf dem Bildschirm und du
kannst die App nur noch mit dem Gamepad steuern. Schaltest du dein Gamepad aus, erscheinen die Steuerelemente
wieder. Ohne das Gamepad macht das Spiel aber nur halb
so viel Spaß!
◀ ▲ Verschiedene Screenshots der KosmoBits-App
!
SO LÄDST DU DIE KOSTENLOSE APP HERUNTER:
Für das Installieren einer App benötigst du Zugang zu Google Play oder zum Apple App
Store. Bitte deine Eltern um Unterstützung beim Installieren der App.
Wenn du ein Gerät mit Android hast, öffne Google Play, mit einem IPhone musst du den
App Store öffnen. Gib ­einfach den Suchbegriff KosmoBits ein und installiere die App.
Für das Spiel benötigst du deine vier SensorBots. Die sind
sehr nützlich und helfen dir, Hindernisse im Spiel aus dem
Weg zu räumen. Du kannst sie einfach in dein Gamepad
einstecken (siehe Bild). Sobald du einen Sensor eingesteckt
hast, ­verwandelt sich dein Spiele-Charakter in einen der
vier Bots. Jeder von ihnen hat seine ganz eigenen Fähigkeiten. Hast du z.B. den blauen Bot "Newton" eingesteckt,
musst du dein Gamepad kräftig nach vorne und hinten
schütteln, damit seine Fähigkeiten aktiviert werden. Du
findest bestimmt selbst heraus, wie du bei den anderen
Sensorbots die Spezialfähigkeiten aktivierst.
Spiel das Spiel in Ruhe durch und schau dir auch die an­
deren Inhalte der App im Hauptmenü an. Dort erfährst
du schon eine Menge zu deinem Experimentierkasten und
zum Thema Programmieren.
Viel Spaß dabei!
Die Welt der
Mikrocontroller
Willkommen in der Welt der Mikrocontroller! Sie sieht deiner eigenen Welt erstaunlich ähnlich. Genauer gesagt: Sie
sieht haargenau so aus wie deine! Überall in deiner Umgebung verstecken sich unzählige Mikrocontroller und verrichten unbemerkt ihre Arbeit. Kaum ein elektrisches Gerät
funktioniert noch ohne einen Mikrocontroller: Die elektrische Zahnbürste, die Fernbedienung des Fernsehers, das
Gamepad, das Digitalthermometer, die sprechende Puppe,
der bellende Spielzeughund, die Waschmaschine, der
Rauchmelder, der Toaster, und und und …
▲ KosmoBits-Controller
KosmoBits
ABER WAS IST EIN
MIKROCONTROLLER?
Ein Mikrocontroller ist ein ziemlich kleiner (»Mikro«) Computer. Er unterscheidet sich allerdings grundlegend von
den Computern, mit denen du normalerweise zu tun hast:
Er hat keine Tastatur, keine Maus, auch einen Bildschirm
findest du nicht.
Stattdessen besitzt er eine Menge kleiner Füßchen. Die
werden Pins genannt. Ein Pin ist so etwas wie die Verbindung des Mikrocontrollers zur Außenwelt. Einige der Pins
haben festgelegte Funktionen. Die meisten sind allerdings
sogenannte GPIO-Pins. Das ist eine Abkürzung für
»Allzweckeingabe/-ausgabe« (engl. General Purpose Input / Output). Diese GPIO-Pins können zur Ein/- oder Ausgabe benutzt werden. So, wie du es gerade brauchst.
1. EINGABE:
Du kannst einen Eingabe-Pin zum Beispiel mit einem Sensor verbinden. Dieser überwacht die Außenwelt und
schickt über wechselnd hohe elektrische Spannung Informationen über die Umgebung, wie Temperatur oder Helligkeit an den Prozessor. Bei deinem Gamepad registriert ein
Eingabe-Pin auch, wenn du eine Taste drückst.
2. AUSGABE:
Der Prozessor kann je nach Programmierung auf diese Informationen reagieren. Dafür brauchst du Ausgabe-Pins,
die die Verbindung zu LEDs oder zum Soundmodul herstellen, welche durch die Höhe der weitergeleiteten elektrischen Spannung mit verschiedenen Tönen und Farben
reagieren.
Richtig spannend wird es dann, wenn du mehrere Pins
gleichzeitig benutzt. So kann der Mikrocontroller selbstständig auf die Sensoren reagieren, also beispielsweise
Alarm schlagen, wenn es ihm zu warm wird.
Was dein Mikrocontroller mit einem normalen Computer
gemein hat, ist der Hauptprozessor, das Gehirn eines jeden
Computers. Das ist das kleine schwarze Viereck oben links
auf dem Mikrocontroller. In der Mitte befindet sich ein kleinerer Prozessor. Dieser ist für die Kommunikation zwischen
Micocontroller und PC verantwortlich. Rechts sitzt der
Bluetooth-Chip, der eine drahtlose Verbindung ermöglicht.
WAS BEDEUTET EIGENTLICH ARDUINO?
In dieser Anleitung wird dir immer wieder das Wort »Arduino«
­begegnen. Das ist der Name für eine weit verbreitete Mikrocon­
troller-Plattform, also Platinen und dazugehörige Entwick­
lungsumgebung, von der der KosmoDuino abgeleitet wurde.
Lange Zeit war die Mikrocontroller-Programmierung nur etwas
für Spezialisten. Die Begründer des Arduino-Projektes haben es
sich im Jahr 2005 deshalb zur Aufgabe gemacht, die Programmie­
rung und Nutzung einfacher Mikrocontroller so simpel wie möglich
zu gestalten. Kunststudenten, die nie zuvor etwas mit Programmierung zu tun hatten, sollten damit in der Lage sein,
Mikrocontroller in ihrer Arbeit zu verwenden.
Rund um die Arduino-Plattform hat sich mittlerweile eine große Community gebildet, die unzählige interessanter
­Projekte entwickelt hat. Viele davon kannst du mit deinem KosmoDuino nachbauen: Er ist mit einem Arduino Uno
Board kompatibel.
Mehr zum Arduino-Projekt erfährst du auf www.arduino.cc. Allerdings ist die Seite englischsprachig.
DER KOSMOBITS-CONTROLLER
Mit deinem KosmoBits-Controller hältst du nun deinen
­eigenen Mikrocontroller in den Händen. Wir haben ihn
­KosmoDuino genannt, da er vom Arduino-Mikrocontroller
abgeleitet wurde. Was er genau macht, ist deine Entscheidung. Denn damit er überhaupt etwas macht, muss er von
dir programmiert werden.
Wie das geht, erfährst du in dieser Anleitung.
Vorbereitung
Um deinen KosmoDuino zu programmieren, benötigst
du einen normalen PC oder einen Laptop mit der
­Arduino-Software. Die Software wird auch ProgrammierUmgebung genannt, da sie eine Vielzahl von Hilfsmitteln
zusammenfasst, die du zum Programmieren brauchst.
Nach dem Download führst du die heruntergeladene Datei
aus. Da die Arduino-Software ständig überarbeitet wird,
gibt es immer wieder neue Versionen. Zu dem Zeitpunkt,
als diese Anleitung entstanden ist, war die Version 1.6.6
aktuell, die Datei hieß arduino-1.6.6-windows.exe.
Wir empfehlen aber das Arbeiten mit der Version 1.6.5, da
diese von uns ausgiebig getestet wurde. Ältere Versionen
findest du auf der Seite unter »PREVIOUS RELEASES«.
Nach dem Start der Datei folgst du den Anweisungen des
Installationsprogramms.
INSTALLATION DER KOSMOBITS-­
BIBLIOTHEKEN UND BEISPIELE
INSTALLATION DER KOSTENLOSEN
ARDUINO-SOFTWARE
In einer sogenannten Software-Bibliothek werden nützliche und wieder verwendbare Funktionen zur Verfügung
gestellt, die dir das Programmieren erleichtern. Wir haben
die KosmoBits-Bibliotheken entwickelt. Sie enthalten auch
sämtliche Programmier-Beispiele, die du in dieser Anleitung findest.
Die Arduino-Software lädtst du von der Seite
https://www.arduino.cc/en/Main/Software herunter.
Dort findest du verschiedene Versionen für die gängigsten
Betriebssysteme. Für Windows-Betriebssyteme wählst du
»Windows Installer« aus.
Die KosmoBits-Bibliotheken kannst du auf der Seite
www.kosmobits.de/downloads herunterladen. Die Datei
heißt KosmoBits_Archiv.zip.
Es handelt sich um eine .zip-Datei, die du in den ArduinoOrdner entpacken musst.
1. Öffne den Explorer.
2. Gehe in den Downloads-Ordner.
3. Öffne die Datei KosmoBits_Archiv.zip mit einem
Doppelklick.
4. Markiere alle in dem Archiv vorhandenen Dateien und
Ordner, indem du gleichzeitig die Tasten »Strg« und
»A« drückst.
5. Drücke dann die Tasten »Strg« und »C«, um die ausgewählten Dateien zu kopieren.
6. Gehe in den Ordner Dokumente ➜ Arduino ➜ libraries.
▲ Downloadseite auf www.arduino.cc
Auf der folgenden Seite wirst du um eine Spende gebeten.
Das Arduino-Projekt, das die Entwicklung der ArduinoSoftware vorantreibt, finanziert sich zu einem großen Teil
aus solchen Spenden. Du kannst die Software aber auch
ohne Spende kostenlos herunterladen, indem du auf »Just
Download« klickst.
7. Drücke nun gleichzeitig die Tasten »Strg« und »V«, um
die Dateien und Ordner einzufügen.
Prima, jetzt kannst du mit dem Programmieren beginnen.
Du brauchst nur noch die Arduino-Software zu starten,
und schon kann es losgehen!
KosmoBits
PROJEKT 1
ERKLÄRUNGEN ZUM PROGRAMM-CODE:
Hier steht die Erklärung zum Programm-Code. Teile aus
dem Code sind immer orange hinterlegt.
Hier steht der Programm-Code
// Kommentare zum Code sind immer grau.
// Dieser Text gehört nicht zum Code, sondern
// dient der Erklärung und der Übersichtlichkeit

Dein erstes Programm: Blink!
Um dein erstes Programm zu schreiben, startest du am PC
die Arduino-Umgebung. Es öffnet sich ein Fenster, in das
du deinen Programm-Code eingeben kannst. Ein paar Zeilen sind bereits für dich vorgefertigt worden:
void setup() {
Das ist das Grundgerüst eines jeden Arduino-Programms:
void loop() {
1. Dein KosmoDuino arbeitet zunächst alle Anweisungen
in der Funktion setup() ab, also alle Anweisungen, die
in den geschweiften Klammern nach setup() stehen.
// put your setup code here, to run once:
// put your main code here, to run repeatedly:
2. Danach wird die Funktion loop() aufgerufen. Das
heißt, dein Mikrocontroller arbeitet alle Anweisungen
innerhalb der geschweiften Klammern nach loop() ab.
Wenn die letzte Anweisung abgearbeitet wurde, ruft
dein Controller die Funktion loop() erneut auf. Das
heißt, die Anweisungen in loop() werden in einer Endlosschleife immer und immer wieder aufgerufen. Daher
auch der Name: loop ist Englisch und bedeutet Schleife.
ARDUINO WIRD EINGESCHALTET
setup()
Das kann man sich gut mit einem sogenannten Flussdia­
gramm veranschaulichen: Das Programm folgt dabei immer der Pfeilrichtung: Vom Einschalten, zu setup() , zu
loop() und dann immer wieder zu loop() zurück.
loop()
▲ Flussdiagramm
Du könntest das bereits als Programm auf deinen KosmoDuino hochladen. Da aber weder in setup() noch in
loop() irgendwelche Anweisungen stehen, würde das
Programm eben auch nichts machen.
Deshalb gibst du deinem KosmoDuino jetzt etwas zu tun!
Ändere dazu den Programm-Code folgendermaßen ab:
int ledPin = 13;
void setup() {
pinMode(ledPin, OUTPUT);
void loop() {
digitalWrite(ledPin, HIGH);
mierung
Im Bereich der Arduino-Programm
Begriff
wird für ein Programm auch oft der
tung
»Sketch« verwendet. In dieser ­Anlei
utzt
werden beide Begriffe ben
delay(500);
digitalWrite(ledPin, LOW);
delay(500);
PROJEKT 1
Lass dich von den englischen Begriffen und unterschiedlichen Klammern nicht abschrecken! Wir gehen das Programm
gleich Schritt für Schritt durch. Dann wirst du sehen, dass es gar nicht so schwer zu verstehen ist!
Vorher wollen wir uns aber ansehen, was das Programm eigentlich macht. Du musst es also auf deinen KosmoDuino laden.

EIN PROGRAMM AUF DEN K
­ OSMODUINO HOCHLADEN
Um einen Sketch auf deinen KosmoDuino hochzuladen,
gehst du wie folgt vor:
1. Schließe den KosmoDuino mit dem USB-Kabel an deinen
Computer an. Das Interaction Board benötigst du nicht.
2. Speichere deinen Programm-Code wenn nötig ab. Klicke
dazu auf das »Speichern«-Symbol in der
Arduino-Umgebung.
3. Stelle sicher, dass die richtige Platine ausgewählt ist:
Werkzeuge ➜ Platine ➜ »Arduino/Genuino Uno«.
4. Stelle sicher, dass du den richtigen Port ausgewählt
hast:
Werkzeuge ➜ Port ➜ z.B. »COM3« (Arduino/Genuino
Uno).
Neu
Öffnen
Hochladen
Verifizieren
Statuszeile
Fenster für nähere
Erläuterungen
5. Klicke jetzt in der Arduino-Umgebung auf das
»Hochladen«-Symbol.
Wenn du alles richtig gemacht hast, sollten in der Statuszeile der Arduino-Umgebung nacheinander die folgenden
Meldungen erscheinen:
1. Sketch wird kompiliert …
Sketch wird kompiliert …
2. Hochladen …
Hochladen …
3. Hochladen abgeschlossen.
Hochladen abgeschlossen.
gleichzeitig auf
Du kannst immer nur ein Programm
n du mit dem
deinen KosmoDuino hochladen. Wen
len möchtest,
GamePad das KosmoBits-Spiel spie
.ino aufspielen.
musst du die Datei KosmoBits_ App
g des Kastens auf
­Diese Datei ist auch bei Auslieferun
dem KosmoDuino vorinstalliert.
10
Speichern
KosmoBits
PROJEKT 1
FEHLERMELDUNG?
Solltest du eine Fehlermeldung sehen, schaue dir deinen
Text noch einmal genau an. Hast du vielleicht etwas
falsch geschrieben? Die Stelle, an der ein Fehler im Pro­
grammtext zu Problemen führt, wird in der Arduino-Um­
gebung rot markiert, siehe Abbildung. A
­ llerdings ist der
wirkliche Fehler oft schon vorher zu s­ uchen. Schon kleine
Tippfehler führen in der Regel zu F
­ ehlermeldungen!
­Solltest du keinen Fehler finden, dann schau dir den
­gelben Kasten weiter unten an. Dort wird unter »BeispielProgramme öffnen« erklärt, wie du die in der Anleitung
­beschriebenen Beispiele nutzen kannst, ohne sie selbst
­eintippen zu müssen.
'pinnMode' was not declared in this scope
Fehlermeldungen kopieren
BlinkOnBoard.ino: In function 'void setup()':
Tippfehler: »pinnMode« statt »pinMode«!
Die Fehlerstelle ist rot hinterlegt. ▶
BlinkOnBoard:11: error: 'pinnMode' was not declared in this scope
'pinnMode' was not declared in this scope
Hat alles geklappt? Prima! Dann solltest du jetzt sehen,
dass auf dem KosmoDuino eine kleine, grüne LED – die sogenannte »Onboard-LED« – regelmäßig blinkt.
Beispiel-Programme öffnen
auch direkt öffnen.
Alle Programmbeispiele kannst du
ung unter
Du findest sie in der Arduino-Umgeb
«.
»Datei« ➜ »Beispiele« ➜ »KosmoBits
ERKLÄRUNG
Jetzt wird es aber Zeit, das Programm zu verstehen.
Schauen wir es uns doch einmal genauer an.
Die erste Zeile lautet: int ledPin = 13;
Anweisungen müssen in der Arduino
eine
Programmiersprache mit
en
­Semikolon (Strichpunkt) abgeschloss
werden.
Hier wird eine Variable mit dem Namen ledPin definiert.
Variablen sind wichtige Bestandteile eines jeden Programms. In Variablen kannst du nämlich Werte speichern –
also Zahlen, Buchstaben oder ganze Wörter. Jede Variable
hat einen Namen. Unter dem Namen kannst du den gespeicherten Wert wieder abrufen.
Wenn du einen Wert in einer Variablen speichern möchtest,
benutzt du das Gleichheitszeichen »=«: Auf die linke Seite
des Gleichheitszeichens kommt die Variable, auf die rechte
11
PROJEKT 1
der Wert. int ledPin = 13 bedeutet also, dass der Wert
13 in der Variablen ledPin gespeichert wird. Man sagt:
»Der Variablen ledPin wird der Wert 13 zugewiesen.«
Wo immer du in deinem Programm die Zahl 13 benutzen
möchtest, kannst du nun statt »13« auch »ledPin«
schreiben.
WAS ABER BEDEUTET int ?
In der Arduino-Programmiersprache kann eine Variable
nicht beliebige Werte aufnehmen. Die Werte müssen von
­einem bestimmten Typ sein, den man festlegen muss.
In diesem Fall ist der Typ int . Das bedeutet, dass die
­Variable sogenannte Integer-Werte aufnehmen kann.
Das sind für deinen KosmoDuino die ganzen ­Zahlen von
-32768 bis 32767.
void setup() {
pinMode(ledPin, OUTPUT);
Die Funktion setup() ist übrigens eine spezielle Funktion.
Sie wird bei jedem Start deines KosmoDuinos automatisch
als erstes aufgerufen.
Was aber macht die Funktion setup() ? Sie ruft eine andere Funktion auf: pinMode() . Mit dieser Funktion legst du
fest, in welcher Betriebsart ein Pin arbeiten soll. In diesem
Fall soll der Pin ledPin (Pin Nummer 13), als OUTPUT ,
also als Ausgabe-Pin, arbeiten.
Ein Ausgabe-Pin funktioniert wie ein Schalter, den du
­programmgesteuert ein- oder ausschaltest. Die anderen
möglichen Betriebsarten lernst du in späteren Projekten
kennen.
Wenn die Anweisungen in setup() von deinem Kosmo­
Duino abgearbeitet worden sind, wird als nächstes die
Funktion loop() aufgerufen. Schauen wir uns an, was
diese Funktion beinhaltet:
void loop() {
Hier wird eine Funktion definiert. Sie heißt setup() . Wenn
digitalWrite(ledPin, HIGH);
eine Funktion im Programm-Code aufgerufen wird, werden
alle in ihr enthaltenen Anweisungen Schritt für Schritt abgearbeitet. Das sind alle Anweisungen, die zwischen den
geschweiften Klammern stehen. Eine Funktion kannst du
dir also als ein kleines Unterprogramm vorstellen.
delay(500);
digitalWrite(ledPin, LOW);
delay(500);
FUNKTIONEN
Mit Funktionen kannst du deine Programme in kleinere Blöcke aufteilen. Das hilft, den Überblick zu behalten, und für
Ordnung im Programm zu sorgen. Außerdem kannst du häufig benutzte Abfolgen von Anweisungen in eine Funktion ver­
packen. Statt jedesmal den gleichen Text im Programm-Code zu wiederholen, kannst du dann einfach die entsprechende
Funktion aufrufen.
Ähnlich wie bei der Definition einer Variablen, muss man auch bei der Definition einer Funktion zunächst ­einen Typ ange­
ben. In diesem Fall void .
Das ist der sogenannte Rückgabetyp. Eine Funktion kann nämlich am Ende einen Wert an das aufrufende Programm zu­
rück geben. Hier ist der Rückgabetyp void . Das ist Englisch und bedeutet »leer«. Mit anderen Worten: Diese Funktion
­liefert keinen Wert zurück! Ein Beispiel für die Rückgabe eines Wertes ist die Temperatur, die vom Sensor gemessen wurde.
Wichtig: Gib deinen Funktionen immer einen Namen, der bereits ausdrückt, was die Funktion macht. Das hilft dabei,
ein Programm zu verstehen, wenn man es liest.
12
KosmoBits
PROJEKT 1
Was passiert, wenn loop() aufgerufen wird? Die erste
­Anweisung in loop() ist:
kunden sind eine halbe Sekunde. Das Programm wartet
eine halbe Sekunde lang und macht nichts.
digitalWrite(ledPin, HIGH);
Danach folgt die Anweisung
Mit digitalWrite() (engl. für »digital Schreiben«) kannst
du steuern, ob an einem Ausgabe-Pin eine Spannung anliegt oder nicht. Beim Aufruf musst du dafür der Funktion
digitalWrite() zwei Dinge mitteilen:
1. Welcher Pin ist gemeint?
2. Soll die Spannung am Pin ein- ( HIGH ) oder aus- ( LOW )
geschaltet werden?
Das kannst du vielleicht jetzt schon alleine verstehen.
Richtig: Die LED wird wieder ausgeschaltet!
Danach wartet der KosmoDuino wieder eine halbe Sekunde: delay(500); .
Und dann?
Dann geht das Ganze wieder von vorne los! loop() ist
nämlich eine besondere Funktion in der Arduino-Programmierung. Sie wird endlos wiederholt! Alle Befehle in
loop() werden wie in einer Endlosschleife immer und immer wieder ausgeführt. Man nennt das die Hauptschleife.
loop() ist somit die wichtigste Funktion in jedem KosmoBits-Programm. Hier wird gesteuert, was der KosmoDuino
tatsächlich macht, während setup() die nötigen Vorarbeiten erledigt.
In diesem Fall wird also die Spannung an Pin Nummer 13
( ledPin ) eingeschaltet: Die LED leuchtet!
Wenn du einen anderen Pin einschalten möchtest, also
z. B. Pin Nummer 9, dann schreibst du
digitalWrite(9, HIGH); .
Die nächste Anweisung ist:
delay(500); .
»Delay« ist Englisch und bedeutet »Verzögern«. Mit der
delay() Anweisung kannst du den Programmablauf für
eine bestimmte Zeit verzögern, also einfach warten. Wie
lange, das wird durch die Zahl bestimmt, die du beim Aufruf von delay() übergibst, hier 500 . Die Zeit wird in Millisekunden (Tausendstelsekunden) angegeben. 500 Millise-
TYPEN
digitalWrite(ledPin, LOW); .
Was hier passiert, wenn die Hauptschleife wiederholt wird,
hast du bereits gesehen: Im regelmäßigen Abstand von
­einer halben Sekunde wird die LED auf dem KosmoDuino
ein- und wieder ausgeschaltet, und wieder ein und wieder
aus, usw. Mit anderen Worten: Die LED blinkt.
Einige geläufige Typen und ihre Bedeutung
TYP
BEDEUTUNG
WERTE
int
Ganze Zahlen oder HIGH / LOW (an / aus)
-32768 bis 32767
long
Ganze Zahlen, groß
-2 147 483 648 bis 2 147 483 647
float
Gleitkommazahlen: »Zahlen mit Komma«
z.B. 1.5; 3.141; 2.678 (engl. Schreibweise: Punkt statt Komma!)
double
Wie float aber mit doppelter Genauigkeit
z.B. 3.141964; 21.45873
char
Einzelne Buchstaben
z.B. a ; A ; c ; C
const
Nicht veränderbare Größe
Kann alle Werte annehmen
13
PROJEKT 2
ACHTUNG! Nicht geeignet für Kinder unter 10 Jahren. Falls ein inkor­
rekter Kurzschluss durch unterschiedliche Polaritäten verursacht,
oder der Kondensator unter falschen Bedingungen verwendet wird,
können heiße Oberflächen durch Bauteile auf der Platine entstehen.
Ausschalter
In deinem ersten Sketch »Blink« hast du gelernt, wie du
mit einem Programm eine LED auf dem KosmoDuino blinken lassen kannst. Dazu hast du einen Pin des Controllers
als Ausgabe-Pin benutzt, und damit die LED ein- und
ausgeschaltet.
Du kannst einen Pin aber auch als Eingabe-Pin benutzen.
Es wird an dem Pin dann keine Spannung ein- oder ausgeschaltet. Stattdessen kannst du in deinem Programm feststellen, ob gerade eine elektrische Spannung an den Pin
angelegt ist.
DER PLAN
int ledPin = 13;
int schalterPin = 9;
int schalterWert = HIGH;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(schalterPin, INPUT_PULLUP);
void loop() {
schalterWert = digitalRead(schalterPin);
Das kannst du nutzen, um die LED mit einem einfachen
Schalter ein- und auszuschalten.
DU BRAUCHST
›K
 osmoDuino
› 2 Jumperkabel männlich-männlich (Erklärung, siehe S. 16)
VORBEREITUNG
Stecke das eine Jumperkabel auf Pin 9, das andere
auf ­einen der Gnd-Pins. Gnd steht für Ground (engl. für
­Erdung). Diese Pins haben keine eigentliche Funktion,
­sondern leiten nur Strom ab.
digitalWrite(ledPin, schalterWert);
delay(50);
Lade den Sketch wie auf Seite 10 beschrieben auf deinen
KosmoDuino. Nach dem Hochladen beginnt die LED zu
leuchten. Wenn du jetzt die freien Kontakte der beiden
Jumperkabel zusammenführst, so dass sie sich berühren,
hört sie auf zu leuchten.
DAS PROGRAMM
Was also macht das Programm?
Du definierst zunächst einmal drei Variablen:
• ledPin für den Pin, an dem die LED angeschlossen ist.
• schalterPin weist du den Wert 9 zu, denn du schließt
deinen »Schalter« an Pin 9 an.
• schalterWert bekommt erst einmal den Wert HIGH . Du
wirst später Pin 9 »auslesen« und den gelesenen Wert in
schalterWert speichern.
14
int ledPin = 13;
int schalterPin = 9;
int schalterWert = HIGH;
KosmoBits
PROJEKT 3
ACHTUNG! Nicht geeignet für Kinder unter 10 Jahren. Falls ein inkor­
rekter Kurzschluss durch unterschiedliche Polaritäten verursacht,
oder der Kondensator unter falschen Bedingungen verwendet wird,
können heiße Oberflächen durch Bauteile auf der Platine entstehen.
Das ist fast wie in deinem ersten Programm. Der ledPin
wird als Ausgabe-Pin ( OUTPUT ) betrieben. Pin 9
( schalterPin ) wird allerdings als Eingabe-Pin betrieben.
Deshalb benutzt du in der pinMode() -Anweisung für
schalterPin nicht den Wert OUTPUT , sondern
INPUT_PULLUP .
void setup() {
Zunächst liest du mit digitalRead(schalterPin) den
­aktuellen Zustand von Pin 9 aus. Ist der Pin elektrisch mit
einem »Gnd« Pin verbunden, so ergibt das den Wert LOW .
Das bedeutet es liegt keine Spannung an. Andernfalls den
Wert HIGH . Diesen Wert speicherst du in der Variablen
schalterWert .
Anschließend schreibst du diesen Wert in den LED Pin.
Wenn Pin 9 also mit dem Gnd-Pin verbunden ist, schaltest
du die LED aus. Andernfalls schaltest du sie ein.
void loop() {

pinMode(ledPin, OUTPUT);
pinMode(schalterPin, INPUT_PULLUP);
schalterWert = digitalRead(schalterPin);
digitalWrite(ledPin, schalterWert);
delay(50);
Danach wartest du mit delay(50) kurz, bevor das Ganze wiederholt wird.
Einschalter
DU BRAUCHST
›K
 osmoDuino
› 2 Jumperkabel männlich-männlich
VORBEREITUNG
Stecke das eine Jumperkabel auf Pin 9, das andere auf
­einen der Gnd-Pins.
DER PLAN
Im vorherigen Projekt hast du gelernt, wie du eine LED mit
Hilfe eines einfachen »Schalters« ausschalten kannst. Was
aber machst du, wenn es genau umgekehrt funktionieren
soll, die LED also erst angeht, wenn der Kontakt geschlossen wird? Du änderst das Programm!
DAS PROGRAMM
int ledPin = 13;
int schalterPin = 9;
int schalterWert = HIGH;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(schalterPin, INPUT_PULLUP);
Lade den Sketch wie auf Seite 10 beschrieben, auf deinen
KosmoDuino. Jetzt bleibt die LED nach dem Hochladen
dunkel. Nur wenn sich die beiden freien Kontakte der
­Jumperkabel berühren, leuchtet sie.
void loop() {
schalterWert = digitalRead(schalterPin);
if(schalterWert == LOW) {
		digitalWrite(ledPin, HIGH);
} else {
		digitalWrite(ledPin, LOW);
delay(50);
15
PROJEKT 3
ERKLÄRUNG

Wir schauen uns nur die loop() -Funktion an, denn nur dort
hat sich im Vergleich zum »Ausschalter« etwas geändert.
Genau wie beim »Ausschalter« liest du als erstes den
schalterPin aus und speicherst den aktuellen Wert, also
HIGH oder LOW in der Variablen schalterWert ab.
Du möchtest jetzt aber nicht den gelesenen Wert in den
LED-Pin schreiben, sondern den genau umgekehrten:
Wenn schalterWert den Wert LOW hat, möchtest du
die LED einschalten ( digitalWrite(ledPin, HIGH) ),
sonst möchtest du die LED ausschalten
( digitalWrite(ledPin, LOW) ).
Das drückst du in deinem Programmtext mit
if(...){...} else{...} aus. »if« ist Englisch für »wenn«
und »else« bedeutet »sonst«. Du ahnst es schon: Damit
kannst du im Programm auf Bedingungen reagieren.
void loop() {
schalterWert = digitalRead(schalterPin);
if(schalterWert == LOW) {
		digitalWrite(ledPin, HIGH);
} else {
		digitalWrite(ledPin, LOW);
delay(50);
Die Bedingung, auf die hier reagiert wird, ist
schalterWert == LOW . Das kannst du als Frage
­verstehen: »Ist schalterWert gleich LOW?« Die Antwort
­darauf wertest du mit der if() Anweisung aus:
Wenn schalterWert gleich LOW ist
( if(schalterWert == LOW) ), wird der Programm-Code
in der ersten geschweiften Klammer ausgeführt:
digitalWrite(ledPin, HIGH) . Die LED wird
eingeschaltet.
Sonst ( else ) wird der Teil in der geschweiften Klammer
ausgeführt: digitalWrite(ledPin, LOW) . Die LED wird
ausgeschaltet.
Schließlich wartest du mit delay(50) kurz, bevor das
Ganze wiederholt wird.
16
JUMPERKABEL
Jumperkabel werden benutzt, um auf einfache Weise elek­
tronische Bauteile miteinander zu verbinden. In diesem Ex­
perimentierkasten findest du zwei verschiedene Ausfüh­
rungen: männlich-männlich und männlich-weiblich. Das
heißt wirklich so! »männlich-männlich« bedeutet, dass
sich an beiden Seiten ein Stecker befindet. Bei »männlichweiblich« befindet sich hingegen an einer Seite ein Stecker
und an der anderen eine Buchse. Jumperkabel werden oft
auch als Patchkabel bezeichnet.
»Weibliches Ende«
»Männliches Ende«
KosmoBits
INTERACTION BOARD
Das Interaction Board
Zugegeben, die kleine LED, die du bislang zum Leuchten
gebracht hast, ist nicht sehr aufregend. Trotzdem war sie
hilfreich, um dir einen schnellen Einstieg in die Programmierung deines KosmoDuino zu ermöglichen.
Damit du ebenso schnell auch spannendere Dinge mit deinem Mikrocontroller machen kannst, haben wir das Interaction Board entwickelt. Du hast es vermutlich schon im
Spielemodus kennen gelernt. Darauf befinden sich einige
praktische elektronische Bauteile, die du in vielen Projektideen einsetzen kannst:
Um mit dem Interaction Board zu arbeiten, musst du zunächst deinen KosmoDuino in die Sockel auf dem Interaction Board stecken, siehe Abbildung.
• Zwei Taster (»Button 1« und »Button 2«)
• Eine mehrfarbige LED (»NeoPixel«)
• Ein Drehrad (»Drehencoder«)
• Ein Lautsprecher (»Buzzer«)
Und ganz wichtig:
• Eine Buchse zum Anschluss der KosmoBits-Sensoren (Temperatur, Bewegung, Helligkeit, Lautstärke)
• Ein Akku, damit du deinen KosmoDuino auch ohne
angeschlossenen Computer benutzen kannst.
Dann kann es auch schon direkt los gehen! In den folgenden Projekten wirst du zunächst die Möglichkeiten des Interaction Boards erkunden, bevor es dann mit aufwendigeren Projekten weitergeht.
ACHTUNG!
Um ein Programm auf den
Mikrocontroller hochzu­
laden musst du das USBKabel in die USB-Buchse
des KosmoDuinos stecken.
Der USB-Anschluss des
­Interaction Boards ist nur
zum Laden des Akkus
geeignet.
Programm
hochladen
Akku laden
17
PROJEKT 4
Mehrfarbige LED NeoPixel
Buntes Licht
DU BRAUCHST
› KosmoDuino im Interaction Board
DER PLAN
Auf dem Interaction Board findest du eine mehrfarbige
LED, NeoPixel genannt. Damit kannst du die Farbe und die
Helligkeit der LED selbst bestimmen. Wie das geht, lernst
du in diesem kleinen Projekt, mit dem du den NeoPixel in
unterschiedlichen Farben leuchten lässt.
DAS PROGRAMM
Das ist neu für dich. Mit einer #include -Anweisung, kannst
du Programm-Code aus anderen Dateien in dein Programm
einbinden. Hier wird der Inhalt aus den Dateien »Adafruit_
NeoPixel.h« und »KosmoBits_Pixel.h« eingebunden.
#include 
#include 
Diese beiden Zeilen musst du immer dann am Anfang deines Programms einfügen, wenn du den NeoPixel benutzen
möchtest!
Bislang hast du nur Variablen kennen gelernt, die als Behälter für Zahlenwerte dienen. Die Variable pixel , die du
hier definierst, ist anders: Sie nimmt keine Zahlen auf, sondern dient als Behälter für ein Objekt vom Typ KosmoBits_
Pixel. Das klingt schwieriger, als es ist. Objekte können nur
etwas mehr als einfache Werte wie int .
Sie haben nämlich nicht nur einen Wert, sondern bringen
auch noch eigene Funktionen mit. Die werden auch als Methoden bezeichnet. Dein pixel zum Beispiel ist ein Objekt, mit dem du den NeoPixel auf dem Interaction Board
ansteuern kannst. Dafür besitzt er eine Methode namens
setColor() , mit der du Farbe und Helligkeit des NeoPixels einstellen kannst. Wie du sie benutzt, lernst du gleich
in der Hauptschleife.
KosmoBits_Pixel pixel;
Um Farbe und Helligkeit deines NeoPixels einzustellen,
benötigst du vier Zahlenwerte. Einen für die Helligkeit
und drei für die Grundfarben rot, grün und blau. Die Werte speicherst du in den entsprechenden Variablen rot ,
gruen , blau und helligkeit .
int rot = 0;
Die unterschiedlichen Farben werden nämlich durch Mischen dieser drei Grundfarben erzeugt. Wie stark die jeweilige Farbe in dieser Mischung vertreten sein soll,
stellst du mit dem zugehörigen Zahlenwert ein. Du kannst
Werte von 0 bis 255 benutzen. 0 bedeutet, dass die jeweilige Farbe gar nicht leuchtet. Bei dem Wert 255 leuchtet
die jeweilige Farbe mit höchstmöglicher Helligkeit.
18
int gruen = 0;
int blau = 0;
int helligkeit = 0;

KosmoBits
In setup() ist diesmal nichts zu tun, da das Programm,
das du mit der #include -Anweisung eingebunden hast,
das schon für dich erledigt.
void setup() {
In der Hauptschleife wird zunächst der Helligkeitswert gesetzt: helligkeit = 50; . Die höchste Helligkeit wird mit
dem Wert 255 erzielt, bei 0 bleibt der NeoPixel dunkel.
void loop() {
Danach werden der Reihe nach verschiedene Farben erzeugt. Dazu werden jeweils den Variablen rot , gruen
und blau unterschiedliche Werte zugewiesen.
Entscheidend ist für jede Farbe die Zeile
pixel.setColor(rot, gruen, blau, helligkeit); . Erst
damit wird dem NeoPixel nämlich mitgeteilt, dass er eine
neue Farbe darstellen soll! setColor() ist dabei eine sogenannte Methode des Objekts pixel . Um eine Methode
eines Objekts aufzurufen, wird der Methodenname mit einem Punkt getrennt an den Namen des Objekts angehängt.
Mit delay(500); lässt du deinen KosmoDuino jeweils eine
halbe Sekunde warten, bevor er die nächste Farbe
einstellt.

// Hier ist nichts zu tun.
// 50 ist ein guter Helligkeitswert.
// Die höchste Helligkeitsstufe ist 255.
// Das blendet aber schon sehr!
helligkeit = 50;
// rot
rot = 255;
gruen = 0;
blau = 0;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
// grün
rot = 0;
gruen = 255;
blau = 0;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
// blau
rot = 0;
gruen = 0;
blau = 255;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
// lila
rot = 255;
gruen = 0;
NeoPixel
leuchtet in
unterschiedlichen
Farben ▶
blau = 255;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
// türkis
rot = 0;
gruen = 255;
blau = 255;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
// gelb
rot = 255;
gruen = 255;
blau = 0;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
19
PROJEKT 4
// weiß

rot = 255;
gruen = 255;
blau
= 255;
pixel.setColor(rot, gruen, blau, helligkeit);
delay(500);
SOFTWARE-BIBLIOTHEKEN
▲ Bibliothek
20
Damit man nicht in jedem Programm das Rad wieder neu
erfinden muss, gibt es sogenannte Software-Bibliotheken. In denen werden keine Bücher gesammelt, sondern
wieder verwendbare Programmfunktionen und Definiti­
onen. Es gibt Bibliotheken, die mathematische Funktio­
nen zur Verfügung stellen, andere kümmern sich darum,
dass man bestimmte Hardware, also zum Beispiel Sen­
soren oder auch den NeoPixel, komfortabel benutzen
kann. Damit man die Mittel, die einem durch eine solche
Bibliothek zur Verfügung gestellt werden, auch nutzen
kann, muss man die jeweilige Bibliothek in das eigene
Programm einbinden.
Das geschieht mit Hilfe der #include -Anweisung:
#include  bindet zum Beispiel
die KosmoBits_Pixel-Bibliothek ein. Manche Bibliothek
verwendet aber auch Funktionen aus anderen Biblio­
theken. Die muss man dann zusätzlich einbinden, wie
im Beispiel der KosmoBits_Pixel-Bibliothek. Die benötigt
nämlich zum Funktionieren die Adafruit_NeoPixel Bib­
liothek, die durch #include 
eingebunden wird.
KosmoBits
NACHGEHAKT
In der Nahaufnahme sind die drei einzelnen
LEDs des NeoPixels gut zu erkennen. ▶
Additive
Farbmischung
Vergrößerte
Aufnahme ei
nes Bildschirm
die einzelnen
s, bei dem
Farbpunkte zu
erkennen sind
Was du als weißes Licht kennst, ist in Wirklichkeit eine Mischung aus
Licht unterschiedlicher Farben. Aus welchen Farben es tatsächlich besteht, kannst du an einem
­Regenbogen ablesen. Ein Regenbogen entsteht nämlich dadurch, dass das Licht der Sonne durch
die Regentropfen in der Luft in seine Einzelfarben aufgespalten wird.
Umgekehrt kannst du aber auch Licht unterschiedlicher Farben zusammen mischen. Das Ergebnis
ist eine andere Farbe. Jeder Farbbildschirm nutzt dieses Prinzip: Der Fernseher, dein Computer, dein
Smartphone oder Tablet. Bei all diesen Geräten besteht jeder einzelne Bildpunkt (»Pixel«) aus drei
einfarbigen Bildpunkten in den Farben Rot, Grün und Blau. Weil sie so dicht beieinander liegen,
kannst du sie aus der normalen Entfernung nicht einzeln wahrnehmen. Erst wenn du ganz dicht
­herangehst, oder eine Lupe benutzt, kannst du die einzelnen Farbpunkte erkennen.
Wenn du dir den NeoPixel auf dem Interaction Board genau anschaust, kannst du, solange er nicht
leuchtet, drei verschiedene Bereiche erkennen. Jeder Bereich kann nur eine einzige Farbe erzeugen.
Eben Rot, Grün oder Blau. Mit Hilfe der Methode setColor() sagst du dem NeoPixel, wie hell die
einzelnen Bereiche leuchten sollen.
Versuche doch mal weitere Farben zusammen zu mischen,
­indem du die einzelnen Farbwerte variierst. Einen Anhaltspunkt, welche Mischungen welche Farben ergeben, liefert dir
das Bild neben der Tabelle. Deine Ergebnisse kannst du in die
folgende Tabelle eintragen:
Beschreibung
der Farbe
Wert Rot
Wert Grün
Wert Blau
Rot
255
Grün
255
Blau
255
▲ In einem
­Regenbogen
kannst du die
einzelnen
Farben
des Sonnenlichts erkennen.
21
PROJEKT 5
Auf Tastendruck
DER PLAN
In diesem Projekt wirst du lernen, wie du die Tasten auf
dem Interaction Board benutzen kannst, um den NeoPixel
des Interaction Boards in verschiedenen Farben leuchten
zu lassen.
Der NeoPixel soll zunächst dunkel bleiben. Drückst du
­Taste 1 leuchtet der NeoPixel rot, drückst du Taste 2 leuchtet er blau. Wenn du beide Taste gleichzeitig drückst,
leuchtet er lila.
DU BRAUCHST
› KosmoDuino im Interaction Board
DAS PROGRAMM
#include 
#include 
#include 
Wie man Bibliotheken und den Code aus anderen Dateien
in ein Projekt einbindet, hast du bereits im letzten Projekt
gelernt. Neu ist hier KosmoBits_Pins.h . Darin sind Namen
für die verschiedenen vom Interaction Board genutzten
Pins deines KosmoDuinos definiert. Die KosmoBits-Bibiliotheken werden wir uns später noch genauer anschauen.
▲ Finger drückt auf rechte Taste – NeoPixel leuchtet rot
▲ Finger drückt auf linke Taste – NeoPixel leuchtet blau
▲ Zwei Finger drücken auf beide Tasten – NeoPixel leuchtet lila
Hier definierst du zwei Konstanten für die Pins, an die die
beiden Taster des Interaction Boards angeschlossen sind.
Diese werden mit const abgekürzt. Dieses Schlüsselwort
teilt dem Programm mit, dass ein Objekt oder eine Variable
nicht veränderbar ist.
const int taste1 = KOSMOBITS_TASTE_1_PIN;
Wie im vorigen Programm speicherst du die verschiedenen Farbwerte und die Helligkeit in entsprechenden Variablen, die du hier definierst.
int rot = 0;
const int taste2 = KOSMOBITS_TASTE_2_PIN;
int gruen = 0;
int blau = 0;
const int helligkeit = 50;
Um den NeoPixel auf dem Interaction Board steuern zu
können, brauchst du wieder ein KosmoBits_Pixel Objekt.
Das definierst du hier.
22
KosmoBits_Pixel pixel;
KosmoBits
In setup() stellst du mittels pinMode() den Betriebsmodus für die Taster-Pins ein. Da die Taster über einen
­Widerstand an die Pins angeschlossen sind, benutzt du
die Betriebsart INPUT .
void setup() {
In der ersten if -Anweisung wird mittels digitalRead()
der Pin ausgelesen, an den Taste 1 angeschlossen ist.
Wenn die Taste gedrückt ist, ergibt das den Wert LOW :
rot wird der Wert 255 zugewiesen, also der größtmögliche Rotwert.
Wird die Taste nicht gedrückt, wird rot auf 0 gesetzt.
void loop() {
Das Ganze wird dann für Taste 2 in der zweiten if -Anweisung wiederholt. Nur, dass dort der Wert für blau geändert wird.
Mit pixel.setColor(rot, gruen, blau, helligkeit);
wird schließlich der neue Farbwert des NeoPixels
eingestellt.

pinMode(taste1, INPUT);
pinMode(taste2, INPUT);
if (digitalRead(taste1) == LOW) {
		 rot = 255;
} else {
		 rot = 0;
if (digitalRead(taste2) == LOW) {
		 blau = 255;
} else {
		 blau = 0;
pixel.setColor(rot, gruen, blau, helligkeit);
Am Ende der Hauptschleife lässt du den Controller noch
50 Millisekunden warten.
delay(50);
WAS PASSIERT EIGENTLICH BEIM HOCHLADEN?
Wenn du ein Programm auf deinen KosmoDuino hochlädst, passiert tatsächlich eine ganze Menge. So wie du es ge­
schrieben hast, versteht der Mikrocontroller das Programm nämlich nicht: Er spricht die Programmiersprache einfach
nicht. Deshalb muss das Programm erst in Maschinensprache übersetzt werden. Das macht ein sogenannter Compiler
(gesprochen: »Kompeiler«).
Die Programmiersprache, die du benutzt, ist also nur eine Zwischensprache, die du recht einfach verstehen und schreiben
kannst, die aber vor allem der Compiler leicht in Maschinensprache übersetzen kann.
23
WISSEN KOMPAKT
Nur unter einer Bedingung:
Die if-Anweisung
ANWEISUNG 1
- (englisch für
Im Programm-Code hast du die if
. Hier wollen wir
»wenn«) Anweisung bereits benutzt
uen. Mit Hilfe der
sie uns noch etwas genauer anscha
e deines Programms
if -Anweisung kannst du Teil
bestimmte
nur dann ausführen lassen, wenn eine
Bedingung erfüllt ist:
ANWEISUNG 2
// Einfache if-Anweisung
if (Bedingung) {
n die
// Wird nur ausgeführt, wen
ist
// Bedingung erfüllt
if
Anweisung1;
Anweisung2;
...
ACHTUNG!
zu findender Fehler
Ein häufiger und nicht immer leicht
doppelten Gleich­
ist, in einer if -Anweisung, statt des
enden, also zum
heitszeichens, das einfache zu verw
che Anweisung
Beispiel statt if (a == b) die fals
if (a = b) .
g a der Wert von
In dem Fall wird in der if -Anweisun
ßer als Null ist, gilt das
b zugewiesen. Wenn dieser grö
den geschweiften
als wahr ( true ), und der Block in
Klammern wird ausgeführt.
24
n Klammern
Die Programmteile in den geschweifte
die Bedingung
werden nur dann ausgeführt, wenn
e Block in den
amt
­erfüllt ist. Andernfalls wird der ges
rsprungen.
gescheiften Klammern einfach übe
tswert zurück
Die Bedingung muss einen Wahrhei
sch). Meistens
l­ iefern: true (wahr) oder false (fal
Dazu gibt es die
vergleicht man zwei Zahlenwerte.
indest so ähnlich
­Vergleichsoperatoren, die dir zum
annt sind:
aus dem Mathematikunterricht bek
OPERATOR
BEDEUTUNG
BEISPIEL
true (WAHR)
==
gleich
a == b
wenn a gleich b ist
kleiner als
ab
wenn a größer als b ist
!=
ungleich
a != b
wenn a ungleich b ist
<=
kleiner/gleich
a <= b
wenn a kleiner oder gleich b ist
>=
größer/gleich
a >= b
wenn a größer oder gleich b ist
en auch
werte werd
ts
ei
rh
Die
t, abgepen genann
boolesche Ty
ol .
kürzt mit bo
true
ch die Werte
li
ig
le
Dieser k
nnehmen.
oder false a
KosmoBits
Du kannst eine if -Anweisung auc
h um einen else
-Block erweitern. "Else" ist Englisc
h und bedeutet
"sonst". Der else -Block wird also
dann, und nur dann,
ausgeführt, wenn die Bedingung nich
t erfüllt ist.
Schließlich kannst du mit else if
(engl. »sonst,
wenn«) noch einen Block einbauen,
der eine zweite Bedingung überprüft, wenn die erste
nicht erfüllt wurde.
// if-Anweisung mit else-B
lock
if (Bedingung1) {
// Wird nur ausgeführt, wen
n die
// Bedingung erfüllt ist.
Anweisung1;
// if-Anweisung mit else-B
lock
if (Bedingung) {
// Wird nur ausgeführt, wen
n die
// Bedingung erfüllt ist.
Anweisung1;
Anweisung2;
Anweisung2;
...
} else {
// Dieser Block wird ausgef
ührt, wenn
// die Bedingung nicht erf
üllt ist.
Anweisung3;
Anweisung4;
...
} else if (Bedingung2){
// Dieser Block wird ausgef
ührt, wenn
// die Bedingung nicht erf
üllt ist.
Anweisung3;
Anweisung4;
} else {
// Dieser Block wird ausgef
ührt, wenn
// keine der vorher geprüf
ten
// Bedingungen erfüllt wir
d.
Anweisung5;
...
Den abschließenden else -Block kan
nst du dabei
auch weg lassen. Auch kannst du beli
ebig viele
else if -Blöcke aneinander reih
en.
25
PROJEKT 6
Blink-Würfel
Mit diesem Projekt machst du deinen KosmoDuino zu einem einfachen Würfel. Auf Tastendruck ermittelt er eine
Zufallszahl von 1 bis 6 und signalisiert dir das Ergebnis
durch Blinken des NeoPixels.
DU BRAUCHST
› KosmoDuino im Interaction Board
DER PLAN:
• Ist der Controller bereit, so leuchtet der NeoPixel blau.
• Drückst du auf Taste 1, beginnt der NeoPixel entsprechend des Würfelergebnisses grün zu blinken, also einmal, wenn eine Eins gewürfelt wurde, zweimal, wenn
eine Zwei gewürfelt wurde, usw.
• Nach einer kurzen Pause leuchtet der NeoPixel wieder
blau. Das bedeutet, er ist bereit erneut zu würfeln.
DAS PROGRAMM
Du bindest zunächst wieder die bekannten Bibliotheken ein
und legst ein KosmoBits_Pixel an, damit du den NeoPixel
auf dem Interaction Board ansprechen kannst.
Danach legst du ein paar Konstanten an, die den Code lesbarer machen.
#include 

#include 
#include 
KosmoBits_Pixel pixel;
const int tasterPin = KOSMOBITS_TASTE_1_PIN;
const int blinkDauer = 500; // Millisekunden
const int blinkPause = 250; // Millisekunden
const int helligkeit = 50;
In setup() bereitest du wie üblich deinen Controller auf
die kommenden Aufgaben vor:
Mit pinMode(tasterPin, INPUT) stellst du den Pin, an
den Taster 1 angeschlossen ist, als Input-Pin ein.
void setup() {
pinMode(tasterPin, INPUT);
	randomSeed(analogRead(12)); // Startwert für
// Zufallsgenerator
pixel.setColor(0, 0, 255, helligkeit); // Blau
Später wirst du eine Zufallszahl erzeugen lassen. Das
// signalisiert Betriebsbereitschaft
macht ein Zufallsgenerator, der aber einen möglichst zu}
fälligen Startwert benötigt. Um den zu bekommen, liest du
mit analogRead(12) Pin 12 aus. Da dort nichts angeschlossen ist, sind die Werte, die du so erhältst schon sehr
zufällig. Die Funktion analogRead() wirst du später noch
genauer kennenlernen. Mit randomSeed(...) wird der
ausgelesene Wert dann dem eigentlichen Zufallsgenerator
als Startwert übergeben (»random« bedeutet übersetzt
zufällig).
Schreibweise, wie du
Dies ist eine verkürzte Version der
Schließlich lässt du den NeoPixel mit
Die Zahlen in den
sie in Projekt 4 kennengelernt hast.
pixel.setColor(0, 0, 255, helligkeit);
t/Grün/Blau).
Klammern steuern den RGB-Wert (Ro
blau leuchten.
In der Hauptschleife loop() liest du mit digitalRead()
den tasterPin aus. Wird er gedrückt, dann ist das Ergebnis
LOW . Mit Hilfe der if -Anweisung wird dann die Funktion
wuerfeln() aufgerufen, in der das Würfelergebnis ermittelt
und ausgegeben wird. Andernfalls macht loop() nichts.
26
void loop() {
if (digitalRead(tasterPin) == LOW) {
		wuerfeln();
KosmoBits
PROJEKT 6
Hier definierst du dir eine eigene Funktion namens
wuerfeln() . Darin wird eine Zufallszahl im Bereich von
1 bis 6 ermittelt und anschließend ausgegeben. Gehen
wir sie Schritt für Schritt durch:
void wuerfeln() {
// (1)
// Erst einmal Licht aus, um zu zeigen, dass
// auf den Tastendruck reagiert wird.
pixel.setColor(0, 0, 0, 0); // Licht aus
Zunächst (1) machst du das Licht des NeoPixels aus und
wartest kurz. Die entsprechenden Befehle kannst du mittlerweile sicherlich erkennen.
delay(500);
// (2) Erzeuge Zufallszahl
Jetzt geht es um das eigentliche Würfeln. Da dein KosmoDuino nicht wirklich würfeln kann, musst du anders an
das Würfelergebnis kommen: Du befragst einen
Zufallsgenerator.
Das machst du mit random(1, 7) (2). Damit fragst du den
Zufallsgenerator nach einer zufällig ausgewählten Zahl.
Der erste Parameter, hier 1, gibt an, dass die kleinste mögliche Zahl 1 sein soll. Der zweite Parameter, hier 7, bedeutet,
dass die zufällig ausgewählte Zahl kleiner als 7 sein soll.
Wichtig: Der zweite Parameter muss also immer um 1
größer sein, als die größtmögliche Zahl, die vom Zufallsgenerator erzeugt werden soll. Das ist vielleicht etwas
verwirrend, ist aber leider so. Die so erzeugte Zufallszahl
wird in der Variablen zahl gespeichert.
Jetzt soll die Zufallszahl durch Blinken ausgegeben werden (3). Dazu bedienst du dich einer sogenannten for Schleife. Den Aufbau der for -Schleife wirst du auf den
folgenden Seiten ausführlich kennen lernen. An dieser
Stelle ist erst einmal nur wichtig, dass der Code in den geschweiften Klammern genau zahl -mal ausgeführt wird.
Wenn zahl den Wert 1 hat, 1 mal. Wenn zahl den Wert
2 hat, 2 mal usw.

int zahl = random(1, 7);
// (3) Blinke zahl-mal
for (int i = 0; i < zahl; ++i) {
		 pixel.setColor(0, 255, 0, helligkeit); // Grün
		delay(blinkDauer);
		 pixel.setColor(0, 0, 0, 0); // Licht aus
		delay(blinkPause);
// (4) Abschluss des Würfelns signalisieren.
	delay(blinkDauer); // Pause am Ende etwas
// länger
pixel.setColor(0, 0, 255, helligkeit); // Blau
// signalisiert Betriebsbereitschaft
Was geschieht in den geschweiften Klammern? Genau:
Der NeoPixel leuchtet einmal für die Dauer blinkDauer
grün, und wird dann für die Dauer blinkPause ausgeschaltet. Kurz: Der NeoPixel blinkt einmal grün. Da die
for -Schleife aber zahl -mal durchlaufen wird, blinkt
der NeoPixel insgesamt eben zahl -mal. Es wird also das
Würfelergebnis durch Blinken ausgegeben.
Schließlich (4) wird nach einer weiteren kurzen Pause
( delay(blinkDauer) ) der NeoPixel wieder auf blau gestellt, um anzuzeigen, dass wieder gewürfelt werden kann.
Da wuerfeln() in deinem Programm nur aus der Hauptschleife loop() heraus aufgerufen wird, geht es anschließend zurück in die Hauptschleife. Als nächstes
wird daher in loop() wieder geprüft, ob die Taste gedrückt ist oder nicht.
Viel Spaß beim Würfeln!
Mehr Infos über die for -Schleife bekommst du auf den
­Seiten 30/31.
27
PROJEKT 7
Der serielle Monitor
DU BRAUCHST
› KosmoDuino
› Computer
› USB-Kabel
DER PLAN
Mit Hilfe des seriellen Monitors kannst du dir von deinem
KosmoDuino kleine Botschaften auf den Bildschirm deines
Computers schicken.
Um den seriellen Monitor nutzen zu können, gehst du
­folgendermaßen vor:
DAS PROGRAMM
Füge in setup() die Zeile Serial.begin(115200); ein.
Wann immer du etwas auf den seriellen Monitor ausgeben
möchtest, kannst du das nun mit Hilfe der Befehle
Serial.print() und Serial.println() tun. Der Unterschied zwischen den beiden Varianten ist, dass
Serial.println() noch einen Zeilenumbruch einfügt.
Die nächste Ausgabe beginnt also in einer neuen Zeile.
void setup() {

Serial.begin(115200);
void loop() {
Serial.print("Hallo!");
delay(500);
Schauen wir uns das mit einem kleinen Beispiel an:
Lade das Programm auf deinen KosmoDuino hoch. Scheinbar geschieht überhaupt nichts. Klicke jetzt auf das Lupensymbol oben rechts in der Arduino-Umgebung. Es öffnet
sich ein neues Fenster, der serielle Monitor.
Vermutlich siehst du zunächst nur komische Zeichen. Das
kannst du aber schnell ändern, indem du die richtige Übertragungsgeschwindigkeit einstellst. Unten rechts im seriellen Monitor findest du eine Auswahlliste, in der du
»115200 Baud« auswählen musst. Dann solltest du sehen,
wie ein »Hallo!« nach dem anderen in das Fenster geschrieben wird.
▲ Mit einem Klick auf die Lupe oben rechts in der Arduino-Umgebung
startest du den seriellen Monitor.
Senden
÷ôôõôõõõôõôõõôõõôõõõôõõúúúôôõõõõõôô
Kein Zeilenende
9600 Baud
▲ Wenn die falsche Übertragungsrate, hier 9600 Baud, eingestellt ist,
siehst du nur wirre Zeichen.
Senden
Hallo!Hallo!Hallo!
Kein Zeilenende
115200 Baud
▲ Ist die richtige Übertragungsgeschwindigkeit eingestellt, kannst du im
seriellen Monitor »Botschaften« vom KosmoDuino empfangen.
28
KosmoBits
PROJEKT 7
Schließe jetzt den seriellen Monitor. Ersetze in der Hauptschleife den Aufruf Serial.print("Hallo!"); durch
Serial.println("Hallo!"); :
void loop() {

Serial.println("Hallo!");
delay(500);
Lade das geänderte Programm auf den Controller und
starte den seriellen Monitor erneut. Jedes »Hallo!« bekommt nun eine eigene Zeile.
Senden
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Hallo!
Kein Zeilenende
115200 Baud
▲ Im Gegensatz zu Serial.print() folgt nach der Ausgabe mit
Serial.println() immer eine neue Zeile.
Mit Serial.println() kannst du aber nicht nur vorher
festgelegte Texte ausgeben, sondern auch gerade erst
­ermittelte Messwerte. Das wirst du im nächsten Projekt,
»Thermometer« auf Seite 33 kennen lernen.
ACHTUNG!
Wenn du versuchst, ein Programm auf den KosmoDuino zu laden, während der serielle Monitor geöffnet ist, kommt
es manchmal zu einer Fehlermeldung. Schließe dann den seriellen Monitor und versuche, das Programm erneut
hochzuladen.
29
DIE FOR-SCHLEIFE
Die for-Schleife
Wenn Programmteile wiederholt ausgeführt werden,
spricht man von einer Schleife. Eine wichtige Schleife
hast du bereits kennengelernt: Die Hauptschleife loop() .
Darin erledigt dein KosmoDuino die wichtigsten Aufgaben
deiner Programme. Er liest Eingabe-Pins aus, verarbeitet
die Messdaten und reagiert schließlich darauf. Immer und
­immer wieder von vorne.
Oftmals möchtest du aber nicht in einer Endlosschleife
­gefangen sein, sondern wünschst dir nur eine bestimmte
Anzahl von Wiederholungen. Dafür kannst du eine for Schleife verwenden. Du wirst sie meistens in der folgenden
Weise als sogenannte Zählschleife verwenden:
for (int i = 0; i < 20; ++i) {
Anweisung1;
Anweisung2;
...
Was bedeutet das? Mit dem Wort for wird die Schleife
­eingeleitet. Die Anweisungen, die wiederholt ausgeführt
werden, stehen in dem Block in den geschweiften Klammern. Man nennt diesen Block mit den zu wiederholenden
Anweisungen auch den Schleifenrumpf. Damit die Schleife
aber auch weiß, wie oft diese Anweisungen wiederholt
werden sollen, braucht die for -Schleife noch ein paar
­Angaben, die du in den runden Klammern finden kannst.
Schauen wir uns die einmal genauer an:
int i = 0; :
Das ist die sogenannte Initialisierung der Schleife. Bevor
die Schleife das erste Mal durchlaufen wird, legst du hier
die Zählvariable i an und gibst ihr den Wert 0. Du kannst
der Zählvariablen einen beliebigen Namen und Anfangswert geben. Solange die Zählvariable keine besondere Bedeutung hat, benutzt man meist die Buchstaben i , j und
k als Namen. In aller Regel startet man mit dem Anfangswert 0.
i < 20; :
Das ist die Testbedingung: Vor jedem Durchlauf der Schleife wird diese Bedingung geprüft. Ist die Bedingung erfüllt,
wird die Schleife durchlaufen, also der gesamte Programmcode in den geschweiften Klammern ausgeführt.
Ist die Bedingung nicht erfüllt, wird die Schleife verlassen:
Der Programmcode in den geschweiften Klammern wird
kein weiteres Mal ausgeführt. Stattdessen wird das Programm mit der nächsten Anweisung nach der Schleife
fortgesetzt.
++i :
Das ist zunächst einmal eine Kurzform für i = i + 1 . Der
Wert der Zählvariablen i wird also um 1 erhöht. Aber
wann? Nach jedem Schleifendurchlauf!
Sofern im Schleifenrumpf der Wert der Zählvariablen i
nicht verändert wird, passiert also folgendes:
Vor dem ersten Durchlauf hat i den Wert 0. Das ist kleiner
als 20. Die Testbedingung ist also erfüllt, und die Schleife
wird durchlaufen. Nachdem die Anweisungen im Schleifenrumpf ausgeführt wurden, wird nun der Wert der Zählvariablen um 1 erhöht. Der Wert von i ist jetzt 1. Die Bedingung ist immer noch erfüllt, der Schleifenrumpf wird
ausgeführt, i wieder um 1 erhöht und so weiter und so
weiter. Wenn i schließlich den Wert 19 hat, wird noch einmal der Schleifenrumpf ausgeführt und danach i auf den
Wert 20 erhöht. Die Testbedingung ist dann nicht mehr erfüllt, die Schleife wird verlassen.
Wie oft ist der Schleifenrumpf jetzt ausgeführt worden? Er
ist ausgeführt worden für die folgenden Werte der Zählvariablen i : 0, 1, 2, 3, ..., 19. Die Zahlen 1 bis 19 ergeben 19
Druchläufe, dazu kommt noch ein Durchlauf für den Wert
0. Es sind also insgesamt 20 Durchläufe!
Die Zählvariable ist übrigens nicht allein zum Zählen da.
Ihren aktuellen Wert kannst du auch jederzeit im Schleifenrumpf verwenden. Wenn du zum Beispiel alle Zahlen
von 1 bis 42 auf dem seriellen Monitor ausgeben möchtest,
kannst du das so machen:
// Gibt die Zahlen 1, 2, 3,..., 42 aus:
for (int i = 1 ; i <= 42; ++i) {
	Serial.println(i); // Gibt den aktuellen
// Wert von i aus
30
KosmoBits
DIE FOR-SCHLEIFE
Hier startet die Schleife mit dem Anfangswert 1. Getestet
wird diesmal nicht, ob i kleiner als 42 ist, sondern ob i
kleiner oder gleich 42 ist. Das heißt, dass die Schleife auch
für den Wert 42 noch einmal durchlaufen wird.
Es geht aber auch in umgekehrter Reihenfolge:
Tatsächlich kannst du anstelle von ++i oder --i beliebige Anweisungen verwenden. Du kannst zum Beispiel nur
die geraden Zahlen ausgeben:
// Gibt die Zahlen 2, 4, 6, ..., 42 aus.
for (int i = 2; i <= 42; i = i + 2) {
// Gibt die Zahlen 42, 41, 40, ..., 1 aus:
for (int i = 42; i >= 1; --i) {
Serial.println(i);
Serial.println(i);
Die Schleife startet mit dem Anfangswert 42. Sie wird solange durchlaufen, wie i einen Wert hat, der größer oder
gleich 1 ist. Mit --i wird diesmal i nach jedem Schleifendurchlauf um 1 verringert, also rückwärts gezählt.
Hier startet die Schleife bei 2 und nach jedem Schleifendurchlauf wird die Zählvariable mit i = i + 2 gleich um
2 erhöht.
31
SENSOREN
Sensoren
Bislang hast du gelernt, wie
dein KosmoDuino auf einen Tastendruck reagieren kann. In
diesem Experimentierkasten findest du aber
auch eine Menge
Sensoren, mit denen dein Mikrocontroller auf seine Umwelt
reagieren kann: Die
KosmoBits-Module!
Mit dem Temperatursensor
kann dein Controller die Temperatur überwachen, mit dem
Lichtsensor die Helligkeit. Der Bewegungssensor erlaubt es dir, auch
leichteste Bewegungen des KosmoDuinos zu registrieren, und mit dem Schallsensor kannst du auf Geräusche warten.
Bewegungssensor
Temperatursensor
Lichtsensor
Schallsensor
Aber wie kommt der KosmoDuino an die Daten
der Sensoren? Wie erfährt er, wie warm es ist,
oder wie hell?
Ganz einfach: Die Sensoren geben ihre Messwerte in
Form einer elektrischen Spannung an den Mikrocontroller weiter. Der kann diese Spannung dann an einem Pin
auslesen. Viele der Pins können nämlich nicht nur »an«
und »aus« unterscheiden, sondern auch unterschiedliche
Spannungen messen. Dazu dient der Befehl analogRead() ,
mit dem du die elektrische Spannung an einem Pin bestimmen kannst. Das Ergebnis ist ein Zahlenwert von 0 bis
1023. Je höher die elektrische Spannung ist, die an dem Pin
anliegt, umso höher ist der Wert. Bei 0 liegt gar keine
Spannung an, bei 1023 sind es 5 Volt.
Natürlich musst du analogRead() auch sagen, welcher
Pin ausgelesen werden soll. In der Regel wird das der Pin
KOSMOBITS_SENSOR_PIN sein, der in der Datei
KosmoBits_Pins.h definiert wird. Diese Datei solltest du
also immer mit #include  einbinden, wenn du auf die Sensoren der KosmoBits-Module zugreifen möchtest.
Den seriellen Monitor hast du bereits kennen gelernt.
Das ist ein wichtiges Werkzeug, wenn du mit den Sensoren
arbeiten möchtest. Warum, erfährst du in den nächsten
Projekten.
32
KosmoBits
PROJEKT 8
Thermometer
DU BRAUCHST
› KosmoDuino im Interaction Board
› Temperatursensor
VORBEREITUNG
Stecke den Temperatursensor in das Interaction Board.
DER PLAN
In diesem Projekt wirst du deinen KosmoDuino zu einem
Thermometer machen. Die Temperatur wird dabei mit Hilfe
des Temperatursensors gemessen. Die Ausgabe der Temperatur erfolgt über den seriellen Monitor.
DAS PROGRAMM
Schreibe jetzt den folgenden Code und lade ihn auf den Controller:
Das Programm ist schnell erklärt. Mit analogRead() wird
in der Hauptschleife wiederholt die Spannung am
sensorPin ausgelesen. Der Messwert wird dann über den
seriellen Monitor ausgegeben. Du wirst dieses Programm
immer wieder benutzen, wenn du einen neuen Sensor
­kennenlernen möchtest.
Öffne also den seriellen Monitor und schau dir die Messwerte an. Lege einen Finger auf den schwarzen Punkt, der
aus dem Gehäuse des Sensors heraus schaut. Du solltest
sehen, dass sich die gemessenen Werte verändern. Nach einer Temperatur sieht das aber noch nicht aus. Du musst
also noch die Messwerte in eine Temperatur umrechnen.
Dabei hilft dir die KosmoBits-Bibliothek. Darin findest du
nämlich eine Funktion, die genau das macht. Sie heißt
thermistor_messwert_in_celsius() .
Um sie nutzen zu können, musst du zuvor die Datei
KosmoBits_Thermistor.h einbinden.
#include 

const int sensorPin = KOSMOBITS_SENSOR_PIN;
void setup() {
pinMode(sensorPin, INPUT);
Serial.begin(115200);
void loop() {
int wert = analogRead(sensorPin);
Serial.print("Messwert: ");
Serial.println(wert);
delay(1000);
◀ Board mit Temperatursensor
33
PROJEKT 8

ÄNDERE ALSO DEIN PROGRAMM SO AB:
Schließe den seriellen Monitor, lade das Programm hoch
und öffne wieder den seriellen Monitor. Du siehst, dass nun
in regelmäßigen Abständen die aktuelle Temperatur ausgegeben wird.
#include 
#include 
const int sensorPin = KOSMOBITS_SENSOR_PIN;
void setup() {
pinMode(sensorPin, INPUT);
Serial.begin(115200); // Ausgabe über seriellen
// Monitor ermöglichen.
void loop() {
int messwert = analogRead(sensorPin);
float celsius = thermistor_messwert_in_
celsius(messwert); // Messwert in Grad Celsius
// umrechnen.
Serial.print(celsius); // Wert von celsius wird
// ausgegeben.
Serial.println("Grad Celsius"); // Ausgabe von
// "Grad Celsius" und Zeilenumbruch.
delay(1000);
34
KosmoBits
WISSEN KOMPAKT
RECH NE N IM PROGRA MM :
Zahlen und Variable, die Zahlen aufn
ehmen können,
hast du bereits kennen gelernt. Die
nützen dir aber
nicht viel, wenn du mit ihnen nicht
rechnen kannst.
Denn in aller Regel wirst du mit dein
em KosmoDuino
einen Zahlenwert aus einem Sensor
auslesen, und damit dann etwas anderes steuern. Daz
u musst du aus
dem Messwert einen anderen Zahlenw
ert errechnen.
In der Arduino-Programmiersprache
stehen dir dafür
alle Grundrechenarten zur Verfügu
ng. Für Plus- und
Minusrechnung werden dabei die übli
chen Symbole
»+« und »-« benutzt. Für die Multipl
ikation benutzt
man einen Stern »*«, für die Division
den einfachen
Schrägstrich »/«.
Du kannst übrigens auch den bisherig
en Wert einer Variablen benutzen, um daraus den neu
en zu berechnen:
Für den häufig genutzten Rechenschr
itt i = i + 1;
gibt es sogar eine Kurzform:
// Addition (plus)
int x; // x ist eine ganze
Zahl.
x = 1 + 4; // x hat den Wer
t 5.
// Subtraktion (minus)
x = 5 - 3; // x hat den Wer
t 2.
// Multiplikation (mal)
x = 3 * 4; // x hat den Wer
t 12.
// Division (geteilt durch)
x = 12 / 6; // x hat den
Wert 2.
// Punktrechnung vor Strich
rechnung
x = 4 * 3 + 2; // x hat den
Wert 14.
int x = 4;
x = x + 2; // x hat jetzt
den Wert 6.
x = 2 * x; // x hat jetzt
den Wert 12.
int i = 0;
i++; // entspricht x = x
+ 1.
++i; // entspricht ebenfa
lls x = x + 1.
35
PROJEKT 9
Finger-Disko
DU BRAUCHST
›K
 osmoDuino im Interaction Board
› Bewegungssensor
VORBEREITUNG
Mit dem Bewegungssensor kann dein KosmoDuino auch
kleinste Bewegungen registrieren. Um ein Gefühl dafür zu
entwicklen, steckst du zunächst den Bewegungssensor ins
­Interaction Board. Lade dann den Sketch »SensorLesen« auf
deinen KosmoDuino.
Im seriellen Monitor kannst du nun die Messwerte des Bewegungssensors beobachten. Solange du den Controller nicht
bewegst, schwankt der Messwert leicht um einen Mittelwert.
Bewege den Controller nun in verschiedene Richtungen,
drehe und kippe ihn. Du wirst feststellen, dass es Bewegungs- und Drehrichtungen gibt, die eine starke Veränderung des Messwertes verursachen. In andere Richtungen
änderst sich der Wert kaum.
Trommel jetzt erst vorsichtig, dann etwas kräftiger mit den
Fingern auf das Gehäuse des Interaction Boards. Obwohl
die Erschütterungen, die deine Finger auslösen, nur sehr
Tatsächlich misst der Sensor lediglich die Beschleunigung
des Sensors längs der sogenannten z-Achse, also der
»Vor-Zurück-Achse«. ­Deshalb ­verändert sich der Wert,
wenn du den Controller nach vorne oder zu dir hin be­
wegst. Bei Bewegungen nach oben oder unten verändert
sich der Wert dagegen nicht.
klein sind, werden sie vom Sensor erkannt. Wenn du den
Controller auf den Tisch legst, reicht es meist sogar, nur auf
den Tisch zu trommeln. Auch das wird vom Sensor bemerkt.
Das machen wir uns nun zu Nutze, um deinen KosmoDuino
in eine Finger-Trommel-Disko-Beleuchtung zu verwandeln.
Dazu benutzt du das folgende Programm:
DER PLAN
▲ Finger trommeln auf Platine, NeoPixel blinkt.
DAS PROGRAMM
Zunächst bindest du mit den #include -Anweisungen wieder die benötigten Bibliotheken ein, definierst sensorPin ,
um die Sensorwerte auslesen zu können, sowie pixel ,
um den NeoPixel ansteuern zu können.
Um Abweichungen vom Ruhezustand erkennen zu können,
definierst du noch die Variable ruhewert . Darin wird später der Mittelwert in Ruhe gespeichert.
36
Bunte Lichter tanzen im Rhythmus deiner Finger. Mit
­diesem Projekt verwandelst du deinen KosmoDuino in
eine Finger-Disko.
#include 
#include 
#include 
const int sensorPin = KOSMOBITS_SENSOR_PIN;
KosmoBits_Pixel pixel;
int ruhewert = 0;
KosmoBits
PROJEKT 9
Um den Ruhewert zu bestimmen, soll der Mittelwert aus
20 Messwerten berechnet werden. Die Zahl der Messwerte
wird in der Konstanten N gespeichert, so dass man sie
leicht ändern kann. Der Mittelwert wird in der Variablen
mittelwert gespeichert.
Die for -Schleife ist dir mittlerweile geläufig. Sie wird Nmal, hier also 20-mal, durchlaufen.
In jedem Durchlauf wird dem aktuellen mittelwert ein
weiterer Messwert hinzu addiert. Vor der nächsten Messung wird 10 Millisekunden lang gewartet.
int bestimmeRuhewert() {

const int N = 20; // Zahl der Messwerte
float mittelwert = 0;
for (int i = 0; i < 20; ++i) {
mittelwert = mittelwert +
analogRead(sensorPin);
		delay(10);
mittelwert = mittelwert / N;
return mittelwert;
Wenn die Schleife verlassen wird, ist in der Variablen
mittelwert die Summe der 20 Messwerte gespeichert.
Um daraus den Mittelwert zu berechnen, muss die Summe
noch durch die Zahl der Messwerte geteilt werden. Das geschieht in der Zeile mittelwert = mittelwert / N; .
Schließlich wird mit return mittelwert; der berechnete
Mittelwert zurückgegeben.
Das ist einfach: Mit pinMode(sensorPin, INPUT); wird
der sensorPin als Input-Pin gesetzt. Schließlich wird der
Ruhewert bestimmt und in der Variablen ruhewert
gespeichert.
void setup() {
In der Hauptschleife wird zunächst ein aktueller Sensorwert gelesen und in wert abgespeichert. Jetzt soll die Abweichung vom Mittelwert bestimmt und in der Variablen
differenz gespeichert werden. Die Abweichung soll immer positiv sein. Da du nicht weißt, ob der aktuelle Sensorwert größer oder kleiner als ruhewert ist, wird mit Hilfe
der if -Anweisung zwischen zwei Fällen unterschieden:
Ist wert größer als ruhewert , so wird differenz als
wert - ruhewert berechnet, sonst als
ruhewert - wert .
void loop() {
Mit pixel.setColor() wird nun abhängig vom
differenz -Wert die Farbe des NeoPixels eingestellt: Je
größer die Differenz, umso höher wird der Rotanteil, und
umso geringer der Grünanteil.
pinMode(sensorPin, INPUT);
ruhewert = bestimmeRuhewert();
int wert = analogRead(sensorPin);
int differenz;
if (wert > ruhewert) {
		 differenz = wert - ruhewert;
} else {
		 differenz = ruhewert - wert;
pixel.setColor(2 * differenz, 100 - 2 * differenz, 0, differenz); // RGB-Wert und Helligkeit
// einstellen.
delay(10);
Hast du eigene Ideen, wie die Farbe
des NeoPixels auf die Abweichung
­ uhewert reagieren soll?
vom R
­Probiere es aus! Dir fallen bestimm
viele interessante Varianten ein.
37
PROJEKT 10
Piep!
› KosmoDuino im Interaction Board
p!
Piep!
DU BRAUCHST
Pie
Mit dem Interaction Board kannst du auch Töne erzeugen.
Wie das geht, erfährst du in diesem kleinen Projekt.
DER PLAN
Der KosmoDuino piept in regelmäßigen Abständen. Keine
Sorge, später lernst du auch noch, wie man eine Sirene
oder gar ein Musikinstrument aus ihm macht.
DAS PROGRAMM
Zunächst bindest du die Datei KosmoBits_Pins.h ein, und
definierst dir dann die Konstante buzzerPin , um den Pin
anzusprechen, an den der »Buzzer«, also der Miniaturlautsprecher, angeschlossen ist.
#include 
In setup() ist diesmal nichts zu tun.
void setup() {
const int buzzerPin = KOSMOBITS_BUZZER_PIN;
// Nichts zu tun.
Der Aufbau der Hauptschleife loop() kommt dir vermutlich bekannt vor. Er entspricht dem Programm »Blink«,
das du als allererstes Programm auf deinen KosmoDuino
geladen hast. Anstatt aber eine LED blinken zu lassen,
machst du diesmal Töne. Dazu dienen zwei Befehle:
tone(buzzerPin, 440); erzeugt einen Ton mit der Fre-
quenz 440 Hz. Das ist der Kammerton A. Der Ton bleibt solange eingeschaltet, bis du ihn mit noTone(buzzerPin);
wieder ausschaltest. Damit der Ton regelmäßig ein- und
ausgeschaltet wird, hängst du an jeden dieser Befehle mit
delay(500); eine Pause von einer halben Sekunde Länge.
38

void loop() {
tone(buzzerPin, 440);
delay(500);
noTone(buzzerPin);
delay(500);
KosmoBits
PROJEKT 11
Zufallstöne!
Wie du deinen KosmoDuino zum Piepen bringst, hast du
­gerade im Projekt »Piep!« gelernt. Aber immer wieder der
selbe Ton, das ist auf Dauer doch etwas langweilig. Hier
lernst du, wie du dem Controller Zufallstöne entlocken
kannst.
DU BRAUCHST
› KosmoDuino im Interaction Board
DER PLAN
Sowohl Tonhöhe als auch die Dauer des jeweiligen Tones
werden vom Zufallsgenerator bestimmt.
DAS PROGRAMM
Das Programm ist ziemlich simpel. In setup() übergibst
du dem Zufallsgenerator einen Startwert, wie du es schon
beim Würfel-Projekt getan hast.
In der Hauptschleife wird dann zunächst mit
int freq = random(110,1000); die Frequenz freq des
nächsten Tons zufällig festgelegt, danach auf gleiche Weise die Dauer.
Schließlich wird der Ton mit tone(buzzerPin,freq);
ausgegeben. delay(dauer); am Ende sorgt dafür, dass
der Ton für eben die Dauer dauer gespielt wird.
#include 

const int buzzerPin = KOSMOBITS_BUZZER_PIN;
void setup() {
randomSeed(analogRead(12));
void loop() {
int freq = random(110, 1000);
int dauer = random(10, 150);
tone(buzzerPin, freq);
delay(dauer);
SCHALL
Infraschall
Hörbare
Frequenzen
Ultraschall
Wenn die Luft, die auf unsere Trommelfelle drückt, hin und
her schwingt, nehmen wir das als Ton wahr. Je schneller
die Luft dabei schwingt, umso höher klingt der Ton.
­Physiker messen das als »Schwingungen pro Sekunde«,
genannt Frequenz. Die Einheit dafür heißt Hertz, abge­
kürzt Hz. Ein Hertz bedeutet, dass die Luft pro Sekunde
eine ganze Schwingung vollendet. Je höher die Frequenz
eines Tons, umso höher klingt auch der Ton. Der Mensch
kann Töne mit Frequenzen zwischen 16 und 20.000 Hertz
wahrnehmen. Viele Tiere sind aber auch in der Lage Töne
im Infra- und Ultraschallbereich wahrzunehmen.
39
PROJEKT 12
Sirene
Jetzt bringst du etwas Ordnung in das akustische Chaos:
Mit diesem Projekt lässt du deinen KosmoDuino wie eine
Sirene aufheulen.
DU BRAUCHST
DER PLAN
Bei jedem Durchlauf der Hauptschleife wird ein neuer Ton
ausgegeben. Dabei wird die Tonhöhe jedesmal etwas erhöht. Ist eine bestimmte Frequenz, also Tonhöhe, erreicht,
springt die Tonhöhe wieder zum Anfangswert. Das Ganze
beginnt dann von vorne.
› KosmoDuino im Interaction Board
DAS PROGRAMM
Hier legst du die Frequenzen fest, innerhalb derer sich die
Tonhöhen bewegen sollen. FREQ_MIN entspricht dem
tiefsten Ton der Sirene, FREQ_MAX dem höchsten. Du
kannst mit diesen Parametern auch experimentieren,
­indem du die Werte änderst und so den Klang der Sirene
deinem Geschmack anpasst.
DELAY bestimmt, wie lange ein einzelner Ton gehalten
werden soll.
#include 

const int buzzerPin = KOSMOBITS_BUZZER_PIN;
const int FREQ_MIN = 440;
const int FREQ_MAX = 660;
const int DELAY = 4;
int freq = FREQ_MIN; // Frequenz des Tones, der
// ausgegeben wird.
Die Variable freq schließlich speichert die aktuelle Frequenz. Gestartet wird bei FREQ_MIN .
In setup() ist diesmal nichts zu tun.
void setup() {
// Nichts zu tun.
In der Hauptschleife wird zunächst ein Ton mit der Frequenz freq ausgegeben (1). Nach einer Pause der Länge
DELAY wird dann die Frequenz freq mit ++freq; um den
Wert 1 erhöht. In der if -Anweisung wird dann überprüft,
ob die maximale Frequenz schon überschritten wurde.
Wenn ja, wird die Frequenz freq wieder auf den Startwert
FREQ_MIN zurückgesetzt.
void loop() {
tone(buzzerPin, freq); // (1)
delay(DELAY);
++freq; // Kurz für: freq = freq + 1;
if (freq > FREQ_MAX) {
		 freq = FREQ_MIN;
Im nächsten Projekt wirst du eine ganze Tonleiter erklingen lassen. Aber vorher musst du noch ein wichtiges Hilfsmittel der Programmierung kennenlernen: Arrays.
40
KosmoBits
WISSEN KOMPAKT
Arrays
Wenn du viele Werte vom gleichen
Typ speichern möchtest, zum Beispiel die letzten 100 Mes
swerte, wird es
mit einfachen Variablen schnell unü
bersichtlich und
aufwendig zu tippen. Du müsstest
schließlich für jeden
einzelnen Wert eine eigene Variabl
e anlegen, also zum
Beispiel:
int wert1;
int wert2;
Ein Array wird im Deutschen manchmal
auch Feld oder ­Datenfeld genannt.
­Allerdings ist die englische Bezeichnung
auch im Deutschen sehr viel gängiger.
Ein Array legst du allgemein folgend
int wert3;
...usw...
ermaßen an:
typ arrayName[länge];
int wert 100;
Viel einfacher ist es, stattdessen ein
sogenanntes Array
(gesprochen »Ärräj« mit weichem,
englischem »r«) zu
benutzen.
In einem Array kannst du nämlich
gleich mehrere Werte speichern. Damit du auf die vers
chiedenen Werte zugreifen kannst, werden sie im Arra
y durchnummeriert.
Du kannst dir ein Array also als eine
Art Tabelle vorstellen, in der die einzelnen Werte in
nummerierte Spalten eingetragen werden. Die Nummer
ierung der Spalten beginnt allerdings nicht mit 1,
sondern mit 0:
IND EX
…
WERTE Wert 0 Wert 1 Wert 2 Wer
t 3 … Wert n
Der Typ legt fest, welche Art von Dat
en in dem Array
­ espeichert werden können (int, floa
t, usw.). Die Anzahl
der Werte, die in einem Array gespeich
ert werden können, wird als Länge bezeichnet.
Um also zum Beispiel ein Array anz
ulegen, das 10 Integerwerte aufnehmen kann, gehst du
so vor:
int meinArray[10]; // Ein
Array, das 10
// int Werte aufneh men kan
Du kannst einem Array auch gleich
bei der Def inition
Werte zuweisen, indem du die einzelne
n Werte in geschweiften Klammern angibst:
int meinArray[4] = {0, 4,
2, 3};
In dem Fall brauchst du nicht unbedin
gt anzugeben,
wie viele Werte es sind. Du kannst
also auch so
schreiben:
int meinArray[] = {0, 4,
2, 3};
41
WISSEN KOMPAKT
elnen Werte auf Null
Häufig möchtest du, dass alle einz
so schreiben:
gesetzt werden. Das kannst du kurz
Array der
int meinArray[10] = {}; //
den auf 0
// Länge 10. Alle Werte wer
// gesetzt.
ys zuzugreifen,
Um auf die einzelnen Werte eines Arra
x des Wertes an,
gibst du in eckigen Klammern den Inde
n du dir das Array
auf den du zugreifen möchtest. Wen
ht der Index der
also als Tabelle vorstellst, entspric
Nummer der Spalte.
// Array der
int meinArray[100] = {};
0.
// Länge 100; alle Werte
Wert an IndexDer
//
meinArray[2] = 42;
// Position 2 ist jetzt 42.
x erhält den in
int x = meinArray[2]; //
ition 2
// meinArray an Index-Pos
r also 42.
// gespeicherten Wert, hie
ACHTUNG!
42
t 1 ist, sondern 0, ist
Da der Index für den ersten Wert nich
y der Länge N nicht
der höchstmögliche Index für ein Arra
Länge 100, wäre
N, sondern N - 1. Bei einem Array der
Benutzt du einen hö­
also der höchstmögliche Index 99.
ler im Programmab­
heren Index, kommt es zu einem Feh
t vorhersagen.
lauf: Was dann passiert lässt sich nich
ige Werte für den In­
Achte also darauf, dass du nur gült
dex benutzt.
n Werten einen
Häufig möchtest du aus den einzelne
Summe aller Einzelneuen berechnen, zum Beispiel die
r ihren Index anwerte. Da du die einzelnen Werte übe
einer for -Schleife
sprechen kannst, geht das nun mit
sehr einfach:
Länge 100.
// werte ist ein Array der
int sum me = 0;
< 100;
for (int index = 0; index
++index) {
ex];
sum me = sum me + werte[ind
wird der Wert
Beim ersten Durchlauf der Schleife
Danach wird
werte[0] zu sum me hinzu addiert .
nächste Wert addiert. Das
index um 1 erhöht, und der
te Wert, also
wird solange wiederholt, bis der letz
werte[99] , addiert wurde.
y benutzen, um
Im nächsten Projekt wirst du ein Arra
eine Tonleiter abzuspielen.
KosmoBits
PROJEKT 13
Tonleiter
DU BRAUCHST
› KosmoDuino im Interaction Board
DER PLAN
Dein KosmoDuino spielt eine Tonleiter.
DAS PROGRAMM
Zunächst bindest die Datei KosmoBits_Pins.h ein und
­ efinierst dir die Konstanten buzzerPin und
freqGrundton . Schließlich legst du noch das Array
tonleiter[] an, in dem die Frequenzverhältnisse der
Töne einer Dur-Tonleiter abgelegt werden. Um die Frequenz eines Tones zu ermitteln, musst du den entsprechenden Wert mit der Frequenz des Grundtones multiplizieren.
#include 

const int buzzerPin = KOSMOBITS_BUZZER_PIN;
const int freqGrundton = 220; // Das ist der
// Ton A (eine Oktave tiefer als der Kammer// ton A aus Projekt 10).
float tonleiter[] = {1.f, 9.f/8, 5.f/4, 4.f/3,
3.f/2, 5.f/3, 15.f/8, 2.f};
Diesmal passiert alles bereits in setup() . In der for Schleife wird die Variable i von 0 bis 7 hochgezählt.
Für jeden Wert von i wird dann mit
void setup() {
tone(buzzerPin, tonleiter[i] * freqGrundton); der
		delay(500);
i -te Ton der Tonleiter ausgegeben. Wie oben bereits beschrieben, wird zur Ermittlung der richtigen Frequenz die
Frequenz des Grundtons freqGrundton mit dem entsprechenden Frequenzverhältnis tonleiter[i] multipliziert.
for (int i = 0; i < 8; ++i) {
		 tone(buzzerPin, tonleiter[i] * freqGrundton);
noTone(buzzerPin);
Nach einer Pause wird die for -Schleife erneut durchlaufen, bis der höchste Ton der Tonleiter erreicht wurde. Danach ist Stille: noTone(buzzerPin);
In der Hauptschleife wird diesmal nichts gemacht. Die
Tonleiter wird also nur ein einziges Mal abgespielt. Um die
Tonleiter nochmal abzuspielen, kannst du die Reset-Taste
auf dem KosmoDuino drücken. Dadurch wird der Code zurückgesetzt und von Neuem ausgeführt.
void loop() {
// Hier wird nichts gemacht.
43
PROJEKT 14
Sensor-Orgel
Nachdem du nun gelernt hast, wie man Tonleitern spielt,
kannst du in diesem Projekt ein richtiges Musikinstrument
programmieren.
DU BRAUCHST
DER PLAN
› KosmoDuino im Interaction Board
› Bewegungssensor
Per Tastendruck erzeugst du Töne. Die Tonhöhe kannst du
verändern, indem du das Interaction Board bewegst. Mit
ein wenig Übung kannst du so richtige Melodien spielen.
DAS PROGRAMM
Zunächst definierst du ein paar Konstanten für Sensor-,
Buzzer- und Taster-Pin. Danach legst du wie im vorigen
Projekt ein Array für die Tonleiter, sowie eine Konstante für
den Grundton, an.
Mit den Konstanten messwertMin und messwertMax
stellst du ein, wie weit der Controller gekippt werden
muss, um den höchsten bzw. den tiefsten Ton zu spielen.
Du kannst diese Werte später für dich anpassen. Die
­ on­stante skalierung benutzt du später, um aus einem
­Messwert die Tonhöhe zu bestimmen. Du teilst damit quasi
den gesamten Messbereich in 9 Bereiche ein.
Der Bewegungssensor ist recht empfindlich. Deshalb
schwanken die Messwerte ein wenig. Damit die Tonhöhe
dadurch nicht zu wackelig wird, nimmst du nicht direkt
den letzten Messwert, um daraus die Tonhöhe zu berechnen, sondern bestimmst den Mittelwert von 10 Messungen.
Die letzten 10 Messwerte werden dazu in dem Array
werte[] gespeichert. Durch int werte[N] = {};
­werden alle Werte darin zunächst auf 0 gesetzt.
Mit der Variablen index wird das Array durchlaufen.
­Gestartet wird wie üblich bei 0.
Hier werden nur die jeweiligen Pin-Modi eingestellt.
#include 

const int sensorPin = KOSMOBITS_SENSOR_PIN;
const int buzzerPin = KOSMOBITS_BUZZER_PIN;
const int tasterPin = KOSMOBITS_TASTE_2_PIN;
const float tonleiter[] = {1.f, 9.f/8, 5.f/4,
4.f/3, 3.f/2, 5.f/3, 15.f/8, 2.f};
const int freqGrundton = 220; // Das ist der
// Ton A.
const int messwertMin = 300;
const int messwertMax = 400;
const int skalierung = (messwertMax - messwert
Min) / 9;
const int N = 10; // Anzahl der Werte, die
// gemittelt werden.
int werte[N] = {}; // Hier werden die letzten
// 10 Werte gespeichert.
int index = 0;
void setup() {
pinMode(sensorPin, INPUT);
pinMode(tasterPin, INPUT);
Zunächst liest du einen neuen Messwert und speicherst ihn
im Array werte an Index-Position index . Damit der
nächste Messwert an der darauffolgenden Position gespeichert wird, wird mit ++index; die Variable index um 1
erhöht. Wird dabei der Wert N erreicht, stellt die
44
void loop() {
// Lese einen neuen Wert vom Sensor und
// speichere ihn in werte[].
werte[index] = analogRead(sensorPin);
KosmoBits
PROJEKT 14

if -Anweisung index auf 0 zurück. Das Array wird wieder von vorne befüllt.
// Erhöhe den Index um 1, damit der nächste
// Wert an der nächsten Stelle
// im Feld werte[] gespeichert werden kann.
Danach geht es daran, den Mittelwert der letzten 10 Messwerte zu bestimmen. Dazu wird die Variable mittelwert
zunächst auf 0 gesetzt. In der for -Schleife werden dann
alle im Array werte[] gespeicherten Messwerte zu
mittelwert hinzu addiert. Um daraus dann den Mittelwert zu bestimmen, muss das Ergebnis noch durch die Zahl
der Werte geteilt werden:
mittelwert = mittelwert / N; .
Mit int tonIndex = (mittelwert - messwertMin) / skalierung;
ermittelst du den »Tonindex«: Der wievielte Ton der Tonleiter soll gespielt werden?
++index;
// Wenn index == N ist, ist das Feld voll
// beschrieben.
// index wird dann auf 0 gesetzt, damit im
// nächsten Durchlauf
// der älteste Wert überschrieben wird.
if (index == N) {
			index = 0;
// Jetzt wird der Mittelwert der letzten N
// Messwerte berechnet.
Es kann sein, dass tonIndex einen ungültigen Wert hat,
also kleiner als 0 oder größer als 7 ist. Deshalb korrigierst
du das im Zweifelsfall mit der if-else -Anweisung.
Schließlich wird in der letzten if -Abfrage getestet, ob der
Taster gedrückt ist. Wenn ja, wird der entsprechende Ton
ausgegeben. Wenn nicht, wird kein Ton ausgegeben.
int mittelwert
= 0; // Starte mit dem Wert 0
// Summiere die letzten 10 gemessenen Werte.
for (int i = 0; i < N; ++i) {
		 mittelwert = mittelwert + werte[i];
// Teile die Summe durch die Zahl der Werte.
mittelwert = mittelwert / N;
int tonIndex = (mittelwert - messwertMin) /
skalierung;
// tonIndex darf nicht kleiner 0 und nicht
// größer 7 sein:
if (tonIndex < 0) {
		 tonIndex = 0;
} else if (tonIndex > 7) {
		 tonIndex = 7;
// Ton ausgeben
if (digitalRead(tasterPin) == LOW) {
		 tone(buzzerPin, tonleiter[tonIndex] * freqGrundton);
		delay(10);
} else {
		noTone(buzzerPin);
		delay(1);
Zugegeben: Das war schon etwas umfangreicher.
Das Ergebnis lohnt sich aber!
45
PROJEKT 15
Der serielle Plotter
DU BRAUCHST
› KosmoDuino im Interaction Board
› Schallsensor
DER PLAN
Bei dem Schallsensor handelt es sich im Grunde um ein
kleines Mikrofon, das du über den Sensor-Pin auslesen
kannst. Um zu verstehen, wie er sich verhält, benutzt du
am besten ein weiteres tolles Werkzeug der Arduino-Umgebung, nämlich den seriellen Plotter.
DAS PROGRAMM

Stecke den Schallsensor in das Interaction Board und lade dann das folgende kleine Programm auf deinen KosmoDuino:
Besonders viel macht der Code nicht. Bei jedem Durchlauf
der Hauptschleife wird lediglich ein neuer Wert vom Sensor-Pin gelesen und mit Serial.println() ausgegeben.
#include 
const int sensorPin = KOSMOBITS_SENSOR_PIN;
void setup() {
pinMode(sensorPin, INPUT);
Serial.begin(115200);
void loop() {
Serial.println(analogRead(sensorPin));
Starte jetzt aus dem Menü »Werkzeuge« den Seriellen
Plotter.
Es öffnet sich ein neues Fenster, in dem es ganz schön wild
zu geht.
Versuche jetzt einmal verschiedene Geräusche zu machen,
zu pfeifen oder zu singen. Du wirst sehen, wie sich das Bild
im seriellen Plotter verändert.
An der Skala auf der linken Seite kannst du leicht ablesen,
wie groß die Werte sind, die der Sensor liefert. Im hier abgebildeten Beispiel siehst du, dass 0 der niedrigste Wert ist.
Das ist auch klar, etwas kleineres kann analogRead()
nicht liefern. Der größte gemessene Wert ist ungefähr 250.
Wenn du aber in die Hände klatschst, können die gemessenen Werte auch mal auf 800 ansteigen.
Das kannst du im folgenden Projekt prima ausnutzen!
46
115200 Baud
KosmoBits
PROJEKT 16
Der Klatschschalter
Wäre es nicht cool, wenn dein KosmoDuino auf Klatschen
reagieren würde? Mit Hilfe des Schallsensors kannst du
das leicht programmieren.
DU BRAUCHST
› KosmoDuino im Interaction Board
› Schallsensor
DER PLAN
Wenn du einmal klatschst, soll der NeoPixel auf dem Interaction Board eingeschaltet werden. Wenn du dann noch
einmal klatschst, geht er wieder aus.
DAS PROGRAMM
Es werden die üblichen Dateien eingebunden sowie die
Konstante sensorPin für den Sensor-Pin definiert.
Die Konstante schwelle regelt die Empfindlichkeit deines
Klatschschalters. Wird der hier eingestellte Wert vom
Messwert überschritten, so schaltet der Schalter um. Entweder von »an« auf »aus«, oder eben umgekehrt.
In der Variablen an speicherst du den aktuellen Zustand
des NeoPixels ab. Ist er an, so wird ihr der Wert true
(wahr) zugewiesen, andernfalls der Wert false (falsch).
Zu Beginn des Programms ist der NeoPixel aus:
bool an = false; .
#include 
In setup() wird der Pin-Modus des Sensor-Pins eingestellt und der NeoPixel ausgeschaltet.
void setup() {

#include 
#include 
const int sensorPin = KOSMOBITS_SENSOR_PIN;
const int schwelle = 500;
KosmoBits_Pixel pixel;
bool an = false;
pinMode(sensorPin, INPUT);
pixel.setColor(0, 0, 0, 0);
In der Hauptschleife wird fortwährend der Schallsensor
ausgelesen. Ist der gemessene Wert größer als der in
schwelle eingestellte Wert, so wird die Funktion
umschalten() aufgerufen und anschließend kurz
gewartet.
void loop() {
int sensorWert = analogRead(sensorPin);
Serial.println(sensorWert);
if (sensorWert > schwelle) {
		umschalten();
		delay(200);
Hier schreibst du dir deine eigene Funktion
void umschalten() . Es wird dort abgefragt, ob der NeoPixel derzeit an ist. Wenn ja, wird der NeoPixel ausgeschaltet und an der Wert false zugewiesen.
Andernfalls (»else«) wird der NeoPixel eingeschaltet und
an der Wert true (wahr) zugewiesen.
Kurz: umschalten() macht genau das, was der Name vermuten lässt. Es wird zwischen "ein" und "aus" hin und her
geschaltet.
void umschalten() {
if (an) {
		 pixel.setColor(0, 0, 0, 0);
		 an = false;
} else {
		 pixel.setColor(255, 0, 0, 30);
		 an = true;
47
PROJEKT 17
Der Schubladenwächter
Hattest du schon immer den Verdacht, dass dein Bruder
oder deine Schwester heimlich deine Schublade durchwühlt, wenn du nicht zu Hause bist? Mit dem Schubladenwächter Projekt kannst du ihn überführen! Das Gute d
­ aran:
Der Täter merkt nicht einmal, dass die Schublade überwacht wird: Es gibt keinen Alarm, nichts weist den Täter
darauf hin, dass seine Tat bemerkt wurde. Erst, wenn du
den KosmoDuino befragst, zeigt er dir an, ob sich jemand
an deinen Geheimnissen zu schaffen gemacht hat!
DU BRAUCHST
› KosmoDuino im Interaction Board
› Lichtsensor
DER PLAN
In einer geschlossenen Schublade ist es dunkel, in einer offenen nicht. Mit dem Lichtsensor kannst du also feststellen, ob deine Schublade geöffnet wurde oder nicht.
Du wirst deinen KosmoDuino so programmieren, dass er
folgendes für dich macht:
1. Nach dem Einschalten wartet er darauf, durch einen
Druck auf Taste 1 »scharf« gestellt zu werden.
2. Ist der Schubladenwächter scharf geschaltet, wartet er,
bis die Schublade geschlossen wurde. Erst dann beginnt
er mit der Überwachung der Schublade.
3. Wird die Schublade dann wieder geöffnet, gibt es zwei
Möglichkeiten, wie es weitergeht:
Notiere dir, welche Messwerte der Sketch ausgibt, wenn du
den Lichtsensor
• dem Tageslicht aussetzt,
• der Dämmerung aussetzt,
• mit der Hand abdeckst,
• mit einer Taschenlampe bestrahlst.
a) Wird die Schublade wieder geschlossen, so wird dies
als »Schublade wurde geöffnet« gezählt.
LICHT
b) Drückst du auf Taste 2, so wird dir durch den NeoPixel
angezeigt, wie oft die Schublade geöffnet wurde.
Dämmerung
VORBEREITUNG: SENSORWERTE
MESSEN
Um zu bemerken, ob die Schublade geöffnet wurde, benutzt du den Lichtsensor. Er misst die Helligkeit des Lichts,
das auf ihn fällt. Solange sich dein KosmoDuino in der
dunklen Schublade befindet, wird er einen niedrigen Wert
messen. Wird die Schublade aber geöffnet, erhöht sich der
gemessene Wert. Leider ist es nicht in jeder geschlossenen
48
Schublade immer vollständig dunkel. Ab welchem Helligkeitswert ist die Schublade aber geöffnet? Das probierst
du nun aus! Stecke dazu als Erstes den Lichtsensor in das
Interaction Board. Jetzt musst du herausfinden, wie hell es
im Hellen ist. Das machst du, indem du den Sensor ausliest
und den Messwert über den seriellen Monitor ausgibst.
Das machst du wie immer mit dem Sketch SensorLesen.
MESSWERT
Tageslicht
abgedunkelt
Taschenlampe
Du wirst diese Werte später benötigen, wenn du dir
­ berlegst, wann die Schublade als geschlossen gewertet
ü
werden soll.
KosmoBits
PROJEKT 17

DAS GRUNDGERÜST
Wir benutzen in diesem Projekt den NeoPixel und die beiden Tasten. Deshalb werden hier die benötigten Bibliotheken eingebunden.
#include 
Wir definieren drei Konstanten, um den Sensor und die Tasten auszulesen, sowie die drei Variablen taste1 , taste2
und sensorWert , in dem die aktuellen Messwerte gespeichert werden.
const int sensorPin = KOSMOBITS_SENSOR_PIN;
#include 
#include 
const int taste1Pin = KOSMOBITS_TASTE_1_PIN;
const int taste2Pin = KOSMOBITS_TASTE_2_PIN;
int taste1 = HIGH;
int taste2 = HIGH;
int sensorWert = 0;
Damit der Programm-Code übersichtlich bleibt, hilft es,
sich das Programm als eine Maschine vorzustellen, die in
unterschiedlichen Betriebsarten (Modi) betrieben werden
kann. Je nach Modus wird in der Hauptschleife etwas anderes gemacht.
enum Modus {LEERLAUF, COUNTDOWN, WARTE_BIS_
DUNKEL, GESCHLOSSEN, OFFEN};
Modus modus = LEERLAUF;
Dazu definieren wir mit dem Wort enum Modus einen sogenannten Aufzählungstypen: Eine Variable des Typs
Modus kann nur die Werte annehmen, die in den geschweiften Klammern stehen, also LEERLAUF ,
COUNTDOWN usw.
Anschließend definieren wir die Variable modus in der der
aktuelle Betriebsmodus gespeichert wird. Wir beginnen im
Modus LEERLAUF .
Die Konstante DUNKEL_WERT legt fest, ab welchem Messwert des Lichtsensors die Schublade als geschlossen gewertet wird. Manche Schubladen lassen immer noch ein
wenig Licht hinein. Passe den Wert also so an, dass er für
deine Schublade passend ist. Die Werte, die du zur Vorbereitung gemessen hast, helfen dir dabei!
const int DUNKEL_WERT = 5;
unsigned long zaehler = 0;
KosmoBits_Pixel pixel;
In der Variablen zaehler wird gespeichert, wie oft die
Schublade geöffnet wurde. Schließlich verschaffen wir
uns mit pixel noch Zugriff auf den NeoPixel.
Wenn die Überwachung beendet wurde, möchten wir wieder in den Ausgangszustand zurückkehren. Also so, als ob
wir den KosmoDuino gerade erst eingeschaltet hätten. Dafür führen wir die Funktion reset() ein. Der NeoPixel wird
ausgeschaltet, modus auf LEERLAUF und zaehler zurück auf 0 gesetzt. Zur Kontrolle wird über die serielle
Schnittstelle »Reset!« ausgegeben.
void reset() {
pixel.setColor(0, 0, 0, 0); // Pixel aus
modus = LEERLAUF;
zaehler = 0;
Serial.println("Reset!");
49
PROJEKT 17
In setup() legen wir, wie üblich, die Betriebsarten der
­benutzten Pins fest und initialisieren die Ausgabe über die
serielle Schnittstelle. Danach wird reset() aufgerufen,
um den Schubladenwächter in den Ausgangszustand zu
versetzen.

void setup() {
pinMode(sensorPin, INPUT);
pinMode(taste1Pin, INPUT);
pinMode(taste2Pin, INPUT);
Serial.begin(115200);
reset();
In der Hauptschleife werden je nach Betriebsart verschiedene loop-Funktionen aufgerufen. Dazu dient die
switch(modus) -Anweisung. Damit wird eine Fallunterscheidung eingeleitet. Für jeden Fall (engl. case), also
möglichen Wert von modus , wird eine andere Funktion
aufgerufen:
• Hat modus den Wert LEERLAUF , wird loopLeerlauf()
aufgerufen.
• Hat modus den Wert COUNTDOWN , wird
loopCountdown() aufgerufen, usw.
Wichtig ist die break; -Anweisung (engl. abbrechen), um
die Behandlung eines Falles abzuschließen und die Fallunterscheidung zu beenden. Ohne die break; Anweisung
würde der Code des nächsten Falles auch ausgeführt
werden.
void loop() {
switch(modus) {
case LEERLAUF:
		loopLeerlauf();
		break;
case COUNTDOWN:
		loopCountdown();
		break;
case WARTE_BIS_DUNKEL:
		loopWarteBisDunkel();
		break;
case GESCHLOSSEN:
		loopGeschlossen();
		break;
case OFFEN:
		loopOffen();
		break;
Damit haben wir das Grundgerüst unseres Programms
­fertig. Jetzt müssen wir uns nur noch überlegen, was
­genau der Schubladenwächter in den unterschiedlichen
Betriebsarten machen soll.
◀ Board mit Lichtsensor
50
KosmoBits
PROJEKT 17

IM LEERLAUF
Im Leerlauf wartet der Schubladenwächter darauf, dass
Taste 1 gedrückt wird, um die Überwachung zu starten. Dafür verantwortlich ist die Funktion loopLeerlauf() , die im
Modus LEERLAUF aus der Hauptschleife aufgerufen wird.
Den Code verstehst du mittlerweile wahrscheinlich schon
ohne Probleme. In der Variablen gedrueckt wird gespeichert, ob die Taste gedrückt wurde. Wird Taste 1 gedrückt,
wird die while() -Schleife durchlaufen: Der NeoPixel leuchet grün, und die Variable gedrueckt wird auf den Wert
true gesetzt. Wenn Taste 1 losgelassen wird, wird die
while() -Schleife verlassen. Am Ende wird mit der if() Anweisung getestet, ob die Taste gedrückt worden ist.
Falls ja, wird der Modus auf COUNTDOWN gesetzt. Andernfalls wird loopLeerlauf() verlassen und wieder die
Hauptschleife aufgerufen. Die ruft dann erneut
loopLeerlauf() auf, weil sich der Modus ja nicht geändert hat.
void loopLeerlauf() {
Serial.println("Leerlauf");
bool gedrueckt = false;
while(digitalRead(taste1Pin) == LOW) {
		// Taste 1 wurde gedrückt.
		 // Warte, bis sie wieder losgelassen wird.
		 pixel.setColor(0, 255, 0, 25);
		 gedrueckt = true;
		delay(50);
if (gedrueckt) {
		 modus = COUNTDOWN;
COUNTDOWN
Auch hier dürfte dir das meiste bekannt vorkommen. Zunächst wird in der Konstanten COUNTDOWN_ZAHL festgelegt, wie viele Sekunden der Countdown dauern soll:
5 Sekunden. Der NeoPixel wird ausgeschaltet und nach
500 Millisekunden der eigentliche Countdown in der
for() -schleife gestartet: 5-mal »An - Warten - Aus«. Danach wird der NeoPixel eine Sekunde (1000 Millisekunden)
lang auf »rot« gesetzt. Schließlich wird der Modus auf
WARTE_BIS_DUNKEL gesetzt und loopCountdown()
verlassen.
void loopCountdown() {
const int COUNTDOWN_ZAHL = 5;
Serial.println("Countdown");
pixel.setColor(0, 0, 0, 0); // Pixel aus
delay(500);
// Der eigentliche Countdown: Wie Blink.
for (int i = 0; i < COUNTDOWN_ZAHL; ++i) {
		 pixel.setColor(0, 255, 0, 25); // Grün
		delay(500);
		 pixel.setColor(0, 0, 0, 0); // Pixel aus
		delay(500);
pixel.setColor(255, 0, 0, 25); // Rot
delay(1000);
pixel.setColor(0, 0, 0, 0); // Pixel aus
modus = WARTE_BIS_DUNKEL;
WARTEN BIS ES DUNKEL IST
Das ist einfach: Es wird so lange die while -Schleife durchlaufen, bis es dunkel ist. Gemessen wird alle 10 Millisekunden. Wenn die while() -Schleife verlassen wurde, wird
der Modus auf GESCHLOSSEN gesetzt und
loopBisDunkel() verlassen.
void loopBisDunkel() {
Serial.println("Warte bis dunkel");
while (analogRead(sensorPin) > DUNKEL_WERT) {
		delay(10);
modus = GESCHLOSSEN;
delay(1000);
51
PROJEKT 17
ÜBERWACHEN (GESCHLOSSEN)
Die eigentliche Überwachung der Schublade geschieht im
Modus GESCHLOSSEN , also in loopGeschlossen() . Zunächst wird die aktuelle Helligkeit gemessen. Ist es dunkel, wird eine Sekunde (1000 Millisekunden) lang gewartet. loopGeschlossen() wird dann aus der Hauptschleife
erneut aufgerufen.
Ist es hell, so wird nach 0,5 Sekunden noch einmal gemessen. Ist es immer noch hell, werten wir das, als »Schublade ist offen«. Der Modus wird auf OFFEN gesetzt: Im
nächsten Durchlauf der Hauptschleife wird dann
loopOffen() aufgerufen.
void loopGeschlossen() {

Serial.println("Im Dunkeln");
sensorWert = analogRead(sensorPin);
if (sensorWert < DUNKEL_WERT) {
// Es ist
// noch dunkel.
delay(1000); // Warte 1 Sekunde, loop() ruft
// diese Funktion dann wieder auf.
} else {
// Es ist hell! Kontrolliere nach
// 0,5 Sekunden noch einmal.
		delay(500);
		 if (analogRead(sensorPin) >= DUNKEL_WERT) {
			// Es ist hell:Schublade geöffnet!
			modus = OFFEN;
EINDRINGLINGE (OFFEN)?
Ist die Schublade geöffnet worden, muss der Schubladenwächter noch herausfinden, ob es sich um einen Eindringling
handelt. Vielleicht hast du die Schublade ja selbst geöffnet.
Das erledigt loopOffen() . Diese Funktion wird aus der
Hauptschleife immer dann aufgerufen, wenn modus den
Wert OFFEN hat. Wir kontrollieren zunächst Taste 2: Wird sie
gedrückt, dann wird das Ergebnis der Überwachung ausgegeben, indem die Funktion ausgabe() aufgerufen wird.
Wird Taste 2 nicht gedrückt, so wird im else if -Teil die
Helligkeit kontrolliert: Ist es jetzt dunkel, ist die Schublade
wieder geschlossen worden. zaehler wird dann mit
++zaehler um den Wert 1 erhöht.
void loopOffen() {
Serial.println("geöffnet");
delay(50);
taste2 = digitalRead(taste2Pin);
sensorWert = analogRead(sensorPin);
if (taste2 == LOW) {
		ausgabe();
} else if (sensorWert < DUNKEL_WERT) {
		// Schublade wieder zu.
		++zaehler;
		 modus = GESCHLOSSEN;
Ist weder Taste 2 gedrückt, noch die Schublade wieder geschlossen worden, wird die Funktion verlassen und von
der Hauptschleife erneut aufgerufen.
AUSGABE
Um die Ausgabe des Überwachungsergebnisses kümmert
sich die Funktion ausgabe() . Zunächst wird das genaue
Ergebnis über die serielle Schnittstelle ausgegeben. Für die
schnelle Kontrolle, ohne angeschlossenen Computer, wird
das Ergebnis aber auch über den NeoPixel ausgegeben: Ist
die Schublade geöffnet und wieder geschlossen worden
(also zaehler > 0 ), so leuchtet der NeoPixel für 2 Sekunden lang rot. Andernfalls leuchtet er grün. Danach wird
der Schubladenwächter mit reset() wieder in den Ausgangszustand zurückgesetzt.
void ausgabe() {
Serial.print("Die Schublade wurde ");
Serial.print(zaehler);
Serial.print("-mal geöffnet!\n");
if (zaehler > 0) {
		 pixel.setColor(255, 0, 0, 25);
} else {
		 pixel.setColor(0, 255, 0, 25);
delay(2000);
reset();
52
KosmoBits
PROJEKT 18
ACHTUNG! Nicht geeignet für Kinder unter 10 Jahren. Falls ein inkor­
rekter Kurzschluss durch unterschiedliche Polaritäten verursacht,
oder der Kondensator unter falschen Bedingungen verwendet wird,
können heiße Oberflächen durch Bauteile auf der Platine entstehen.
In den Kühlschrank
geschaut
Wie kann man eigentlich feststellen, ob das Licht im
­Kühlschrank wirklich aus geht, wenn du die Kühlschranktür schließt? Nachsehen kannst du ja nicht ohne weiteres.
Schließlich müsstest du dazu die Tür wieder öffnen und
dann ginge das Licht wieder an.
Mit deinem KosmoDuino allerdings, ist das kein Problem!
DU BRAUCHST
› KosmoDuino im Interaction Board
› Lichtsensor
› 4 Jumperkabel männlich-weiblich
VORBEREITUNG
DER PLAN
Löse von dem Strang mit den männlich-weiblichen
­Jumperkabeln einen Strang mit 4 Kabeln ab. Die Stecker­
enden steckst du in die Buchsen, in die du sonst die
­KosmoBits-Sensor-Module hineinsteckst.
Mit dem Lichtsensor misst du die Helligkeit im Kühlschrank. Den NeoPixel auf dem Interaction Board lässt du
entsprechend der gemessenen Helligkeit aufleuchten.
Aber wie kannst du dir außerhalb des Kühlschranks anzeigen lassen, wie hell es in seinem Inneren ist? Ganz einfach:
Du benutzt »Verlängerungskabel«, um den Sensor anzuschließen! Den Sensor hältst du dann mit Hilfe der Kabel
in den Kühlschrank, während der KosmoDuino mit dem
­Interaction Board draußen bleibt.
In die Buchsenenden der Kabel steckst du dann den
­Lichtsensor. Achte unbedingt darauf, dass jeder Pin des
Lichtsensor über die Jumperkabel mit genau der Buchse
verbunden ist, in der er normalerweise stecken würde.
Die Kabel dürfen sich also nicht überkreuzen.
Die Kabel sind so dünn, dass du die Kühlschranktür
­trotzdem schließen kannst!
53
PROJEKT 18
DAS PROGRAMM
Das Programm verstehst du bestimmt schon ganz alleine.
Trotzdem ganz kurz: In setup() stellst du den Pin-Modus
des Sensor-Pins ein und schaltest den NeoPixel aus.
In der Hauptschleife misst du über den Licht-Sensor
die Helligkeit und speicherst den Messwert in der
Variablen helligkeit . Da der Helligkeitswert bei
pixel.setColor() nicht größer als 255 sein darf, begrenzt du den Wert von helligkeit mit Hilfe der if -Anweisung auf 255.
Jetzt brauchst du nur noch den Sensor in den Kühlschrank
zu halten und die Tür zu schließen. Und? Geht das Licht
aus?
#include 

#include 
#include 
const int sensorPin = KOSMOBITS_SENSOR_PIN;
KosmoBits_Pixel pixel;
void setup() {
pinMode(sensorPin, INPUT);
pixel.setColor(255, 255, 255, 0);
void loop() {
int helligkeit = analogRead(sensorPin);
if (helligkeit > 255) {
		 helligkeit = 255;
pixel.setColor(255, 255, 255, helligkeit);
delay(10);
▲ Jumperkabel in Kühlschrank
54
KosmoBits
PROJEKT 19
ACHTUNG! Nicht geeignet für Kinder unter 10 Jahren. Falls ein inkor­
rekter Kurzschluss durch unterschiedliche Polaritäten verursacht,
oder der Kondensator unter falschen Bedingungen verwendet wird,
können heiße Oberflächen durch Bauteile auf der Platine entstehen.
Geisteraugen
DER PLAN
Wie wäre es damit, zu Halloween den Kürbis noch etwas
unheimlicher zu machen? Mit deinem KosmoDuino kannst
du ihm Geisteraugen basteln.
Lass die Augen deines Kürbis zufällig bunt blinken. Dazu
ertönt in unregelmäßigen Abständen ein gruseliges
Rauschen.
DU BRAUCHST
› KosmoDuino im Interaction Board
› 2 Widerstände
› grüne LED
› rote LED
› 3 Jumperkabel männlich-männlich
› 4 Jumperkabel männlich-weiblich
› Breadboard
VORBEREITUNG
Diesmal braucht es etwas mehr als nur das Interaction
Board, denn du musst eine kleine elektronische Schaltung
aufbauen. Die baust du aus den links genannten Teilen
nach der Abbildung zusammen.
Achte dabei auf die richtige Polung der LEDs.
IN DIESEM BEISPIEL IST DER AUFBAU FOLGENDERMASSEN:
• Ein Jumperkabel verbindet einen Gnd-Pin mit der
(-)-Leiste des Breadboards.
• Ein Jumperkabel verbindet Pin 11 des KosmoDuinos
mit Feld j 57 auf dem Breadboard.
• Ein Jumperkabel verbindet Pin 6 des KosmoDuinos
mit Feld j 51 auf dem Breadboard.
• Die Widerstände verbinden die (-)-Leiste und Feld a 57
sowie (-)-Leiste und Feld a 51.
•D
 as lange Beinchen der roten LED steckt in Feld f 57,
das kurze in e 57. Bei der grünen LED verhält es sich
entsprechend mit Reihe 51.
•U
 m die LEDs vom Breadboard zu den Kürbisaugen
zu führen, verwendest du die 4 männlich-weiblich
Jumperkabel um die LEDs an den entsprechenden
Stellen mit dem Breadboard zu verbinden.
55
PROJEKT 19

DAS PROGRAMM
Das Programm ist äußerst einfach. Zuerst werden Kon­
stanten für die benutzten Pins definiert. In setup() geben
wir dem Zufalssgenerator einen Startwert.
In der Hauptschleife wird zunächst mit analogWrite()
die Helligkeit der jeweiligen LED auf einen zufälligen Wert,
random(0, 256) , eingestellt. Das bewirkt das Flackern
der Geisteraugen.
Um das Rauschen zu erzeugen, erzeugst du dann in der
if -Anweisung mit random(0, 1000) wieder eine Zufallszahl. Diesmal zwischen 0 (kleister möglicher Wert) und
999 (größter möglicher Wert).
Ist die Zufallszahl größer als 900, dann schreibst du in der
anschließenden for -Schleife mit
analogWrite(buzzerPin, random(0, 256)); 3000 Zufallswerte in den buzzerPin . Das ergibt das Rauschen
im Lautsprecher.
Die Zufallszahlen, die mit Hilfe der random() -Funktion
­erzeugt werden, sind gleich verteilt. Das bedeutet, dass
jede mögliche Zahl über lange Zeit betrachtet gleich häufig erzeugt wird. Das Rauschen wird aber nur in den Fällen
ausgegeben, in denen die Zufallszahl größer ist als 900.
Das passiert in ungefähr einem Zehntel der Fälle. Möchtest
du, dass das Rauschen seltener auftritt, musst du statt der
900 eine größere Zahl wählen.
#include 
const int buzzerPin = KOSMOBITS_BUZZER_PIN;
const int rotPin = 11;
const int gruenPin = 6;
void setup() {
randomSeed(analogRead(3));
pinMode(rotPin, OUTPUT);
pinMode(gruenPin, OUTPUT);
void loop() {
// Blinken
analogWrite(rotPin, random(0, 256));
analogWrite(gruenPin, random(0, 256));
delay(200);
// Rauschen
if (random(0, 1000) > 900) {
		 for (int i = 0; i < 3000; ++i) {
			analogWrite(buzzerPin, random(0, 256));
Du kannst diese blinkenden und flackernden Geisteraugen
nun in einen Kürbis oder in ein selbst gebasteltes Gespenst
einbauen.
Die Geisteraugen lassen sich auch prima mit anderen Ideen
kombinieren. Wie wäre es zum Beispiel mit einer Sirene,
die aufheult, wenn du den Kürbis mit einer Taschenlampe
anstrahlst? Sicherlich weißt du mittlerweile, wie du das
machen kannst, und hast noch viel mehr tolle Ideen!
▲ Geisteraugen
56
KosmoBits
BREADBOARD
Das Breadboard, selten auf Deutsch auch Steckbrett genannt, ist ein einfacher Weg, kleine elektronische Schaltungen
aufzubauen. Die äußeren rot und blau gekennzeichneten Reihen sind dabei elektrisch miteinander verbunden. Hier legt
man üblicherweise die Spannungsversorgung an. Dazu verbindet man einen der mit »Gnd« (englisch für Ground, deutsch
Masse) gekennzeichneten Pins des Mikrocontrollers mit einem (-)-Feld, und einen »5V«-Pin mit einem (+)-Feld im Bread­
board. Die senkrechten Spalten (a bis e und f bis j) sind ebenfalls miteinander elektrisch verbunden. Allerdings nur bis zu
dem »Graben« in der Mitte des Breadboards. Die Details kannst du in der Abbildung erkennen.
Wie geht es weiter?
Du hast jetzt viele Grundlagen der Arduino-Programmierung erlernt. Darauf kannst und solltest du aufbauen. Das
­KosmoBits-Set erlaubt dir einen guten Start, denn neben dem eigentlichen Mikrocontroller hast du bereits ein Breadboard, einige LEDs, Jumperkabel und natürlich Sensoren. Mit Hilfe des Akkus kannst du das Ganze sogar unabhängig von
einem Computer betreiben, ohne zusätzliche Teile zu benötigen. Der Akku ist sogar ziemlich leistungsstark. Das merkst
du daran, dass er relativ selten aufgeladen werden muss. Mit anderen Worten: Du bist bestens ausgerüstet!
Im Internet wirst du jede Menge weitere Projektideen finden. Vermutlich wirst du dazu gelegentlich ein weiteres Elektronikteil benötigen. Den Rest hast du aber schon. Vor allem aber kannst du mittlerweile sogar schon programmieren.
Lass deiner Kreativität freien Lauf.
Viel Spaß dabei!
57
WISSEN KOMPAKT
Eingerückt
ert, dass viele
Vielleicht hast du dich schon gewund
en hier findest,
­Zeilen, die du in den Programmtext
ter rechts beginnen
­eingerückt sind, also ein wenig wei
ach: Das erleichals andere. Die Antwort ist recht einf
mmtext.
tert den Überblick über den Progra
piel
Nehmen wir mal ein einfaches Beis
LOW) {
if (digitalRead(taste1) ==
rot = 255;
} else {
rot = 0;
Das könntest du auch so schreiben:
LOW) {
if (digitalRead(taste1) ==
rot = 255;
} else {
rot = 0;
oder sogar noch schlimmer so:
LOW) {rot = 255;} else
if (digitalRead(taste1) ==
{rot = 0;}
, es ist nur etwas
Das bedeutet alles genau das Gleiche
ersten Beispiel
anders formatiert. Und trotzdem, im
des Programms
kannst du auf einen Blick die Struktur
lesen.
erkennen. Es ist leichter den Code zu
iesen, den ProDeshalb hat es sich als praktisch erw
ter einzurücken,
grammcode jedes Mal eine Stufe wei
h sollte in aller
wenn ein neuer Block beginnt. Auc
eigene Zeile
­Regel jede einzelne Anweisung eine
bekommen.
dich dabei und
Die Arduino-Umgebung unterstützt
en von alleine
rückt neue Blöcke in den meisten Fäll
per Hand einrücken
ein. Wenn du Textteile doch einmal
lichst nicht die
möchtest, dann benutze dafür mög
Leertaste, sondern die Tab-Taste.
◀ Automatische Formatierung
58
KosmoBits
NACHGEHAKT
Was ist
­eigentlich
ein Bug?
▲ Die Logbuch-Seite mit Motte
Wenn ein Programm nicht das tut, was es eigentlich soll, spricht man von einem Bug. Man könnte
es auch einfach einen Fehler nennen, der englische Begriff Bug (deutsch: Käfer) wird aber viel öfter
verwendet. Die Geschichte dahinter ist erstaunlich!
Frühere Computer, wie zum Beispiel der 1947 fertig gestellte Harvard Mark II, besaßen noch keine
Mikroprozessoren. Stattdessen rechneten sie mit Hilfe von elektro-mechanischen Relais. Ein Relais
besteht im Grunde aus einem Elektromagneten und einem Schalter, der sich magnetisch betätigen
lässt. Schaltet man den Elektromagneten an, betätigt er den Schalter. Schaltet man den Magneten
wieder an, bewegt sich der Schalter wieder in die »Aus«-Stellung. Wichtig ist, dass sich in einem
solchen Relais tatsächlich etwas bewegt, nämlich der Schalter.
Am 9. September 1947
machten sich die für den
Mark II zuständigen Techniker auf die Suche nach
­einem Fehler. Sie fanden
ihn: Es handelte sich um
eine Motte, die sich in einem
­Relais verklemmt hatte.
Der erste Bug in einem Programm war also tatsächlich
ein Insekt. Die Motte haben
sie pflichtbewusst in das
Logbuch des Mark II
eingeklebt.
▲ Harvard Mark II
59
NACHGEHAKT
Auf einer Maker Faire ▶
Arduino und
die Maker
Hast du auch schon einmal davon geträumt, ein richtiger Erfinder oder eine Erfinderin zu sein? Neue
­Maschinen und Apparate zu erdenken und sie dann
Wirklichkeit werden zu lassen? Immer mehr Menschen geben sich nicht mehr mit Träumen zufrieden.
Sie machen es einfach. Sie sind Maker!
Maker ist englisch und bedeutet »Macher«. Früher
▲ Workshop auf einer Maker Faire
hätte man diese Macher einfach Tüftler oder Bast-
ler genannt. Doch das trifft es nicht ganz: Während die meisten Tüftler früher eher alleine in ihrer
Bastelstube vor sich hin gewerkelt haben, zieht es die Maker auch gerne in die Öffentlichkeit.
So sind in vielen Städten sogenannte Hackerspaces oder Makerspaces entstanden. Sie sind eine
­Mischung aus Treffpunkt und Gemeinschaftswerkstatt. Hier tauschen sich die Maker aus, präsentieren ihre neuesten Ideen, geben sich Ratschläge und können dabei auf gemeinschaftliche Teile
und Werkzeuge zurückgreifen.
Weltweit entstehen auch immer mehr Maker Faires. Das ist wieder englisch und bedeutet »Maker
Messe«. Hier können sich die Maker einer breiteren Öffentlichkeit präsentieren. Darüber hinaus
gibt es dort meist ein umfangreiches Angebot an Workshops, in denen erfahrene Macher dazulernen und Einsteiger die ersten Schritte erlernen können.
Eine wichtige Rolle spielen bei den Projekten der
­Maker oft Mikrocontroller wie der Arduino. Erst durch
sie ist es möglich geworden, komplizierte Apparate
zu verwirklichen, ohne dafür erst teure Spezialelek­
tronik entwickeln zu müssen.
Maker-Projekt ▶
60
KosmoBits
◀ Ein 3D-Drucker bei der Arbeit
3D-Drucker
Was nützt die beste Elektronik mit der toll­
sten Software, wenn man für seine Projektidee einfach kein passendes Gehäuse findet?
­Mittlerweile gibt es auch dafür eine passende Maker-Lösung: Die 3D-Drucker.
Das sind Geräte, die nicht zweidimensional (2D) auf Papier drucken, sondern dreidimensional (3D)
Dinge und Gegenstände ausdrucken können. Klingt nach Science-Fiction, ist aber vom Prinzip
­eigentlich doch ganz einfach. Man benutzt dazu meist ein Kunststoffmaterial, das zunächst
­ähnlich wie ein Faden auf einer Spule aufgerollt ist. Dieses Filament wird dann in ­einer Düse so
weit erhitzt, dass es schmilzt. In geschmolzener Form wird der Kunststoff computergesteuert an
­einer bestimmten Stelle wieder ausgespritzt. Der Kunststoff kühlt dann ab und härtet aus.
Tropfen für Tropfen, Schicht für Schicht werden so aufwändigste Gegenstände aufgebaut.
Geräte, die so etwas können, gibt es schon länger, aber erst in den letzten Jahren sind sie für
­Hobby-Bastler bezahlbar geworden.
Übrigens: Auch die ersten Test-Versionen des KosmoBitsControllers sind auf diese Weise entstanden!
▲ Filament für 3D-Drucker
◀ Verschiedene 3D-gedruckte Prototypen aus der KosmoBits-Entwicklung
61
FEHLERMELDUNGEN
Häufige Fehlermeldungen
error: expected ';' before ')'
Es wurde ein Semikolon vor einer schließenden Klammer
erwartet, aber nicht gefunden.
BEISPIEL:
LÖSUNG:
In function 'int mittelwert2()':
DoppelKlatscher:86: error: expected ';' be-
Nach i < N muss das Komma durch ein Semikolon ersetzt werden.
fore ')' token
for (int i = 0; i < N, ++i) {
exit status 1
expected ';' before ')' token
error: '...' was not declared in this scope
Ein im Programm benutzter Name, ist dem Compiler nicht
bekannt. Oftmals ein Zeichen für einen einfachen Tippfehler.
BEISPIEL:
error: 'pinnMode' was not declared in this
LÖSUNG:
Tippfehler korrigieren: Richtig heißt es pinMode .
scope
pinnMode(A1, INPUT);
error: '...' does not name a type
Ein im Programm benutzter Typ ist dem Compiler nicht
bekannt. In den meisten Fällen handelt es sich entweder
um einen Tippfehler, oder du hast vergessen eine entsprechende Datei einzubinden.
BEISPIEL:
error: 'KosmoBits_Pixel' does not name a
type
KosmoBits_Pixel pixel;
62
LÖSUNG:
Binde die »KosmoBit_Pixel.h« ein:
#include 
#include 
KosmoBits
avrdude: ser_open(): can't open device "\\.\COM4": Zugriff verweigert
Vermutlich hast du vergessen, den seriellen Monitor zu
schließen, bevor du dein Programm hochladen wolltest.
LÖSUNG:
Schließe den seriellen Monitor und lade das Programm
­erneut hoch.
avrdude: ser_open(): can't open device "\\.\COM4": Das System kann die
angegebene Datei nicht finden.
1. Du hast vergessen, den KosmoDuino mit dem Computer
zu verbinden. Vielleicht hast du das USB-Kabel auch nur
versehentlich in die Ladebuchse des Interaction Boards
gesteckt.
LÖSUNG:
2. Es ist der falsche Port eingestellt. Überprüfe das im
Menü »Werkzeuge ➜ Port« und ändere den Port
gegebenenfalls.
LÖSUNG:
Verwende das USB-Kabel um deinen Computer mit dem
USB-Port am KosmoDuino zu verbinden.
Wähle einen anderen Port aus.
Wenig Arbeitsspeicher verfügbar, es können Stabilitätsprobleme auftreten.
Nicht genug Arbeitsspeicher
Dein Programm füllt fast den gesamten Arbeitsspeicher
des Mikrocontrollers oder ist sogar schon zu groß dafür.
Vermutlich hast du ein ziemlich großes Array angelegt.
BEISPIEL:
int array[1000] = {}; // Das ist zu groß!
LÖSUNG:
Ändere dein Programm so, dass du mit einem kleineren
­Array auskommst.
63
NOTIZEN
64
› › › KosmoBits Quickstart-Guide
MIT SPIELEN LOSLEGEN:
› Bau dein eigenes Gamepad zusammen
• Detaillierte Anweisungen findest du in der Anleitung
ab S. 3
› Lade den Akku des Gamepads
• Verwende dazu den USB-Anschluss am Interaction Board,
nicht den Anschluss am Kosmoduino!
› Lade die KosmoBits-App auf dein Tablet oder Smartphone
• Die App findest du bei Google Play oder im Apple App Store
› Aktiviere Bluetooth auf deinem Tablet oder Smartphone
› Starte die App
› Schalte dein Gamepad an
• Schiebe den Schalter am oberen Rand des Gamepads auf die Position »on«
• Die Verbindung erfolgt automatisch
› Bau die SensorBots zusammen und halte sie bereit
› Viel Spaß beim Spielen!
MIT PROGRAMMIEREN LOSLEGEN:
› Installiere die Arduino-Software auf deinem Computer
• Die Software bekommst du kostenlos unter arduino.cc/en/Main/
Software. Wir empfehlen die von uns getestete Version 1.6.5
› Öffne die Arduino-Software
› Schreibe dein Programm in der Arduino-Software
› Verbinde den KosmoDuino-Microcontroller per USB mit
­deinem PC
› Lade dein Programm auf den KosmoDuino
• Dein Programm wird direkt nach dem Hochladen vom K
­ osmoDuino
ausgeführt
• Viele spannende Programmier-Projekte findest du in der Anleitung
• Für viele Programmier-Projekte benötigst du die KosmoBits-Bibliotheken. Diese kannst du kostenlos unter kosmobits.de/downloads
herunterladen. (Detaillierte Anweisungen findest du in der Anleitung auf S. 8)
› Viel Spaß beim Programmieren!
Android, Google Play und das Google Play-Logo sind Marken von Google Inc.
Apple und das Apple Logo sind Marken der Apple Inc., die in den USA und weiteren Ländern eingetragen sind. App Store ist eine Dienstleistungsmarke der Apple Inc.
› › › KosmoBits Quickstart-Guide
ÜBERSICHT ÜBER EINIGE WICHTIGE BEFEHLE
PROGRAMMSTRUKTUR
ERKLÄRUNG
void setup(){ }
Initialisierung. Am Anfang jedes Programms können erste Einstellungen vorgenommen werden, das sogenannte »setup«. Hier
wird zum Beispiel festlegt, welche Pins welche Funktion übernehmen sollen oder wo die LEDs angeschlossen sind. Das setup
wird nach jedem Start oder Neustart nur einmal durchgeführt.
void loop(){ }
Hauptschleife. Der Hauptteil des Programms ist der sogenannte
Loop. Es ist eine Schleife, die sich solange wiederholt, wie der Microcontroller läuft. Hier sind alle wichtigen Funktionen untergebracht, die dauerhaft das System überwachen oder verändern.
VARIABLEN
BEISPIEL
int (ganze Zahlen)
int led = 13;
long (lange ganze Zahlen)
long meinWert = 111111;
float (Fließkommazahlen)
float meinWert = 2.5;
char (Alphanumerische Zeichen: Buchstaben,
Zahlen, Sonderzeichen)
char meinBuchstabe = ´a´;
array (Variablenfeld)
int meineWerte[4] = {12, 18, 23, 86}
BEFEHL
BEISPIEL
ERKLÄRUNG
pinMode()
pinMode(led, OUTPUT);
Setzt den Pin mit dem Namen »led« als Aus­
gabe-Pin fest.
digitalWrite()
digitalWrite(led, HIGH);
Legt einen Strom auf dem Pin mit dem Namen
»led« an.
digitalRead()
digitalRead(Schalter)
Liest den Zustand von Pin »Schalter« aus: Ist
der Schalter an (HIGH) oder aus (LOW)?
analogWrite()
analogWrite(led, 255)
Setzt den Pin mit dem Namen »led« auf den
Wert 255
analogRead()
analogRead(temp)
Liest den Wert, den der Pin mit dem Namen
»temp« liefert.
delay()
delay(1000);
Lässt das Programm eine Sekunde warten
(=1000 Millisekunden).
Serial.begin()
Serial.begin(115200)
Beginnt die Übertragung von Daten zum PC
mit 115200 Baud (Symbolen pro Sekunde)
Serial.println()
Serial.println(„Hallo“);
Zeigt im seriellen Monitor »Hallo« an.
0718020 SO 300416

File Type                       : PDF
File Type Extension             : pdf
MIME Type                       : application/pdf
PDF Version                     : 1.7
Linearized                      : Yes
Create Date                     : 2016:07:21 19:51:04+02:00
Creator                         : Adobe InDesign CS6 (Macintosh)
Modify Date                     : 2016:09:28 15:48:03+08:00
Has XFA                         : No
XMP Toolkit                     : Adobe XMP Core 5.4-c005 78.147326, 2012/08/23-13:03:03
Creator Tool                    : Adobe InDesign CS6 (Macintosh)
Metadata Date                   : 2016:09:28 15:48:03+08:00
Version ID                      : 1
Document ID                     : uuid:5c9b1b23-0c78-4998-bd59-14014802e54e
Instance ID                     : uuid:f4f25295-4667-48fc-a722-351113d55661
GTS PDFX Version                : PDF/X-4
Producer                        : Adobe PDF Library 10.0.1
Trapped                         : False
Format                          : application/pdf
Title                           : 1620141_KosmoBits_Manual_Cover.indd
Page Count                      : 68