Projekt 40: Regelung eines fertigen Laborversuchsaufbaus "Lageregelung": Unterschied zwischen den Versionen

Aktuelle Version vom 5. Februar 2016, 23:21 Uhr

Autoren: Madleine Kahr, Adam Fankhauser
Betreuer: Prof. M. Göbel

Aufgabe

Die Aufgabe in diesem Projekt bestand darin, einen Regler für einen fertigen Laborversuchsaufbau zu entwickeln, welcher die Lage eines Schlittens regelt. Der Regler soll auf der Hardware eines Arduino Uno Boards laufen, dieser soll sich außerhalb des Aufbaus befinden und über einen 50 poligen Stecker angeschlossen werden. Sowohl der Aufbau, als auch das Arduino-Board waren zum Projektbeginn vorhanden, wodurch keine Beschaffung von Hardware notwendig war. Die Vorgehensweise bei diesem Projekt richtete sich klassisch nach den vier Projektphasen: Vorbereitung, Planung, Durchführung und Präsentation/Dokumentation.

Erwartungen an die Projektlösung

Darstellung der Theorie
Entwurf eines Regelkreises
Recherche zu bestehenden Lösungen
Systemidentifikation (Übertragungsfunktion der Regelstrecke bestimmen)
Vergleichen und bewerten Sie verschiedene Regleransätze (P, I, D), Darstellung der Soll-/Istgrößen.
Programmiersprache: C
Test und wiss. Dokumentation
Live Vorführung während der Abschlusspräsentation

Schwierigkeitsgrad

Anspruchsvoll (***)

Vorbereitung

Zur Vorbereitung auf das Projekt wurde der aktuelle Stand des Projekts analysiert. Dazu wurde die Dokumentation auf der HSHL-Wiki Seite zur Rate gezogen, sowie die Informationen, die im Projektordner abgelegt wurden. Aus den Unterlagen des letzten Projektes ging hervor, dass schon einmal ein funktionierender PI-Regler entwickelt wurde, dieser wurde zur Einarbeitung analysiert und getestet. Dabei sind mehrere Sachen aufgefallen. Zum einen wurde in der Programmierung des Arduino der Befehl digitalWrite() benutzt, um den Motor mit einem PWM-Signal anzusteuern . Die Funktion lässt aber nur zu, dass der Ausgang die Signale HIGH und LOW liefert, was in der Regelung nur genauso lange funktioniert, wie der I-Anteil des Reglers klein bleibt. Die eigentliche Funktion des Ausgangs zur Erzeugung eines PWM-Signals wird mit der Funktion analogWrite() erzeugt, welche Werte von 0 bis 255 als Eingangsgrößen akzeptiert. Im Gegensatz zu der letzten Projektbearbeitung sollte dieses Mal selber Softwaretechnisch ein Regler entwickelt werden, d.h. ohne Unterstützung einer Library. Dazu wurden die Ansätze eines digitalen Zeitdiskreten PID Reglers recherchiert. Aus der Vorlesung Mess- & Regelungstechnik wurde entnommen, dass der D-Anteil gefiltert werden muss, hierzu wurde aus den Vorlesungsunterlagen das PT1-Filter entnommen.

Versuchsaufbau

	Pin an Arduino	Pin/Bezeichnung an dem Laborversuchsaufbau (Signale)
1	A0	Potentiometer - "Sollwert" (0-1023)
2	A1	Potentiometer - "P-Anteil" (0-1023)
3	A2	Potentiometer - "I-Anteil" (0-1023)
4	A3	Potentiometer - "D-Anteil" (0-1023)
5	A4	Potentiometer - Linear (0-1023)
6	3 (PWM)	Motoransteuerung Rechtslauf (LOW , 0-255)
7	4	Motoransteuerung (LOW, HIGH)
8	5 (PWM)	Motoransteuerung Linkslauf (LOW , 0-255)

Der Laborversuch ist so aufgebaut, dass durch einen Servomotor eine Spindel angetrieben wird. Dieser Motor lässt sich im Links- und Rechtslauf antreiben. Auf der Spindel befindet sich ein Schlitten, welcher sich durch die Drehung der Spindel auf dieser nach links und rechts bewegt. Der Fahrweg des Schlittens beträgt ca. 14 cm Durch ein Linearpotentiometer, das parallel zur Spindel angebracht ist, lässt sich die Position des Schlittens bestimmen. An den Endpositionen des Potentiometers befinden sich Endschalter, welche die Stromversorgung für den Motor ausschalten, um einen Überlauf des Schlittens zu verhindern. Über vier Drehpotentiometer, die sich an der Vorderseite des Aufbaus befinden lassen sich zum einen die gewünschte Sollposition, sowie die verschiedenen Regleranteile einstellen. Der Versuchsaufbau wird über ein Arduino Uno Board gesteuert, welches mit einem PC verbunden ist. Die Pinbelegung des ist in der nachfolgenden Tabelle dargestellt:

Planung

Bei der Planung des Projektes sollte die Regelung des Aufbaus bestimmt und simuliert werden. Dafür wurde die Theorie dargestellt, ein Regelkreis entworfen und das System mithilfe von Matlab/Simulink simuliert. Da die Programmieroberfläche von Arduino keine Logging Funktionen bietet wurde hier auf das Tool Terminal.exe zurückgegriffen. Damit wurden die Messergebnisse aufgenommen, um sie mit Excel oder Matlab zu visualisieren.

Theorie

Die Übergangsfunktionen der zeitdiskreten Regler P, PI und PID sind hier entnommen. Die Regelstrecke weist ein I-Verhalten auf. Dies wurde experimentell ermittelt, indem ein Einheitssprung in die Regelstrecke eingeführt wurde. Praktisch bedeutet dies, den Motor anzuschalten. Das bedeutet wiederum, dass der zurückgelegte Weg sich über die Zeit aufintegriert. Die Messdaten wurden visualisiert, über die Steigung der Geraden konnte der Faktor $K_i$ der Regelstrecke bestimmt werden.

Regelkreis

Die Sollgröße wird über das Drehpotentiometer bestimmt und in den Regelkreis eingebracht. Die Regelabweichung wird an den Regler, welcher als P, PI oder PID-Regler realisiert werden soll, übergeben. Dieser übergibt dann ein PWM-Signal an die Regelstrecke. Diese besteht aus dem Motor und der Spindel. Durch das Linearpotentiometer wird die Ist-Position bestimmt, welche als Rückführgröße wieder in den Regelkreis eingeht.

Simulation mit Matlab/Simulink

Mithilfe von Matlab/Simulink wurde die Regelstrecke simuliert. Mithilfe dieser Simulation konnten die Einflüsse der verschiedenen Reglertypen und die Veränderung von ihren Kennwerten prinzipiell veranschaulicht werden. Dadurch wurden die Abläufe im Regelkreis deutlich.

Durchführung

Bei der Durchführung wurde zunächst der Regler in der Programmiersprache C umgesetzt. Danach wurde der P-Regler eingesetzt, um die Regleranteile nach Ziegler/Nichols zu ermitteln. Dazu wurde der $K_p$ Faktor so hoch gedreht, bis das System instabil wurde, d.h. dass der Schlitten über den eingestellten Sollwert hin- und hergefahren ist. Dies ergab: $K_{p,krit} = 2800$ und $T_{krit} = 1,5s$ . Die Berechnung mithilfe dieser Ergebinisse ergab folgende Einstellungen:

P-Regler: $K_p = 1400$

PI-Regler: $K_p = 1260$ $K_i = 988$

PID-Regler: $K_d = 1680$ $K_i = 2240$ $K_d = 302$

Mit diesen Einstellungen wurden nun die Regler getestet und folgende Sprungantworten aufgenommen.

Programmcode

//--------------------------------------------------------
//PID Regler für Laborversuchsaufbau "Lageregelung"
//Hochschule Hamm-Lippstadt
//Fachpraktikum Elektrotechnik
//
//Datum:  14.12.2015
//Autoren:  Madleine Kahr, Adam Fankhauser
//--------------------------------------------------------

//PINs definieren
#define MotorAnsteuerung 4
#define MotorRechts 3
#define MotorLinks 5
#define SollPoti A0
#define KpPoti A1
#define KiPoti A2
#define KdPoti A3
#define LinearPoti A4

//Größen definieren
double SollPosition, IstPosition, Stellgroesse, Regeldifferenz;
double Kp, Ki, Kd;
double PAnteil, IAnteil, DAnteil, RegeldifferenzSumme;
int Wertebereich_Kp, Wertebereich_Ki, Wertebereich_Kd;

//Zeiten definieren
double now, then, dt;

//Variablen für PT1_Filter definieren
float k_f,T0_f, Regeldifferenz_filt_neu_f, Regeldifferenz_filt_alt_f;

void setup()
{
  Serial.begin(9600); //Kommunikation mit Baudrate 9600 starten

  //Digitale Pins als OUTPUT definieren
  pinMode(MotorAnsteuerung, OUTPUT);
  pinMode(MotorRechts, OUTPUT);
  pinMode(MotorLinks, OUTPUT);

  //Variablen setzen
  Wertebereich_Kp = 3000;
  Wertebereich_Ki = 2500;
  Wertebereich_Kd = 1000;
  RegeldifferenzSumme = 0;
  T0_f = 0.001;   // T0_f << T_d
  
  then = millis(); //Startzeit holen
}

void loop()
{
  //Werte der Proportinalbeiwerte auslesen und umrechnen
  Kp = analogRead(KpPoti);
  Kp = Kp/1023*Wertebereich_Kp;
  Ki = analogRead(KiPoti);
  Ki = Ki/1023*Wertebereich_Ki;
  Kd = analogRead(KdPoti);
  Kd = Kd/1023*Wertebereich_Kd;

  //Soll- und Istposition auslesen und umrechnen, Regeldifferenz berechnen
  SollPosition = analogRead(SollPoti);
  SollPosition = SollPosition/1023*14;
  IstPosition = analogRead(LinearPoti);
  IstPosition = 14 - (IstPosition - 157)/(850-157)*14;

  Regeldifferenz = SollPosition - IstPosition;

  //aktuelle Zeit holen, Zeitdifferenz berechnen (Abtastzeit)
  now = millis();
  dt = (now-then)/1000;
  then = now;

  //Anti-Windup Strategie
  if((Stellgroesse < 255) && (Stellgroesse > 0))
    RegeldifferenzSumme = RegeldifferenzSumme + Regeldifferenz;

  //Signal filtern für D-Anteil
  k_f = dt/(T0_f+dt);
  Regeldifferenz_filt_neu_f = (1-k_f) * Regeldifferenz_filt_alt_f + k_f * Regeldifferenz;
  
  //Anteile berechnen und zu Stellgröße addieren
  PAnteil = Regeldifferenz*Kp;
  IAnteil = RegeldifferenzSumme*dt*Ki;
  DAnteil = ((Regeldifferenz_filt_neu_f-Regeldifferenz_filt_alt_f)/dt)*Kd;
  
  Stellgroesse = abs(PAnteil + IAnteil + DAnteil); 

  //Stellgröße für Übergabe an Motor vorbereiten
  if(Stellgroesse > 255)
    Stellgroesse = 255;
  if(Stellgroesse < 1)
    Stellgroesse = 0; 

  //Ausgabe an Konsole für Überwachung und Logging  
  Serial.print(now);
  Serial.print(";     Ist; ");
  Serial.print(IstPosition);
  Serial.print(" ;cm; Soll; ");
  Serial.print(SollPosition);
  Serial.print(" ;cm;");
  Serial.print("     Kp; ");
  Serial.print(Kp);
  Serial.print(" ; Ki; ");
  Serial.print(Ki);
  Serial.print(" ; Kd; ");
  Serial.print(Kd);
  Serial.print(" ;     Stellgroesse; ");
  Serial.print(Stellgroesse);
  Serial.print(" ; Regelabweichung; ");
  Serial.print(Regeldifferenz);
  /*Serial.print(" ; esummme; ");
  Serial.print(RegeldifferenzSumme); */
  Serial.print(" ;   PAnteil; ");
  Serial.print(PAnteil);
  Serial.print(" ; IAnteil; ");
  Serial.print(IAnteil);
  Serial.print(" ; DAnteil; ");
  Serial.print(DAnteil);
  Serial.println(" ,");

  //Übergabe der Stellgröße an Motor 
  if(Regeldifferenz > 0) // Schlitten nach rechts fahren lassen
  {   
    digitalWrite(MotorLinks, LOW);
    analogWrite(MotorRechts, Stellgroesse);
    digitalWrite(MotorAnsteuerung, HIGH);
  }
  else if(Regeldifferenz < 0) // Schlitten nach links fahren lassen
  {
    digitalWrite(MotorRechts, LOW);
    analogWrite(MotorLinks, Stellgroesse);
    digitalWrite(MotorAnsteuerung, HIGH);
  }

}

Präsentation/Dokumentation

Die Präsentation des Projektes erfolgte über einen Messeauftritt in der Hochschule Hamm-Lippstadt. Bei dieser Messe wurden alle Projekte des Elektrotechnikfachpraktikums vom Wintersemester 15/16 vorgestellt. Bei dieser Präsentation wurden mithilfe des Versuchsaufbaus und einer Visualisierung über Matlab die im Semester erreichten Projektziele gezeigt. Zur Veranschaulichung wurden Plakate mit den wichtigsten Informationen in der Nähe des Versuchsaufbaus aufgestellt. Die Dokumentation erfolgte über diesen Artikel im HSHL-Wiki und über ein Präsentationsvideo

Fazit

Als Fazit lässt sich sagen, dass das Projekt zum größten Teil, aber nicht vollständig abgeschlossen werden konnte. Das System konnte erfolgreich identifiziert werden, ebenso konnte ein funktionierender Regler in der Programmiersprache C implementiert werden. Schon in der Theorie konnte nachgewiesen werden, dass ein einfacher P-Regler bei Betrachtung der Führungsgröße keine statische Regelabweichung hinterlässt. Die Messergebnisse haben allerdings gezeigt, dass der P-Regler trotzdem eine statische Regelabweichung hinterlässt. Zurückzuführen ist dies darauf, dass auch Störeinflüsse einfließen, die in der Theorie nicht berücksichtigt wurden. Die Auswertung des PI-Reglers zeigt, was auch die Theorie besagt, dass keine stationäre Regelabweichung zurück bleibt, der Regler aber langsamer reagiert. Leider konnte bei dieser Projektbearbeitung der PID-Regler nicht so eingestellt werden, dass dieser vernünftige Ergebnisse liefert. Dies bleibt als Anregung für die Studierenden zurück, die dieses Projekt als nächstes bearbeiten. Außerdem wurde von Prof. Schneider als Anregung gegeben, die Implementierung des Reglers in Matlab/Simulink umzusetzen, um aus der Simulation des Systems einen einfachen Übertrag zum anwendbaren Regler und eine gute Vergleichsmöglichkeit zwischen Simulation und Realität zu haben.

Quellen

Vorlesung Mess- und Regelungstechnik von Prof. Göbel

Digitaler Regler

→ zurück zum Hauptartikel: Fachpraktikum Elektrotechnik (WS 14/15)