Bahn berechnen - Sollposition

[Markus]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

wie kann ich die Bahn auf der Skizze im Anhang berechnen?

Also am Anfang während der Beschleunigung gilt: s = 0,5 * a * t²

Wenn die Sollgeschwindigkeit(v) erreicht ist gilt: s = v * t

s = Strecke (Sollposition)
a = Beschleunigung
t = Zeit
v = Geschwindigkeit

Nun gilt es die obere Bahn zu berechnen bis die Geschwindigkeit wieder auf 0 ist.

ich denke ich müsste zuerst die Restzeit berechnen die es braucht bist die Sollgeschwindigkeit bei der eingestellten negativen Beschleunigung (Bremsrampe) den Wert v = 0 erreicht hat.

Diese zeit müsste dann in eine Funktion eingesetzt werden die mit die Sollposition entsprechend rechnet.

Aber da bin ich mit meinem verstaubten Mathe am Ende...

DANKE!

 

[Larry Laffer]

Hallo Markus,
das ist auch nichts, wo es eine direkte Formel dafür gibt. Es ist vielmehr ein Teil einer Schleife, die so lange abgearbeitet wird bis die Bedingung (v = Vorgabe) erreicht ist. Ist dir der Wert, den du für a (Beschleunigung) hast / haben willst bekannt ?
Wohin soll das gehen - es ist ja immerhin eine Funktion, die jeder Servo-Regler unterschwellig leistet ...

Gruß
LL

 

[Markus]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo Markus,
das ist auch nichts, wo es eine direkte Formel dafür gibt.

das glaube ich nicht
gut mit der schleife hast du nicht ganz unrecht, der wert s soll ja zyklisch (verlauf von t) neu gerechnet werden.
dafür gibt eine formel, nur blick ich es nicht...

Ist dir der Wert, den du für a (Beschleunigung) hast / haben willst bekannt ?

ist alles bekannt bis auf s der soll ja gerechnet werden.
gut und vermutlich muss erst das delta-t gerechnet werden um das s für die zeit von v=soll bis v=0 rechnen zu können.

aber wie?

Wohin soll das gehen - es ist ja immerhin eine Funktion, die jeder Servo-Regler unterschwellig leistet ...

Gruß
LL

jep, servoregler, und mc bausteine für alle möglichen steuerung haben die funktion drin, ich will sie auch haben:

https://www.sps-forum.de/threads/20779

 

[HMI-Muckel]

Hallo Markus,

ich würd es so machen:
v = sqrt(2*a*(Sist-Ssoll))
anschliessend mit v auf einen Rampenbaustein gehen
dessen Rampensteigung "a" entspricht.
Das daraus resultierende V ist die gesuchte Sollgeschwindigkeit.
Es fellen nur noch die nötigen Verriegelungen zum Start der
Positionierung

Beste Grüsse
Martin

 

[Markus]

Hallo Markus,

ich würd es so machen:
v = sqrt(2*a*(Sist-Ssoll))
anschliessend mit v auf einen Rampenbaustein gehen
dessen Rampensteigung "a" entspricht.
Das daraus resultierende V ist die gesuchte Sollgeschwindigkeit.
Es fellen nur noch die nötigen Verriegelungen zum Start der
Positionierung

Beste Grüsse
Martin

eben genau das will ich nicht machen!
habe ich bisher so gemacht, funktioniert auch ganz gut für einfache positionierungen.

ich will ganz bewusst den obigen weg mit dem bahnsollwert gehen/versuchen. mal sehen was so ne 319er mit <5ms zkluszeit alles kann...

 

[rostiger Nagel]

Zuviel Werbung?
-> Hier kostenlos registrieren

hallo markus ich hatte mal eine zielregelung in IPOS für einen MQP
gemacht, ich blicke nicht mehr richtig durch...aber vielleicht hilft es.

/*=============================================
   Zielregelung
   30.11.05  Helmut_von_der_Reparatur
   Eingabevariablen:
   TargetPos                Ziel in incr
   Reg_Speed                Geschwindigkeit in Anwendereinheit
   Ausgabe:
   Position_erreicht
   Lokale Variablen:
   Timer_1
   Reg_Differenz
   Reg_Divisor_Rampe
   Reg_Divisor_Rampe_min
   Reg_Divisor_Rampe_max
   Reg_Faktor_Rampe
   Reg_Lose_fahren
   Reg_Lose_gefahren
   Reg_Fenster              In Incrementen
   Verwendung
   Automatik Modus
   Funktionsweise
   Es wird wird die Differenz zwischen soll und Istposition ermittelt
   Dieser Wert ist die Geschwindigkeit, die nach oben durch die
   Feldbusgeschwindigkeit begrenzt wird. Damit sanft in das Ziel gefahren
   werden kann wird dieser Wert über einen Faktor und Divisor bewertet.
   Damit man nicht in das Ziel reinschleicht ist ein zweiter Divisor
   vorhanden (Divisor_min). Dieser wird kurz vor dem Ziel aktiv. Die Stoprampe ist
   keine Gerade.
   Die Stoprampe wird verschliffen
===============================================*/
Funktion_Zielregelung()
  {
  //-----  Ziel ohne Schleife  -----
  Reg_Schmier = TargetPos;
  //-----  Schleife ausrechnen  -----
  if(Reg_Lose_fahren && !Reg_Lose_gefahren)
    Reg_Schmier = TargetPos + (Reg_Lose* Faktor_Position / Divisor_Position);
  //-----  Schleife überfahren, Fahrt wiederholen  -----
  if(TargetPos > ActPos_Mot + Reg_Fenster)
    Reg_Lose_gefahren = 0;
  //-----  Differenz zwischen Soll und Ist ausrechnen  -----
  Reg_Differenz = Reg_Schmier - ActPos_Mot;
  if(Reg_Differenz < 0)
    Reg_Schmier = -Reg_Differenz;
    else
    Reg_Schmier = Reg_Differenz;
  //-----  Ziel-Regelung durchführen  -----
  Reg_Divisor_Rampe = Reg_Schmier / 5 + Reg_Divisor_Rampe_min;
  if(Reg_Divisor_Rampe > Reg_Divisor_Rampe_max)
    Reg_Divisor_Rampe = Reg_Divisor_Rampe_max;
  Reg_Schmier = Reg_Differenz * Reg_Faktor_Rampe / Reg_Divisor_Rampe;
  if(Reg_Differenz > 0 && Reg_Schmier < 0)
     Reg_Schmier = Reg_Speed;
  if(Reg_Differenz < 0 && Reg_Schmier > 0)
     Reg_Schmier = -Reg_Speed;
  if(Reg_Schmier > Reg_Speed)
     Reg_Schmier = Reg_Speed;
  if(Reg_Schmier < -Reg_Speed)
     Reg_Schmier = -Reg_Speed;
  if((Reg_Schmier > 0) && (Reg_Schmier < Reg_Mindestdrehzahl))
     Reg_Schmier = Reg_Mindestdrehzahl;
  if((Reg_Schmier < 0) && (Reg_Schmier > -Reg_Mindestdrehzahl))
     Reg_Schmier = -Reg_Mindestdrehzahl;
  //-----  Geschwindigkeit berechnen  -----
  Soll_Speed = Reg_Schmier * 0x4000 / 3000 * (Faktor_Speed / Divisor_Speed);
  //-----  Zieleinlauf durchführen  -----
  if(Reg_Differenz > Reg_Fenster || Reg_Differenz < -Reg_Fenster)
    Timer_1 = Verz_Ziel;
  if(Timer_1 == 0 && (Reg_Lose_gefahren || !Reg_Lose_fahren))
    Pos_erreicht_SET;
  if(Timer_1 == 0 && Reg_Lose_fahren)
    Reg_Lose_gefahren = 1;
  if(TargetPos == ActPos_Mot)
    Soll_Speed = 0;
  //-----  Geschwindigkeit herausgeben  -----
  mcd.PO2 = Soll_Speed;
  }

 

[Cerberus]

Hallo Markus,

Der Bremsweg in Abhängigkeit der Zeit die schon gebremst wird berechnet sich wie folgt:

S(t) = Vsoll * t - 0,5 * a * t

Dabei ist S der Bremsweg (zu Beginn der Bremsung 0), Vsoll die Geschwindigkeit die beim Beginn der Bremsung erreicht ist, a ist die "Bremsbeschleunigung" (also z.B. 4 m/s² wenn mit 4 m/s² abgrebremst wird) und t ist die Zeit die seit Beginn der Bremsung schon vergangen ist.

 

[Larry Laffer]

... bei konsequenter Umsetzung und Umstellung der obigen Einzel-Formeln ergibt sich für den Beschleunigungs-/Bremsweg die Formel :

s = 2 * v² / a

... ist es das ?

 

[Cerberus]

Zuviel Werbung?
-> Hier kostenlos registrieren

Achtung

Hallo Markus,

Der Bremsweg in Abhängigkeit der Zeit die schon gebremst wird berechnet sich wie folgt:

S(t) = Vsoll * t - 0,5 * a * t

Dabei ist S der Bremsweg (zu Beginn der Bremsung 0), Vsoll die Geschwindigkeit die beim Beginn der Bremsung erreicht ist, a ist die "Bremsbeschleunigung" (also z.B. 4 m/s² wenn mit 4 m/s² abgrebremst wird) und t ist die Zeit die seit Beginn der Bremsung schon vergangen ist.

Achtung grober Fehler.

Muss natürlich ein t² sein:

S(t) = Vsoll * t - 0,5 * a * t²



Und zum Nachvollziehen mal noch die Erklärung dazu:

Die Geschwindigkeit während des Bremsens lässt sich wie folgt darstellen. V = Vsoll - a * t, wobei a wieder die Verzögerung und t die Zeit seit Beginn der Bremsung ist. Da der Weg nichts anderes als das Integral über die Geschwindigkeit ist, muss man die Geschwindigkeitsformel nur noch integrieren und erhält dann obige Formel für den Weg.

 

[Markus]

danke, aber ich mache immer noch was falsch...

zur erklärung, "zielposition" ist in dem falle der tabelle die poisiton ab der abgeremst werden soll.

später müsste diese position dann gerechnet werden ala

zeitpunkt wo das ziel erreicht wird - bremszeit

hoffe ihr werde aus der excel schlau...

 

[Cerberus]

Wenn ich deine Daten und meine Formeln nehm, dann hab ich folgendes:

Vsoll = 50 mm/s
a = 20 mm/s²
s = Vsoll * t - 0,5 * a * t²
v = Vsoll - a * t

Da die Endgeschwindigkeit null sein soll, kannst du aus der unteren Formel die Bremszeit ausrechnen:

v = Vsoll - a * t
0 = 50 - 20 * t
t = 2,5 s

Aus t und den anderen Werten kann man dann mit Hilfe der oberen Fromel den Bremsweg ausrechnen:

s = Vsoll * t - 0,5 * a * t²
s = 50 * 2,5 - 0,5 * 20 * 6,25
s = 62,5 mm

Daraus folgt dann, dass du 62,5 mm vor deiner gewünschten Endposition deine Bremse anschmeißen musst.

 

[wwwandy]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich finde es ja echt schade, dass ihr die interessanten Themen immer mittags diskutiert, wo normale Leute arbeiten ;-). Zum Thema, Beschleunigungskonstant ist das alles schön machbar, ruckkonstant wird ecklig...

@Markus: Da du ein zeitdiskretes System hast variieren die Ergebnisse leicht, wenn du vom Integral auf die (reale) Summenformel übergehst. Ist aber zu vernachlässigen, wenn du kleine Zykluszeiten hast und sich die Geschwindigkeiten in Grenzen halten. Es sei noch erwähnt, dass üblicherweise nach der Geschwindigkeit "0" ein kleines Fester existiert, indem ein einfacher P-Regler verwendet wird für die Endpositionierung. Kannst dir ja vorstellen: Du hast eine Zykluszeit T. Jetzt berechnest du, dass du mit der angegeben negativen Beschleunigung 80.4*T zum stoppen brauchst. Wann fängst nun an zu bremesen? 80T oder 81T vorher? egal was du machst, entweder stoppst du kurz vorher oder kurz hinterher. Und das auch wenn du ständig ein Zustandsmodell mitlaufen hast...

Gruß von Andy

 

[wwwandy]

Für den Fall, dass sich jemand für ruckkonstante Positionierung interessiert:
Der Witz dabei ist, dass T (die Zykluszeit) eben nicht klein ist, in dem Fall unten 4s !!!
Alle Formel als Summe, keine Integrale(das wäre einfacher zu rechnen bei T->0)

function ret=a_f(a0,j,T,k)
 ret=a0+j*T*k;
endfunction

function ret=v_f(a0,v0,j,T,k)
 ret=v0+a0*T*k+(j*T^2*k.*(k+1))/2;
endfunction

function ret=s_f(a0,v0,s0,j,T,k)
 ret=s0+v0*T*k+(T^3*k.^3*j)/6+(T^3*k.^2*j)/2+(T^3*k*j)/3+(T^2*k.^2*a0+T^2*k*a0)/2.0;
endfunction

#Bei gegebenen Anfangsbedingungen zurückgelegter Weg bis Stop
#Phase 1 :bis auf mimal negative Beschleunigung
#Phase 2 :mit konstanter Beschleunigung weiter
#Phase 3 :bis auf Beschleunigung 0 und Geschwindigkeit 0

function ret=s_stop_dist(jm,am,a,v,T)
 #Zeit bis mimale negative Beschleunigung aufgebaut wurde
 k1=(am-a)/(jm*T);
 #Geschwindigkeit, bei der mimale Bremsbeschleunigung aufgebaut wurde
 v1=v_f(a,v,-jm,T,k1);
 #Weg der bis dorthin zurückgelegt wurde
 s1=s_f(a,v,0,-jm,T,k1);

 #"von hinten" Phase 3 berechnen
 k3=am/(jm*T);
 v2=v_f(0,0,jm,T,k3-1);
 s3=s_f(0,0,0,jm,T,k3-2);

 #Wie lange dauert die Phase mit mimaler Bremsbeschleunigung?
 k2=(v1-v2)/(am*T);
 s2=s_f(-am,v1,0,0,T,k2);
 #printf("k1=%f  k2=%f  k3=%f\n",k1,k2,k3);
 ret=s1+s2+s3;
endfunction

Pos_Soll= 3046.2; #slog(13)*2

max_v=44.8; # in 1/s
max_a=1.6;  # in 1/s²
max_j=0.1;  # in 1/s^3

j=0;a=0;v=0;s=0;    #Anfangsbedingungen / Initialisierung

T=4.0 ; 

#Abtastpunkte bis max Beschleunigung
k_start= max_a/(max_j*T);

#Geschwindigkeit, beim Erreichen der maximalen Beschleunigung
v_accel=v_f(0,0,max_j,T,k_start); 
v_decel=v_f(max_a,0,-max_j,T,k_start);
 
s_accel=s_stop_dist(max_j,max_a,0,max_v,T)

for i=1:30

 s_accel_log(i)=s_stop_dist(max_j,max_a,a,v,T); #Nur debugging

 bremsen=(Pos_Soll-s)<=s_accel+v*T*0; 

 if (bremsen && (Pos_Soll-s) > (s_f(0,0,0,max_j,T,k_start-2)))
   #negative Beschleunigung aufbauen 
   a_faktor=-1;
 elseif ((Pos_Soll-s)>s_accel && v < (max_v - v_decel)) 
   #positive Beschleunigung aufbauen
   a_faktor=1;
 else
   #Beschleunigung auf 0 vermindern
   a_faktor=0;
 endif

 #Wenn a_faktor positiv mit max_j bis max_a erhöhen,
 #wenn negativ mit -max_j bis -max_a senken,
 #wenn 0 dann wenn a positiv mit -max_j senken,
 #            wenn a negativ mit max_j erhöhen bis max_a=0

 da=max_j*T*a_faktor;
 if (abs(a+da)<=max_a)
  a=a+da;
 endif

 if (a_faktor==0)    
    a=a-(max_j*T)*sign(a);
    if (abs(a)<max_j*T)
    a=0;
    endif
 endif

 v=v+a*T;
 s=s+v*T;

 slog(i)=s; alog(i)=a; vlog(i)=v; #Nur für debugging
endfor

plot(alog,"-o;a;",vlog/20,"-o;v;",slog/1000,"-o;s;")

 

[Markus]

Also seit man es mir erklärt verstehe ich es nicht mehr...

Mein Ziel:
Ein Baustein der eine folgende Parameter bekommt:
- Istposition [mm]
- Zielposition [mm]
- Beschleunigung (a) [mm/s²]
- Verzögerung (a) [mm/s²]
- Geschwindigkeit (v) [mm/s]

Daraus soll er die Bahn generieren, nach der ein nachgeschalteter Drehzahlregler P-Regler (ggf. noch mit I-Anteil) abhänig von der Aktuellen Bahnsollposition und der Istposition (Schleppabstand) eine Drehzhal für den Antrieb generiert.

Mein Ansatz:

U Neuer_Fahrauftrag
FP HM_1
SPBN CAL1
 
// Beschleunigungszeit und Weg berechnen
t = v / a
s = v * t / 2
 
// Verzögerungszeit und Weg berechnen
t = v / a
s = v * t / 2
 
// Verfahrzeit Konstantfahrt berechnen
s = ABS(Istpos-Zielpos) - Beschleunigungsweg - Verzögerungsweg
t = s / v
 
// Gesamtzeit für Fahrauftrag
t = Beschleunigunszeit + Verzögerungszeit + Verfahrzeit Konstantfahrt
 
L 0
T Istzeit
 
CAL1: nop 0
 
L Istzeit
T t
 
 
 
// -->- Sollposition für Verzögunsrampe berechnen
L Istzeit
L Gesamtzeit - Verzögerungszeit
>=R
SPBN V_AC
 
s = V * t - 0,5 * a * t²

 
SPA END1 
V_AC: nop 0
// --<-------------------------------------------------
 
 
 
 
// -->- Sollposition für Beschleunigunsrampe berechnen
L Istzeit
L Beschleunigunszeit
<=R
SPBN V_DE
 
s = v * t / 2
 
SPA END1
V_DE: nop 0
// --<-------------------------------------------------
 
 
 
 
// -->- Sollposition für Konstantfahrt berechnen
 
s = v * t
 
// --<-------------------------------------------------
 
 
END1: nop 0
 
 
 
// Istzeit Integrieren
 
L Istzeit
L letzter Zyklus
+R
T Istzeit

//edit
- Verzögerungsrampe hat Vorrang (hatte voher zuerst den Spung in die Beschleunigungsrampe)
- Hatte die falsche Formel zur berechnung der Verzögerungsbahn

 

[wwwandy]

Zuviel Werbung?
-> Hier kostenlos registrieren

Mein Ziel:
Ein Baustein der eine folgende Parameter bekommt:
- Istposition [mm]
- Zielposition [mm]
- Beschleunigung (a) [mm/s²]
- Verzögerung (a) [mm/s²]
- Geschwindigkeit (v) [mm/s]

Maximale Beschleunigung und Verzögerung getrennt?
Ich gehe auch mal davon aus, dass du den maximalen Betrag der Geschwindigkeit meinst (|v_max|).

Ausgang des Bausteins soll also die Sollposition für den aktuellen Zyklus sein? Nicht eher die Geschwindigkeit?

 

[Onkel Dagobert]

Hallo Markus,

...
Mein Ziel:
Ein Baustein der eine folgende Parameter bekommt:
- Istposition [mm]
- Zielposition [mm]
- Beschleunigung (a) [mm/s²]
- Verzögerung (a) [mm/s²]
- Geschwindigkeit (v) [mm/s]..

Ist es für dich von Bedeutung, die Beschleunigung vor zu geben? Mir steht ein Projekt bevor, bei dem ich mehrere hydraulische Achsen steueren bzw, positionieren muß. Ich denke daran, den Sollwert der Bahn aus Start- und Endposition und einer vorgegebenen Laufzeit zu berechnen. Istposition, Zielposition und Laufzeit werden geteacht. Über einen P-Regler wird ein Proportionalventil angesteuert. Zusätzlich wird die Geschwindigkeit begrenzt. Die Beschleunigung/Verzögerung ergibt sich dann abhängig von der Proportionalverstärkung und der Maximalgeschwindigkeit. So stelle ich es mir jedenfalls vor. Programmtechnisch wäre es relativ einfach. Wie's funktioniert, wird sich noch zeigen.

Der Baustein könnte dann folgende Eingangs-Parameter bekommen:
- Istposition
- Zielposition
- Laufzeit
- maximale Geschwindigkeit

Würde dir das etwas nützen?


Gruß, Onkel

 

[Markus]

Maximale Beschleunigung und Verzögerung getrennt?

in der plc open haben die das auch so, finde ich nicht schlecht.

Ich gehe auch mal davon aus, dass du den maximalen Betrag der Geschwindigkeit meinst (|v_max|).

wie meinen?
die sollgeschwindigkeit eben mit der zwischen den beiden rampen während der konstantfahrt gefahren werden soll.

Ausgang des Bausteins soll also die Sollposition für den aktuellen Zyklus sein? Nicht eher die Geschwindigkeit?

ja am ende schon die geschwindigkeit...

s = Sollpos aktueller Zyklus - Sollpos letzter zyklus

v = s / t



zu diesem v soll dann später der n-regler seinen korrekturfaktor addieren...

 

[Markus]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo Markus,



Ist es für dich von Bedeutung, die Beschleunigung vor zu geben? Mir steht ein Projekt bevor, bei dem ich mehrere hydraulische Achsen steueren bzw, positionieren muß. Ich denke daran, den Sollwert der Bahn aus Start- und Endposition und einer vorgegebenen Laufzeit zu berechnen. Istposition, Zielposition und Laufzeit werden geteacht. Über einen P-Regler wird ein Proportionalventil angesteuert. Zusätzlich wird die Geschwindigkeit begrenzt. Die Beschleunigung/Verzögerung ergibt sich dann abhängig von der Proportionalverstärkung und der Maximalgeschwindigkeit. So stelle ich es mir jedenfalls vor. Programmtechnisch wäre es relativ einfach. Wie's funktioniert, wird sich noch zeigen.

Der Baustein könnte dann folgende Eingangs-Parameter bekommen:
- Istposition
- Zielposition
- Laufzeit
- maximale Geschwindigkeit

Würde dir das etwas nützen?


Gruß, Onkel

hm aber du hast ja dann weder eine start- noch eine stoprampe?

in deinem falle wäre das bei einem "idealen" zylinder ja:

s = ABS(Istpos-Zielpos)
t = laufzeit

v = s/t

ne "richtige" bahn gibt das ja dann nicht, oder habe ich es nicht begriffen?

also ich habe in dem projekt hier an die 30 achsen die ich so gassi führen will, darunter auch ein paar hydraulische...

easy-motion-controll, beckhoff, sew,... und wie sie alle heissen die ihre MC bausteine nach PLC_OPEN gemacht haben machen das im prinzip auch so.

später will ich so ggf. auch zwei achsen über positionstabellen verschleifen, so eine art kurvenscheibe um zb ein portal zu fahren... deshlab der ansatz erst mal ne bahn zu generieren...

 

[Onkel Dagobert]

hm aber du hast ja dann weder eine start- noch eine stoprampe?...

Nein, die hätte ich so nicht, jedenfalls nicht "definiert". Ich berechne lediglich meinen Sollwert zwischen Start- und Endposition über der Zeit. Den Rest macht der P-Regler und eine Geschwindigkeitbegrenzung.

v = P * (Istpos-Sollpos) // Sollpos ist mein berechneter Wert

Ich merke schon, du brauchst es exakter. Für meinen Fall müsste es jedoch ausreichen, hoffe ich.


Gruß, Onkel

 

[Markus]

ich gehe davon aus das dein unterer grenzwert wür die positionierzeit duch die v-max gerechnet wird, eine zeitvorgabe die mit v-max nicht erreicht werden kann macht ja keinen sinn, somit wäre der parameter sinnlos.

in deinem fall wäre ggf. dann auch das interessant, damit habe ich inzwischen auch einige sps-positionierungen sauber am laufen:

Hallo Markus,

ich würd es so machen:
v = sqrt(2*a*(Sist-Ssoll))
anschliessend mit v auf einen Rampenbaustein gehen
dessen Rampensteigung "a" entspricht.
Das daraus resultierende V ist die gesuchte Sollgeschwindigkeit.
Es fellen nur noch die nötigen Verriegelungen zum Start der
Positionierung

Beste Grüsse
Martin

einen P-Regler schalte ich ja auch nach, der ist auch wichtig!
Ggf. noch mit einem I-Anteil, falls bei kleinen Positionsänderungen das Moment zum anfahren nicht ausreicht.

P = (Sollpos_Zyklus - Istpos_Zyklus) * P-Faktor