pdf | 1.7 Mb - bugnplay.ch

Transcrição

Bau eines
Led Cube
Programmierung des 2D Spiel Snake in 3D und
Darstellung von verschiedenen Mustern
Maturaarbeit 2012
Autoren: Nicole Trachsler & Lukas Roth
Betreuer: Dr. Adrien Cornaz
Co-Referent: Dr. Kai Köhler
Kantonsschule Wohlen
Inhaltsverzeichnis
Inhaltsverzeichnis .................................................................................................................................... 2
1 Vorwort ................................................................................................................................................ 4
2 Abstract ................................................................................................................................................ 5
3 Einleitung ............................................................................................................................................. 6
4 Hardware .............................................................................................................................................. 7
4.1 Led Cube Konstruktion ................................................................................................................. 7
4.2 Multiplexing Verfahren ............................................................................................................... 11
4.3 Transistoren ................................................................................................................................. 12
4.4 Steuerung ..................................................................................................................................... 12
4.4.1 Arduino Board Mega 2560 ................................................................................................... 12
4.4.2 Pin-Erweiterung.................................................................................................................... 12
4.4.3 M74HC595 Tri-State-Shift-Register .................................................................................... 13
4.4.4 Spannung .............................................................................................................................. 14
4.4.5 Stromstärke ........................................................................................................................... 14
4.4.6 Schaltplan zur Pin-Erweiterung ............................................................................................ 15
4.4.7 Klatschmodul, Steuerungspanel und MP3-Player ................................................................ 16
5 Software ............................................................................................................................................. 18
5.1 Snake ........................................................................................................................................... 19
5.1.1 Snake Initialisierung ............................................................................................................. 19
5.1.2 While Schlaufe ..................................................................................................................... 19
5.1.3 Arduino Board ...................................................................................................................... 21
5.2 Muster.......................................................................................................................................... 22
5.2.1 Glitzern ................................................................................................................................. 22
5.2.2 Regen .................................................................................................................................... 22
5.2.3 Explosion .............................................................................................................................. 24
5.2.4 Zufallswandern ..................................................................................................................... 25
5.2.5 Sinuswelle vom Mittelpunkt................................................................................................. 26
5.2.6 Viereck ................................................................................................................................. 27
5.3 Text anzeigen .............................................................................................................................. 28
5.4 Klatschmodul............................................................................................................................... 29
5.5 Anzeige()-Funktion ..................................................................................................................... 29
6 Schlusswort ........................................................................................................................................ 32
7 Literaturverzeichnis ............................................................................................................................ 33
7.1 Literatur ....................................................................................................................................... 33
7.2 Webseiten .................................................................................................................................... 33
8 Bildverzeichnis ................................................................................................................................... 34
9 Anhang ............................................................................................................................................... 36
9.1 Code Blocks Projekt in separater Datei ....................................................................................... 36
9.2 Source Code für das Arduino Board in separater Datei .............................................................. 36
9.3 Video vom Led Cube .................................................................................................................. 36
9.4 Selbständigkeitserklärung ........................................................................................................... 37
1 Vorwort
Im März 2012 galt es ein Thema für unsere Maturitätsarbeit im kommenden Jahr zu finden.
Wir entschieden uns, dass wir gerne etwas im Bereich der Technik oder Informatik machen
möchten und machten uns Gedanken über mögliche Themen. Unsere erste Idee war, eine Art
3D Bildschirm zu bauen. Als nächstes kam uns die Idee, dass wir das alte und gut bekannte
2D Handyspiel Snake auf einem 3D Bildschirm programmieren könnten. Wir gaben auf der
Videoplattform Youtube das Stichwort Led Cube ein und waren beide sofort fasziniert von
den blinkenden Würfeln.
Das Zusammenspiel aus Elektronik und Informatik interessierte uns und wir wollten mehr
darüber erfahren. Wir entschieden uns dafür, diese Ideen zu kombinieren und einen
Led Cube zu bauen. Auf dem Cube sollte man Muster darstellen können sowie das 2D Spiel
Snake in 3D spielen können. Somit war unser Thema gefunden und wir konnten mit der Arbeit beginnen.
Wir möchten uns herzlich bei unserem Betreuer Herrn Cornaz bedanken, welcher uns zu jeder
Zeit kompetent auf unsere Fragen antwortete. Ebenfalls ein Dankeschön geht an Herrn Köhler, welcher sich als Co-Referent zur Verfügung stellte. Für die finanzielle Unterstützung
danken wir unseren Eltern, die kurzerhand als Sponsoren für unser Projekt einsprangen. Weiter möchten wir allen danken, die mitgeholfen haben, die Arduino Plattform zu entwickeln,
welche uns die Arbeit um einiges erleichtert hat.
Wir empfehlen jedem Leser und jeder Leserin dieser Arbeit, sich unbedingt das Video im
Anhang anzuschauen. Nur so kann man einen Eindruck vom Ganzen bekommen und die Faszination, die dahinter steht, begreifen.
4
2 Abstract
Unsere Hauptfragestellung war der Bau eines
Led Cube, auf welchem wir mit Hilfe
eines Arduino Boards verschiedene Muster programmieren wollten. Wir einigten uns darauf,
512 Leds zu benutzen, da diese Anzahl ausreicht, um grössere Muster schön anzuzeigen. Als
Fernziel nahmen wir uns vor, ein spielbares 3D Snake zu implementieren.
Um uns ein Grundwissen an Elektrotechnik anzueignen, konsultierten wir das Buch ‚Fachkunde Elektronik‘ von Peter Basian. Mit Hilfe von Baukästen und den dazugehörigen Bastlerboards bauten wir einfache Schaltungen. Ausserdem nutzten wir das Internet zur weiteren
Informationsbeschaffung. Später entschieden wir uns dafür, zuerst zwei Prototypen in der
Grösse
und
zu bauen, bevor wir uns an das Endprodukt wagten.
Am Ende hatten wir einen funktionsfähigen blauen
Led Cube. Sofern alle Lötstellen
intakt sind, funktioniert der Würfel einwandfrei. Er ist in der Lage verschiedene komplexe
Muster anzuzeigen. Diese sind auf dem Mikroprozessor auf dem Arduino Mega Board gespeichert und werden in Real-Time berechnet. Somit muss der Cube nicht an den Computer
angeschlossen sein, um zu funktionieren. Es genügt, wenn er über das Netzgerät Strom erhält.
Um Snake zu spielen, muss das Board via USB-Port an den Computer angeschlossen sein.
Mit Hilfe von sechs Tastaturtasten sendet man über die Kommunikationskanäle des Arduino
Boards die neuen Koordinaten der Schlange. Zur einfacheren Ansteuerung der verschiedenen
Led Cube Funktionen haben wir ein User Interface erstellt. Das Programm zeigt beim Spielen
von Snake die aktuelle Punktzahl auf dem Bildschirm an.
Als Zusatzfunktion haben wir ein Klatschmodul von Conrad dazwischen geschaltet, so dass
der Cube auf Klatschen reagieren kann. Klatscht der Benutzer nun laut, wird ein Muster aufgerufen. Wechselt man in den Muster-Modus, wird beim Abspielen der Muster automatisch
Musik dazu abgespielt. Diese Musik stammt von einem alten MP3-Player, welcher ebenfalls
über das Arduino Board angesteuert wird und mit Boxen verbunden ist.
Es gibt noch unendlich viele Möglichkeiten, weitere Muster zu implementieren, somit mussten wir irgendwo einen Schlussstrich ziehen. Auch könnte man den gleichen Würfel mit
RGB-Leds bauen, um unterschiedliche Farben darzustellen. Anstelle des 3D Snake könnte
man zum Beispiel ein 3D Tetris Spiel programmieren oder selbst ein Spiel erfinden. Unsere
verfügbare Zeit genügte leider bei weitem nicht, um alle unsere Ideen zu verwirklichen.
5
3 Einleitung
Die Arbeit ist in zwei Teile aufgeteilt. Im ersten Teil wird die Hardware des Led Cubes erklärt, im zweiten Teil die Software des Würfels. Am Anfang des Hardware Teils wird genau
erklärt, wie der
Led Cube gebaut wird. Es wird gezeigt, was das Multiplexing Verfah-
ren ist und wozu es verwendet wird. Anschliessend wird darauf eingegangen, welches Board
für die Kommunikation mit dem Computer zum Einsatz kommt. Die Funktion des Schieberegisters M74HC595 wird erläutert und es wird aufgezeigt, wie ein einzelnes Schieberegister
geladen wird und wie es in die Schaltung eingebunden wird.
Ebenfalls im Hardware Teil wird veranschaulicht, wie man die benötigte Spannung und
Stromstärke für den Led Cube berechnet. Zur besseren Verständlichkeit wurden Ausschnitte
aus dem Schaltplan eingefügt und erklärt. Am Ende von diesem Teil wird auf die Einbindung
des Klatschmoduls und des MP3-Players eingegangen.
Im zweiten Teil wird zuerst anhand eines Bildes das Grundschema der Software aufgezeigt.
Danach wird ausführlich über die Implementierung des Snake Spiels berichtet. Es wird erklärt, wie das neue Fressen gesetzt wird und wie der Tastaturinput ausgewertet wird. Des
Weiteren wird gezeigt, wie abgefragt wird, ob es nach der nächsten Bewegung zu einer Kollision mit der Schlange selbst kommt und somit ein Game Over ausgegeben werden muss.
Anschliessend wird auf die verschiedenen Muster eingegangen. Dabei werden sechs ausgewählte Muster ausführlich erklärt und mit Codestücken belegt. Die Text Anzeige wird ebenfalls erklärt. Es wird veranschaulicht, wie das Klatschmodul funktioniert. Ganz zum Schluss
wird auf die Anzeige-Funktion eingegangen, welche benötigt wird, um etwas auf dem Led
Cube anzuzeigen.
6
4 Hardware
4.1 Led Cube Konstruktion
Der
Led Cube besteht aus 512 blauen Leds. Alle Leds sind oval und haben einen
Durchmesser von 3mm. Die Anode ist 19mm lang und die Kathode 17mm. Alle 512 Leds
wurden einzeln auf ihre Funktionalität getestet, um zu verhindern, dass später ein defektes
Led eingebaut wird.
Abbildung 1 Led Teststation
Mit einer Bohrmaschine wird in ein Stück Holz ein
Lochgitter gebohrt. Zwischen zwei
Löcher hat es einen Abstand von genau 10mm. Die Kathoden von allen Leds werden um 90°
angewinkelt und 64 Leds mit den Köpfen nach unten in die Löcher gesteckt. Alle Kathoden
zeigen in eine Richtung ausser die Kathoden der untersten Reihe. Die Kathoden überlappen
sich jeweils um etwa 1 mm. An dieser Stelle werden sie mit Lötzinn verlötet.
Abbildung 2 Holzplatte mit einer angefangenen Led Ebene
7
Sind alle 64 Leds miteinander verlötet, werden die letzten 3mm der Anoden mit einer Zange
um 45° angewinkelt, damit man sie später gut auf die nächste Ebene löten kann.
Abbildung 3 Fünf Led Ebenen
Dieser Prozess wird acht Mal wiederholt. Nun wird eine Ebene ins Holz gesteckt und die
zweite gleich ausgerichtet daraufgelegt. Der Abstand zwischen den horizontal aufeinander
gelegten Leds soll 10mm betragen, damit am Schluss ein symmetrischer Würfel entsteht. Um
dies zu vereinfachen, wurde aus Karton eine Abstandshilfe mit der richtigen Dicke gebastelt
und dazwischen gelegt.
Abbildung 4 Drei aufeinander gelötete Ebenen mit Abstandshilfe
8
Hier muss darauf geachtet werden, dass alle Anoden auf der gleichen Höhe zusammengelötet
werden. Mit Hilfe einer Zange können die Leds aus der oberen Ebene beim Löten an der
Anode etwas angehoben werden.
Sind alle acht Ebenen aufeinander gelötet, hat der Würfel ein Ausmass von
. Danach wird aus einer 4mm dicken Sperrholzplatte ein
grosses Quadrat ausgesägt. In die Mitte werden 64 Löcher mit 3mm Durchmesser im Abstand
von 10mm gebohrt. Ebenfalls werden auf einer Seite, nahe an der äussersten Lochreihe, acht
zusätzliche 1mm Löcher gebohrt. Diese werden benötigt, um von jeder Ebene einen Draht
nach unten zu führen. Anschliessend wird die Sperrholzplatte mit einem schwarzen Papier
überzogen. Alle Anoden der untersten Ebene wurden durch die 64 Löcher geführt und unter
der Platte um 90° angewinkelt, um ein herausfallen des Würfels zu verhindern.
Abbildung 5 512 fertig verlötete Leds
9
An jede Ebene wird etwas versetzt ein Draht angelötet. Die Drähte werden möglichst straff
nach unten durch die acht Löcher geführt. Dabei ist darauf zu achten, dass sich diese acht langen Drähte nirgends berühren.
Im untenstehenden Schaltplan sieht man, wie die Anoden und Kathoden verlötet wurden. Für
die ssieben Ebenen, welche nicht auf dem Schaltplan sind, gilt dasselbe. Der einzige Unterschied ist, dass die Kathoden der Ebenen jeweils an einen eigenen Transistor gehängt werden.
Abbildung 6 Schaltplan von einer der acht Ebenen
In der Abbildung unten sieht man den gesamten Led Cube von unten mit den Kabeln von den
Anoden-Stecken und den Ebenen, die zur Steuerungsplatine führen.
10
Abbildung 7 Led Cube von unten
4.2 Multiplexing Verfahren1
Da es kein vernünftiges Board mit 512 IO-Pins gibt, um jedes Led einzeln anzusteuern, muss
eine Lösung gefunden werden, mit welcher die Anzahl benötigter Pins verringert werden
kann. Hier kommt das sogenannte Multiplexing Verfahren zum Einsatz. Bei der Cube Konstruktion wurde bereits erklärt, dass alle Kathoden einer Ebene miteinander verlötet wurden.
So entstanden 64 vertikale Anoden-Stecken. Somit müssen nun nicht an alle Leds 2 separate
Kabel geführt werden, was auf Grund von Platzmangel sowieso unmöglich wäre. Die acht
Drähte von den verschiedenen Ebenen werden alle über einen eigenen Transistor zum Ground
geführt. Die Anzahl benötigter IO-Pins wurde von 512 auf 72 verringert.
Das eigentliche Multiplex Verfahren besteht darin, dass nie alle Ebenen gleichzeitig leuchten
sondern immer nur eine. Die Transistoren der 8 Ebenen werden ganz schnell hintereinander
geöffnet und wieder geschlossen. Geschieht dies mit einer genug hohen Frequenz, kann unser
Auge das Blinken nicht mehr als Blinken wahrnehmen. Das Auge nimmt dann nur noch ein
Leuchten wahr.
Trotz des Multiplexings kann immer noch jedes Led einzeln angesteuert werden. Der Pin,
welcher mit dem Anoden-Stecken, auf welchem das betroffene Led liegt, verbunden ist, wird
1
http://de.wikipedia.org/wiki/Multiplexverfahren, Abruf: 29.8.2012
11
auf High gesetzt. Ebenfalls wird der Pin, der den Transistor der richtigen Ebene steuert, wird
auf High gesetzt.
4.3 Transistoren
Wir verwenden 8 BD139 NPN-Transistoren, um die Ebenen anzusteuern. Alle 64 Kathoden
einer Ebene sind parallel an den Kollector eines Transistors gelötet. So erhält man acht Transistoren, die den Stromkreis einer Ebene öffnen oder schliessen können. Die Emitter sind miteinander verbunden und zu einem gemeinsamen Ground geleitet. Wichtig ist, dass die Transistoren eine Stromstärke von 1.5A vertragen.
4.4 Steuerung
4.4.1 Arduino Board Mega 25602
Um vom Computer aus mit dem Led Cube zu kommunizieren, benötigt man einen Mikroprozessor. Für diesen Led Cube wurde das Bastlerboard Arduino Mega 2560 benutzt. Dieses
Board ist mit 52 digitalen IO-Pins und einigen Input-Pins ausgerüstet. Ausserdem können
einige IO-Pins als serielle Kommunikationskanäle genutzt werden. Über diese Kommunikationskanäle kann das Arduino Board live von einem Computer aus angesteuert werden.
4.4.2 Pin-Erweiterung
Wie im vorigen Kapitel erwähnt, benötigt das Grundgerüst des Led Cubes 8 digitale Ausgänge zum Ansteuern der Transistoren, welche die Ebenen aus- und einschalten. Zusätzliche
werden 64 digitale Ausgänge für die einzelnen vertikalen Verbindungen benötigt. Das Arduino Board Mega 2560 hat jedoch nur 52 Output-Pins, von denen noch zwei für die Kommuni-
2
http://arduino.cc/en/Main/arduinoBoardMega2560, Abruf: 3.1.2013
12
kation mit dem Computer benötigt werden. Um auf die benötigte Anzahl an Pins zu kommen,
werden acht Tri-State-Shift-Register vom Typ M74HC595 zur Hilfe genommen.
4.4.3 M74HC595 Tri-State-Shift-Register3
Das M74HC595 Tri-State-Shift-Register ist ein 8 Bit Schieberegister, welches alle Ausgänge
hoch- beziehungsweise niederohmig schalten kann (Tri-State). Angesteuert wird es über einen
seriellen Input (SER) und zwei Clocks (SCK und RCK). Zuerst werden alle Ausgänge auf
hochohmig gestellt, dabei muss RCK auf Low gesetzt werden, damit man beim Setzen der
neuen Bits die Bits nicht durchflackern sieht. Danach werden mit Hilfe der SCK Clock und
dem seriellen Input die Bits an die richtige Stelle geladen. Anschliessend wird der RCK Pin
wieder auf High gesetzt, um die gesetzten Bits anzuzeigen. Aus einem Ausgang sind somit
acht Ausgänge entstanden, welche ein bisschen verzögert sind, da die Bits zuerst in das
Schieberegister geladen werden müssen.
Hat man mehrere Schieberegister, so gibt es die Möglichkeit diese hintereinander zu schalten.
Das überlaufende Bit kann am Ausgang Q-Quer abgefangen und im nächsten Schieberegister
gespeichert werden. Ausserdem kann man bei allen seriell hintereinander geschalteten Schieberegistern die beiden Clocks (SCK und RCK) parallel schalten.
In dieser Steuerung wird mit acht M74HC595 gearbeitet. Die SCK und RCK werden jeweils
parallel in allen acht Schieberegister geführt, da die Bits bei allen Schieberegistern im gleichen Rhythmus eingelesen werden. So kann man Output-Pins auf dem Arduino Board sparen
und die Bits schneller in das Schieberegister laden. Wie genau die Bits in die Schieberegister
geladen werden, wird im Kapitel Anzeige()-Funktion erklärt.
3
Datasheet des M74HC595, http://www.produktinfo.conrad.com/datenblaetter/150000-174999/155762-da-01en-LOGIK_IC_M74HC595B1R_STM.pdf, Abruf: 3.1.2013
13
Abbildung 8 Schaltplan des M74HC595
4.4.4 Spannung
Ein Led hat einen Spannungsabfall von ca. 3.1 V und leuchtet bei 20 mA hell, ausserdem ist
dann die Lebensdauer maximal. Aufgrund dessen berechnet man den Wiederstand, der seriell
zwischen dem Ausgang des M74HC595 und den vertikalen Verbindungen im Led Cube geschaltet werden muss. Mithilfe des Ohm’schen Gesetzes rechnet man
. In der
Praxis werden 100Ω Wiederstände verwendet, da diese leicht in grossen Mengen erhältlich
sind. So ist sicher gestellt, dass die Spannung nie über den gewünschten Wert kommt, um das
Led nicht zu beschädigen.
4.4.5 Stromstärke
Wie oben erwähnt, benötigen die blauen Leds 20mA, um stark zu leuchten. Um 64 Leds parallel zu schalten, werden also
benötigt. Da das Arduino Board Mega über
das USB Kabel vom Computer oder einem USB-Netzgerät aus versorgt wird, reicht die
Stromstärke nicht aus. Aus dem USB Anschluss des Computers kann man höchstens von fünf
LOAD’s Strom ziehen, die jeweils maximal 0.1A liefern, was zusammen nur 0.5A ergibt.4
Der Led Cube benötigt somit eine externe Stromquelle, welche 5V und ca. 1.28A liefert. Hier
kommt ein Egston BI07-050140-AdV Steckernetzteil, welches 5V Gleichspannung und 1.4A
liefert,
4
zum
http://www.mikrocontroller.net/topic/23513, Abruf: 28.8.2012
14
Einsatz. Die Stromstärke liegt leicht über der benötigten Stromstärke, was die Laufzeit der
Leds jedoch nicht zu stark beeinflussen sollte. Weiter bringt es den Vorteil, dass die Leds genügend hell leuchten.
4.4.6 Schaltplan zur Pin-Erweiterung
Abbildung 9 Schaltplan der M74HC595
15
In der Abbildung 8 sieht man den Schaltplan unserer Steuerung, die mit dem Arduino Mega
2560 verbunden ist und an den Ausgängen (S1-S64) mit den vertikalen Verbindungen des Led
Cubes verbunden ist (Siehe Abb. 6).
Abbildung 10 Platine von oben
Abbildung 11 Platine von unten
Auf den oben eingefügten Grafiken sieht man die Platine von oben und von unten, auf welcher die Tri-State-Shift-Register aufgelötet sind. Es befinden sich noch einige andere Module
auf der Platine, z.B. der Anschluss zum MP3-Player, die Verbindung zu dem Steuerungspanel
usw.
4.4.7 Klatschmodul, Steuerungspanel und MP3-Player
Abbildung 12 Steuerungspanel
Abbildung 13 Klatschmodul von Conrad
16
Als weiteres Element ist am Arduino Board ein Klatschmodul von Conrad angehängt. Dieses
Klatschmodul lässt nach jedem registrierten Klatscher (oder auch anderen lauten Lauten) ein
Relais zusammenziehen oder auseinandergehen. Dies wirkt wie ein Schalter, der an den Pin
51 des Arduino Boards angeschlossen ist. Um zu definieren, wann das Klatschmodul eingeschaltet ist, ist auf dem Steuerungspanel ein Kippschalter vorhanden, der beim Pin 53 ans
Arduino Board angeschlossen ist. Mit dessen Hilfe wird das Klatschmodul an- oder ausgeschaltet. Weiter hat es auf dem Steuerungspanel einen „Startschalter“, mit welchem der Benutzer das automatische Abspielen der Muster starten kann. Der „Startschalter“ ist mit dem
Pin 49 verbunden.
Über den Pin 45 wird ein MP3-Player angesteuert. Der Pin 45 ist mit einem Transistor (NPN
BC547) verbunden, welcher parallel zum Anschaltknopf und Steuerungsknopf des MP3Players geschaltet ist. Den MP3-Player kann man über den Transistor einerseits einschalten,
indem man Pin 45 100 Millisekunden auf High stellt. Weiter kann man die Musik an/abschalten, indem man den Pin 45 für 20 Millisekunden auf High stellt.
Abbildung 14 Schaltplan der Zusatzmodule
17
5 Software
Anschalten
Erste
Prüfung
Zweite
Prüfung
Anzeige
Connected
Snake
Anzeige des vom
PC aus gesendeten
Snake
Automatische
Anzeige der
Muster
Anzeige aller
Muster der Reihe
nach
Klatschmodul
Wechseln der
Muster bei jedem
Klatschen
Start
Disconnected
Abbildung 15 Software-Flowchart
Wie im obigem Diagramm dargestellt, wird sobald dem Arduino Board Strom zugeführt wird
(oder der reboot-Knopf gedrückt wird) geprüft, ob es mit einem Computer verbunden ist, respektive ob der Benutzer den Cube über den Computer steuern will oder nicht. Um diese Prüfung durchzuführen, stellt das Arduino Board über eine serielle Schnittstelle (mit 9600 Bit pro
Sekunde) eine Verbindung mit dem Computer her. Damit der Anwender genügend Zeit für
das Starten des Programmes hat, wartet das Arduino Board, bis der Anwender den StartKnopf auf dem Steuerpad des Cubes drückt. Wenn dieser Knopf nicht gedrückt wurde, dafür
aber ein ‚c‘ (für connected) vom Computer aus gesendet wurde, springt es in die ConnectedSchleife. Wird jedoch der ‚Start’ Knopf gedrückt, geht es in die Disconnected-Schlaufe.
Ist das Programm in der Connected-Schlaufe, wird weiter geprüft, ob der Anwender Snake
spielen will oder ob er in die Muster-Schlaufe gehen will. Befindet sich das Programm jedoch
in der Disconnected-Schlaufe, wird geprüft ob der Anwender den Cube über das Klatschodul
steuern will oder ob er einfach alle Muster sehen will, ohne Einfluss darauf zu nehmen.
Will man eine Schlaufe zurück kommen, (in der Abbildung 15 entspricht dies einem Schritt
nach links), dann sendet der Computer über die serielle Schnittstelle ein ‚b‘ für back. Im
Klatschmodus prüft das Arduino Board regelmässig den Kippschalter, mit welchem der
18
Klatschmodus ein- und ausgeschaltet wird. Ist dieser auf aus, springt es aus der aktuellen
Schlaufe.
5.1 Snake
Hat sich der Anwender für das Spielen des 3D Spiels Snake entschieden, so übernimmt das
Arduino Board nur noch die Aufgabe, dass vom Computer berechnete 3D Bild anzuzeigen.
Das Spiel selbst wird auf dem Computer berechnet.
5.1.1 Snake Initialisierung
Nachdem das Computerprogramm dem Arduino Board erfolgreich mitgeteilt hat, dass der
Anwender Snake spielen möchte, initialisiert es einen
grossen Char Array. Dieser
Array steht für die 512 Leds und wird Feldarray genannt. Jeder Char im Array wird zuerst auf
‚f‘ für frei gesetzt. Danach wird der Punkt mit den Koordinaten [0][0][0] auf ‚s‘ gesetzt, um
zu definieren, wo sich die Schlange am Anfang befindet. Weiter werden drei Variablen vom
Typ Queue initialisiert, welche für die x-,y- und z-Koordinaten der Schlangenteile stehen. Am
Typ Queue können Zahlen hinten angehängt werden. Weiter kann man das vorderste Element
auslesen und/oder löschen.
5.1.2 While Schlaufe
Wenn alle Elemente initialisiert sind, werden solange die folgenden Aktionen ausgeführt, bis
der Spieler Game Over ist oder das Programm beendet wurde.
Fressen setzten
Hat die Schlange im letzten Zug das Fressen gefressen oder wurde noch gar kein Fressen gesetzt, wie es am Anfang des Spieles der Fall ist, werden drei Zufallskoordinaten erstellt. Anschliessend schaut das Programm, ob das Feld mit den besagten Koordinaten frei ist. Ist es
19
frei, so setzt es das Fressen auf diesem Feld. Ist es hingegen besetzt, erstellt es so lange neue
Zufallskoordinaten, bis sie frei sind und das Fressen gesetzt werden kann.
Steuerung der Schlange
Die ganze Zeit über wird per SDL die Tastatur abgefragt. Hat das Programm entschieden,
welche Taste zuletzt gedrückt wurde, prüft es, ob die gedrückte Taste nicht in die Gegenrichtung der aktuellen Richtung zeigt. Falls dies nicht der Fall ist, wird der Input entgegengenommen. Das Programm speichert die Koordinaten, bei denen der Schlangenkopf wäre, wenn
es die Schlange in die vom Benutzer vorgeschlagene Richtung bewegen würde.
Prüfung der Zukunftskoordinaten
Zuerst wird geprüft, ob die Zukunftskoordinaten noch im Spielfeld liegen. Ist dem nicht so,
werden sie so übertragen, dass die Schlange am anderen Ende des Spielfeldes wieder ins Feld
hineinkommt.
Danach wird geprüft, ob sich auf den Zukunftskoordinaten das Fressen befindet. Falls ja, wird
die Punktzahl um eins erhöht. Ausserdem merkt sich das Programm, dass es wieder Fressen
setzen muss. Weiter merkt es sich, dass im aktuellen Durchgang ein Punkt gemacht wurde.
Wurde im aktuellen Durchgang kein Punkt erzielt, wird das letzte Element der Schlange gelöscht. Dies geschieht mit Hilfe der bereits initialisierten Queue. Das älteste Element, dass in
die Queue gesetzt wurde, wird abgerufen und gelöscht. Weiter aktualisiert das Programm den
Feldarray.
Als letzter Schritt wird geprüft, ob an den Zukunftskoordinaten noch keine Schlange ist. Falls
das Zukunftsfeld bereits von einem Schlangenteil belegt wird, hat der Benutzer die Schlange
in ihren eigenen Schwanz gesteuert und somit verloren. Ist das Zukunftsfeld frei, setzt man
den Char im Feldarray auf ‚s‘ für Schlange und speichert die Koordinaten in der Queue.
Anzeige auf dem Bildschirm
Ist der Spieler im aktuellen Zug nicht Game Over gegangen, wird die Punktanzahl mit Hilfe
von SDL auf dem Bildschirm ausgegeben.
20
Anzeige auf dem Led Cube
Bei einem Zug werden nur die Änderungen im gesamten Feld ans Arduino Board übermittelt.
Ein Versuch zeigte, dass es zu lange dauert, dem Arduino Board bei jedem Zug das gesamte
Spielfeld zu schicken. Das Computerprogramm merkt sich während des gesamten Zuges, was
sich am Feldarray verändert hat und speichert die Koordinaten der veränderten Punkte. Danach werden die Anzahl Veränderungen, die Koordinaten der veränderten Punkte und die
Koordinaten des Fressens über den seriellen Kommunikationskanal ans Arduino Board gesendet. Die Datenmenge konnte so um einiges vermindert werden, da pro Zug maximal zwei
Veränderungen gesendet werden müssen.
5.1.3 Arduino Board
Das Arduino Board empfängt zuerst die Anzahl der Veränderungen und danach die Koordinaten der veränderten Felder und stellt alle Boolean an den empfangenen Koordinaten um. Zum
Schluss empfängt es die Koordinaten des Feldes, auf dem sich das Fressen befindet.
Nach dem Empfangen der Daten und dem Aktualisieren des anzuzeigenden Arrays geht es in
eine While-Schlaufe. Hier bleibt es, bis der Computer wieder etwas sendet. In dieser Schlaufe
wird dann die Anzeige()-Funktion aufgerufen, welche den aktuellen Array auf dem Cube anzeigt und weiter unten erläutert wird. Danach wird das Feld im aktuellen Array gewechselt, in
dem sich das Fressen befindet und das Programm springt wieder an den Anfang der Schlaufe.
Ob vom Computer etwas gesendet wurde, testet es mit der Funktion Serial.available(). Serial.available() gibt True zurück, falls etwas im Buffer ist. Ist nichts im Buffer, gibt sie False
zurück. Der Buffer des Arduino Boards kann 64 Bytes speichern.5
5
http://www.arduino.cc, Abruf: 31.12.2012
21
5.2 Muster
Ausser dem Snake Spiel sind auf dem Arduino Board diverse Muster programmiert. Der User
kann diese entweder einzeln über den Computer aufrufen oder er drückt den Start Knopf auf
dem Bedienungspanel. Die Muster werden dann in einer gespeicherten Reihenfolge angezeigt.
Um die Arbeit nicht zu überladen, werden nur einige interessante Funktionen erläutert. Alle
Originalfunktionen können im Anhang der Arbeit im Source Code für das Arduino Board
angesehen werden.
5.2.1 Glitzern
Wird die Funktion Glitzern aufgerufen, werden zuerst alle
Leds abgeschaltet. Anschliessend werden 500 Mal zwei
3D-Koordinaten zufällig bestimmt und die dazugehörigen
Leds angeschaltet, falls sie noch nicht an sind. Zwischen
jedem Anschalten wird der aktuelle Stand kurz angezeigt.
Danach werden erneut 500 Mal zwei 3D-Koordinaten erzeugt und die dazugehörigen Leds abgeschaltet, falls sie
überhaupt an waren. Der gesamte Vorgang wird zwei Mal
Abbildung 16 Glitzern
wiederholt.
5.2.2 Regen
Bei der Regen-Funktion sollen zufällig ‚Tropfen‘ von
oben durch den Led Cube fallen. Um dies zu verwirklichen, wird ein Loop 200 Mal durchlaufen. In diesem
Loop werden zuerst zwei neue Tropfen bestimmt. Dies
geschieht mit Hilfe folgender Codezeile:
Abbildung 17 Regen
22
ledarray[aktuell_led_array][random(0,8)][random(0,8)][7]=HIGH;
In der obersten Ebene des aktuellen Ledarrays wird ein Led auf High gesetzt, dessen x und y
Koordinaten zufällig gewählt werden. Dies geschieht zweimal.
Danach wird der aktuelle Ledarray der Anzeige()-Funktion übergeben. Im nächster Schritt
werden alle Leds eine Ebene nach unten versetzt, indem das darüber liegende Led angesehen
wird und dessen Status kopiert wird:
for (int i=0;i<8;i++)
{
for (int ii=0;ii<8;ii++)
{
for (int iii=0;iii<7;iii++)
{
ledarray[aktuell_led_array][i][ii][iii]=ledarray[aktuell_led_array][i][ii][iii+1];
ledarray[aktuell_led_array][i][ii][iii+1]=LOW;
}
}
}
iii geht nur bis sechs, da die Leds der obersten Ebene bereits gesetzt sind. Die oberste Ebene
muss anders gesetzt werden, da man ansonsten auf eine nicht existierende Ebene zugreifen
würde und es zu einer Speicherübergreifung käme. Danach geht die Funktion wieder an den
Anfang des Loops.
23
5.2.3 Explosion
Abbildung 18 Verlauf der Explosion
Die Explosions-Funktion zeigt acht Mal eine hohle Kugel an einem zufällig bestimmten Mittelpunkt an. Der Aussen- und Innenradius dieser Kugel vergrössert sich jeweils.
Zuerst wird der Mittelpunkt des Kreises mit Hilfe von drei Zufallszahlen von zwei bis sechs
zufällig bestimmt:
x=random(2,6); y=random(2,6); z=random(2,6);
Danach wird jedes durchgegangen und der Abstand zum Mittelpunkt des Kreises ausgerechnet: √(
)
(
)
(
)
, wobei a, b und c für die Koordinaten des
Punktes stehen. Ist der Abstand kleiner als der Aussenradius, wird das besagte Led auf High
gesetzt. Ist er jedoch auch noch kleiner als der Innenradius, wird das Led auf Low gesetzt.
Die beiden Radien werden nun schnell erhöht. Zwischen jeder Erhöhung wird die Anzeige()Funktion aufgerufen.
24
5.2.4 Zufallswandern
Abbildung 19 Verlauf des Zufallswandern
Bei der Zufallswandern-Funktion wird zuerst die unterste Ebene angeschaltet. Diese wird
einige Millisekunden angezeigt. Danach ‚läuft‘ jedes Led zufällig weit nach oben. Die Idee
der Funktion ist, dass die Leds, sobald sie ihren Platz erreicht haben, stehen bleiben.
Um dies auszuführen, erstellt die Funktion einen
Array, in dem sie die Höhe der 64 Leds
speichert. Diese ist am Anfang immer null. Weiter wird ein
Boolean Array erstellt, in
dem gespeichert wird, ob das Led schon mal angehalten hat. Alle Elemente des Arrays werden am Anfang ebenfalls auf False gesetzt, da alle noch nie angehalten haben.
Nun wird für alle senkrecht übereinander liegenden Leds geprüft, ob ihr Led noch nie angehalten hat, ob es noch nicht oben angekommen ist und ob es laufen darf. Dies wird über eine
Zufallszahl entschieden. Die Chance weiterlaufen zu dürfen, beträgt pro Test 66.6%, damit
nicht die Hälfte schon ganz unten nicht mehr weiter kommt. Trifft eine der Bedingungen nicht
zu, wird nur gespeichert, dass das Led dieser Spalte nicht mehr laufen darf. Treffen alle drei
Bedingungen zu, wird zuerst die neue Höhe des Leds gespeichert. Weiter wird das Led um
eins nach oben verschoben und der alte Platz auf Low gesetzt. Der ganze Vorgang wird sieben Mal wiederholt. Hätte ein Led also jedes Mal „Glück“, ist es am Schluss schon oben angekommen.
Der aktuelle Stand wird nun einige Sekunden angezeigt. Danach ‚laufen‘ alle Leds, die noch
nicht oben angekommen sind auch noch Schritt für Schritt nach oben. Dies geschieht auf die
gleiche Weise wie oben beschrieben, mit dem Unterschied, dass die Leds auch laufen dürfen
wenn sie einmal angehalten haben und sie immer laufen dürfen, nicht nur mit einer 66.6%
Chance. Sind alle oben angekommen, ist die Funktion zu Ende.
25
5.2.5 Sinuswelle vom Mittelpunkt
Bei dieser Funktion soll am Mittelpunkt des Cubes eine
Welle entstehen. Dies wird verwirklicht, indem man pro
Säule ein Led anschaltet, dessen Höhe durch eine Sinusfunktion bestimmt wird.
Konkret erzeugt die Funktion einen Loop. Im Loop wird
eine Variable time bei jedem Durchgang um 0.5 erhöht.
Weiter wird zuerst der ganze Array auf Low gesetzt. Da-
Abbildung 20 Sinuswelle
nach wird jede Led-Säule durchgegangen und zuerst der
Abstand der Säule zum Mittelpunkt berechnet. Um eine ganze Periode auf dem Cube abzubilden, muss der Abstand zwischen - und
liegen, da 360° im Bogenmass
Die Sinusfunktion wird im Bogemass berechnet und eine Periode beträgt
√(
)
(
entsprechen.
.
)
Nun wird aus dem Abstand die Höhe des Leds berechnet. Um am Ende eine Amplitude von
vier und eine Periode von acht zu erhalten, wird der Sinus des Abstandes mit der time addiert
und danach mit acht multipliziert. Dann kann die Höhe Werte von -8 bis 8 erreichen. Weiter
wird eins subtrahiert, damit die Höhe nur bis sieben geht. Zum Ganzen wird noch acht addiert. Nun liegt der Abstand zwischen -1 und 15. Um die z-Koordinaten zu bekommen, teilt
man nun das Ganze noch durch vier. So liegt die Höhe schlussendlich zwischen -0.25 und 7.5.
Wandelt man dies nun in einen Integer Wert um, liegt die Höhe zwischen 0 und 7. So wird für
jede Säule ein Led mit den Koordinaten [x][y][Höhe] auf High gesetzt.
(
)
Vor jeder Erhöhung von time wird der aktuelle Array der Anzeige()-Funktion (im Code displedarray) übergeben. Zur Verdeutlichung noch der Source Code:
void sinmitte()
{
for (float time=0;time<3.141*50;time+=0.5)
{
set_ledarray_low_or_high(LOW);
26
for (float i=0;i<8;i++)
{
for (float ii=0;ii<8;ii++)
{
ledarray[aktuell_led_array][(int)i][(int)ii]
[(((int)((sin(time+sqrt((4-i)/4*(4-i)/4+(4-ii)/4*(4-ii)/4)*3.141/1.2))*81))+8)/2]=HIGH;
}
}
displedarray(5);
}
}
5.2.6 Viereck
Bei der Viereck-Funktion sollen am Schluss alle Leds
leuchten, die am Aussenrand des Cubes sind, wie in der
nebenstehenden Grafik gezeigt. Bei der Implementierung des Musters musste viel Code geschrieben werden,
da es schwierig war, das Ganze zu vereinfachen.
Zuerst geht man der x- und y-Achse nach und stellt ein
Led nach dem anderen an, wobei man zwischendurch
Abbildung 21 Viereck auf dem Cube
immer wieder die Anzeige()-Funktion aufruft.
{
ledarray[aktuell_led_array][i][0][0]=HIGH;
ledarray[aktuell_led_array][0][i][0]=HIGH;
displedarray(time);
}
Danach geht man von den letzten zwei angestellten Leds wieder den Kanten entlang nach
oben zum Punkt [7][7][0].
{
ledarray[aktuell_led_array][7][0][i]=HIGH;
displedarray(time);
}
27
Von den drei als letztes angeschalteten Leds geht man nun zum Punkt [7][7][7] und von den
Punkten [7][0][7] und [0][7][7] geht man zum Punkt [0][7][7].
{
ledarray[aktuell_led_array][7-i][0][7]=HIGH;
ledarray[aktuell_led_array][0][7-i][7]=HIGH;
displedarray(time);
}
Alle Kanten mit Ausnahme der Kante von [0][0][7] zu [0][0][0] sind nun gemacht, also wird
diese von [0][0][7] her auch noch auf High gesetzt.
{
ledarray[aktuell_led_array][0][0][7-i]=HIGH;
displedarray(time);
}
5.3 Text anzeigen
Um generell Text auf dem Led Cube anzuzeigen, wird
für jeden Char des anzuzeigenden Strings die Buchstabendispl Funktion aufgerufen. Für jeden Char gibt es
einen
Array, der besagt, wie der Buchstabe in 2D
aussieht. Die Buchstabendispl Funktion lädt nun die 2D
Matrix (x und y) des Chars in eine
Matrix und
verschiebt die 2D Matrix in z-Richtung. Zwischen jedem Verschieben ruft sie die Anzeige()-Funktion auf.
Dies gibt dem Zuschauer das Gefühl, dass sich jeder
Buchstabe auf ihn zubewegt.
Diese Funktion wird an einigen Stellen aufgerufen:
28
Abbildung 22 Buchstabe 'e' auf dem Cube

Wenn man beim Snake Game Over geht, schreibt dies der Led Cube und zeigt die erreichte Punktzahl an.

Beim Start der automatischen Muster-Anzeige und beim Ende.
5.4 Klatschmodul
Ist der Kippschalter auf dem Steuerungspanel des Cubes auf On, dann befindet sich der User
in der Klatschmodulschlaufe. In dieser Schlaufe bleibt er solange, bis der Schalter wieder auf
Off gesetzt wird.
Beim Betreten der Klatschmodulschlaufe wird zuerst der aktuelle und der alte Klatschstand
mit dem aktuellen Stand (Low oder High) am Eingang aktualisiert. Danach wartet das Programm, bis das Klatschmodul seinen Zustand ändert.
Stellt das Arduino Board jedoch eine Änderung beim Klatschmodul fest, lässt es eine Ebene
in eine beliebige Richtung durch den Led Cube fahren.
Wird der Schalter wieder zurückgestellt, geht das Programm automatisch wieder in die Startschlaufe, in der es auf den connected respektive disconnected Befehl wartet.
5.5 Anzeige()-Funktion
Dies ist die wichtigste und meistbenötigte Funktion auf dem Arduino Board. Wie in den obigen Kapiteln häufig erwähnt, wird die Anzeige()-Funktion benötigt, um den von diversen
Funktionen erstellten Led Array auf dem Led Cube anzuzeigen. Der Led Array hat eine Größe
von
, was der Anzahl Leds des Cubes entspricht. Gespeichert sind in ihm pro Led ein
True oder ein False. Um den Array auf dem Led Cube darzustellen, blinkt immer nur eine
Ebene des Cubes (siehe 4.2 Multiplexing Verfahren). Jedoch blinken alle so schnell, dass es
das menschliche Auge nicht sieht. Zuerst schaltet man also die alte Ebene aus, indem man den
Pin des Arduino Boards, der mit dem Transistor der Ebene verbunden ist, auf Low schaltet.
Danach schaltet man den RCK Pin auf Low, damit alle Tri-State-Shift-Register Ausgänge
hochohmig sind.
29
Um nun die einzelne Ebene darzustellen, werden die M74HC595 Shift-Register der Reihe
nach geladen, indem man die SerialClock, welche zu allen Schieberegister parallel führt, zuerst Low setzt. Danach schaut man im Ledarray nach, ob das aktuelle Led leuchten soll oder
nicht, und stellt dann den entsprechenden seriellen Eingang der acht Schieberegister auf High
respektive Low. Hat man die ersten 8 Bits in die 8 verschiedenen Schieberegister geladen,
wird die SerialClock wieder High gesetzt. Der ganze Vorgang wird acht Mal wiederholt, bis
bei allen acht Schieberegister je acht Bits gesetzt sind. Dies entspricht exakt den 64 Pins, die
pro Ebene benötigt werden.
Danach schaltet man zuerst den RCK Pin auf High, damit alle Tri-State-Shift-Register Ausgänge wieder niederohmig sind. Weiter wird der Transistoren-Pin der neuen Ebene auf High
gesetzt, um den Stromkreislauf bei der neuen Ebene zu schließen
Der ganze Vorgang wird je nachdem wie lange man den aktuellen Ledarray sehen möchte
wiederholt. Die Anzahl Wiederholungen wird der Funktion als Argument mitgegeben.
Beim Testen leuchteten die Leds nur sehr schwach, da sie nur zwischen jedem 672. digitalWrite() Befehl auf High gesetzt wurden, was bedeutet dass sie nur 0.148% der Zeit am
Leuchten waren. Um dies zu verhindern, wird immer wenn eine Ebene am Leuchten ist ein
Delay von einer Millisekunde gesetzt. Dies bedeutet, dass die Blinkfrequenz der Leds vermindert wird, da alle acht Ebenen viel länger leuchten. Die Frequenz ist jedoch immer noch
hoch genug, so dass das Auge kein Blinken der Leds wahrnimmt. Der Vorteil des Delays ist,
dass die prozentuale Leuchtdauer der Leds nun drastisch erhöht wurde. Sie leuchten neu zwischen jedem 672. digitalWrite() Befehl und zwischen 7 Millisekunden, was wie oben erwähnt
zwar weniger häufig ist, dafür leuchten sie eine Millisekunde lange. Da die Dauer des Leuchtens nun im Verhältnis zum abgeschalteten Zustand grösser ist, leuchten die Leds heller.
Zur Verdeutlichung der Code der gesamten Funktion:
void displedarray(long long int time)
{
for (long long int faktor=0;faktor<time;faktor++)
{
for (int aktuelleebene=0;aktuelleebene<8;aktuelleebene++)
{
//alte ebene ausschalten (mithilfe des Transistors)
//zuerst aber noch checken ob die alte ebene nicht aktuelle-1, sondern die
//höchste ist =>7(respektive ebene 8)
if (aktuelleebene==0)
{digitalWrite(ebenentransistoren[7],LOW);}
30
else
{digitalWrite(ebenentransistoren[aktuelleebene-1],LOW);}
//zur sicherheit aber eigentlich unnötig den RCK pin LOW setzten
digitalWrite(RCK, LOW);
///alle acht shiftregister laden (M74HC595, 8 Bit)
for(int i = 8 - 1; i >= 0; i--){
//serielle clock low stellen
digitalWrite(SCK_, LOW);
//bei allen acht registern die 8 bits paralell einlesen (zuerst bei allen das
//erste, danach das zweite....)
for (int ii=0;ii<8;ii++)
{
int val = ledarray[aktuell_led_array][i][ii][aktuelleebene];
digitalWrite(serialoutputpins[ii], val);
}
digitalWrite(SCK_, HIGH);
}
//tri state wieder "aufheben" => durchgänge öffnen
digitalWrite(RCK, HIGH);
//aktuelle ebene öffnen, um den strokreislauf zu schliessen
digitalWrite(ebenentransistoren[aktuelleebene],HIGH);
delay(1);//eine Millisekunde warten, da die Led s sonst nur sehr dunkel leuchten
}
}
}
31
6 Schlusswort
Mit Hilfe des Led Cubes wurde gezeigt, dass es möglich ist mit einem Arduino Board, welches nur 52 digitale Output-Pins zur Verfügung stellt, einen funktionsfähigen Led Cube zu
bauen. Die zur Hilfe genommenen Tri-State-Shift-Register ermöglichten im Zusammenspiel
mit dem Multiplexverfahren eine massive Expansion der Output-Pins. So können die 512
Leds im Cube einzeln angesteuert werden, ohne dass zu jedem Led zwei einzelne Kabel geführt werden müssen. Dies ist insbesondere wichtig, da man möglichst gut durch den Cube
sehen sollte, um den 3D Effekt nicht zu verlieren.
Der
Led Cube kann diverse Muster anzeigen, z.B. eine Sinuskurve, explodierende
Kugeln, Regen, Würfel und noch viele mehr. Besonders ist, dass alles Real-Time vom Arduino Board aus berechnet wird und man den Cube auch ohne Verbindung zu einem Computer
laufen lassen kann. Der Gedanke vom 3D Bildschirm konnte verwirklicht werden. Als Benutzer sieht man gut durch den Led Cube und nimmt somit ein echtes 3D Bild wahr. Bei einem
nächsten Led Cube könnten die Abstände zwischen den Leds länger gewählt werden, damit
der Zuschauer noch besser durch den gesamten Cube sieht und der Cube ein bisschen grösser
werden würde.
Ein weiteres Tool ist das Klatschmodul, welches dem Arduino Board mitteilt, ob der Benutzer
geklatscht oder sonst einen lauten Laut gemacht hat. So kann der Led Cube auch auf Geräusche reagieren, was einen besonderen Reiz bietet. Der Benutzer kann so nicht nur dem Spektakel zusehen, sondern auch noch aktiv darauf Einfluss nehmen.
Der Versuch das altbekannte Handyspiel Snake auf dem Led Cube in 3D darzustellen ist geglückt. Das 3D Snake ist spielbar. Der Spieler erkennt das Futter gut durch das Blinken und es
ist eine echte Herausforderung die Schlange im dreidimensionalen Raum zum Futter zu führen. Spass macht es umso mehr, da man am Schluss des Games seine erreichte Punktzahl auf
dem Led Cube sieht.
32
7 Literaturverzeichnis
7.1 Literatur

Basian, Peter: Fachkunde Elektrotechnik. Europa Lehrmittel, Zürich 2012

Willemer, Arnold: Einstieg in C++. Galileo Computing, 4. Auflage
7.2 Webseiten

http://arduino.cc/en/Main/arduinoBoardMega2560, Abruf: 3.1.2013

http://arduino.cc/playground/Interfacing/CPPWindows, Abruf: 15.8.2012

http://de.wikipedia.org/wiki/Multiplexverfahren, Abruf: 29.8.2012

http://lazyfoo.net/SDL_tutorials/lesson11/index.php, Abruf: 22.8.2012

http://www.mikrocontroller.net, Abruf: 10.8.2012

http://www.mikrocontroller.net/topic/23513, Abruf: 28.8.2012

http://www.produktinfo.conrad.com/datenblaetter/150000-174999/155762-da-01-enLOGIK_IC_M74HC595B1R_STM.pdf, Abruf: 3.1.2013
33
8 Bildverzeichnis
Abbildung 1 Led Teststation
Nicole Trachsler & Lukas Roth, 2012
Abbildung 2 Holzplatte mit einer angefangenen Led Ebene
Abbildung 3 Fünf Led Ebenen
Abbildung 4 Drei aufeinander gelötete Ebenen mit Abstandshilfe
Abbildung 5 512 fertig verlötete Leds
Abbildung 6 Schaltplan von einer der acht Ebenen
Abbildung 7 Led Cube von unten
Abbildung 8 Schaltplan des M74HC595
http://www.produktinfo.conrad.com/datenblaetter/150000-174999/155762-da-01-enLOGIK_IC_M74HC595B1R_STM.pdf, Abruf: 3.1.2013
Abbildung 9 Schaltplan der M74HC595
Abbildung 10 Platine von oben
Abbildung 11 Platine von unten
Abbildung 12 Steuerungspanel
34
Abbildung 13 Klatschmodul von Conrad
Abbildung 14 Schaltplan der Zusatzmodule
Abbildung 15 Software-Flowchart
Abbildung 16 Glitzern
Abbildung 17 Regen
Abbildung 18 Verlauf der Explosion
Abbildung 19 Verlauf des Zufallswandern
Abbildung 20 Sinuswelle
Abbildung 21 Viereck auf dem Cube
Abbildung 22 Buchstabe 'e' auf dem Cube
35
9 Anhang
9.1 Code Blocks Projekt in separater Datei
9.2 Source Code für das Arduino Board in separater Datei
9.3 Video vom Led Cube: http://www.youtube.com/watch?v=Vz2NAAvF2iI
36
9.4 Selbständigkeitserklärung
Betreuungsperson: Dr. Adrien Cornaz
Co-Referent: Dr. Kai Köhler
Wir erklären hiermit, dass wir diese Arbeit

ohne unerlaubte fremde Hilfe angefertigt

keine anderen als die angegebenen Quellen benutzt und

in eigenen Worten formuliert haben.
Sämtliche Stellen, die wörtlich aus fremden Quellen entnommen oder mit eigenen Worten
wiedergegeben wurden, haben wir als solche gekennzeichnet und die Urheberschaft angegeben.
Name: Trachsler
Vorname: Nicole
Ort, Datum: …………………………..
Unterschrift: ……………………………..
Name:
Vorname: Lukas
Roth
Ort, Datum: …………………………..
Abt.: 4F
Abt.: 4F
Unterschrift: ……………………………..
37

pdf | 1.7 Mb - bugnplay.ch

Transcrição

Documentos relacionados

Saisonfi nale - Die Homepage der Karl Klein Baustoffe GmbH

Pluspol 12V gelb Minuspol schwarz Stecker Widerstand 560 Ohm LED

Bailey is een groothandel in verlichting die lampen levert voor elke

-Ausstattung: 2x LED Frontblitzer der III. Generation 1x Stativ LED

SINTA LED SINTA LED - Lichtlinie in ihrer schönsten Form

LED Strip Komplettset RGB

Unterwasserscheinwerfer CUBE Line CUBE Line UWS EVAlight

Aufbau 3D Cube 8x8x8

Einsatzleitwagen Holzminden - Wagener Technik GmbH Kassel

Highlight Your Truck