Escape Game: Kugel-Balancierer

Autoren:	Kilian Engelhardt, Daniel Block
Betreuer:	Prof. Schneider

Einleitung

Das Escape Game "Kugel-Balancierer" entsteht im Rahmen des Moduls Angewandte Mechatronik des Studiengangs Business and Systems Engineering (BSE). Anhand dieses Projekts lässt sich zeigen, wie sich mit wenigen Bauteilen ein experimentelles Puzzle für ein physikalisch-technisches Escape Game entwerfen lässt. Eine Kugel rollt auf einer einachsig kippbaren Schiene, ein Servomotor verändert den Neigungswinkel, ein Distanzsensor misst die Position. Die Spielenden stellen über drei Drehregler die P-, I- und D-Anteile eines Reglers ein. Ziel ist es, die Kugel für eine definierte Zeit im Fenster um die Mittelposition zu halten – gelingt dies, wird ein Code auf dem Display ausgegeben.

Das Puzzle erinnert an klassische Murmelbahnen und vermittelt zugleich zentrale Begriffe der Regelungstechnik. Die zugrunde liegende Physik ist anschaulich: Entlang der geneigten Ebene wirkt die Beschleunigung $a\approx g\cdot \alpha$ (für kleine Winkel $\alpha$), die den Kugelort verändert. Ein PID-Regler nach der Formel $u(t)=K_P\cdot e(t)+K_I\int e(t)\mathrm{d}t+K_D\frac{\mathrm{d}e}{\mathrm{d}t}$ stabilisiert das System. Hierbei stellt der Winkel des Servomotors die Stellgröße $u$ dar, der Positionsfehler $e$ bildet die Regelgröße.

Bezüglich der Vorgehensweise bei diesem Projekt wurde sich am Ablauf des V-Modells orientiert.

Schwierigkeitslevel: fortgeschritten

Lernziele: Spielerisch die Anwendung eines Reglers und die Einflüsse der drei Anteile P, I und D erlernen

Bezug zum BSE Studium: Regelungstechnik, Messdatenverarbeitung (Filterung)

Anforderungen

Als erster Schritt nach Vorgehensweise des V-Modells wurden Anforderungen definiert, welche während der Arbeiten am Projekt des Escape Games erfüllt werden sollen.

Die Anforderungen wurden in folgende Kapitel untergliedert und in Tabelle 1 festgehalten:

• Hardware
• Komponententest
• Software
• Programmierung
• Dokumentation

Tabelle 1: Anforderungsliste Kugel-Balancierer

ID	Typ (I = Info, A = Anforderung)	Kapitel	Inhalt	Ersteller	Datum	Status Auftragnehmer
10	I	1	Hardware
11	A		Die Sensoren und Aktoren müssen mit dem Arduino verbunden sein.	Block	02.10.2025	Ausstehend
12	A		Die Außenmaße des Kugel-Balancierers müssen kleiner als 358,02 x 250 x 250 mm sein.	Block	02.10.2025	Ausstehend
13	A		Die konstruierten Bauteile sollen mittels 3D-Druck hergestellt werden, wobei der Anteil des für Stützstrukturen verwendeten Filaments weniger als 10 % des gesamten Filamentverbrauchs betragen darf.	Block	02.10.2025	Ausstehend
20	I	2	Komponententest
21	A		Die Verdrahtung der elektronischen Komponenten mit dem Mikrocontroller muss mit dem Verdrahtungsplan überstimmen.	Engelhardt	02.10.2025	Ausstehend
22	A		Der Distanzsensor muss die Distanz zum Ball in einem Bereich von 3 bis 30 cm messen können.	Engelhardt	02.10.2025	Ausstehend
23	A		Der Distanzsensor muss eine Abtastrate von mindestens 20 Hz haben.	Engelhardt	02.10.2025	Ausstehend
24	A		Der Servomotor muss die Schiene von der Mittelstellung aus um mindestens 3 cm nach oben und 3 cm nach unten bewegen können.	Engelhardt	02.10.2025	Ausstehend
30	I	3	Software
31	A		Die Programmierung des Mikrocontrolleralgorithmus muss durch die MATLAB/Simulink Software in der Version 2024b erfolgen.	Engelhardt	02.10.2025	Ausstehend
32	A		Der Mittelpunkt der Schiene muss mit einer Kalibrierfunktion einstellbar sein.	Engelhardt	02.10.2025	Ausstehend
33	A		Die Gewinnkondition muss erreicht werden, wenn der Ball für 5 Sekunden in der Mitte der Schiene (± 1,5 cm) balanciert wird.	Engelhardt	02.10.2025	Ausstehend
34	A		Der Code für das nächste Rätsel muss bei Erreichen der Gewinnkondition auf dem Display angezeigt werden.	Engelhardt	02.10.2025	Ausstehend
40	I	4	Programmierung
41	A		Der Servomotor muss mit einem PWM-Signal angesteuert werden.	Block	02.10.2025	Ausstehend
42	A		Eine Funktion zur Filterung falscher Messwerte muss in den Algorithmus implementiert werden.	Block	02.10.2025	Ausstehend
43	A		Das PWM-Signal für den Servomotor muss von einem PID-Regler berechnet werden	Block.	02.10.2025	Ausstehend
44	A		Die P-, I- und D-Anteile des Reglers müssen in Echtzeit über Drehregler einstellbar sein.	Block	02.10.2025	Ausstehend
45	A		Die aktuellen Werte für die P-, I- und D-Anteile des Reglers müssen auf einem Display angezeigt werden.	Block	02.10.2025	Ausstehend
50	I	5	Dokumentation
51	A		Alle Softwarekomponenten müssen einen Header besitzen.	Engelhardt	02.10.2025	Ausstehend
52	A		Ein Wiki-Artikel muss nach Anleitung fertiggestellt werden.	Engelhardt	02.10.2025	Ausstehend
53	A		Die angefertigten CAD-Modelle und Programmdaten müssen in SVN hochgeladen werden.	Engelhardt	02.10.2025	Ausstehend

Materialliste

Tabelle 2: Materialliste

Nr.	Anz.	Komponente	Beschreibung
1	1	Funduino Mega	Microcontroller
2	1	Sharp GP2Y0A41SK0F	Distanzsensor
3	1	MG996R	Servomotor
4	3	KY-040	Drehregler
5	1	I602 I2C LCD Modul	Display
6	1	Taster	Taster
7	1	Reely Kugellager 3mm	Kugellager für Schiene
8	1	Gehäuse	3D-Druck Gehäuse
9	2	Gabelkopf	Gabelkopf mit M3 Gewinde für Koppelstange
10	1	M3 Gewindestange	M3 Gewindestange für Koppelstange
11	1	Netzteil	9V, 30W Netzteil
12	1	Diverse Verdrahtungsadern	Zum Verbinden der Komponenten
13	1	Diverse Schrauben	Zum Zusammenbauen der Komponenten

Funktionaler Systementwurf

In der folgenden Abbildung 2 ist der funktionalen Systementwurf des Kugel-Balancierers dargestellt. Die mechanischen Elemente werden aus Holz bzw. mittels 3D-Druck erstellt. Mittels Servomotor kann der Drehwinkel einer Drehscheibe (Stellgröße) verändert werden, um die Laufbahn der zu balancierenden Kugel (in gelb dargestellt) zubewegen. An einer Seite der Laufbahn befindet sich ein Infrarot Distanzsensor, um die aktuelle Position dieser Kugel auf der Laufbahn zu erfassen, welche ebenfalls die Regelgröße des Systems darstellt. Diese soll durch einen auf dem Mikrocontroller (hier Arduino MEGA) ausgeführten PID Regler geregelt werden. Um das Escape Game zu starten und die P-, I- und D-Anteile des Reglers über die drei Rotary Encoder einzustellen, muss das System über den seitlichen Schalter eingeschaltet werden. Bei Erfolg wird ein Code über den Display ausgegeben.

Abb. 2: Funktionaler Systementwurf des Balancierers

Technischer Systementwurf

Als technischer Systementwurf für das Projekt wurde der folgende Verdrahtungsplan erstellt (siehe Abbildung 3). In diesem sind alle elektronischen Bauteile des Balancierers sowie deren Verdrahtung mit dem Mikrocontroller dargestellt.

Abb. 3: Technischer Systementwurf des Balancierers

Komponentenspezifikation

Servomotor

Der MG996R ist ein leistungsstarker Servomotor, der präzise Positionsbewegungen ausführen kann. Er wandelt PWM-Signale in eine definierte Drehstellung in Grad um und hält diese Position durch ein internes Rückkopplungssystem. Durch sein hohes Drehmoment ist der Servo in der Lage, die Wippe des Balancierers ohne Probleme zu bewegen.

• Betriebsspannung: 4,8 bis 7,2 V
• Stellkraft: 11 kg/cm bei 6,0 V
• Metallgetriebe
• 3 Pins (VCC,GND,PWM)

Infrarot-Distanzsensor

Der Sharp GP2Y0A41SK0F ist ein optischer Infrarot-Abstandssensor, der die Entfernung eines Objekts im Bereich von etwa 4 bis 30 cm messen kann. Das Messprinzip des Sensors beruht auf dem Aussenden eines Infrarotlichtstrahls mittels Infrarot LED, welcher von einem sich im Messbereich des Sensors befindlichen Objekt reflektiert und vom Detektor des Sensors (PSD, position sensitive detector) erneut aufgenommen und ausgewertet wird. In Abbildung 4 ist der Messaufbau des Distanzsensors zur Verdeutlichung dargestellt. Eine resultierende Ausgangsspannung des Sensors kann beispielhaft mithilfe der Kennlinie aus dem Sensordatenblatt (siehe Abbildung 5) in einen Abstand zum Objekt in cm umgerechnet werden, im weiteren Verlauf des Projekts wird jedoch eine eigene Sensorkalibrierung an verschiedenen Messpunkten durchgeführt.

• Betriebsspannung: 4,5 bis 5,5 V
• Messbereich: 4 bis 30 cm
• Abtastrate: ca. 60 Hz
• Pinbelegung: 3 Pins (VCC,Vo,GND)

Abbildung 4: Messaufbau des Sharp IR GP2Y0A41SK0F [1]

Abbildung 5: Sensorkennlinie Sharp IR GP2Y0A41SK0F: Objektabstand in Abhängigkeit der Ausgangsspannung [2]

Drehgeber

Bei den für das Projekt verwendeten Drehgebern zur Einstellung der PID-Anteile handelt es sich um die KY-040 rotary encoder. Deren wesentliche Merkmale sind nachfolgend aufgelistet:

• Betriebsspannung: 5V
• 20 Pulse pro 360° Umdrehung
• kontinuierlich drehbar
• 5 Pins (CLK,DT,Switch,VCC,GND)

Anhand der Pins CLK, DT und GND kann die Drehrichtung des Drehgebers bestimmt werden. Liegt zuerst ein High-Signal an den Pins CLK und GND an, handelt es sich um eine Drehung im Uhrzeigersinn. Wird jedoch zuerst das High-Signal zwischen den Pins DT und GND erkannt, liegt eine Drehung im Gegenuhrzeigersinn vor. [3]

LCD-Display

Als Display zur Ausgabe von bspw. Nutzeranweisungen wird ein 1602 I2C LCD Modul mit HD44780 eingesetzt. Dieses besitzt die folgenden Eigenschaften:

• Betriebsspannung: 5V
• Pinbelegung: 4 Pins (VCC, GND, SDA, SCL)
• Display besitzt blaue Hintergrundbeleuchtung und weiße Schrift
• 2 Zeichenreihen mit 16 Zeichen pro Reihe auf Display
• verlötetes I2C HD44780 Modul

Umsetzung (HW/SW)

Hardware-Umsetzung

Gehäuseentwicklung

Die Entwicklung des Gehäuses begann mit einer ersten Skizze des möglichen Aufbaus. Im Mittelpunkt stand dabei der Kippmechanismus der Schiene in Kombination mit dem Servomotor. Daher wurde zunächst dieser zentrale Mechanismus konzipiert und anschließend das restliche Gehäuse darum herum konstruiert.

Die nachfolgende Abbildung zeigt die ursprüngliche Skizze des Kugel-Balanciers, welche als Grundlage für die weitere Entwicklung des CAD-Modells diente.

Abbildung 6: Skizze des Kugel-Balancierer

Die Schiene besitzt eine Länge von 30 cm, wobei sich ihr Drehpunkt exakt in der Mitte befindet. Schiene und Servomotor sind über eine Verbindungsstange miteinander gekoppelt. Der Anschlusspunkt dieser Verbindungsstange liegt 7,5 cm vom Drehpunkt der Schiene entfernt, während die Stange selbst 7 cm lang ist. Die Verbindungsstange wird über einen Servoarm mit dem Servomotor verbunden. Der Abstand zwischen dem Drehpunkt des Servos und der Anbindung der Verbindungsstange beträgt dabei 2,5 cm. In der Neutralstellung des Servos befindet sich die Schiene waagerecht, während die Verbindungsstange senkrecht steht. Alle genannten Maße wurden im Rahmen der Gehäuseentwicklung berücksichtigt.

Die nachfolgende Abbildung zeigt die vollständige Baugruppe des Kugel-Balanciers.

Abbildung 7: Kugel-Balancierer Baugruppe

Ein zentraler Gedanke bei der Entwicklung des Gehäuses für den Kugel-Balancierer war ein modularer Aufbau. Das bedeutet, dass die Baugruppe aus mehreren einzelnen Komponenten besteht, die zusammen das Gesamtmodell bilden. Dadurch wird gewährleistet, dass einzelne Bauteile leicht ausgetauscht werden können und jederzeit ein einfacher Zugang zu allen wichtigen Komponenten möglich ist.

Die Wandstärke der Bauteile beträgt in den meisten Fällen 3 mm, ein guter Kompromiss zwischen Stabilität und Materialverbrauch. Im Folgenden werden die einzelnen Komponenten sowie deren Zusammenspiel näher beschrieben. Die entsprechenden Abbildungen finden sich im Anschluss an diesen Abschnitt.

Grundmodell

Das Gehäuse basiert zunächst auf dem Grundmodell, welches als Bodenplatte für das gesamte System dient und gleichzeitig mehrere Befestigungspunkte bereitstellt. Dazu gehört unter anderem der Servomotor, der direkt auf der Bodenplatte verschraubt wird. Zusätzlich ist auf der Grundplatte die von uns entwickelte Stecker-Platine befestigt.

Für den Einschub der Hauptplatine ist ein Schienenmechanismus integriert. Weitere Informationen zu den Platinen folgen im Unterkapitel „Platinenentwicklung“. Ebenfalls auf der Bodenplatte befindet sich der Verbindungsturm, der den Drehpunkt für die Schiene bildet.

Hauptgehäuse

Die nächste Komponente ist das Hauptgehäuse, das die äußere Hülle bildet und mit vier M3-Schrauben auf der Bodenplatte befestigt wird. Auch hier sind wieder verschiedene Bauteile integriert:

Das LCD-Display, das in einem ergonomischen Winkel angebracht ist, um ein komfortables Ablesen zu ermöglichen.

Drei Drehgeber sowie ein zusätzlicher Taster, die gemeinsam in einer Reihe unterhalb des Displays angeordnet sind.

Das Hauptgehäuse ist an beiden Seiten sowie auf der Rückseite offen. Diese Öffnungen werden mit separaten Seitenteilen verschlossen, die mithilfe von Neodym-Magneten befestigt werden. Dazu werden die Magnete sowohl im Hauptgehäuse als auch in den Seitenteilen eingesetzt. Diese modulare Bauweise ermöglicht einen besonders einfachen Zugang zum Innenraum. Über die rechte Seitenwand kann zudem direkt auf die Hauptplatine zugegriffen werden.

Schiene

Eine weitere zentrale Komponente ist die Schiene, auf der die Kugel balanciert wird. Diese ist über den Drehpunkt mit der Grundplatte verbunden, wobei ein Kugellager im Drehpunkt für eine reibungslose und spielfreie Bewegung sorgt.

Für den Neigungsmechanismus ist die Schiene über eine M3-Gewindestange mit dem Servomotor gekoppelt. An beiden Enden der Gewindestange befinden sich Gabelköpfe, welche die Verbindung zu Schiene und Servoarm herstellen.

Auf der Schiene ist außerdem ein IR-Abstandssensor montiert. Dafür wurde ein eigenes Sensorgehäuse entwickelt, das über Befestigungslöcher direkt mit der Schiene verschraubt wird. Auf der gegenüberliegenden Seite befindet sich eine Abdeckung, die einen statischen Hintergrund für den Sensor erzeugt. Beide Bauteile, Sensorgehäuse und Sensorabdeckung, werden im Abschnitt „Komponententest des IR-Sensors“ ausführlich erläutert, da sie aufgrund ihrer speziellen Ausgestaltung eine optimale Funktion des Sensors unterstützen.

Im Folgenden werden Bilder der einzelnen Komponenten gezeigt: Die nachfolgende Abbildung zeigt die vollständige Baugruppe des Kugel-Balanciers.

Abbildung 8: Grundplatte Kugel-Balancierer	Abbildung 9: Hauptgehäuse des Kugel-Balancierers	Abbildung 10: Rechte Wand des Kugel-Balancierers
Abbildung 11: Linke Wand des Kugel-Balancierers	Abbildung 12: Hintere Wand des Kugel-Balancierers	Abbildung 13: Schiene des Kugel-Balancierers
Abbildung 14: Hauptgehäuse des Abstandsensors für den Kugel-Balancierer	Abbildung 15: Rückplatte des Abstandsensors für den Kugel-Balancierer	Abbildung 16: Schienen Abdeckung für den Kugel-Balancierer

Platinenentwicklung

Der Kugel-Balancierer benötigt einen Mikrocontroller, um die Sensoren und Aktoren ansteuern zu können und die erforderlichen Regelungsberechnungen durchzuführen. Wir haben uns für die Nutzung eines Arduino Mega 2560 entschieden, da dieser ausreichend Rechenleistung sowie genügend Ressourcen bietet. Allerdings wollten wir nicht das vollständige Arduino-Mega-Entwicklungsboard verwenden, da die Vielzahl an Header-Pins für unser Projekt nicht benötigt wird. Zudem bieten Steckverbindungen über klassische Pin-Header keine dauerhafte, zuverlässige Lösung und sind eher für erste Prototypen geeignet. Aus diesem Grund entschieden wir uns, eine eigene Hauptplatine zu entwickeln, auf der sich unser Mikrocontroller befindet.

Um weiterhin vollständige Kompatibilität mit dem Arduino-Framework – und damit auch die modellbasierte Programmierung mit Simulink – sicherzustellen, haben wir die wesentlichen Komponenten des Arduino Mega 2560 übernommen. Unser Mikrocontroller ist daher ein ATmega2560, ergänzt durch den originalen ATmega16U2 als USB-zu-Serial-Schnittstelle. Eine Verbesserung, die sich aus der Eigenentwicklung ergab, war die Integration eines USB-C-Anschlusses anstelle des klassischen USB-B-Ports zur Programmierung des Boards.

Für die Entwicklung des Schaltplans in Multisim und der Platinenlayouts in Ultiboard dienten die originalen Arduino-Mega-2560-Rev3-Schaltpläne als Vorlage. Das Ergebnis ist eine kompakte Hauptplatine, die funktional einem Arduino-Mega-Board entspricht, jedoch ohne die Vielzahl an Pin-Headern auskommt.

Stecker-Platine

Um die Sensoren und Aktoren bequem mit der Hauptplatine verbinden zu können, entwickelten wir zusätzlich eine zweite Platine, die im Folgenden als Stecker-Platine bezeichnet wird. Die Verbindung zwischen beiden Platinen erfolgt über eine Einschubführung und eine Kombination aus Pin-Header und Buchsenleiste. Eine schematische Darstellung des Systems zeigt die folgende Abbildung.

Abbildung 17: Platinen des Kugel-Balancierers

Da wir beide Platinen selbst entwickeln konnten, waren wir in der Lage, die Abmessungen optimal an das vorhandene Gehäuse anzupassen und den Innenraum bestmöglich auszunutzen.

Die Stecker-Platine übernimmt neben der Signalverteilung zusätzlich die Spannungsversorgung. Der Kugel-Balancierer wird mit einem 9-Volt-Netzteil betrieben, während die Elektronik – insbesondere Hauptplatine, Sensoren und Aktoren – eine Versorgungsspannung von 5 Volt benötigt. Aus diesem Grund befindet sich auf der Stecker-Platine ein integrierter Spannungswandler mit den zugehörigen Kondensatoren und einer Schutzdiode.

Da der Servomotor kurzfristig hohe Ströme benötigt und dadurch Spannungsschwankungen verursachen kann, wurden zusätzlich spezielle Entstörmaßnahmen implementiert. Dazu zählen groß dimensionierte Elektrolytkondensatoren in unmittelbarer Nähe des Servo-Anschlusses sowie kleine Keramikkondensatoren direkt am Anschluss des IR-Abstandssensors. Diese Maßnahmen verhindern Störungen im Sensorsignal.

Die Stecker-Platine liefert somit die 5-Volt-Versorgung für die Hauptplatine. Alternativ kann das System über den USB-C-Anschluss gespeist werden; jedoch dürfen USB-C-Versorgung und 9-Volt-Netzteil nicht gleichzeitig angeschlossen sein.

Im Anschluss folgen die Schaltpläne sowie die Layout-Darstellungen der beiden Platinen.

Abbildung 18: Multisim Schaltplan der Kugel-Balancierer Hauptplatine Seite 1	Abbildung 19: Multisim Schaltplan der Kugel-Balancierer Hauptplatine Seite 2	Abbildung 20: Platinenlayout der Kugel-Balancierer Hauptplatine
Abbildung 21: Multisim Schaltplan der Kugel-Balancierer Stecker-Platine	Abbildung 22: Platinenlayout der Kugel-Balancierer Stecker-Platine

Aus Ultiboard wurden anschließend die erforderlichen Gerber-Dateien exportiert, auf deren Basis die Platinen gefertigt werden konnten. Die Produktion erfolgte beim chinesischen Leiterplattenhersteller JLCPCB. Parallel dazu wurden verschiedene elektronische Komponenten bestellt.

Ein Großteil der benötigten Bauteile wurde jedoch von einem originalen Arduino Mega 2560 Rev3 ausgelötet und wiederverwendet, um Kosten zu sparen und eine vollständige Kompatibilität sicherzustellen.

Komponententest

Im folgenden wird die Funktion der einzelnen mechatronischen Hauptkomponenten des Kugel Balancierers in Simulink getestet. Dabei wurden die notwendigen Bibliotheken und Support Packages heruntergeladen und verwendet.

Servomotor

Zur Nutzung des Servomotors wurde das "Simulink Support Package for Arduino Hardware" verwendet. Dieses Paket stellt den Simulink Block "Standard Servo Write" zur Verfügung, welcher über eine Konstante im Bereich von 0 bis 180° angesteuert wird. Dieser Block erzeugt dann ein PWM-Signal am ausgewählten digitalen PWM-Pin (hier Pin 9, siehe Abbildung 23), um den Servowinkel zu verstellen.

Abbildung 23: Testmodell Servomotor Simulink

Im verbauten Zustand wurden verschiedene Stellungen des Servomotors im Bereich von 0 bis 180° getestet. Außerdem konnte festgestellt werden, dass sich die Wippe bei 95° in einer ausbalancierten Stellung befindet.

Drehgeber / Taster

Um die Drehgeber auszulesen, wurde erneut ein Simulink-Block "Digital Input Pin" des Arduino Support Packages in einem Testmodell verwendet und ausgelesen werden (siehe Abbildung 24 & 25).

Abbildung 25: Testmodell der Drehgeber

Abbildung 26: Testmessung der Drehgeber

Leider musste während des Komponententests der Drehgeber festgestellt werden, dass die im Simulink-Modell eingestellte und für die Ausführung des PID-Reglers benötigte Schrittdauer zu hoch ist, um die Drehgeber verlässlich auszulesen. Drehungen der Drehgebern konnten oftmals nicht erfasst werden oder wurden übersprungen. Somit wurde sich dafür entschieden, statt der Drehgeber drei Kipptaster zu verwenden. Diese konnten 1:1 gegen die Drehgeber ausgetauscht und im Testszenario verlässlich ausgelesen werden, ohne Betätigungen zu überspringen. Nachfolgend ist eine Messung der Taster in Abbildung 27 dargestellt.

Abbildung 27: Testmessung der Kipptaster

IR-Sensor

Um den Infrarotsensor zur Distanzmessung nutzen zu können, muss zuerst eine Kalibrierung des Sensors durchgeführt werden. Dabei wurde die Spannung an verschiedenen Messpunkten auf der Schiene des Kugelbalanciers gemessen, indem die Kugel in 1-cm-Schritten von 3 cm bis 28 cm auf der Schiene positioniert wurde. Hier traten jedoch Probleme auf, da die Position der Kugel nicht zuverlässig erfasst werden konnte. Durch konstruktive Maßnahmen (siehe Abbildung 14 bis 16) konnte die Zerstreuung des Infrarotlichts maßgeblich reduziert werden. Die Messpunkte konnten dann in einer Lookup-Tabelle in Simulink verarbeitet werden. Anhand der Ausgangsspannung des Sensors kann dadurch die aktuelle Distanz bestimmt werden. Die Messwerte sind der folgenden Tabelle zu entnehmen.

Kalibrierung des IR-Sensors

Entfernung in cm	Spannung in V
3	2.341
4	2.268
5	2.243
6	2.048
7	1.799
8	1.623
9	1.461
10	1.31
11	1.207
12	1.109
13	1.031
14	0.9677
15	0.9189
16	0.8553
17	0.8162
18	0.7771
19	0.7331
20	0.694
21	0.6745
22	0.6354
23	0.5914
24	0.567
25	0.5474
26	0.53
27	0.51
28	0.4888

Anschließend wurde eine Sprungantwort des Systems und die Distanz der Kugel ausgemessen. Bei einer Neigung der Wippe um 2° konnte die folgende Messung in Abbildung erfolgreich durchgeführt werden:

Abb. 25: Sprungantwort des Kugel-Balancierers

LCD-Display

Zum Auslesen des Displays wurde eine Arduino Bibliothek in Verbindung mit dem I/O-Device Builder genutzt. Der genutzte Code befindet ist in Kapitel 7.4.7 LCD-Steuerung dargestellt. Mithilfe des I/O-Device Blocks können Arduino Bibliotheken in Kombination mit C/C++ Code genutzt werden. So kann eine normale Textausgabe auf dem 16x2 LCD-Display mithilfe des C++-Befehls "lcd.print()" ausgegeben werden. Mithilfe des Befehls "lcd.clear()" kann der Text auf dem Display gelöscht und mit "lcd.setCursor()" kann die Stelle des Displays ausgewählt werden, an der der Text geschrieben werden soll. Mithilfe des I/O-Device Builders, der Arduino Bibliothek und dieser Befehle konnte das Display so erfolgreich getestet werden.

Reglerauslegung

Der Kugel-Balancierer stellt ein klassisches Beispiel für ein instabiles System der Regelungstechnik dar. Im Gegensatz zu stabilen Systemen, wie etwa einer Temperaturregelung, erreicht die Kugel ohne aktiven Regeleingriff keinen statischen Endwert. Da die Erdbeschleunigung in Form der Hangabtriebskraft konstant auf die Kugel wirkt, resultiert daraus ein sogenanntes I2-Verhalten (Doppelintegrator). Physikalisch lässt sich dies dadurch erklären, dass die Position der Kugel das zweifache Zeitintegral der Beschleunigung ist: Die erste Integration führt von der Beschleunigung zur Geschwindigkeit, während die zweite Integration die zurückgelegte Distanz liefert.

Um dieses Verhalten mathematisch für eine Simulation in Simulink abzubilden, muss die Regelstrecke experimentell identifiziert werden. Hierzu wird eine Sprungantwort aufgenommen, indem der Servomotor im offenen Regelkreis auf einen festen Winkel gestellt wird. In diesem spezifischen Versuch wurde ein Winkel von 85° gewählt, was bei einer definierten Mittelstellung von 95° einer Neigung von Δα = 10∘ entspricht. Während die Kugel die Schiene entlangrollt, zeichnet ein Distanzsensor die Position kontinuierlich auf. Die folgende Abbildung zeigt die Messung.

Abb. 3: Technischer Systementwurf des Balancierers

Die Auswertung dieser Messdaten erfolgt über ein mathematisches Modell, bei dem ein Polynom zweiten Grades ($x(t)=p1\cdot t^2+p2\cdot t+p3$​) an die Messkurve angepasst wird. Der Koeffizient $p1$​ dieses Polynoms entspricht dabei dem physikalischen Term $\frac{1}{2}a$. Durch einfaches Umstellen lässt sich somit die reale Beschleunigung $a$​ bestimmen. Um die für die Übertragungsfunktion $G(s)=\frac{K}{s^2}$ benötigte Streckenverstärkung $K$​ zu ermitteln, wird die berechnete Beschleunigung durch den Eingangssprung dividiert. Dabei muss man den Neigungswinkel von Grad in Radiant umzurechnen. Der folgende Programmcode zeigt die Berechnung von dem K-Faktor aus der Sprungantwort mit der polyfit Funktion in Matlab:

clear; close all; clc
%**************************************************************************
%                   Hochschule Hamm-Lippstadt                             *
%**************************************************************************
% Modul	          : K_Faktor_Bestimmung.m                                 *
%                                                                         *
% Datum           : 01.01.2026                                            *
%                                                                         *
% Funktion        : Dieses Skript berechnet den K-Faktor für die          *  
%                   Übertragungsfunktion des Kugel-Balancierers basierend *
%                   auf der Sprungantwort                                 *
%                                                                         *
% Implementation  : Matlab R2024b                                         *
%                                                                         *
% Toolbox         :                                                       *
%                                                                         *
% Author          : Kilian Engelhardt, Daniel Block                       *
%                                                                         *
% Bemerkung       :                                                       *
%                                                                         *
% Letzte Änderung : 01 Jan 2026                                           *
%                                                                         *
%**************************************************************************
% Laden der Messdaten
load("Regelstrecke_10.mat")

% Zeit- und Positionsdaten aus dem timeseries-Objekt extrahieren
t_raw = Regelstrecke_10.Time;
x_raw = Regelstrecke_10.Data;

% Den relevanten Zeitraum isolieren (Bereich, in dem die Kugel rollt)
index = find(t_raw >= 10 & t_raw <= 11.36);
t_crop = t_raw(index);
x_crop = x_raw(index);

% Daten normieren: Zeit und Weg bei 0 starten lassen
t_fit = t_crop - t_crop(1); 
x_fit = x_crop - x_crop(1);

% Mathematische Modellbildung: Polynom 2. Grades an die Messdaten fitten (Parabel)
% p(1) ist der Koeffizient vor t^2, p(2) vor t, p(3) ist die Konstante
p = polyfit(t_fit, x_fit, 2);

% Physikalische Beschleunigung berechnen (Umkehrung von s = 1/2 * a * t^2)
a_messung = 2 * p(1);

% Rekonstruktion der Kurve basierend auf dem Fit für den grafischen Vergleich
x_rekonstruiert = polyval(p, t_fit);

% Ergebnissdarstellung
figure;
plot(t_fit, x_fit, 'bo', 'DisplayName', 'Messdaten'); hold on; % Originaldaten als Punkte
plot(t_fit, x_rekonstruiert, 'r-', 'LineWidth', 2, 'DisplayName', 'Parabel-Fit'); % Fit als Linie
xlabel('Zeit [s]');
ylabel('Weg [cm]');
legend;
title(['Beschleunigung a = ', num2str(a_messung), ' cm/s^2']);

% Berechnung der Streckenverstärkung K für die Regelstrecke
winkel_deg = 10; % Eingestellter Sprungwinkel in Grad
winkel_rad = winkel_deg * (pi/180); % Umrechnung in Radiant für die Übertragungsfunktion

% Bestimmung des K-Faktors
K_identifiziert = a_messung / winkel_rad;

Der berechnete k-Faktor beträgt 188,87 und wurde mithilfe des entsprechenden Skripts ermittelt. Die Übertragungsfunktion zur Simulation des Kugel-Balancierers lautet somit $G(s)=\frac{188,87}{s^2}$ Mit dieser Übertragungsfunktion kann nun ein Regler implementiert und getestet werden. Zu diesem Zweck wurde ein Simulink-Modell aufgebaut, das in der folgenden Abbildung dargestellt ist.

Abb. 3: Technischer Systementwurf des Balancierers

Die Regelparameter wurden mit diesem Modell variiert und getestet. Mit den Werten für Kp = 2, Ki = 0,2 und Kd = 0,4 entsteht folgende Regelung.

Abb. 3: Technischer Systementwurf des Balancierers

Man erkennt, dass der Regler den gewünschten Sollwert am Ende erreicht. Somit kann diese Parameterkombination als geeignet angesehen werden, um das Ziel des Kugel Balancierers das erfolgreiche Halten der Kugel in der Mitte zu erreichen.

Software-Umsetzung

Als erster Schritt zur Umsetzung der Software wurde ein Programm-Ablaufplan (siehe Abbildung 23) erstellt, um die benötigten Funktionen des zu erstellenden Algorithmus schrittweise festzulegen. Nach einer Initialisierung des Systems wird die Hauptschleife des Programms ausgeführt. Zu Beginn der Schleife wird die Messspannung des IR-Sensors ausgelesen werden, um diese in eine Distanz zur Kugel umrechnen zu können. Anhand der berechneten Distanz wird die Abweichung der Kugel zur Wippenmitte bestimmt (Regelfehler). Als nächstes sollen die an den Drehgeber bzw. Taster eingestellten Parameter des PID-Reglers werden ausgelesen und auf dem Display ausgegeben werden. Der Regler berechnet dann die Stellgröße (Servowinkel), welche über ein PWM-Signal den Servomotors ansteuert und die der Wippe bewegt. Zulsetzt sorgt eine Bedingung dafür, dass eine Win-Kondition beim Halten der Kugel in der Mitte der Wippe für 5 Sekunden ausgelöst und der Gewinncode auf dem Display ausgegeben wird.

Abbildung 23: Programm-Ablaufplan des Kugel-Balancierers

Das Simulink-Modell für den Kugel-Balancierer ist in mehrere Subsysteme aufgebaut, welche jeweils eine bestimmte Aufgabe übernehmen. Dieser Aufbau dient der Strukturierung der Programmierung und fördert die Wartbarkeit des Programms. Die Subsysteme wurden zuerst einzeln getestet, um anschließend die Funktion des Gesamtsystems testen zu können. Die folgende Abbildung zeigt das Gesamtmodell des Kugel-Balancierers.

Abbildung 24: Hauptmodell des Kugel-Balancierers

Das Modell ist in die folgenden Subsysteme aufgeteilt:

• Tasterbestimmung
• Sollwert-Modus-Bestimmung
• Distanzbestimmung
• Regler
• Spielstatus
• Servosteuerung
• LCD-Steuerung

Im Folgenden werden die einzelnen Subsysteme genauer erläutert. Dabei ist zu beachten, dass der Block LCD-Steuerung kein klassisches Subsystem ist, sondern ein selbst erstellter Block, der mithilfe des IO Device Builders erzeugt wurde.

Tasterbestimmung

Abbildung 25: Tasterbestimmung Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Tasterbestimmung-Subsystem des Kugel-Balancierers. Dieses Modell wertet die Signale der Kipptaster aus, um damit die Reglerparameter zu steuern. Die Idee hinter diesem Modell ist es, einen Zähler zu implementieren, der seinen Wert erhöht, wenn der Kipptaster nach oben gedrückt wird, und verringert, wenn der Taster nach unten gedrückt wird. Zunächst werden die Signale der Taster über einen digitalen Eingang in Simulink eingelesen. Anschließend werden die Signale auf eine positive Flanke überprüft. Dadurch wird sichergestellt, dass der Zählerwert nur um eins erhöht oder verringert wird, auch wenn der Taster gedrückt gehalten wird. Das bedeutet, dass der Detect-Block bei gedrücktem Taster nur für einen Zyklus ein Signal mit dem Wert 1 ausgibt. Die Signale des Kipptasters werden anschließend addiert, wobei der Taster nach unten einen Wert von −1 besitzt. Da das resultierende Signal nur für einen Zyklus anliegt, wird ein Integrator-Block verwendet, der als Zähler fungiert. Zum Schluss werden die einzelnen Parameter durch einen voreingestellten Wert dividiert, um die finalen Reglerparameter auszugeben.

Sollwert-Modus-Bestimmung

Abbildung 26: Sollwert-Modus-Bestimmung Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Sollwert-Modus-Bestimmung-Subsystem des Kugel-Balancierers. Dieses Modell liest den Taster aus und implementiert sowohl die Funktionalität zur Sollwertkalibrierung als auch zur Bestimmung des Betriebsmodus. Der Kugel-Balancierer regelt die Kugel in die Mitte der Schiene. Abhängig von äußeren Einflüssen, wie beispielsweise Lichtverhältnissen, kann es jedoch vorkommen, dass der voreingestellte Sollwert nicht mit dem tatsächlich gemessenen Mittelpunktabstand übereinstimmt. Aus diesem Grund besteht die Möglichkeit, die Mittelpunktdistanz zu kalibrieren. Hierfür wird ein Taster verwendet. Wird dieser weniger als drei Sekunden gedrückt, so wird der Betriebsmodus gewechselt. Dabei wird vom Regelmodus in den Kalibriermodus übergegangen. Im Kalibriermodus fährt die Schiene auf einen definierten Winkel. Mithilfe der Kalibrierhilfe kann die Kugel anschließend exakt in der Mitte gehalten werden. Wird der Taster nun für mindestens drei Sekunden gedrückt, so wird die aktuell gemessene Distanz ausgelesen und als neuer Sollwert gespeichert. Durch dieses Vorgehen kann der Kugel-Balancierer zuverlässig auch unter unterschiedlichen äußeren Einflüssen betrieben werden.

Distanzbestimmung

Abbildung 27: Distanzbestimmung Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Distanzbestimmung-Subsystem des Kugel-Balancierers. Dieser Block liest die Ausgangsspannung des Sharp-IR-Sensors ein. Dabei handelt es sich um einen Analogwert im Bereich von 0 bis 1023. Zunächst wird dieser Wert in eine entsprechende Spannung umgerechnet. Anschließend wird mithilfe der Sensorkennlinie und der gemessenen Spannung die Distanz bestimmt. Die Sensorkennlinie wurde zuvor experimentell eingemessen und in Simulink mithilfe einer Lookup-Tabelle realisiert. Die zugehörigen Kennlinienwerte wurden bereits im Kapitel Komponentenspezifikation des Sensors behandelt. Zusätzlich wird das Distanzsignal gefiltert, um ein sauberes und störungsarmes Signal für die Regelung bereitzustellen. Hierfür kommen ein Medianfilter sowie ein Tiefpassfilter zum Einsatz. Der Medianfilter dient der Eliminierung von Ausreißern, da der Sharp-IR-Sensor zu systematischen Messausreißern neigt. Zur Glättung des Signals wird anschließend ein Tiefpassfilter verwendet. Der Alpha-Parameter des Tiefpassfilters wurde experimentell mithilfe einer Open-Loop-Simulation bestimmt.

Regler

Abbildung 28: Regler Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Regler-Subsystem des Kugel-Balancierers. Dieses System ist als klassischer Regelkreis aufgebaut. Zu Beginn wird die Regelabweichung aus dem Sollwert und der aktuellen Distanz berechnet. Diese Regelabweichung wird anschließend dem Regler zugeführt, der anhand der drei Reglerparameter einen Stellwert berechnet. Die Reglerparameter werden über das Tasterbestimmung-Subsystem gesetzt und können während des Betriebs verändert werden. Nach der Berechnung des Stellwerts wird der Winkel der Mittelstellung addiert, da der Servo im Bereich von 0° bis 180° angesteuert wird. In der Theorie entspricht die Mittelstellung einem Winkel von 90°. Aufgrund des mechanischen Aufbaus liegt die tatsächliche Mittelstellung jedoch bei 95°. Abschließend wird der Ausgang auf die zulässigen Endwerte begrenzt. Zusätzlich wird eine Begrenzung der Änderungsrate implementiert, da der Servo nicht unendlich schnell reagieren kann.

Spielstatus

Abbildung 29: Spielstatus Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Spielstatus-Subsystem des Kugel-Balancierers. Dieses System überwacht den aktuellen Spielstatus. Ziel des Kugel-Balancierers ist es, die Kugel für eine bestimmte Zeit in der Mitte der Schiene zu halten. Ist die Regelabweichung kleiner oder gleich 0,3 cm, zählt ein Integrator-Block hoch. Erreicht der Integrator-Block einen Wert von fünf Sekunden, wird der Spielstatus auf Sieg gesetzt und das Display gibt den Gewinncode aus. Befindet sich die Kugel auch nur kurzzeitig außerhalb der Toleranz von 0,3 cm, wird der Integrator-Block zurückgesetzt, sodass die Zeitmessung erneut beginnt.

Servosteuerung

Abbildung 30: Servo_Steuerung Subsystem des Kugel-Balancierers

Die vorherige Abbildung zeigt das Servo-Steuerung-Subsystem des Kugel-Balancierers. Dieses Modell erhält einen Servowinkel als Eingang und steuert damit den Servo an. Im Normalfall wird der Servowinkel vom Regler vorgegeben. Soll jedoch der Sollwert kalibriert werden, wird nicht der vom Regler berechnete Winkel verwendet, sondern ein fester Winkel von 85° eingestellt. Dadurch kann die Kugel mithilfe der Kalibrierhilfe in der Mitte gehalten werden, sodass der neue Sollwert eingestellt werden kann.

LCD-Steuerung

Der folgende Programmcode zeigt die LCD_Steuerung des Kugel-Balancierers. Dieser Block wurde mithilfe des IO Device Builders erstellt. Als Unterstützung diente ein Erklärvideo von Prof. Göbel auf seinem YouTube-Kanal [4]. In diesem Block wird eine Arduino-Bibliothek verwendet, um ein 16×2-LCD-Display in Simulink ansteuern zu können. Im Spielbetrieb werden die drei Regelparameter des PID-Reglers auf dem Display angezeigt. Wird vom Spielbetrieb in den Kalibriermodus gewechselt, so wird dieser Moduswechsel ebenfalls auf dem Display dargestellt. Sollte der Sollwert geändert werden, erscheint zusätzlich eine entsprechende Meldung auf dem Display. Tritt schließlich die Siegbedingung ein, indem die Kugel für die vorgegebene Zeit in der Mitte gehalten wird, so wird eine Siegesmeldung zusammen mit einem Code auf dem Display ausgegeben.

//**************************************************************************
// Hochschule Hamm-Lippstadt *
//**************************************************************************
// Modul : LCD_I2C.cpp *
// *
// Datum : 26. Dezember 2025 *
// *
// Funktion : In diesem Block ist die Logik für das LCD Display des Kugel-
//              Balancierers implementiert. Je nach Modus werden die drei 
//              Regel-Parameter angezeigt oder eine Kalibriernachricht. 
//              Bei erfolgreichem Regeln der Kugel wird ein Code angezeigt.*
// *
// Implementierung : MATLAB R2024b *
// *
// Req. library : [https://github.com/johnrickman/LiquidCrystal_I2C LiquidCrystal I2C von Frank de Brabander]
// *
// Autor : Kilian Engelhardt, Daniel Block
// *
// Bemerkung : getestet
// *
// Letzte Änderung : 26. Dez 2025 
// *
//**************************************************************************

#include "C:\Users\Daniel\Documents\Uni\BSE\BSE_Semester_2\Praktikum\SVN\194_Kugel-Balancierer\Matlab_Simulink\LCD\LCD_I2C.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <math.h>

// Initialisierung des LCD: Adresse 0x27, 16 Spalten, 2 Zeilen
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Globale Variablen zum Speichern der Zustände des vorherigen Durchlaufs
double oldKp = 0, oldKi = 0, oldKd = 0, oldSollwert = 0;
const double epsilon = 0.0001; // Empfindlichkeit für Vergleich

// Initialisiert das LCD-Display beim Start des Systems
void setupFunctionLCD_I2C(){
    lcd.init();
    lcd.backlight();
}


// Kp double [1,1]
// Ki double [1,1]
// Kd double [1,1]
// Modus uint8 [1,1]
// Sollwert double [1,1]
// WIN logical [1,1]

void stepFunctionLCD_I2C(double Kp,int size_vector_a,double Ki,int size_vector_b,double Kd,int size_vector_c,uint8_T Modus,int size_vector_d,double Sollwert,int size_vector_e,boolean_T WIN,int size_vector_f){
    // Statische Flags, um einmalige Aktionen beim Zustandswechsel zu steuern
    static bool ersterDurchlauf = false;
    static bool kalibrierDurchlauf = false;
    static bool winDurchlauf = false;
    
    // Gewinnzustand
    if (WIN == true) {
        if (winDurchlauf == false) {    // Nur ausführen, wenn wir gerade erst gewonnen haben
            lcd.clear();
            lcd.setCursor(0, 0);
            lcd.print("Gewonnen!");
            lcd.setCursor(0, 1);
            lcd.print("Code: 1234");
            winDurchlauf = true;

            // Andere Status-Flags zurücksetzen
            ersterDurchlauf = false;
            kalibrierDurchlauf = false;
        }
    }
    else {
        // Spielmodus (Modus == 1), Anzeige der PID-Parameter.
        if (fabs(Modus - 1) < 0.001) {
            bool changed;
            // Prüfen, ob dies der erste Wechsel in diesen Modus ist
            if (ersterDurchlauf == false) {
                changed = true;
                ersterDurchlauf = true;
            }
            else
                changed = false;
            // Prüfen, ob sich einer der PID-Werte geändert hat
            if (fabs(Kp - oldKp) > epsilon) changed = true;
            if (fabs(Ki - oldKi) > epsilon) changed = true;
            if (fabs(Kd - oldKd) > epsilon) changed = true;

            if (changed) {
                // Buffer für die Umwandlung von double zu String (dtostrf)
                char bKp[10], bKi[10], bKd[10];
                // Formatierung auf 2 Nachkommastellen
                dtostrf(Kp, 0, 2, bKp);
                dtostrf(Ki, 0, 2, bKi);
                dtostrf(Kd, 0, 2, bKd);

                // Anzeige der PID-Werte auf dem LCD
                lcd.clear();
                lcd.setCursor(0, 0);
                lcd.print("Kp:");
                lcd.print(bKp);
                lcd.print(" ");
                lcd.print("Ki:");
                lcd.print(bKi);

                lcd.setCursor(0, 1);
                lcd.print("Kd:");
                lcd.print(bKd);

                // Neue Werte als alte speichern
                oldKp = Kp;
                oldKi = Ki;
                oldKd = Kd;

                kalibrierDurchlauf = false;
                winDurchlauf = false;
            }
        }
        // Kalibriermodus (Modus == 0)
        else if (fabs(Modus) < 0.001){
            bool kalibrierung = false;
            // Initialisierung der Anzeige beim Wechsel in den Kalibriermodus
            if (kalibrierDurchlauf == false) {
                lcd.clear();
                lcd.setCursor(0, 0);
                lcd.print("Kalibriermodus");

                kalibrierDurchlauf = true;
                ersterDurchlauf = false;
                winDurchlauf = false;
            }
            // Prüfen, ob der Sollwert kalibriert wurde
            if (fabs(Sollwert - oldSollwert) > epsilon) kalibrierung = true;
            // Anzeige das Kalibrierung erfolgreich war
            if (kalibrierung) {
                lcd.clear();
                lcd.setCursor(0, 0);
                lcd.print("Sollwert");
                lcd.setCursor(0, 1);
                lcd.print("kalibriert:");

                oldSollwert = Sollwert;
            }
        }
    }
}

Messtechnik

Im Rahmen der Messtechnik wird die Messunsicherheit der eingesetzten Sensoren (hier IR-Distanzsensor) bestimmt, um Aussagen über die Genauigkeit und Zuverlässigkeit der Messergebnisse von Sensoren treffen zu können. Die Bestimmung der Messungenauigkeit eines Messsystems besteht aus Wiederholungsmessungen mit anschließender Berechnung der Standardabweichung und kombinierten Standardunsicherheit aus den Messwerten.

IR-Sensor

Die folgende Abbildung zeigt die berechnete Messunsicherheit des IR Sensors.

Abb. 24: Messunsicherheit des IR-Sensors für den Kugel-Balancierer

Die Abbildung zeigt die Messunsicherheit eines IR-Sensors bei einer Referenzdistanz von 14,5 cm. Aus 5 Messwerten ergibt sich ein Mittelwert von 14,5032 cm mit einer kombinierten Messunsicherheit (Typ C) von ±0,2687 cm, entsprechend 3,71 %.

Die Unsicherheit Typ C setzt sich aus der statistischen Unsicherheit der Messreihe (Typ A) sowie der systematischen Unsicherheit des Messsystems (Typ B) zusammen. Alle Messwerte liegen innerhalb der berechneten Unsicherheitsgrenzen, und der Mittelwert stimmt gut mit dem Referenzwert überein. Das Messergebnis wird daher als verwertbar eingestuft.

Filterauslegung des Tiefpassfilters

Zur Bestimmung des Filterparameters α des Tiefpassfilters wurde eine Open-Loop-Simulation durchgeführt. Hierzu wurde zunächst eine ungefilterte Distanzmessung über einen definierten Zeitraum aufgezeichnet. Dieses Signal wurde anschließend gespeichert und in ein separates Simulink-Modell geladen.

In diesem Modell kamen mehrere Tiefpassfilter mit unterschiedlichen Filterparametern zur Anwendung, um das Signal zu filtern. Die daraus resultierenden gefilterten Signale wurden anschließend in MATLAB ausgewertet. Die folgende Abbildung zeigt die Ergebnisse dieser Auswertung.

Abb. 24: Ergebnisse der OpenLoop Simulation für die Tiefpassfilterauslegung

Auf Grundlage dieser Ergebnisse wurde ein Filterparameter von α = 0,3 gewählt, da sowohl die Signalglättung als auch die entstehende Verzögerung für die vorliegende Anwendung geeignet sind.

Projektunterlagen

Projektplan

Abbildung 4: Gantt Projektplan für das Projekt "Kugel-Balancierer“

YouTube Video

Escape Game - Kugel Balancierer

Literatur

---

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