Projekt 22: Ballbalancierer

Dieser Wiki-Beitrag ist Teil eines Mess- und Regelungstechnik Projektes, welches unter anderem im Rahmen vom Fachpraktikum Elektrotechnik (WS 15/16) und Fachpraktikum Elektrotechnik (WS 17/18) im Studiengang Mechatronik im 5. Semester erarbeitet wurde.
Der Beitrag dient der Dokumentation der Ergebnisse und Erfahrungen die während des Projektes Ballbalancierer erziehlt und gesammelt wurden.

In diesem Wiki Artikel wurden die relevanten Teile der verschiedenen Projektstände der letzten Semester fusioniert. So werden zunächst die Grundlagen bzw. der Grundaufbau des Ballbalancierers, sowie die theoretische Lösung beschrieben. Im weiteren Verlauf sind die unterschiedlichen Projektbearbeitungen detailliert dargelegt.

Projektbearbeitung: Jan Völlmecke
Projektbetreuer: Prof. Dr. Mirek Göbel

Laboraufbau Ballbalancierer (CAD)

Einführung

Der Ballbalancierer ist ein Laborversuch an dem das Verhalten verschiedener Reglertypen untersucht und erlernt werden kann. Dabei wird eine Kugel auf einer Wippe balanciert. Die gewünschte Position der Kugel auf der Wippe, sowie die Parameter des Reglers lassen sich über Potentiometer beliebig einstellen.
Ein Servomotor angesteuert vom Herzstück des Regelsystems, dem Mikrocontroller "Arduino Uno", welcher zugleich als Schnittstelle zwischen Sensorik und Aktorik dient, soll die in Schieflage gebrachte Wippe so ansteuern, dass der Ball unabhängig der Erdanziehungskraft an die gewünschte Position rollt.

Versuchsaufbau

Mechanischer Aufbau

Abb.: Der Ballbalancierer

Der mechanische Aufbau des Ballbalancierers, der in Abbildung "Der Ballbalancierer" zu sehen ist, lässt sich in zwei Bereiche unterteilen. Er besteht aus einem Gehäuse und einer darauf montierten Wippe. Das Gehäuse dient als Stauraum für den Servomotor und Teile der Elektronik. Beim Servomotor handelt es sich um einen "Multiplex Rhino pro SHV digi 4" mit einem maximalen Stellmoment von 230 N/cm bei 6V Betriebsspannung. Allerdings kann der Ballbalancierer davon lediglich 192 N/cm nutzen, weil er nur mit 5V betrieben wird. Das ist aber immer noch mehr als genug, um den Wippenarm bewegen zu können selbst wenn der Ball an einem Ende der Wippe liegt und so das Moment maximal wird. In der Wippe selbst sind zwei Rillenkugellager verbaut, die dafür sorgen, dass die Wippe den Winkeländerungen durch den Servomotor auch folgen kann. Außerdem besitzt sie einseitig eine Vorrichtung, um einen Sensor aufnehmen zu können. Für jeden vorhandenen Sensor existiert dabei ein passendes Gehäuse, sodass diese einfach austauschbar sind. Es ist ein Ultraschallsensor HC-SR04 und ein Infrarotsensor GP2Y0A21 vorhanden. Außerdem sind zwei unterschiedliche Bälle vorhanden. Die Abmessungen dieser sind identisch, der Unterschied besteht lediglich im Material und folglich im Gewicht. Einer der Bälle ist aus Holz, der andere aus Styropor.

Elektrotechnischer Aufbau

Der Ballbalancierer verfügt über drei verschiedene Baugruppen, die elektronisch steuerbar sind.

- 3 LED          : Dienen zum Anzeigen verschiedener Status wie z.B., dass das Gerät eingeschaltet ist oder der Ball sich aktuell in Sollposition befindet
- 4 Potentiometer: Jeweils 1, um die Gewichtung eines Teils des PID-Reglers zu steuern und 1 um die Sollposition des Balles festzulegen
- 1 Servomotor   : Setzt die Befehle des Reglers in Stellwinkel um und balanciert so den Ball in Sollposition.

Abb.2: Schaltplan des Ballbalancierers

Der Ballbalancierer verfügt zudem noch über zwei Sensoren mit denen die Position des Balles auf der Wippe bestimmt werden kann. Es handelt sich um einen Ultraschallsensor und einen Infrarotsensor, von denen immer nur einer verwendet werden kann. Außerdem besitzt der Ballbalancierer einen 50-poligen Stecker. Die einzelnen Bauelemente belegen dabei wie in Abbildung 2 zu sehen ist die entsprechenden Pins. Über diesen Stecker ist der Ballbalancierer mit einem Arduino Uno verbunden. Dieser steuert den Ballbalancierer gemäß dem auf ihm gespeicherten Regler. Zur Entwicklung oder Verbesserung von Regelungsalgorithmen eine Programmierung mit Matlab Simulink oder der Arduino Entwicklungsumgebung zu empfehlen.

Wichtige Größen des Systems

Um einen Regler für das System entwickeln zu können ist wichtig zu wissen welche Größen das System charakterisieren. Erst dadurch kann erreicht werden, dass sich das entwickelte Modell physikalisch so verhält wie die Realität. Verwendet man die Holzkugel sind folgende Werte von Bedeutung:

- m = 0,124kg      : Gewicht der Kugel (Holz)
- r = 0,04m        : Radius der Kugel
- g = 9,81m/s²     : Erdbeschleunigung
- L = 0,6m         : Länge der Regelstrecke bzw. des Wippenarms
- d = 0,009        : Hebelarm des Servomotors
- J = 0,000128kg$\cdot$m²: Massenträgheitsmoment der Kugel
- c = 0,06m        : Abstand zwischen Aufhängung und Servobefestigung

Theoretische Lösung

veränderliche Größen und wirkende Kräfte

Abb.3: Größen und Kräfte

Es gibt nur eine Größe, den Sensorwinkel Φ die , wenn der Austausch der Kugel außer Acht gelassen wird, im System änderbar ist. Diese hat direkten Einfluss auf den Neigungswinkel α.
$\alpha= \frac{d}{c}\cdot \phi$
Die Hangabtriebskraft F_h und die Summe aus der Rotationskraft F_r
$Fr=\frac{J}{r^2}\cdot x_s''$
und der Translationskraft F_t
$Ft=m\cdot x_s''$
(vgl.Abb.3) bilden nach dem 2. Newtonsche Gesetz ein Kräftegleichgewicht
$Fr+Ft=Fh$
daraus ergibt sich folgende Formel
$\frac{J}{r^2}\cdot x_s''+m\cdot x_s''=m\cdot g\cdot sin(\alpha)$
beachtet man das Trägheitsmoment der Kugel
$J=\frac{2}{5}\cdot m\cdot r^2$
ergibt sich
$\frac{2}{5}\cdot m\cdot x_s''+m\cdot x_s''=m\cdot g\cdot sin(\alpha)$
für $x_s''$folgt daraus
$x_s'' = \frac{5}{7}\cdot g\cdot sin(\alpha)$
für kleine Winkel von α kann folgendes angenommen werden
$sin(\alpha)=\alpha$
und daraus folgend
$x_s''= (\frac{5}{7}\cdot g\cdot \alpha)$.
Durch diese Formel ist das Bewegungsmodell des Balles beschrieben. Für die Übertragungsfunktion mit
$x_s'' = \frac{d^2\cdot s}{d\cdot t^2}$
ergibt sich nach der Laplace Transformation
$(X(s)/\alpha(s))=((\frac{5}{7}\cdot g)s^2)$.

Regelkreis

Das System des Ballbalancierer lässt sich durch einen geschachtelten Regelkreis darstellen. Als Eingangsgröße wird der Abstand der Kugel zum Sensor gewählt (Xs_soll), dieser lässt sich über einen Poti beliebig einstellen. Die Ausgangsgröße ist der aktuelle Abstand (Xs_ist). Dieser wird über den Entfernungssensor gemessen und zurückgeführt. Ex ist die Differenz aus Xs_soll und Xs_ist. Aus dieser Differenz wird ein Referenzwert α_ref für den Neigungswinkel α des Balkens berechnet. Die Differenz aus diesem und dem α_ist ergibt die Regeldifferenz. Im inneren Regelkreis wird diese in den zu stellenden Servowinkel umgerechnet. Über den Servo wird dieser Winkel eingestellt und der Balken neigt sich. Durch die auf die Kugel wirkende Hangantriebskraft beginnt diese zu rollen.

Abb.4: Regelkreis des Ballbalancierers

Projektsteckbrief

Aufgabe
Entwurf eines Reglers für einen mechanisch und elektrisch "fertigen" Laborversuch

Erwartungen an die Projektlösung, Stand WS(15/16), Jan Völlmecke

• Recherche zu bestehenden Lösungen
• Sensorkonzept: Auswahl und Test von geeigneten Sensoren zur Erkennung der Lage des Balls bzw. der Kugel
• Falls erfolgreich:
  • Entwurf eines Regelkreises
  • Systemidentifikation (Übertragungsfunktion der Regelstrecke bestimmen)
  • Vergleichen und bewerten Sie verschiedene Regelansätze (P, PI, PID), Darstellen der Soll-/Istgrößen
• Programmiersprache: C
• Test und wissenschaftliche Dokumentation
• Live Vorführung während der Abschlusspräsentation
• weitere Erwartungen an Präsentation und Dokumentation

Erwartung an die Fortsetzung der Projektlösung, Stand WS(17/18), Leonard Herbstmann und Stefan Koch

• Recherche zum Infrarotsensor Sharp GP2Y0A21 und Ultraschallsensor HC-SR04
• Auswahl des besser geeigneten Sensors anhand Vergleich der Sensoreigenschaften
• Messreihe erstellen um die Ballposition genau bestimmen zu können
• Programmiersoftware von Arduino auf Matlab Simulink umstellen
• Visualisierung der Ballposition mithilfe von Matlab Simulink
• Live Vorführung während der Abschlusspräsentation
• weitere Erwartungen an Präsentation und Dokumentation

Konzeptionsphase

Sensorkonzept-Messdatennutzung

Die Anschließende Projektphase bestand aus den Meilensteinen Konzeptausarbeitung, -Auswahl, und Test des gewählten Konzeptes.
Überwiegend bestand die Ideensammlung in Internetrecherche und aus vorherigen Projektdokuementationen. Es wurde sich über verschiedene Sensoren informiert und in Bezug auf den Ballbalancierer die Umsetzbarkeit untersucht.

Aufgrund der Aussage aus dem vorherigen Wikibeitrag des Projektes Ballbalancierer, dass ein Infrarotsensor besser funktioniere als ein Ultraschallsensor, es jedoch Probleme beim Messbereich gibt, wurde sich dazu entschlossen einen zweiten Infrarotsensor auf die gegenüberliegende Seite der Wippe zu installieren. Diese beiden Signale gilt es dann zu überlagern bzw. auszuwählen mit welchem Sensor in welchem Bereich der Wippe gemessen werden soll. Die Messbereichsproblematik kann so umgangen werden. Die Auswahl des richtigen Sensors erfolgt über folgenden Programmteil:

Weitere Entscheidungsgründe für das Sensorkonzept mit einem weiteren Infrarotsensor, waren das Projektbudget und der vorhandene Lagerbestand der Sharp-Infrarotsensoren (Messbereich 10-80cm) im Mechatroniklabor.

Provisorische Sensor-Test-Montage

Die Sensoren wurden provisorisch vorn an die Sensorhalter angeschraubt und verdrahtet. Die Verdrahtung wurde vorerst, der Komplexität und Umsetzung halber, durch die Öffnung des Wippenpleuls gelegt. Dieses gilt es in weiteren Bearbeitungen zu optimieren. Für die spätere Optimierung wurde bereits ein CAD-Modell des Sensorhalters inklusive Zeichnungsableitung erstellt und den Projektunterlagen beigefügt. Die neuen Sensorhalter dienen als Gehäuse für die Infrarotsensoren, welche dann an dem Rückteil des Sensorhalters zu befestigen sind. Mithilfe der Sensorumhausung sind die Sensoren vor Beschädigungen, insobesondere bei Reglerversuchen mit der Holzkugel geschützt.

Im Anschluss an die Montage wurden die Sensoren mit folgendem C-Code getestet. Dieser Test ließ ein positives, funktionierendes Konzept verzeichnen.

#include <SharpIR.h>

#define ir_sensor_PIN_links A4
#define ir_sensor_PIN_rechts A5
#define model 1080

SharpIR sharp_links(ir_sensor_PIN_links, 25, 93, model);
SharpIR sharp_rechts(ir_sensor_PIN_rechts, 25, 93, model);

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  delay(20);      // it gives you time to open the serial monitor after you upload the sketch
  
    int dis_links=sharp_links.distance();  // this returns the distance to the object you're measuring (mit linkem Sensor)
    int dis_rechts=sharp_rechts.distance();// this returns the distance to the object you're measuring (mit rechtem Sensor)

    Serial.print("Time taken (ms): ");
    Serial.print(millis());
    Serial.print(";");
    Serial.print("Mean distance left sensor; ");  // returns it to the serial monitor
    Serial.print(dis_links);
    Serial.print(";");
    Serial.print("Mean distance right sensor; ");  
    Serial.print(dis_rechts);
    Serial.println(";");
}

Ausarbeitungsphase

Die Ausarbeitungsphase beschränkte sich auf die Entwicklung eines Regelkreises, sowie dessen noch ausbaufähigen Implementierung und die Aufnahme von Messdaten bezogen auf ein Eingabesignal an den Servomotor.

Regelkreis

Sprungantwort

Für die Ermittlung der Sprungantwort wurde der Servomotor, nach einigen Test wie dieser angesteuert werden kann, mit einer Winkeländerung von 10°, da 1° sogut wie keine Auswirkung auf die Steroporkugel hat, auf seine Ruhelage von 90° angesprochen. Das daraus resultierende Ergebnis ist eine Wippenneigung von 10° nach links. Das Diagramm spiegelt die dazu aufgenommenen Messwerte der Sensoren wieder.

Abbildung der aufgenommenen Sprungantwort

#include <Servo.h>
#include <SharpIR.h>

#define ir_sensor_PIN_links A4
#define ir_sensor_PIN_rechts A5
#define model 1080

SharpIR sharp_links(ir_sensor_PIN_links, 25, 93, model);
SharpIR sharp_rechts(ir_sensor_PIN_rechts, 25, 93, model);

Servo myservo;     // erzeugt ein Servo-Objekt
// maximal können acht Servo-Objekte erzeugt werden
 
int pos = 100;        // Variable, die die Servoposition (Winkel) speichert 
                         (zwischen 46°= rechtsschwenk und 132°= linksschwenk, 90° = mittig)

void setup()
{ 
  
  myservo.attach(3);  // an welchem Pin ist der Servo angeschlossen
  Serial.begin(9600);
  //pinMode (ir_sensor_PIN_links, INPUT);
  //pinMode (ir_sensor_PIN_rechts, INPUT);
  myservo.write(90);
  delay (5000);
}

void loop()
{
  myservo.write(pos);                   // sagt dem Servo, in welche Position sich drehen soll     
  delay(15);                            // wartet 15 Millisekunden  
  
    int dis_links=sharp_links.distance();  // this returns the distance to the object you're measuring (mit linkem Sensor)
    int dis_rechts=sharp_rechts.distance();// this returns the distance to the object you're measuring (mit rechtem Sensor)
 
    Serial.print("Time taken (ms): ");
    Serial.print(millis());
    Serial.print(";");
    Serial.print("Einheitssprung; ");
    Serial.print(pos-90);  
    Serial.print(";");
    Serial.print("Mean distance left sensor; ");  // returns it to the serial monitor
    Serial.print(dis_links);
    Serial.print(";");
    Serial.print("Mean distance right sensor; ");  
    Serial.print(dis_rechts);
    Serial.println(";");
}

Fortsetzung Projektlösung / Einleitung

In der Bearbeitung während des Fachpraktikums WS 17/18 stand die genaue Detektion des Balles im Vordergrund.
Die Problematik bestand darin, dass die vorherige Sensorabfrage, welche mit der Arduino Software vorgenommen wurde, ungenaue bzw. schwankende Werte lieferte. Hauptziel des Versuches ist es deshalb, einen geeigneten Sensor für das System zu ermitteln und anschließend für den ausgewählten Sensor eine Implementierung mit Matlab Simulink durchzuführen.

Sensorauswahl

Für den Versuch war eine Auswahl zwischen dem Infrarotsensor Sharp GP2Y0A21 und dem Ultraschallsensor HC-SR04 zu treffen.

Der Sharp GP2Y0A21 ist ein Infrarot-Distanzsensor, er ist extrem effektiv, einfach zu bedienen, sehr erschwinglich und hat einen geringen Stromverbrauch. Der Sensor nutzt das Messprinzip der Triangulation.

Die Spezifikationen sind wie folgt:

• Entfernungsmessbereich: 10 bis 80 cm
• Betriebsspannung: 4.5V bis 5.5V
• Ausgangstyp: Analogspannung
• Maximal zulässiger Winkel:> 40 °
• Zyklus: 25 Hz / 40 ms

Problematiken: Der Messbereich mit 10 bis 80 cm (zweiter Sensor nötig), worst-case: Beeinflussung durch externe Lichtquellen (bspw. Leuchtstoffröhren, Blitze)

Der Ultraschallsensor HC-SR04 ist unempfindlich gegenüber Umgebungsschall, da er in einem weit höheren Frequenzbereich als der Hörbereich arbeitet. Da Ultraschallwellen eine Wellenlänge von nur 1 cm haben können, sind auch Echos von schmalen Objekten feststellbar. Der Sensor zeichnet sich durch stabile Messwerte und hohe Genauigkeit aus.

Simulink Einbindung des GP2Y0A21

Die Spezifikationen sind wie folgt:

• Betriebsspannung +5V +-10%, GND 0V
• Signal Level (Trigger, Echo) TTL Pegel (L < 1,0V)
• messbare Distanz 2cm - ca. 300cm
• Messungen pro Sekunde maximal 50

Problematiken: Messung erfolgt durch "Messkeule" (Objekte nahe der Wippe könnten erfasst werden), Messungen sind "ungenau"

Bei der Übergabe des Projektes waren bereits zwei Infrarotsensoren am System angebracht, welche, wie bereits im Artikel der letzten Projektbearbeitung beschrieben, gegenseitig ihre toten Bereiche ergänzen. Wir begannen zunächst damit die bereits verbauten Sensoren zu überprüfen. Bei dem Sharp GP2Y0A21 handelt es sich um einen nicht linearen Sensor. Das Einbinden des Sensors in Simulink war also nur mit Hilfe einer Funktion möglich, die annähernd das Messverhalten des Sensors beschreibt oder mit Hilfe einer Messreihe und Interpolation. Interpolation bot sich dank des "1-D Lookup Table" Blockes in Simulink an. Eine Messreihe war also von nöten, um die Werte in den Simulink Block "1-D Lookup Table" einzubinden. Bei ersten Testmessungen des Sensors stellte sich jedoch heraus, dass die Messwerte des Sensors stark schwankten (effektiv Abweichungen von bis zu 10cm). Das Problem war hier, dass die erste Messung des Sharp GP2Y0A21 in einem Messintervall keinen stabilen Messwert bietet, wie im Datenblatt des Sensors zu erkennen. Somit war es nötig die Messwerte zu filtern, hier mit einem Median Filter (s. Abbildung), und in der passenden Frequenz den Sensor abzufragen.