Mechatronic components and systems (MCS) - Exam.pdf

Mechatronic components and systems (MCS) - Exam

Mechatronic components and systems (MCS) - Exam Aufgabe 1) Systemintegration in der Mechatronik: Du bist als Ingenieur in einem mechatronischen Projektteam tätig, dessen Ziel es ist, einen Roboterarm zu entwickeln. Der Roboterarm soll Objekte erkennen, greifen und an einem anderen Ort ablegen können. Zu Deinen Aufgaben gehört die Integration verschiedener mechanischer, elektronischer und softwareb...

Mechatronic components and systems (MCS) - Exam

Aufgabe 1)

Systemintegration in der Mechatronik: Du bist als Ingenieur in einem mechatronischen Projektteam tätig, dessen Ziel es ist, einen Roboterarm zu entwickeln. Der Roboterarm soll Objekte erkennen, greifen und an einem anderen Ort ablegen können. Zu Deinen Aufgaben gehört die Integration verschiedener mechanischer, elektronischer und softwarebasierter Komponenten.

a)

Mechanische und Elektronische Komponenten: Beschreibe die Auswahl und Integration der mechanischen und elektronischen Komponenten, die für den Betrieb des Roboterarms notwendig sind. Erkläre, welche Sensoren und Aktoren verwendet werden können und wie diese mit der Steuerungseinheit verbunden werden sollen.

Lösung:

Mechanische und Elektronische Komponenten für den Roboterarm:

Mechanische Komponenten:

Gelenke und Verbindungen: Der Roboterarm benötigt mehrere drehbare Gelenke, um sich flexibel bewegen zu können. Jedes Gelenk kann beispielsweise durch Servomotoren oder Schrittmotoren angetrieben werden. Diese Motoren ermöglichen präzise Winkelbewegungen.
Armstruktur: Die mechanische Struktur des Arms kann aus leichtem und starkem Material wie Aluminium oder Kohlefaser bestehen, um Stabilität bei geringem Gewicht zu gewährleisten.
Greifer Mechanismus: Der Greifer am Ende des Arms kann durch Servomotoren gesteuert werden, um verschiedene Objekte greifen und loslassen zu können. Die Greifer können in verschiedenen Formen und Größen gestaltet werden, um unterschiedliche Anforderungen zu erfüllen.

Elektronische Komponenten:

Steuereinheit: Ein Mikrocontroller oder ein eingebettetes Computersystem, wie Arduino oder Raspberry Pi, kann als zentrale Steuereinheit verwendet werden, um alle Komponenten des Roboterarms zu koordinieren.
Sensoren:

Kameras und Bildsensoren: Kameras werden verwendet, um Objekte zu erkennen. Bildverarbeitungsalgorithmen können auf dem Steuerungscomputer ausgeführt werden, um die Position und Form der Objekte zu analysieren.
Entfernungsmesser: Sensoren wie Ultraschall- oder Infrarotsensoren können zur Entfernungsmessung eingesetzt werden, um die genaue Position der Objekte zu bestimmen.
Positionssensoren: Drehgeber an den Gelenken des Arms können verwendet werden, um die aktuelle Position jedes Gelenks präzise zu bestimmen und Rückmeldungen zur Steuerung zu geben.

Aktoren:

Servomotoren: Diese Motoren eignen sich hervorragend für präzise Bewegungen und werden in den Gelenken und im Greifer verwendet.
Schrittmotoren: Diese Motoren ermöglichen ebenfalls präzise Steuerung und könnten in schlechter gesteuerten Bereichen des Arms verwendet werden, z.B. für einfache Drehbewegungen.

Integration der Komponenten:

Die Steuerungseinheit ist mit allen Sensoren und Aktoren über eine Verkabelung oder drahtlose Kommunikation verbunden. Für die Verkabelung könnten standardisierte Schnittstellen wie I2C, SPI oder UART verwendet werden.
Alle Sensoren (Kameras, Entfernungsmesser, Positionssensoren) senden Daten an die Steuereinheit. Diese verarbeitet die Informationen, um die Bewegungen des Roboterarms zu planen.
Aktoren (Servomotoren, Schrittmotoren) erhalten Steuerbefehle von der Steuereinheit, basierend auf den verarbeiteten Sensordaten und den geplanten Bewegungen. Diese Befehle werden von der Steuereinheit in elektrische Signale umgewandelt, die die Motoren ansteuern.

Dies ermöglicht eine koordinierte Bewegung des Roboterarms, um Objekte präzise zu greifen, zu bewegen und abzulegen.

b)

Steuerung des Roboterarms: Erstelle ein Blockdiagramm, das den Steuerungsprozess des Roboterarms beschreibt. Erläutere, wie die Signale von den Sensoren verarbeitet werden und welche Regelungstechnik angewendet wird, um den Roboterarm präzise zu steuern. Verwende dabei relevante Gleichungen der Regelungstechnik.

Lösung:

Steuerung des Roboterarms:

Blockdiagramm des Steuerungsprozesses:

1. Sensoreingaben:

Bildsensor (Kamera): Dient zur Objekterkennung.
Entfernungsmesser: Bestimmt die Entfernung und Position von Objekten.
Positionssensoren (Drehgeber): Bestimmen die aktuelle Position der Gelenke des Roboterarms.

2. Datenverarbeitung:

Bildverarbeitung: Algorithmen zur Objekterkennung und -verfolgung.
Positionsbestimmung: Verarbeitung der Sensordaten zur genauen Bestimmung der Objektpositionen.

3. Steuerungseinheit: Ein Mikrocontroller, der Daten von den Sensoren verarbeitet und Steuerbefehle an die Aktoren sendet.
4. Aktoren: Motoren, welche die Gelenke des Roboterarms und den Greifer bewegen.
5. Rückmeldungsschleife: Kontinuierliche Überwachung der Position durch Positionssensoren zur Präzisierung und Korrektur von Bewegungen.

Regelungstechnik:

Verwendeter Regler: PID-Regler (Proportional-Integral-Derivative)

PID-Regler-Gleichungen:

Die Ausgangsgröße \(u(t)\) des PID-Reglers wird wie folgt berechnet:

\[ u(t) = K_p e(t) + K_i \int_{0}^{t} e(\tau) \, d\tau + K_d \frac{de(t)}{dt} \]

wobei:
\( e(t) = \text{SP} - \text{PV} \)
\(\text{SP} = \text{Sollwert} \)
\(\text{PV} = \text{Istwert} \)
\( \text{Kp} = \text{Proportionalbeiwert} \)
\( \text{Ki} = \text{Integralbeiwert} \)
\( \text{Kd} = \text{Differentialbeiwert} \)

\( e(t) \) ist der Fehler zwischen dem Sollwert (SP) und dem Istwert (PV) der Position des Roboterarms.
\( K_p \), \( K_i \), und \( K_d \) sind Regelparameter, die für den PID-Regler eingestellt werden müssen, um optimale Leistung zu erzielen.
Das Signal \( u(t) \) wird an die Aktoren gesendet, um die Position der Gelenke des Roboterarms entsprechend anzupassen.
Positionssensoren liefern kontinuierlich Rückmeldungen (PV) an die Steuerungseinheit, um Abweichungen vom Sollwert (SP) zu erkennen und Korrekturen vorzunehmen.

So gewährleistet der Regelungsprozess eine präzise Steuerung der Bewegungen des Roboterarms, um Objekte zu erkennen, zu greifen und an einem anderen Ort abzulegen.

c)

Mensch-Maschine-Schnittstelle: Entwerfe eine Mensch-Maschine-Schnittstelle (HMI), die es dem Benutzer ermöglicht, den Roboterarm zu überwachen und zu steuern. Beschreibe kurz die verwendete Software und Hardware. Lege dar, welche Informationen auf der HMI angezeigt werden sollten und wie der Benutzer sicher mit dem System interagieren kann.

Lösung:

Mensch-Maschine-Schnittstelle (HMI) für den Roboterarm:

Hardware-Komponenten:

Touchscreen-Display: Ein Touchscreen-Monitor dient als zentrales Interface zur Anzeige der Informationen und zur Eingabe von Steuerbefehlen.
Computer oder Embedded System: Ein leistungsstarker Computer oder ein eingebettetes System wie ein Raspberry Pi zur Ausführung der HMI-Software und zur Verarbeitung der Benutzereingaben.
Bedienelemente: Zusätzliche Hardware wie Joysticks, Tasten oder Not-Aus-Schalter zur Steuerung des Roboterarms und zur Erhöhung der Sicherheit.

Software-Komponenten:

GUI-Framework: Eine grafische Benutzeroberfläche (GUI) kann mit Frameworks wie Qt, Tkinter (für Python) oder speziellen HMI-Softwarelösungen wie Ignition HMI entwickelt werden.
Robotersteuerungssoftware: Software, die die Benutzereingaben über die HMI in Steuerbefehle für den Roboterarm umwandelt. Diese Software könnte in Programmiersprachen wie Python, C++ oder unter Verwendung von ROS (Robot Operating System) entwickelt werden.

Angezeigte Informationen auf der HMI:

Positionsinformationen: Aktuelle Position aller Gelenke des Roboterarms in Echtzeit.
Statusanzeigen: Betriebszustand des Roboterarms (z.B. bereit, in Betrieb, Fehler).
Live-Kamera-Feed: Echtzeit-Ansicht des Arbeitsbereichs des Roboterarms zur Überwachung der Arbeitsumgebung.
Fehlermeldungen: Klar verständliche Meldungen bei Fehlfunktionen oder Eingriffen des Roboterarms.
Benutzereingaben: Möglichkeit, die Position und Bewegung des Arms manuell zu steuern, z.B. durch Schieberegler, Tasten oder Gestenerkennung.

Sicherheit und Benutzerinteraktion:

Not-Aus-Schalter: Ein leicht zugänglicher Not-Aus-Schalter, der den Roboterarm sofort stoppt, um Unfälle zu vermeiden.
Benutzerautorisierung: Login-System für verschiedene Benutzerrollen (z.B. Administrator, Bediener) zur Verwaltung von Berechtigungen.
Warnhinweise: Visuelle und akustische Warnsignale bei gefährlichen Situationen.
Interaktive Tutorials: Eingebaute Anleitung oder Tutorial, um den Benutzer mit der Bedienung des Systems vertraut zu machen.

Die Mensch-Maschine-Schnittstelle ermöglicht eine intuitive und sichere Steuerung des Roboterarms, indem sie relevante Informationen übersichtlich darstellt und die Benutzereingaben effektiv in Steuerbefehle verwandelt.

Aufgabe 2)

In einem modernen mechatronischen System zur autonomen Steuerung von Produktionsprozessen werden verschiedene Sensoren und Aktoren integriert. Hierbei werden Temperatur, Position und andere physikalische Größen erfasst und entsprechend verarbeitet, um die gewünschten Bewegungen und Operationen zu steuern. Die Kommunikation zwischen den Komponenten erfolgt über Bussysteme wie CAN, I2C oder SPI. Die Echtzeitfähigkeit und die Kalibrierung spielen eine entscheidende Rolle für die Genauigkeit und Effizienz des Systems. Ebenso ist Fehlermanagement notwendig, um Abweichungen zu erkennen und zu kompensieren.

a)

a) Beschreibe detailliert den typischen Datenfluss in einem mechatronischen System, das Sensoren und Aktoren zur Steuerung eines Förderbands verwendet. Erkläre die Rolle des Mikrocontrollers und die Bedeutung der Echtzeitfähigkeit.

Lösung:

In einem mechatronischen System zur Steuerung eines Förderbands werden Sensoren und Aktoren integriert, um die Bewegung und Funktion des Förderbands zu gewährleisten. Der typische Datenfluss kann wie folgt dargestellt werden:

1. Datenerfassung:Sensoren erfassen verschiedene physikalische Größen wie Temperatur, Position, Geschwindigkeit und Zustand des Förderbands. Diese Sensoren können beispielsweise Temperatursensoren, Positionssensoren (z.B. Encoder) und Geschwindigkeitssensoren sein.
2. Signalauswertung:Die erfassten Daten werden an den Mikrocontroller gesendet, der die Daten verarbeitet. Der Mikrocontroller ist das zentrale Steuerungselement und übernimmt die Aufgabe, die empfangenen Signale auszuwerten und entsprechende Steuerbefehle zu generieren.
3. Steuerungsalgorithmus:Basierend auf den ausgewerteten Daten berechnet der Mikrocontroller, welche Aktionen durchgeführt werden müssen. Dies kann das Anpassen der Förderbandgeschwindigkeit, das Stoppen des Bandes oder das Aktivieren von Alarmsystemen umfassen.
4. Aktorensteuerung:Der Mikrocontroller sendet Steuerbefehle an die Aktoren, die für die physische Bewegung und den Betrieb des Förderbands verantwortlich sind. Diese Aktoren können bspw. Motoren, Bremsen und Ventile sein.
5. Rückmeldung:Aktoren führen die Befehle aus und können Rückmeldung an den Mikrocontroller geben, um den aktuellen Zustand und den Erfolg der ausgeführten Befehle zu bestätigen. Dies ermöglicht eine geschlossene Regelkreisschleife, wobei der Mikrocontroller kontinuierlich aktualisierte Daten empfängt und basierend darauf weitere Steuerbefehle generiert.

Die Rolle des Mikrocontrollers ist entscheidend in diesem System, da er:

die zentrale Steuerungseinheit ist, die die Verarbeitung, Analyse und Steuerung aller Signale und Befehle übernimmt,
die Kommunikation zwischen Sensoren und Aktoren managt,
sicherstellt, dass die gewünschten Bewegungen und Vorgänge entsprechend den Anforderungen ausgeführt werden.

Die Bedeutung der Echtzeitfähigkeit in einem solchen System ist ebenfalls äußerst wichtig:

Die Echtzeitfähigkeit stellt sicher, dass die Daten von den Sensoren in Echtzeit verarbeitet und sofortige entsprechende Aktionen durchgeführt werden können.
Dies ist entscheidend für die Genauigkeit und Effizienz des Systems, da Verzögerungen in der Datenverarbeitung zu Fehlern, Ineffizienzen oder sogar Schäden am System führen könnten.
Besonders bei sicherheitskritischen Anwendungen ist die Echtzeitfähigkeit notwendig, um sofort auf potentielle Gefahren oder Abweichungen reagieren zu können.

b)

b) Entwickle ein einfaches Programm in Python für ein Mikrocontroller-basiertes System, welches die Temperatur von einem Sensorsignal liest (angenommen über I2C-Bus) und abhängig von der Temperatur einen Lüfter (Aktuator) steuert. Der Lüfter soll bei Temperaturen über 30°C eingeschaltet werden und bei Temperaturen unter 25°C ausgeschaltet werden. Nutze dabei Pseudocode zur Vereinfachung.

Lösung:

Hier ist ein einfaches Python-Programm, das diese Anforderungen erfüllt:

import smbus2 # Bibliothek für I2C-Kommunikation import RPi.GPIO as GPIO # Bibliothek zur Steuerung der GPIO-Pins der Raspberry Pi import time # Bibliothek für Zeitfunktionen # I2C-Adresse des Temperatursensors SENSOR_ADDRESS = 0x48 # Beispieladresse, kann je nach Sensor variieren # Pin-Nummer für den Lüfter LUEFTER_PIN = 17 # Ersetze dies durch den korrekten GPIO-Pin def lese_temperatur(): # Funktion zum Lesen der Temperatur vom Sensor mit smbus2.SMBus(1) as bus: # Ersetze '1' durch die richtige Busnummer, falls notwendig temperatur_roh = bus.read_byte_data(SENSOR_ADDRESS, 0) # Daten aus dem Sensor lesen # Rohe Temperaturdaten in eine lesbare Form umwandeln temperatur = temperatur_roh temperatur return temperatur def steuer_luefter(temperatur): # Funktion zur Steuerung des Lüfters if temperatur > 30: # Lüfter einschalten GPIO.output(LUEFTER_PIN, GPIO.HIGH) elif temperatur < 25: # Lüfter ausschalten GPIO.output(LUEFTER_PIN, GPIO.LOW) def setup(): # Setup-Funktion zur Initialisierung der GPIO-Pins GPIO.setmode(GPIO.BCM) GPIO.setup(LUEFTER_PIN, GPIO.OUT) def main(): # Hauptprogramm setup() try: while True: # Endlosschleife, um kontinuierlich die Temperatur zu lesen temperatur = lese_temperatur() print(f'Aktueller Temperaturwert: {temperatur} °C') steuer_luefter(temperatur) time.sleep(1) # Warte 1 Sekunde, bevor die Temperatur erneut gelesen wird except KeyboardInterrupt: GPIO.cleanup() # Bereinige GPIO-Einstellungen bei Programmende if __name__ == '__main__': main()

Erklärung:

Import der notwendigen Bibliotheken: Der Code verwendet die Bibliotheken smbus2 für die I2C-Kommunikation und RPi.GPIO zur Steuerung der GPIO-Pins auf einem Raspberry Pi.
I2C-Adresse und Lüfter-Pin: Die Adresse des Temperatursensors und der GPIO-Pin für den Lüfter sind definiert.
Lesen der Temperatur: Die Funktion lese_temperatur() liest die Temperaturdaten vom Sensor über den I2C-Bus.
Steuerung des Lüfters: Die Funktion steuer_luefter() schaltet den Lüfter ein, wenn die Temperatur über 30°C liegt, und aus, wenn die Temperatur unter 25°C liegt.
Setup und Hauptprogramm: Die Setup-Funktion setup() initialisiert die GPIO-Pins und die Hauptprogrammfunktion main() führt die Endlosschleife aus, die kontinuierlich die Temperatur liest und den Lüfter steuert.
Beenden des Programms: Bei einer KeyboardInterrupt (mit Strg+C) wird das Programm sicher beendet und die GPIO-Pins werden bereinigt.

c)

c) Angenommen, das System ist nicht korrekt kalibriert und misst konstant 3°C zu hohe Temperaturen. Beschreibe ein Verfahren zur Kalibrierung des Temperatursensors und formuliere die mathematische Berechnung zur Kompensation des Messfehlers.

Lösung:

Verfahren zur Kalibrierung des Temperatursensors:

1. Referenzmessung: Verwende ein hochgenaues und bereits kalibriertes Thermometer als Referenzgerät. Platziere den Temperatursensor und das Referenzthermometer unter denselben Umgebungsbedingungen, damit beide Geräte die gleiche Temperatur messen.
2. Vergleich der Messwerte: Messe die Temperatur sowohl mit dem Referenzthermometer als auch mit dem zu kalibrierenden Temperatursensor. Nehmen wir an, das Referenzthermometer zeigt 25°C, während der Temperatursensor 28°C anzeigt.
3. Berechnung der Abweichung: Berechne die Differenz zwischen den beiden Messwerten. In diesem Fall beträgt die Abweichung 3°C (28°C - 25°C).
4. Anpassung des Messalgorithmus: Aktualisiere den Messalgorithmus des Temperatursensors, um den konstanten Messfehler zu kompensieren. Dies erfordert das Subtrahieren des Abweichungswerts von den gemessenen Temperaturen.

Mathematische Berechnung zur Kompensation des Messfehlers:

Sei T_gemessen die Temperatur, die der Sensor misst, und T_korrigiert die korrigierte Temperatur.

Der Sensor misst konstant 3°C zu hoch, daher ist die Korrektur wie folgt zu berechnen:

Formel:

\[T_{\text{korrigiert}} = T_{\text{gemessen}} - 3 \text{°C} \]

Beispiel:

Angenommen, der unkalibrierte Sensorwert beträgt 28°C. Der korrigierte Wert wäre:

Berechnung:

\[T_{\text{korrigiert}} = 28 \text{°C} - 3 \text{°C} = 25 \text{°C} \]

Durch die Anwendung dieser Berechnung auf den Messalgorithmus des Systems kann der Fehler effektiv kompensiert und die Genauigkeit der Temperaturmessungen verbessert werden.

d)

d) Diskutiere das Fehlermanagement in dem beschriebenen Szenario. Wie kann das System Fehler und Abweichungen erkennen und darauf reagieren? Welche Maßnahmen könnten implementiert werden, um die Zuverlässigkeit des Fördersystem zu erhöhen?

Lösung:

Fehlermanagement ist in einem mechatronischen System zur autonomen Steuerung von Produktionsprozessen von entscheidender Bedeutung. Es umfasst die Erkennung, Diagnose und Reaktion auf Fehler und Abweichungen, um die Zuverlässigkeit und Effizienz des Systems zu gewährleisten.

Fehlererkennung und -reaktion:

1. Sensordatenerfassung und -überwachung: Kontinuierliche Überwachung der von den Sensoren erfassten Daten. Mithilfe von Schwellenwertüberwachung und Statistikanalyse können Abweichungen von normalen Betriebsbedingungen identifiziert werden. Zum Beispiel könnten plötzliche Temperatursprünge oder abnormale Positionierungsdaten auf einen Fehler hinweisen.
2. Selbstdiagnose des Systems: Integrierte Selbstdiagnosefunktionen im Mikrocontroller können regelmäßig Tests an den Sensoren, Aktoren und der Elektronik des Systems durchführen, um Anomalien zu erkennen.
3. Protokollierung und Fehlerberichte: Alle erkannten Fehler und Abweichungen sollten protokolliert und an eine zentrale Steuerungseinheit gemeldet werden. Eine Protokollierungsfunktion kann verwendet werden, um historische Daten zur Fehleranalyse zu speichern.
4. Redundante Systeme: Um den Ausfall einzelner Komponenten zu kompensieren, können redundante Sensoren und Aktoren implementiert werden. Bei einem Sensorausfall kann das System auf eine redundante Einheit zurückgreifen.
5. Echtzeit-Alarmierung: Das System sollte in der Lage sein, in Echtzeit Alarmmeldungen zu generieren und an das Bedienpersonal zu senden, wenn ein kritischer Fehler erkannt wird. Dies ermöglicht eine sofortige Reaktion und verhindert größere Schäden oder Produktionsausfälle.

Maßnahmen zur Erhöhung der Zuverlässigkeit:

1. Regelmäßige Kalibrierung: Führe regelmäßige Kalibrierungen der Sensoren durch, um sicherzustellen, dass genaue Messwerte verwendet werden. Automatisierte Kalibrierungsroutinen können hierbei hilfreich sein.
2. Wartungsintervalle: Etabliere regelmäßige Wartungsintervalle für das Fördersystem, bei denen Komponenten überprüft und gegebenenfalls ausgetauscht werden. Präventive Wartungsmaßnahmen können Ausfälle verhindern.
3. Software-Updates: Halte die Software des Systems auf dem neuesten Stand. Fehlerbehebungen und Verbesserungen in der Systemsoftware sollten regelmäßig eingespielt werden.
4. Implementierung von Failsafe-Mechanismen: Füge Failsafe-Mechanismen hinzu, die das System in einem sicheren Zustand halten, wenn ein kritischer Fehler auftritt. Dies könnte das automatische Anhalten des Förderbands oder das Aktivieren von Notbremsen umfassen.
5. Echtzeit-Datenanalyse: Verwende fortgeschrittene Algorithmen zur Echtzeit-Datenanalyse und Mustererkennung, um frühzeitig Anomalien zu erkennen und entsprechende Maßnahmen zu ergreifen. Maschinelles Lernen und KI-Ansätze können hier besonders nützlich sein.

Durch die Integration dieser Maßnahmen in das Fehlermanagementsystem kann die Zuverlässigkeit und Effizienz des Fördersystems erheblich gesteigert werden.

Aufgabe 3)

Betrachten wir ein Regelkreissystem, das durch die Übertragungsfunktion \(\frac{G(s)}{1+G(s)H(s)}\) beschrieben wird, wobei \(G(s)\) die Übertragungsfunktion des offenen Regelkreises und \(H(s)\) die Übertragungsfunktion des Rückführpfads ist.

Um die Stabilität dieses Systems zu bewerten, können wir verschiedene Methoden anwenden, wie z.B. das Routh-Hurwitz-Kriterium, das Nyquist-Kriterium oder das Bode-Diagramm.

a)

Bestimme die Stabilität des Systems mit der folgenden Übertragungsfunktion unter Verwendung des Routh-Hurwitz-Kriteriums:

G(s) = \frac{10(s+2)}{(s+1)(s+3)(s+5)} H(s) = 1

Führe alle notwendigen Schritte durch und zeige, ob das System stabil ist oder nicht.

Lösung:

Um die Stabilität eines Regelkreissystems mit \(\frac{G(s)}{1+G(s)H(s)}\) zu bestimmen, gehen wir durch die folgenden Schritte, wobei \(G(s)\) die Übertragungsfunktion des offenen Regelkreises und \(H(s)\) die Übertragungsfunktion des Rückführpfads darstellt.

Für die gegebenen Übertragungsfunktionen:

G(s) = \frac{10(s+2)}{(s+1)(s+3)(s+5)} H(s) = 1

Die geschlossene Übertragungsfunktion des Systems lautet:
```
 T(s) = \frac{G(s)}{1+G(s)H(s)}
```

Erstellen wir die geschlossene Übertragungsfunktion:

 T(s) = \frac{\frac{10(s+2)}{(s+1)(s+3)(s+5)}}{1+\frac{10(s+2)}{(s+1)(s+3)(s+5)}} = \frac{10(s+2)}{(s+1)(s+3)(s+5) + 10(s+2)}

Der Nenner ist:

(s+1)(s+3)(s+5) + 10(s+2)

Multiplizieren und summieren wir die Terme:

(s^3 + 9s^2 + 23s + 15) + 10(s + 2) = s^3 + 9s^2 + 33s + 35

Das charakteristische Polynom des geschlossenen Systems ist:

s^3 + 9s^2 + 33s + 35

Wir erstellen nun die Routh-Tafel, um die Stabilität zu analysieren:

Erstellen der Koeffiziententabelle:

 s^3 | 1  33  s^2 | 9  35  s^1 | \frac{9 \cdot 33 - 35 \cdot 1}{9} = \frac{262}{9} 0  s^0 | 35

Da alle Einträge in der ersten Spalte der Routh-Tafel positiv sind, bedeutet dies, dass keine Vorzeichenwechsel vorliegen und somit das System stabil ist.

Daher ist das System stabil.

b)

Verwende das Nyquist-Kriterium zur Analyse der Stabilität für das System mit der Übertragungsfunktion:

G(s) = \frac{10(s+4)}{(s^2+2s+2)(s+6)} H(s) = 1

Zeichne das Nyquist-Diagramm und bestimme, ob das System stabil ist.

Lösung:

Um die Stabilität des gegebenen Systems mit dem Nyquist-Kriterium zu analysieren, betrachten wir folgende Übertragungsfunktion:

G(s) = \frac{10(s+4)}{(s^2+2s+2)(s+6)}, \quad H(s) = 1

Das Nyquist-Kriterium basiert auf der Analyse der offenen Schleifenübertragungsfunktion \(G(s)H(s)\). Da \(H(s) = 1\), ergibt dies:

G(s)H(s) = \frac{10(s+4)}{(s^2+2s+2)(s+6)}

Das Nyquist-Diagramm zeigt den Frequenzgang von \(G(s)H(s)\) für \(s = j\omega\) (wobei \(j\) die imaginäre Einheit und \(\omega\) die Frequenz ist).

Um das Nyquist-Diagramm zu zeichnen, führen wir die folgenden Schritte aus:

Bestimme den Frequenzgang \(G(j\omega)\) für verschiedene Werte von \(\omega\).
Skizziere die reale und die imaginäre Achse.
Trage die resultierenden Punkte in die komplexe Ebene ein.
Verbinde die Punkte, um die Kurve zu vervollständigen.

Da wir hier kein Diagramm zeichnen können, stellen wir die theoretische Analyse des Nyquist-Kriteriums dar.

Ermitteln der Pole des geschlossenen Regelkreisesystems:

1 + G(s)H(s) = 0 \implies G(s)H(s) = -1

Finde die Pole der Funktion \(G(s)H(s)\):

(s^2 + 2s + 2)(s + 6) = 0

Die Pole sind:

s = -1 \pm j und s = -6

Nach dem Nyquist-Kriterium bestimmt sich die Stabilität durch die Anzahl der Umläufe um den Punkt -1 in der komplexen Ebene. Diese Umläufe entsprechen der Anzahl der Pole in der rechten Halbebene minus der Anzahl der Nullstellen in der rechten Halbebene.

Ermitteln wir die Frequenzantwort für einige Werte von \(\omega\). Setzen wir \(s = j\omega\) ein:

G(j\omega) = \frac{10(j\omega+4)}{((j\omega)^2 + 2j\omega + 2)(j\omega + 6)} = \frac{10(j\omega + 4)}{(-\omega^2 + 2j\omega + 2)(j\omega + 6)}

Analysieren wir die kritischen Punkte:

Für \(\omega = 0\):

G(j0) = \frac{10(0+4)}{(0+2)(0+6)} = \frac{40}{12} = \frac{10}{3}

Für \(\omega \to \infty\):

G(j\omega) \approx \frac{10j\omega}{j\omega^3} = \frac{10}{\omega^2} \to 0

Für \(\omega = 1\):

G(j1) = \frac{10(j + 4)}{((-1) + 2j + 2)(j + 6)} = \frac{10(j + 4)}{(1 + 2j)(j + 6)}

Fassen wir die wichtige Punkte zusammen, achen wir Pol-Gang schlossen und überprüfen ob -1 sicher:

Da keine Rechte Halbe Poles, P=0
Nyquist Einkreis nur wenn Punkt umkreisen -1 fixes no-cross:

Daher, System Stabil.

c)

Erstelle das Bode-Diagramm für das System mit der Übertragungsfunktion:

G(s) = \frac{20}{(s+2)(s+4)} H(s) = 1

Berechne die Verstärkungs- und Phasenreserve und erkläre anhand der Ergebnisse, ob das System stabil ist.

Lösung:

Um das Bode-Diagramm für das System mit der gegebenen Übertragungsfunktion zu erstellen:

G(s) = \frac{20}{(s+2)(s+4)}, \quad H(s) = 1

folgen wir den folgenden Schritten:

Bestimme die offene Übertragungsfunktion: \(G(s)H(s) = \frac{20}{(s+2)(s+4)}\)
Zeichne die Bode-Diagramme für Betrag und Phase von \(G(j\omega)\).

1. Faktorisiere die Übertragungsfunktion in einzelne Elemente:

G(s) = \frac{20}{(s+2)(s+4)} = \frac{20}{(s+2)} \cdot \frac{1}{(s+4)}

2. Bestimme die asymptotischen Näherungen und zeichne sie.

Zuerst das Bode-Diagramm für \(\frac{20}{s+2}\) (Pol bei s = -2):
Zweiter Pol (s = -4).

3. Bode-Diagramm besteht aus folgenden Abschnitten:

Amplitudengang (Magnitude Plot)
Phasengang (Phase Plot)

4. Magnitude (dB):

Erste Teil: \(20\log_{10}20 = 26\) dB
Ab -2 rad/s sinken um -20 dB/Dekade
Ab -4 rad/s geht weiter um -20 dB/Dekade

Die gesamte Höhe bei -6 rad/s:

26 -40 = -14

5. Phase (grad):

Ab 0: 0°
Ab -2 rad/s: -45° sinkt weiter bis -90°
Ab -4 rad/s: weiterer Abfall bis zu insgesamt -180°

6. Berechne Verstärkungs- und Phasenreserve:

Verstärkungsreserve (Gain Margin GM): Wert des Betrags bei Phasendurchgang -180° erreicht
Phasenreserve (Phase Margin PM): Abstand -180° Phasenschritt bis zum Überflug: P bei -180 zeigt, ob oberhalb 0

System ist stabil, wenn:

Verstärkungsreserve positiv ist
Phasenreserve mehr als 0°

Schluß:

Beispielwerte Eingangs und Ausgang Dämpfung stabil liefert mehr als 0° Phasenreserve. System stabil bestätigt

Aufgabe 4)

Echtzeitprogrammierung für mechatronische AnwendungenProgrammierung, die strikte Zeitvorgaben einhält, um bei mechatronischen Systemen (z.B. Roboter, Fahrzeugsteuerungen) zuverlässig und pünktlich auf Ereignisse zu reagieren.

Echtzeitbetriebssysteme (RTOS) erforderlich
Wichtige Kenngrößen: Latenzzeit, Jitter
Unterscheidung in harte (müssen eingehalten werden) und weiche Echtzeitbedingungen (sollten eingehalten werden)
Typische Programmiersprachen: C, C++, Ada
Prioritätensysteme zur Aufgabensteuerung
Interprozesskommunikation und -synchronisation entscheidend
Nutzung von Timer und Interrupts

a)

(a) Erkläre den Unterschied zwischen harten und weichen Echtzeitbedingungen und gib je ein Beispiel, wo diese Bedingungen jeweils in mechatronischen Systemen angewendet werden.

Lösung:

Echtzeitbetriebssysteme (RTOS) erforderlich
Wichtige Kenngrößen: Latenzzeit, Jitter
Unterscheidung in harte (müssen eingehalten werden) und weiche Echtzeitbedingungen (sollten eingehalten werden)
Typische Programmiersprachen: C, C++, Ada
Prioritätensysteme zur Aufgabensteuerung
Interprozesskommunikation und -synchronisation entscheidend
Nutzung von Timer und Interrupts

(a) Erkläre den Unterschied zwischen harten und weichen Echtzeitbedingungen und gib je ein Beispiel, wo diese Bedingungen jeweils in mechatronischen Systemen angewendet werden.Harte Echtzeitbedingungen:

Definition: Bei harten Echtzeitbedingungen müssen alle zeitlichen Anforderungen strikt eingehalten werden. Ein Versagen kann zu katastrophalen Folgen führen.
Beispiel: Eine Airbag-Steuerung in einem Auto ist ein Beispiel für harte Echtzeitbedingungen. Der Airbag muss innerhalb von Millisekunden nach einem Aufprall aktiviert werden, um die Sicherheit der Insassen zu gewährleisten.

Weiche Echtzeitbedingungen:

Definition: Bei weichen Echtzeitbedingungen sollten die zeitlichen Anforderungen eingehalten werden, aber ein gelegentliches Versagen führt nicht zu katastrophalen Folgen.
Beispiel: Ein Beispiel für weiche Echtzeitbedingungen ist ein Multimedia-Player in einem Fahrzeug. Eine geringe Verzögerung beim Abspielen eines Videos ist tolerierbar und beeinträchtigt nicht die Funktionalität des Gesamtsystems.

b)

(b) Ein Echtzeitsystem hat eine durchschnittliche Latenzzeit von 20ms und einen Jitter von 5ms. Berechne die minimale und maximale Reaktionszeit des Systems.

Lösung:

Echtzeitbetriebssysteme (RTOS) erforderlich
Wichtige Kenngrößen: Latenzzeit, Jitter
Unterscheidung in harte (müssen eingehalten werden) und weiche Echtzeitbedingungen (sollten eingehalten werden)
Typische Programmiersprachen: C, C++, Ada
Prioritätensysteme zur Aufgabensteuerung
Interprozesskommunikation und -synchronisation entscheidend
Nutzung von Timer und Interrupts

(b) Ein Echtzeitsystem hat eine durchschnittliche Latenzzeit von 20ms und einen Jitter von 5ms. Berechne die minimale und maximale Reaktionszeit des Systems.Die Reaktionszeit eines Echtzeitsystems kann durch die durchschnittliche Latenzzeit und den Jitter bestimmt werden.

Definition: Die Latenzzeit ist die Zeit, die ein System benötigt, um auf ein Event zu reagieren.
Definition: Der Jitter ist die Variabilität der Latenzzeit.

Um die minimale und maximale Reaktionszeit zu berechnen:

Minimale Reaktionszeit: Die durchschnittliche Latenzzeit minus den Jitter
Maximale Reaktionszeit: Die durchschnittliche Latenzzeit plus den Jitter

Angaben:

Durchschnittliche Latenzzeit = 20ms
Jitter = 5ms

Berechnungen:

Minimale Reaktionszeit = 20ms - 5ms = 15ms
Maximale Reaktionszeit = 20ms + 5ms = 25ms

Daher betragen die minimale und maximale Reaktionszeit des Systems:

Minimale Reaktionszeit: 15ms
Maximale Reaktionszeit: 25ms

c)

(c) Du hast die Aufgabe, ein Steuerungssystem für einen autonomen Roboter zu implementieren, das auf ein RTOS angewiesen ist. Diskutiere die Wahl der geeigneten Programmiersprache und beschreibe, wie Du Timer und Interrupts im System nutzen würdest, um Echtzeitfähigkeit zu gewährleisten.

Lösung:

Echtzeitbetriebssysteme (RTOS) erforderlich
Wichtige Kenngrößen: Latenzzeit, Jitter
Unterscheidung in harte (müssen eingehalten werden) und weiche Echtzeitbedingungen (sollten eingehalten werden)
Typische Programmiersprachen: C, C++, Ada
Prioritätensysteme zur Aufgabensteuerung
Interprozesskommunikation und -synchronisation entscheidend
Nutzung von Timer und Interrupts

C: C ist sehr weit verbreitet in der Embedded- und Echtzeitprogrammierung. Es ist nah an der Hardware, was niedrige Latenzzeiten und genaue Kontrolle über Ressourcen ermöglicht.
C++: C++ bietet Objektorientierung und höhere Abstraktionsebenen, ist aber auch in der Lage, systemnahe Programmierung zu unterstützen. Es wird oft verwendet, wenn komplexere Softwarestrukturen erforderlich sind.
Ada: Ada wurde speziell für Echtzeitanwendungen entwickelt und bietet eingebaute Funktionen für parallele Programmierung und Zeitmanagement. Es ist sehr zuverlässig und sicher, aber nicht so weit verbreitet wie C oder C++.

Für ein Steuerungssystem eines autonomen Roboters könnte die Wahl auf C oder C++ fallen, da diese Sprachen eine gute Balance zwischen Performance, Hardwarezugriff und entwicklerfreundlichen Funktionen bieten.Nutzung von Timer und Interrupts im System:

Timer: Timer sind essenziell, um periodische Ereignisse in Echtzeitsystemen zu kontrollieren. Im Steuerungssystem des Roboters können Timer benutzt werden, um zu bestimmten Zeitintervallen sensorische Daten zu erfassen, motorische Befehle zu aktualisieren und diverse periodische Hintergrundaufgaben zu erledigen.
Interrupts: Interrupts ermöglichen es dem System, sofort auf äußere oder interne Ereignisse zu reagieren, anstatt auf das Ende eines aktuellen Tasks zu warten. Z.B. könnte ein Sensorwert, der eine Gefahrensequenz identifiziert, einen Interrupt auslösen, um den Roboter sofort zu stoppen und Kollisionen zu verhindern.

Ein Implementierungsbeispiel in C oder C++ könnte so aussehen:Initialisierung eines Timers in C:

#include <avr/io.h>void init_timer() {   // Timer konfigurieren, z.B. mit Compare Match Mode und entsprechender Pre-Scaler-Einstellung   TCCR1B |= (1 << WGM12); // CTC Mode   TCCR1B |= (1 << CS12); // Pre-scaler 256   OCR1A = 15624; // Timer Wert für 1Hz bei 16MHz   TIMSK1 |= (1 << OCIE1A); // Interrupt Enable}ISR(TIMER1_COMPA_vect) {   // Timer-Aktionsroutine   sensor_data_update();   control_logic();}

Initialisierung eines Interrupts in C:

#include <avr/io.h>void init_interrupt() {   // Beispielkonfiguration für externen Interrupt   EICRA |= (1 << ISC01); // Falling edge of INT0   EIMSK |= (1 << INT0); // Enable INT0}ISR(INT0_vect) {   // Interrupt-Aktionsroutine   handle_emergency();}

Diese Beispiele zeigen, wie Timer und Interrupts konfiguriert und genutzt werden können, um die Echtzeitfähigkeit des Steuerungssystems zu gewährleisten und sicherzustellen, dass kritische Aufgaben rechtzeitig ausgeführt werden.

Mechatronic components and systems (MCS) - Exam.pdf

Mechatronic components and systems (MCS) - Exam

Aufgabe 1)

a)

b)

c)

Aufgabe 2)

a)

b)

c)

d)

Aufgabe 3)

a)

b)

c)

Aufgabe 4)

a)

b)

c)

Unternehmen

Produkt

Hilfe

Mechatronic components and systems (MCS) - Exam.pdf

Mechatronic components and systems (MCS) - Exam

Aufgabe 1)

a)

b)

c)

Aufgabe 2)

a)

b)

c)

d)

Aufgabe 3)

a)

b)

c)

Aufgabe 4)

a)

b)

c)

Melde dich kostenlos an, um Zugriff auf das vollständige Dokument zu erhalten