Escape Game: Rätselbox: Unterschied zwischen den Versionen

← Zum vorherigen Versionsunterschied Zum nächsten Versionsunterschied →

Version vom 11. Januar 2026, 12:13 Uhr

→ zurück zur Übersicht: WS 25/26: Escape Game

Autoren:	xiangyao Liu , yunkai Lin
Betreuer:	Marc Ebmeyer

Einleitung

Dieses Projekt basiert auf der Handlung der Kapitel 4 bis 7 des vierten Bandes des Mangas „Detektiv Conan“. In der Geschichte platziert der Täter eine Bombe in einem Shinkansen-Hochgeschwindigkeitszug. Fällt die Geschwindigkeit des Zuges unter 80 km/h, explodiert die Bombe. Conan muss den Fall noch im Zug lösen, um den Täter zu identifizieren und die Krise abzuwenden. Sein Kombinationsprozess stützt sich dabei maßgeblich auf die Schlüsselzahl 80, aus der er weitere Informationen ableitet.

In unserem Projekt erhalten die Spieler durch das erfolgreiche Absolvieren des Labyrinths im ersten Level ebenfalls eine Schlüsselzahl. Anhand verschiedener Hinweise müssen die Spieler von dieser Zahl ausgehend auf die entsprechenden Lösungen schließen. Jede dieser Lösungen stellt ein notwendiges Passwort für das finale Level des Spiels dar. Die Spieler müssen die Passwörter mit den Hinweisen kombinieren, um das letzte Rätsel zu lösen und das Spiel erfolgreich abzuschließen.

Der Schwierigkeitsgrad ist mittel. Das Spiel erfordert grundlegendes logisches Denken und eine gewisse Geschicklichkeit beim Bedienen der Sensoren, ist aber dank visueller Rückmeldungen (LEDs und Display) sowohl für Kinder als auch Erwachsene geeignet. Die Aufgaben sind so gestaltet, dass sie ohne Fachwissen, aber mit Konzentration und Beobachtung lösbar sind.

Der Lerneffekt besteht in der Verbindung von logischem Denken und physikalischer Wahrnehmung. Die Spieler verstehen im Spiel, wie Sensoren funktionieren, wie Zahlenwerte in reale Handlungen umgesetzt werden können und trainieren dabei ihre Problemlösungsfähigkeit sowie ihre Feinmotorik.

Zur Realisierung des Projekts wird die Entwicklungsumgebung MATLAB/Simulink in Verbindung mit dem Arduino Mega 2560 verwendet. Dabei werden alle Systemkomponenten – Sensoren, Aktoren, Steuerlogik und Anzeigeelemente – in Simulink als funktionale Blöcke modelliert. Das Verhalten des Systems kann zunächst im Simulink-Modell simuliert und anschließend über die automatische Codegenerierung direkt auf die Arduino-Hardware übertragen werden . Dadurch wird ein durchgängiger Model-Based Design-Ansatz umgesetzt, wie er im Systems Engineering zentral ist.

Anforderungen

Tabelle 1: Anforderungen an das Escape Game
ID	Inhalt	Prio	Ersteller	Datum	Geprüft von
1	Das Spiel muss in 5 Minuten lösbar sein.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
2	Das Labyrinth-Spiel startet beim Drücken von Taste 1.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
3	Hinweise und Rückmeldungen für die Spieler*innen werden über das OLED-Display angezeigt.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
4	Der Wägezellen-Sensor kann das aufgelegte Gewicht zuverlässig messen.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
5	Der Ultraschallsensor kann den Abstand der Hand zum Sensor zuverlässig messen.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
6	Der Drehwinkelsensor kann die horizontale Rotation des Kastens zuverlässig erfassen.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
7	Die Überprüfung der Bedingungen (Abstand, Winkel, Gewicht) beginnt beim Drücken von Taste 2.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
8	Wenn eine Aufgabe (Gewicht, Abstand, Winkel) korrekt ist, leuchtet die entsprechende LED grün, andernfalls rot.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
9	Beim Bestehen des Labyrinths leuchtet die entsprechende LED grün und das OLED zeigt „Erfolg“ an, andernfalls wird die LED rot und das OLED zeigt „Fehlgeschlagen“ an.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
10	Wenn alle drei Aufgaben korrekt sind und mindestens 3 Sekunden lang erfüllt bleiben, leuchten alle LEDs grün.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
11	Das Endergebnis (Zahlencode) wird auf dem OLED-Display angezeigt.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
12	Der Drehencoder kann die Spielfigur im Labyrinth korrekt steuern.	Niedrig	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
13	Das System muss auch ohne Internet funktionieren.	Niedrig	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
14	Das System muss in eine tragbare Box integriert werden.	Mittel	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
15	Das Spiel muss benutzerfreundlich und sowohl für Kinder als auch Erwachsene geeignet sein.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin
16	Während des Spiels dürfen keine externen Hilfsmittel (z. B. Waage, Lineal) verwendet werden.	Hoch	xiangyao Liu，yunkai Lin	02.10.2025	Xiangyao Liu, Yunkai Lin

Funktionaler Systementwurf

Das Spiel gliedert sich in zwei Abschnitte.
Im ersten Abschnitt muss der Spieler den OLED-Bildschirm auf der Box finden und das darauf dargestellte Labyrinthspiel mithilfe eines Drehgebers lösen. Nach erfolgreichem Abschluss des Labyrinths erhält der Spieler die erste Schlüsselzahl.
Anschließend beginnt der zweite Abschnitt. Hier muss der Spieler anhand von Hinweisen verschiedene Berechnungen mit der ersten Schlüsselzahl durchführen, um drei neue Schlüsselzahlen zu ermitteln. Diese drei Zahlen sind jeweils einem der drei folgenden Rätsel zugeordnet. Das erste Rätsel besteht darin, entsprechend der neuen Zahl passende Gewichtsstücke auszuwählen, die von einem Schwerkraftsensor gemessen werden. Beim zweiten Rätsel muss die Box um einen Winkel gedreht werden, der durch die neue Schlüsselzahl vorgegeben ist. Das dritte Rätsel erfordert das Platzieren eines Hindernisses (hierfür kann auch die Hand dienen), dessen Abstand zum Ultraschallsensor der neuen Schlüsselzahl entsprechen muss.

Jede dieser Aufgaben wird automatisch überprüft. Wenn die Messwerte innerhalb des erlaubten Toleranzbereichs liegen, leuchtet die entsprechende LED grün. Nach dem erfolgreichen Bestehen aller Aufgaben wird auf dem OLED-Display „Erfolg“ angezeigt und ein Zahlencode freigegeben.

Technischer Systementwurf

Die technische Systemarchitektur beschreibt ein mikrocontroller-gesteuertes interaktives Spielsystem mit mehrstufiger Eingabeverarbeitung. Die Stromversorgung liefert die erforderliche Energie für alle Komponenten.

Das System gliedert sich in drei funktionale Ebenen: Eingabe, Verarbeitung und Ausgabe. Auf der Eingabeebene erfassen ein Drehgeber und zwei Tasten die Benutzerbefehle zur Spielsteuerung, während Sensoren (Gewichts-, Winkel- und Abstandssensoren) kontinuierlich physikalische Messdaten sammeln.

Der Mikrocontroller fungiert als zentrale Verarbeitungseinheit, die alle Eingangssignale empfängt, die Spiellogik ausführt und die Bedingungsüberprüfung durchführt. Er verarbeitet die Messdaten der Sensoren in Echtzeit und vergleicht sie mit den vorgegebenen Zielwerten.

Die Ausgabeeinheit besteht aus einem OLED-Display zur visuellen Darstellung des Spielverlaufs und der Systemmeldungen sowie einer LED-Anzeige zur Signalisierung des Erfolgszustands. Das Display zeigt während des Spiels das Labyrinth, Statusinformationen und den generierten Code an, während die LED als binäres Signal für Erfolg oder Misserfolg dient.

Durch diese Systemarchitektur wird ein durchgängiger Datenfluss von der Eingabeerfassung über die intelligente Signalverarbeitung bis zur benutzerfreundlichen Ergebnisdarstellung gewährleistet. Die modulare Struktur ermöglicht eine flexible Anpassung und Erweiterung einzelner Komponenten.

Materialliste

Tabelle 2: Materialliste
Nr.	Anz.	Komponente	Beschreibung	Link
1	1	Arduino Mega 2560	Microcontroller	ARD MEGA2560 R3 Arduino kompatibles Mega 2560 R3 Board
2	1	SSD1306 I²C 128x64	Display	SSD1306
3	1	SEN-PRESSURE02	Drucksensor	ARD SEN PRESSURE Arduino - Drucksensor, 0 g bis 2 kg
4	1	KY-040	Drehgeber	KY-040
5	1	HC-SR04	Ultraschall-Modul	HC-SR04
6	2	Taster	Taster	Taster
7	1	MPU6050（I²C）	Beschleunigungs- und Gyroskop-Sensor	MPU6050
8	4	LED	LED	Iduino SE010 RGB LED-Modul

Komponentenspezifikation

Stückliste (BOM)

In der nachfolgenden Tabelle ist die Bill of Materials für das Projekt zu finden.

Tabelle 3: BOM
ID	Anzahl	Kosten pro Stück €	Summe	Bezeichnung / Komponente	technische Bezeichnung	Beschreibung	Datenblatt	Abbildung
1	1x	19,30€	19,30€	Arduino Mega	ARD MEGA2560 R3 Arduino kompatibles Mega 2560 R3 Board	Der Mircocontroller mit dem ATmega2560 verfügt über 54 digitale I/O - Schnittstellen. Des Weiteren sind 16 analoge Eingänge die die Verarbeitung analoger Signale vorhanden.	Datenblatt Arduino Mega	Abb. 4: Arduino Mega 2560 R3 Board
2	1x	6,99€	6,99€	SSD1306 I²C 128x64	SSD1306	Der SSD1306-Controller ermöglicht die Ansteuerung von OLED-Displays mit einer Auflösung von 128x64 Pixeln über I2C- oder SPI-Schnittstellen.	Datenblatt SSD1306	Abb. 5: OLED-Display
3	1x	4,03€	4,03€	Drucksensor	ARD SEN PRESSURE Arduino - Drucksensor, 0 g bis 2 kg	Der Sensor ist für einen Messbereich von 0 bis 2 kg ausgelegt und liefert ein analoges Signal.	Datenblatt Drucksensor	Abb. 6: Drucksensor.
4	1x	2,2€	2,2€	KY-040 Drehgeber	KY-040	Der inkrementale Drehgeber ermöglicht eine endlose 360°-Rotation und verfügt über einen integrierten Drucktaster.	Datenblatt KY-040	Abb. 7: KY-040
5	1x	3,80€	3,80€	Ultraschall-Modul	HC-SR04	Der Ultraschallsensor misst berührungslos Entfernungen von 2 cm bis 400 cm mittels Schallwellen.	Datenblatt Ultraschall	Abb. 8: HC-SR04
6	2x	0,33€	0,66€	Taster	Taster	Dieses Bauteil dient als taktiles Eingabeelement auf Leiterplatten und kehrt nach dem Loslassen automatisch in die Ausgangsposition zurück.	Datenblatt Taster	Abb. 9: taster
7	1x	5,50€	5,50€	MPU6050	MPU6050	Der MPU6050 vereint ein 3-Achsen-Gyroskop und einen 3-Achsen-Beschleunigungssensor zu einer 6-Achsen-Motion-Tracking-Einheit.	Datenblatt MPU6050	Abb. 10: MPU6050
8	4x	2,49€	9,96€	LED	Iduino SE010 RGB LED-Modul	Das RGB-LED-Modul ermöglicht durch die separate Ansteuerung der Kanäle Rot, Grün und Blau die Darstellung beliebiger Mischfarben.	Datenblatt LED	Abb. 11: LED

Umsetzung (HW/SW)

Technische Daten der Sensoren

Hardware-Modul: Ultraschallsensor HC-SR04

Der HC-SR04 ist ein weit verbreitetes Modul zur berührungslosen Entfernungsmessung. Er nutzt das Sonar-Prinzip , um den Abstand zu Objekten zu erkennen.

Funktionsprinzip：

Das Modul sendet nach Erhalt eines Triggersignals automatisch Ultraschallwellen aus und misst die Zeitspanne bis zum Eintreffen des vom Objekt reflektierten Echos, um daraus unter Berücksichtigung der Schallgeschwindigkeit die Entfernung zum Objekt zu berechnen.

Berechnungsformel

Die Distanz wird berechnet, indem die gemessene Zeitdauer des Echos mit der Schallgeschwindigkeit multipliziert und durch 2 geteilt wird .

$Distanz (cm) = \frac{Echo-Dauer (μ s) \times 0, 0343}{2}$

In diesem Projekt dient das Modul als Kernkomponente für das "Level 2: Sensor-Herausforderung" (Sensor Challenge). Der Spieler muss seine Hand in einer bestimmten Höhe (9 cm - 11 cm) über den Sensor halten, um einen Teil des Rätsels zu lösen.

Tabelle 4: Technische Daten der HC-SR04 Sensoren
	HC-SR04
Messbereich	3 - 400 cm
Versorgungsspannung	5 V
Versorgungsstrom	15 mA
Arbeitsfrequenz	40 kHz
Messwinkel	15 Grad
Genauigkeit	ca. 3mm

Die Verbindung zwischen dem Ultraschallsensor HC-SR04 und dem Arduino Mega 2560 erfolgt über vier Pins. Die genaue Belegung in diesem Projekt ist wie folgt:

Tabelle 5: Hardware-Anschluss: HC-SR04
HC-SR04 Pin	Arduino Mega Pin	Beschreibung
VCC	5V	Stromversorgung
GND	GND	Ground
Trig	D7	Trigger-Signal (Ausgang vom Arduino)
Echo	D6	Echo-Signal (Eingang zum Arduino)

Hardware-Modul: Ultraschallsensor KY-040

Der KY-040 ist ein inkrementaler Drehgeber, der Drehbewegungen in elektrische Signale umwandelt. In diesem Projekt fungiert der KY-040 als Hauptsteuergerät für das Labyrinth-Spiel (Level 1).

Drehen: Steuert die Bewegung des Spielers (hoch/runter oder links/rechts).

Drücken: Der integrierte Taster wechselt die Bewegungsachse (horizontal/vertikal).

Funktionsprinzip

Der KY-040 Inkrementalgeber wandelt mechanische Drehbewegungen in elektrische Impulse um. Das Kernprinzip beruht auf der Auswertung der Phasenverschiebung zwischen zwei Signalen, um die Drehrichtung zu bestimmen.

Interner Aufbau und Signalerzeugung

Wie in der Abbildung12 zu sehen ist, befindet sich im Inneren des Encoders eine Scheibe mit gleichmäßig verteilten Kontaktstellen, die mit dem gemeinsamen Pin C (Ground) verbunden sind.

Erzeugung der Rechtecksignale: Wenn der Knopf gedreht wird, rotiert diese Scheibe. Die Ausgänge A (CLK) und B (DT) berühren abwechselnd die Kontaktflächen der Scheibe.

Das Ergebnis: Durch diesen ständigen Wechsel zwischen Kontakt (Low) und keinem Kontakt (High) entstehen auf beiden Leitungen digitale Rechtecksignale.

Richtungserkennung

Um zwischen Rechts- und Linksdrehung zu unterscheiden, sind die Abnehmer für Signal A und Signal B phasenversetzt angeordnet. Das bedeutet, die Signale ändern sich nicht gleichzeitig, sondern nacheinander (um 90° versetzt). Der Mikrocontroller erkennt die Richtung, indem er prüft, welches Signal sich zuerst ändert.

Laut dem Abbildung13 gilt folgende Logik:

Im Uhrzeigersinn

Bei einer Rechtsdrehung eilt das Signal A dem Signal B voraus.

Signalverlauf: Der Zustand von Ausgang A ändert sich zuerst. Wenn Signal A seine Flanke wechselt (z. B. von High auf Low), hat Signal B seinen Zustand noch nicht geändert.

Erkennung: Der Mikrocontroller registriert eine Änderung an A. Da B zu diesem Zeitpunkt noch unverändert (statisch) ist, wird dies als Rechtsdrehung interpretiert.

Gegen den Uhrzeigersinn

Bei einer Linksdrehung kehrt sich die Reihenfolge um. Signal B eilt nun voraus.

Signalverlauf: Hier ändert sich der Zustand von Ausgang B zuerst.

Erkennung: Wenn der Mikrocontroller nun eine Änderung an A registriert, stellt er fest, dass B seinen Zustand bereits geändert hat . Dies wird als Linksdrehung interpretiert.

Tabelle 6: Technische Daten der KY-040 Sensoren
	KY-040
Betriebsspannung	5V
Drehwinkel	360°
Ausgang	2-Bit-Grau-Code
Taster	Integrierter Push-Button

Tabelle 7: Hardware-Anschluss: KY-040
KY-040 Pin	Arduino Mega Pin	Beschreibung
VCC	5V	Stromversorgung
GND	GND	Ground
SW	D5	Taster-Signal
DT	D3	Datensignal
CLK	D2	Taktsignal

Hardware-Modul: MPU6050

Der MPU6050 ist ein sogenanntes MEMS-Modul (Micro-Electro-Mechanical System), das einen 3-Achsen-Beschleunigungssensor und ein 3-Achsen-Gyroskop auf einem einzigen Chip vereint. In diesem Projekt wird es speziell zur präzisen Neigungserkennung eingesetzt.

Tabelle 8: Technische Daten der MPU-6050 Sensoren
	MPU-6050
Betriebsspannung	3.3V - 5V
Schnittstelle	I2C (SDA/SCL)
Genutzter Sensor	3 Beschleunigungs– und 3 Lageachsen
ADC-Auflösung	16-Bit
Messbereich	± 2, ± 4, ± 8, ± 16 g ± 250, ± 500, ± 1000, ± 2000°/s

Funktionsprinzip：

Obwohl der MPU6050 auch über ein Gyroskop verfügt, nutzt dieses Projekt ausschließlich den Beschleunigungssensor zur Winkelbestimmung. Dies geschieht aus Gründen der Stabilität:

Problem mit dem Gyroskop: Das Gyroskop misst Winkelgeschwindigkeiten. Um daraus einen Winkel zu berechnen, müssen die Werte integriert werden. Dies führt über die Zeit zu einem sogenannten "Drift" (Weglaufen der Werte), wodurch der Nullpunkt instabil wird.

Lösung durch Beschleunigungssensor: Der Beschleunigungssensor misst die permanente Erdanziehungskraft (1g). Da die Schwerkraft eine konstante, vertikale Referenzgröße ist, liefert diese Methode einen absoluten und stabilen Neigungswinkel ohne Drift.

Das Prinzip basiert auf der Projektion des Schwerkraftvektors auf die drei Achsen (X, Y, Z) des Sensors. Wenn die Platine geneigt wird, "verteilt" sich die Schwerkraft auf die X- oder Y-Achsen.

Implementierungslogik：

Die Ermittlung der Neigung erfolgt im Mikrocontroller in zwei Schritten: Datenerfassung und trigonometrische Berechnung.

Schritt 1: Datenerfassung Der Arduino liest die Rohwerte des Beschleunigungssensors aus den Registern des MPU6050:

Ax: Beschleunigung entlang der X-Achse .

Ay: Beschleunigung entlang der Y-Achse .

Az: Beschleunigung entlang der Z-Achse .

Schritt 2: Winkelberechnung

Um den physikalischen Neigungswinkel in Grad zu erhalten, wird das Verhältnis der Achsenwerte zueinander mithilfe der Arkustangens-Funktion berechnet:

Roll-Winkel (Neigung Links/Rechts): $Roll = \arctan (\frac{A_{y}}{A_{z}}) \cdot \frac{180}{π}$

2. Pitch-Winkel (Neigung Vor/Zurück): $Pitch = \arctan (\frac{A_{x}}{A_{z}}) \cdot \frac{180}{π}$

Das Ergebnis sind stabile Winkelwerte in Grad, die direkt für die Logiksteuerung verwendet werden.

Tabelle 9: Hardware-Anschluss: MPU6050
MPU6050 Pin	Arduino Mega Pin	Beschreibung
VCC	5V	Stromversorgung
GND	GND	Ground
SDA	SDA	Serial Data
SCL	SCL	Serial Clock

Hardware-Modul: OLED-Display (SSD1306)

Das OLED-Display (Organic Light Emitting Diode) ist die zentrale visuelle Schnittstelle dieses Projekts. Im Gegensatz zu herkömmlichen LCDs, die eine Hintergrundbeleuchtung benötigen, leuchten die Pixel bei einem OLED-Display von selbst.

In diesem Projekt dient das Display dazu, dem Spieler Echtzeit-Feedback zu geben. Es zeigt:

Den aktuellen Spielstatus und Erfolgs- oder Fehlermeldungen (z. B. "Winner!" oder "Game Over").

Tabelle 10: Technische Daten der SSD1306 Sensoren
	SSD1306
Betriebsspannung	3.3V - 5V
Schnittstelle	I2C (SDA/SCL)
Auflösung	128 x 64 Pixel
Display-Technologie	OLED
Blickwinkel	> 160°

Funktionsprinzip：

Ein OLED-Display besteht aus organischen dünnen Schichten, die zwischen zwei Leitern platziert sind. Wenn Strom fließt, emittieren diese Schichten Licht.

Speicherabbild (GDDRAM): Der SSD1306-Controller verfügt über einen internen Grafikspeicher (Graphic Display Data RAM). Der Mikrocontroller sendet Bilddaten über den I2C-Bus in diesen Speicher. Jeder Bit im Speicher entspricht einem Pixel auf dem Bildschirm (1 = Leuchten, 0 = Aus).

Vorteil gegenüber LCD: Da schwarze Pixel einfach "ausgeschaltet" sind , erreicht das Display einen extrem hohen Kontrast und verbraucht bei dunklen Bildern weniger Strom.

Tabelle 11: Hardware-Anschluss: SSD1306
SSD1306 Pin	Arduino Mega Pin	Beschreibung
VCC	5V	Stromversorgung
GND	GND	Ground
SDA	SDA	Serial Data
SCL	SCL	Serial Clock

Hardware-Modul: Drucksensor (SEN-PRESSURE02)

Der SEN-PRESSURE02 ist ein hochsensibler Dünnschicht-Drucksensor, der speziell für Mikrocontroller-Anwendungen entwickelt wurde.

In diesem Projekt dient er als analoges Eingabeelement. Er erkennt nicht nur, ob gedrückt wird, sondern misst die Intensität des Drucks.

Tabelle 12: Technische Daten der SEN-PRESSURE02 Sensoren
	SEN-PRESSURE02
Betriebsspannung	3.3V - 5V
Messbereich	0 kg bis 2 kg
Reaktionszeit	< 1 ms
Lebensdauer	> 1.000.000 Messungen
Funktionsweise	Analoge Widerstandsänderung

Funktionsprinzip：

Der Sensor arbeitet nach dem piezoresistiven Prinzip: Ruhezustand: Ohne Druck ist der elektrische Widerstand des Sensors extrem hoch (> 10 MΩ). Es fließt kaum Strom.Belastung: Sobald Druck auf die kreisförmige Fläche ausgeübt wird, verringert sich der Widerstand drastisch.Integrierter Spannungsteiler:Im Gegensatz zu rohen FSR-Sensoren verfügt dieses Modul bereits über einen integrierten Festwiderstand (auf der Platine als R1 sichtbar). Dieser bildet zusammen mit dem Sensor die notwendige Spannungsteiler-Schaltung.

Formel: $V_{out} = V_{CC} \cdot \frac{R_{Fest}}{R_{Sensor} + R_{Fest}}$

Tabelle 13: Hardware-Anschluss: SEN-PRESSURE02
SEN-PRESSURE02 Pin	Arduino Mega Pin	Beschreibung
VCC	5V	Stromversorgung
GND	GND	Ground
Signal	A0	Analoges Ausgangssignal

PCB Entwicklung

Für mein Projekt wird ein Mikrocontroller benötigt, der Signale von den verwendeten Sensoren liest und die Aktoren steuert. Angesichts der beträchtlichen Anzahl von Sensoren, die in diesem Projekt zum Einsatz kommen, wurde der Arduino Mega2560 als Mikrocontroller ausgewählt, um einen Mangel an Pins zu vermeiden. Die Wahl fiel auf den Arduino Mega 2560, da dieser über umfangreiche Ressourcen zur Informationsverarbeitung sowie eine hohe Rechenleistung für Steuerungsaufgaben in Echtzeit verfügt. Ein entscheidender Vorteil ist zudem die große Anzahl an Header-Pins: Sie deckt den gesamten Bedarf für den Anschluss aller Sensoren und Aktoren ab und gewährleistet somit eine hohe Flexibilität für die weitere Hardware-Entwicklung.

Um den Montageprozess zu rationalisieren und elektrische Anschlussfehler zu vermeiden, wurde eine spezifische Leiterplatte (PCB) als zentrale Schnittstellenplatine entwickelt. Basierend auf dem elektrischen Anschlussschema für Aktoren, Sensoren und Steuerungen wurden die Stiftleisten präzise auf der Platine platziert und die Leiterbahnen entsprechend dem Schaltplan geroutet.

Da für dieses Projekt nicht der gesamte Funktionsumfang des Arduino Mega 2560 benötigt wird, wurde bei der Schnittstellenkonfiguration auf eine vollständige Replikation des Pin-Layouts verzichtet. Stattdessen wurden gezielt nur die benötigten Pins ausgewählt und positioniert. Dieser Ansatz schafft zusätzlichen Platz auf der Leiterplatte, was die Komplexität der Leitungsführung reduziert und das Design optimiert.

Tabelle : Anschlussschema der Komponenten
Komponente	Pins von Komponente	Pins von Arduino Mega
KY-040	GND	GND
	VCC	V5
	SW	D5
	DT	D3
	CLK	D2
Drucksensor	Signal	A0
	VCC	V5
	GND	GND
SSD1306	VCC	V5
	GND	GND
	SCL	D21
	SDA	D20
HC-SR04	VCC	V5
	GND	GND
	Triger	D13
	Echo	D12
MPU6500	VCC	V5
	GND	GND
	SCL	D21
	SDA	D20
	INV	D19
LED_1	GND	GND
	Green	D23
	Red	D28
LED_2	GND	GND
	Green	D25
	Red	D26
LED_3	GND	GND
	Green	D27
	Red	D24
LED_4	GND	GND
	Green	D29
	Red	D22
Taster_1	GND	GND
Taster_1	Signal_1	D4
Taster_2	GND	GND
Taster_2	Signal_1	D18

Nach der Festlegung des Anschlussschemas für die Sensoren und Aktoren wurde das Layout der Schnittstellenplatine basierend auf dem Schaltplan erstellt. Die Stromversorgung des Systems erfolgt primär über die USB-Schnittstelle des Arduino Mega, ergänzt durch zwei 3,7-V-18650-Lithium-Ionen-Akkus oder einen externen 5-V-Powerbank-Anschluss. Ein integrierter Spannungsregler stabilisiert dabei Spannungen über 5 V auf ein konstantes Niveau von 5 V.

Der unten dargestellte Schaltplan nutzt On-Page-Connectors, um die Verbindungen zwischen den Komponenten übersichtlich zu gestalten. Durch die Zuweisung identischer Bezeichner wurden logische Verknüpfungen hergestellt, ohne das Diagramm mit vermeidbare unübersichtliche kreuzende Linien. zu überladen. Zur besseren Strukturierung wurde der Gesamtplan in mehrere funktionale Blöcke unterteilt. Dieser modulare Ansatz ermöglicht eine intuitive Darstellung der Logik und vereinfacht die Fehlerdiagnose.

Auf dieser Grundlage wurde der in Multisim erstellte Schaltplan in ein Leiterplattenlayout in Ultiboard überführt. Die zunächst als Ratsnest (Fly-Wires) dargestellten Verbindungen wurden im nächsten Schritt zu Leiterbahnen geroutet, woraus das unten dargestellte Layout resultiert.

Die folgenden Bilder zeigen die Vorder- und Rückseite der entworfenen Leiterplatte in 3D-Ansicht.

Komponententest

OLED-Display & Zustandslogik

Testziel

Ziel dieses Unit-Tests ist die Verifizierung der korrekten visuellen Ausgabe auf dem OLED-Display in Abhängigkeit vom internen Systemzustand. Es soll sichergestellt werden, dass die C++-Treiberfunktion die von der Stateflow-Logik gesendeten Zustandswerte korrekt interpretiert und die entsprechenden Grafiken oder Texte

Testumgebung

Tabelle 14: Testumgebung der OLED-Display(Hardware)

Mikrocontroller	Arduino Mega 2560
Ausgabe	0,96" OLED-Display (SSD1306), angeschlossen via I2C
Eingabe	Drehgeber (KY-040) zur Navigation und Simulation von Benutzeraktionen,Taster.

Tabelle 15: Testumgebung der OLED-Display(Software)

Entwicklungsumgebung	MATLAB/Simulink R2024
Modus	External Mode zur Echtzeit-Beobachtung der Signale.
Treiber-Code	(basierend auf Adafruit GFX Library).oled_wrapper.cpp

Implementierungslogik

Die Implementierung folgt einer Drei-Schichten-Architektur, die die logische Entscheidung (Simulink/Stateflow) von der physischen Darstellung (C++) trennt.

a.Zustandsmaschine (Stateflow Logic)

Das "Gehirn" des Systems ist ein Stateflow-Chart, das den Spielablauf steuert. Basierend auf den Eingaben (Taster, Timer, Kollisionen) wechselt das System zwischen folgenden Zuständen:

State 0 (Wait_Start): Startzustand. Wartet auf .

State 1 (Welcome): Zeigt Startnachricht. Wechselt automatisch zu State 2.

State 2 (Maze_Game): Das eigentliche Spiel. Hier wird die Spielerposition （player_r ，player_c） aktiv berechnet.

Transition zu 3: Wenn (Falle).

Transition zu 4: Wenn (Ziel erreicht).

State 5 (Sensor_Level): Ein separater paralleler Status im Stateflow , der aktiviert wird, wenn das Labyrinth gelöst ist oder durch einen Schalter ausgewählt wird.

b.Simulink-Signalfluss

Der Signalfluss im Modell ist so konzipiert, dass er zwei parallele Aufgaben erfüllt: die Berechnung der Spielphysik und die Priorisierung der Bildschirmanzeige. Die Architektur lässt sich in drei logische Pfade unterteilen (siehe Abb. 18).

Pfad 1: Die Physik-Berechnung

Dieser Pfad ist für die Verarbeitung der Spielerbewegungen zuständig. Das Zustandssignal（current_state_out） aus dem Stateflow-Chart „Game_System“wird direkt in den Physik-Baustein（step_game_physics） geleitet.

Funktion als Aktivierungs-Logik: Die implementierte C++ Funktion nutzt den aktuellen Systemzustand als Filter. Nur wenn sich das System im Zustand „Maze Game“（current_state == 2） befindet, werden die Eingabesignale der Drehgeber (Rotary Encoders) aktiv in Koordinatenänderungen umgerechnet.

Ruhezustand: In allen anderen Zuständen wird die Positionsberechnung pausiert oder zurückgesetzt, um Fehlberechnungen im Hintergrund zu vermeiden.

Ausgang: Der Block（step_game_physics） liefert die aktuellen Spielerkoordinaten（player_r， player_c） , die für den nächsten Render-Schritt benötigt werden.

Pfad 2: Die Anzeige-Priorisierung

Bevor der aktuelle Zustand an den Display-Treiber übermittelt wird, durchläuft er eine Priorisierungsstufe, die durch einen Simulink-Switch-Block realisiert ist. Dies ermöglicht es dem System, kritische Sensor-Meldungen visuell vorzuziehen.

Eingangslogik: Der Switch vergleicht das Signal（sensor_state_out） des „Sensor_System“mit einem Schwellenwert.

Fall A (Override): Ist das Sensor-System aktiv (Status > 3), erhält dieser Status Vorrang. Das Display zeigt somit sofort die Sensor-Meldung an, unabhängig davon, was im Spiel gerade passiert.

Fall B (Normalbetrieb): Liegt keine Sensor-Priorität vor, wird der reguläre Spielstatus an das Display durchgereicht.

Pfad 3: Die Visuelle Darstellung

Der Block（draw_frame_wrapper） führt die Informationen aus Pfad 1 und Pfad 2 zusammen

Zustands-Information: Er empfängt den finalen Status vom Switch-Block (Pfad 2), der definiert, welcher Bildschirminhalt gezeichnet werden soll.

Positions-Information: Er empfängt die aktuellen Koordinaten direkt aus dem Physik-Block (Pfad 1).

Die interne Logik kombiniert diese Daten: Wenn der Status ‚Spiel‘ aktiv ist, nutzt die interne C++-Funktion die Koordinaten, um den Spieler an der physikalisch korrekten Position innerhalb des Labyrinths zu zeichnen und basierend auf verschiedenen Statusinformationen entsprechende Ergebnisse darzustellen.

Im Folgenden finden Sie den Code für die Darstellung.

void draw_frame_wrapper(int current_state, int player_r, int player_c) {
#if defined(__AVR__)

    static int skip_counter = 0;
    skip_counter++;
    if (skip_counter < 4) {
        return;
    }
    skip_counter = 0;

    display.clearDisplay();

    switch (current_state) {
    case 0:
        display.setTextSize(2);
        printCenter(F("Hallo"), 15);
        display.setTextSize(1);
        printCenter(F("Bitte Knopf druecken"), 45);
        break;

    case 1:
        display.setTextSize(2);
        printCenter(F("Hallo "), 15);
        display.setTextSize(1);
        display.setCursor(25, 40);
        display.print(F("Spiel Start"));
        break;

    case 2:
        display.setTextSize(1);
        for (int r = 0; r < 7; r++) {
            for (int c = 0; c < 15; c++) {
                int x = c * TILE_SIZE + START_X; int y = r * TILE_SIZE + 5;
                char cell = MAZE_STR[r][c];
                if (cell == '#' || cell == 'I') display.fillRect(x, y, TILE_SIZE, TILE_SIZE, SSD1306_WHITE);
                else if (cell == 'E') { display.setCursor(x + 1, y + 2); display.print('E'); }
            }
        }
        display.fillCircle(player_c * TILE_SIZE + 4 + START_X, player_r * TILE_SIZE + 4 + 5, 2, SSD1306_WHITE);
        break;

    case 3:
        display.setTextSize(2);
        printCenter(F("GAME OVER!"), 10);
        display.setTextSize(1);
        printCenter(F("Falle ausgelost!"), 35);
        printCenter(F("Neustart: Knopf"), 50);
        break;

    case 4:
        display.setTextSize(1);
        printCenter(F("Gratulation!"), 0);
        display.setTextSize(1);
        printCenter(F("Dein Schlussel ist"), 35);
        display.setTextSize(3);
        printCenter(F("090"), 45);
        break;

    case 5:
        
        display.setTextSize(2);
        printCenter(F("SUPER!"), 10);  

        display.setTextSize(1);
        printCenter(F("System Entsperrt"), 35); 

        display.setTextSize(1);
        
        printCenter(F("Code: OK"), 55);
        break;
    }

    display.display();
#endif
}

Testfälle

Die folgenden Testfälle decken alle definierten Zustände des Systems ab.

Tabelle 17: Testfälle der OLED-Display
ID	Test-Szenario	Voraussetzung	Erwartetes Ergebnis	Status
TC-01	Systemstart	System einschalten. Keine Taste drücken	Zeile 1: "Hallo" ，Zeile 2: "Bitte Knopf druecken"	Abb. 16: Systemstart
TC-02	Willkommens-Screen	Drehgeber-Knopf drücken.	Zeile 1: "Hallo "，Zeile 2: "Spiel Start"	Abb. 16: Willkommens-Screen
TC-03	Spielstart	Automatisch nach 3 Sekunden Wartezeit.	Das statische Labyrinth-Raster wird angezeigt. Ein kleiner Punkt (Spieler) ist an der Startposition sichtbar.	Abb. 16: Spielstart
TC-04	Spieler-Bewegung	Im Spiel-Modus : Drehgeber drehen.	Der Punkt auf dem Bildschirm bewegt sich in Echtzeit entsprechend der Drehrichtung.	Abb. 16: Spieler-Bewegung
TC-05	Game Over (Falle)	Spieler steuert in ein Falle	Zeile 1: "GAME OVER!"，Zeile 2: "Falle ausgelost!"，Zeile 3: "Neustart: Knopf"	Abb. 16: Game Over
TC-06	Spiel gewonnen	Spieler zum 'E' (Exit)	Zeile 1: "Gratulation!"，Zeile 2: "Dein Schlussel ist"，Zeile 3: "090"	Abb. 16: Spiel gewonnen
TC-07	Sensor-Level	Aktivierung des Sensor-Modus	Zeile 1: "SUPER!"，Zeile 2: "System Entsperrt"，Zeile 3: "Code: OK"	Abb. 16: Sensor-Level

Ergebnis

Zusammenfassung

Lessons Learned

Projektunterlagen

Projektplan

Projektdurchführung

YouTube Video

Weblinks

Literatur