# Bahn berechnen - Sollposition



## Markus (30 September 2009)

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 (30 September 2009)

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 (30 September 2009)

Larry Laffer schrieb:


> 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:

http://www.sps-forum.de/showthread.php?t=20779


----------



## HMI-Muckel (30 September 2009)

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 (30 September 2009)

HMI-Muckel schrieb:


> Hallo Markus,
> 
> ich würd es so machen:
> v = sqrt(2*a*(Sist-Ssoll))
> ...


 
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 (30 September 2009)

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 (30 September 2009)

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 (30 September 2009)

... 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 (30 September 2009)

*Achtung*



Cerberus schrieb:


> Hallo Markus,
> 
> Der Bremsweg in Abhängigkeit der Zeit die schon gebremst wird berechnet sich wie folgt:
> 
> ...


 
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 (30 September 2009)

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 (30 September 2009)

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 (30 September 2009)

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 (30 September 2009)

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 (1 Oktober 2009)

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 (1 Oktober 2009)

Markus schrieb:


> Mein Ziel:
> Ein Baustein der eine folgende Parameter bekommt:
> - Istposition [mm]
> - Zielposition [mm]
> ...



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 (1 Oktober 2009)

Hallo Markus,



Markus schrieb:


> ...
> Mein Ziel:
> Ein Baustein der eine folgende Parameter bekommt:
> - Istposition [mm]
> ...



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 (1 Oktober 2009)

wwwandy schrieb:


> 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 (1 Oktober 2009)

Onkel Dagobert schrieb:


> Hallo Markus,
> 
> 
> 
> ...




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 (1 Oktober 2009)

Markus schrieb:


> 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 (1 Oktober 2009)

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:



HMI-Muckel schrieb:


> Hallo Markus,
> 
> ich würd es so machen:
> v = sqrt(2*a*(Sist-Ssoll))
> ...




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


----------



## wwwandy (1 Oktober 2009)

Hi Markus,
läuft das jetzt so wie du es dir gewünscht hast oder kann man dir noch helfen?


----------



## Markus (1 Oktober 2009)

wwwandy schrieb:


> Hi Markus,
> läuft das jetzt so wie du es dir gewünscht hast oder kann man dir noch helfen?




eigentlich solltest du beitrag nummer 14 als eine frage von mir an dich interpretieren... 

was hälst du von dem code?
würdest du was ändern?


----------



## Bernard (3 Oktober 2009)

Hallo Markus,
Ich versteh Deine Aufgabenstellung nicht.
a)Hast Du ein vorgegebenes Streckenverhalten und willst die entsprechenden Beschleunigungwerte und deren Zeitabstände berechnen.
b)Oder willst Du aufgrund vorgegebener Beschleunigungswerte, und deren zeitlichen Versatz, Kurvenwerte innerhalb eines Speicherbereiches hinterlegen


----------



## Markus (7 Oktober 2009)

*Hilfe!!!*

So also das tut schon ganz gut, aber noch nicht perfekt...

Am besten schaut ihr euch mal die Excel im Anhang an.

Die gelben felder sind zur eingabe, der rest sind schmierereien und gerechnete werte.

wenn zb folgende parameter eingestellt sind:

Beschleunigung: 300mm/s²
Verzögerung: 300mm/s²
Geschwindigkeit: 600mm/s
Ziel*: 2000mm

*Ziel bezieht sich immer auf eine Startposition von 0


mit den parametern bekomme ich eine saubere bahn mit der sollposition, und die abgeleitete geschwindigkeit sieht auch plausibel aus.

wenn ich jetzt zb nur eine kurze fahrt habe, dann kann ich ja nicht auf v-max beschleunigen weil mir sonst der verzögerungsweg nicht ausreicht.

also wenn ich zb. den parameter ziel auf "1000" schreibe, dann sollte die geschwindigkeit eigentlich ein dreick werden. aber ich habe immer so einen zacken drin...

ich weiß das mein ansatz falsch ist, aber wo?


----------



## Bernard (18 Oktober 2009)

*Bahn berechnen - Sollpositio*

Hab mir mal überlegt ein S7 Programm zu bauen das ein Streckenverhalten
symuliert.das Programm liegt als Anhang dabei.
Folgendes Vorgehen bei Testen:
Ob35 auf 10ms Einstellen(Hardwarekonfiguration).
Alle Bausteine einspielen.
Streckensteuerung mittels beigelegter Vat (steuern und Lesen).
Bei positiver Flanke auf Start und Reset=0 begint die Symulation.
Reset setzt alle Zustände auf null und muß vor Neubegin aktiviert werden.
Alle Streckenangaben in Basiseinheiten.
a=m/S^2,V=m/s,S=M.


----------



## gravieren (18 Oktober 2009)

Hi




> also wenn ich zb. den parameter ziel auf "1000" schreibe, dann sollte die geschwindigkeit eigentlich ein dreick werden. aber ich habe immer so einen zacken drin...


Gib doch mal als Ziel 700 ein.
Dann wird es "negativ".


----------



## Markus (18 Oktober 2009)

hallo,

also ich habe jetzt noch sehr gute hilfe von einem matheprofi bekommen, die excel sieht jetzt schon ganz anders aus...

das mit excel geprüfte und getestete schema werde ich nächste woche in scl umsetzen.


@bernard
kann ich den scl code mal sehen?
mir kommt der fb50 mit seinen 550k recht schlank vor, ich würde gerne mal sehen wie bzw was du machst.
hast du das nur zum "spielen" gemacht oder läuft der baustein auch im richtigen produktiveinsatz?

markus.uhl@uhltronix.com


im anhang ist meine excel berechnung.


----------



## Markus (18 Oktober 2009)

Markus schrieb:


> @bernard
> kann ich den scl code mal sehen?


 
hat sich erledigt, ich habs mal mit offenen augen probiert...


----------



## Bernard (18 Oktober 2009)

*kann ich den scl code mal sehen?*

Der SCL Code liegt im Projekt bei.
Wenn man den Integratoreingang (#Beschleunigung_t) umrechnen und auf Analogwerte geben würde müßte es auch in der Praxis laufen.Allerdungs würde ich mir den Geschwindigkeitswert über ein Differenzierglied auf S(t) errechnen um mir den Geschwindigsmesser zu sparen.
Trotzdem kommt mir der ganze Ansatz doch etwa theoretisch vor,denn in der 
in der Praxis ergibt sich die Beschleunigung=Kraft/Masse für translatorische systeme.Sodas die Beschleunigung eine Funktion der Masse und der Kraft Ist.


----------



## Markus (18 Oktober 2009)

Bernard schrieb:


> Der SCL Code liegt im Projekt bei.
> Wenn man den Integratoreingang (#Beschleunigung_t) umrechnen und auf Analogwerte geben würde müßte es auch in der Praxis laufen.Allerdungs würde ich mir den Geschwindigkeitswert über ein Differenzierglied auf S(t) errechnen um mir den Geschwindigsmesser zu sparen.


 
das verstehe ich jetzt nicht.
ich würde in deinem fall den ausgang des integrators ("Daten_Streckenerfassung".Istwerte.V_Ist) als geschwindigkeitssollwert für den antrieb verwenden.


("Daten_Streckenerfassung".Istwerte.Strecke) wäre quasi die sollposition der achse, sie wird mit dem messwert vom positionssensor der achse verglichen.

die differenz kommt mit einem p-faktor auf die errechnete sollgeschwindigkeit.

ist die differenz zu groß weil die achse nicht folgen kann gibt es nen schleppfehler.




> Trotzdem kommt mir der ganze Ansatz doch etwa theoretisch vor,denn in der in der Praxis ergibt sich die Beschleunigung=Kraft/Masse für translatorische systeme.Sodas die Beschleunigung eine Funktion der Masse und der Kraft Ist.


 
so wie ich das verstanden habe positionieren servoregler und motioncontrol bausteine der ganzen sps-hersteller auch nach dem prinzip.


----------



## Bernard (18 Oktober 2009)

*ich würde in deinem fall den ausgang des integrators*

Also wenn der Streckenistwert(t) differenziert wird,erhält man die Ist-Geschwindigkeit(t).Allerdings gebe ich dir recht,das der erechnete V-Wert sich auf den vorhergehenden Aufruf des OB35 bezieht,also eine Periode hinterherläuft.Bei der hohenTaktung des Ob35 ist für nicht zeitkritische Anwendungen zu vernachlässigen.
Was Siemens und andere Hersteller in der Antriebstechnik machen ist mir leider nicht bekannt.Ich gehe mal davon aus das die Dynamik deren Antriebstechnik so hoch ist das sie von einer festen Beschleunigng ausgehen können.


----------



## Flash (23 Oktober 2009)

@Markus
Versuche gerade eine einfachere Version von deiner Idee zu verwirklichen. Die Positionierung soll mittels Lasermessung, Frequenzumformer und Analogausgang erstellt werden.

Die Bahn selbst muss nicht genau eingehalten werden, aber der Zielpunkt soll zuverlässig erreicht werden.

Während der Beschleunigung und der Konstantfahrt wird zyklisch Berechnet ob der Bremspunkt bereits erreicht ist. Wenn ja wird mit der eingestellten Rampe gebremst. Im Feinpositionsbereich wird nur noch mit minimaler Geschw. gefahren und der Antrieb abgeschaltet wenn der Zielbereich erreicht wurde.

Das Ganze funktioniert eigentlich nur:
- Verpasse ich den Bremspunkt (Zykluszeit) ist der Streckenfehler riesig. zum Beispiel vMax = 2m/s und Zykluszeit 5ms -> Fehler Bremspunkt 10mm
- Versuch ich die Rampe während der Bremsphase zu korrigieren dauert die Schleichfahrt ewig.

Wie korrigiere ich den Fehler des Bremszeitpunktes während der fahrt??


----------



## Grubba (23 Oktober 2009)

@Flash (u evtl. noch Markus)

Habe Dir mal eine PDF angehängt, in der beschrieben wird, wie man das mit den Rampen usw. machen kann.

Insbesondere die Seiten 10 und 11 könnten für Dich interessant sein.


----------



## Flash (23 Oktober 2009)

Interessant... Danke Grubba

Also wenn ich das richtig verstanden habe ist wird hier die Istposition gar nicht berücksichtigt... es wird vorausgesetzt dass das Sytem dem Sollwert folgen kann.

Ich gebe vSoll in % aus brauche aber eine Angabe in m/s. -> Es muss parametriert werden wieviel 100% in m/s entspricht.
-> Wenn diese Angabe nicht genau stimmt, liege ich mit der Sollpositionsberechnung daneben und somit auch mit der Beschl.-berechnung usw.

Wäre es nicht sinnvoller die Istposition anstelle einer berechneten Sollposition für die Restwegberechnung zu verwenden??


----------



## Markus (23 Oktober 2009)

Flash schrieb:


> Also wenn ich das richtig verstanden habe ist wird hier die Istposition gar nicht berücksichtigt... es wird vorausgesetzt dass das Sytem dem Sollwert folgen kann.


 
jepp, so ist es.
aber die vorgegebene sollposition und die tatsächliche istpoition werden verglichen. die differenz gibt den "schleppabstand" an.

ist der schleppabstand zu groß, dann gibts eine schleppfehlerstörung


----------



## Flash (23 Oktober 2009)

Es lebt!!!

Danke Euch für die nützlichen Tipps...

Der Vorteil dieser Methode ist das der Punkt immer genau angefahren wird, allerdings wird die Bremsrampe nur bedingt eingehalten.

Ich berechne die Zykluszeit innerhalb meines Bausteines (sfc64), so muss ich mir keine Gedanken machen in welchen abständen das Ding aufgerufen wird. Die Wiederholgenauigkeit ist auch gegeben und die ganzen Berchnungen sind auch einfacher als bei meinem Ansatz (Bremspunkt berechnen und allenfalls korrigieren).

mfg


----------



## Philip (10 November 2009)

Markus schrieb:


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



das gehört nicht direkt hier ein, aber wenn du ne schnelle CPU willst kuck mal bei Vipa. Die sind 100% kompatibel und da reicht ne 315 um auf 1ms zu kommen.Hab ich gute Erfahrungen.

Gruß  Philip


----------



## Dr.No (29 März 2010)

Hallo Leute!
Ich bin gerade dabei selber ein Rampenbaustein zu schreiben.

Durch die vorherigen Disskussionen bin ich auch schon etwas vorran gekommen, nur komme ich jetzt nicht weiter:

Ich habe auch die drei Phasen:
1. Beschleunigung (Positiv)
2. konstante Fahrt
3. Beschleunigung (Negativ)

Die Zeiten- und Wegstreckenberechnungen für die drei Phasen bekomme ich hin.
Jetzt habe ich Probleme mit der Realisierung der aktuellen Position etc.

Ich bekomme von meinem Antriebsgerät eine Istposition zurück.
Meine Zykluszeit beträgt 2ms.
Wie würdet ihr das jetzt realsisieren?
Mein Motor soll ja jetzt langsam starten - konstant fahren - abbremsen.

Im Anhang das, was ich schon habe... Vielleicht blickt da jemand durch und kann mir irgendwie weiter helfen. DANKE.

Anhang anzeigen Rampe.txt


----------



## Flash (29 März 2010)

Am besten Du nimmst das pdf von Grubba zur Hilfe, dann kann eigentlich nichts schiefgehen...

mfg Flash


----------



## Dr.No (31 März 2010)

Hi!
Danke Flash!
Brauche trotzdem noch Hilfe:
Kann mir jemand erklären, wie Markus die Tabelle für das Diagramm hinbekommen hat??

http://sps-forum.de/attachment.php?attachmentid=8939&d=1255890556

Ich blicke da bei den Formel nicht durch. Wäre echt nett, wenn ihr mir helfen könntet!

ODER hat jemand von euch einen fertigen Positionssollwertgenerator??? Brauche den dringend.

DANKE!


----------



## Markus (31 März 2010)

was ist an der formel unklar?
ich habe das jetzt auch nicht mehr im kop, ist schon ne ganze weil her...


----------



## Dr.No (1 April 2010)

Hallo Markus und die anderen!

Tja, an den Formeln liegt es nicht so ganz. Doch eher mit der Programmierung. (Ich bin ein Anfänger in der Programmierung)
Im Anhang ist mal eine Textdatei, wie mein Generator im Moment aussieht.
(etwas mehr als beim letzten Mal)
(ich programmiere in TwinCat)
Im moment läuft der Generator 1x hoch.
D.h. er fährt langsam an, bleibt dann konstant und bremst ab.

Ein paar Variablen sind noch nicht genutzt. Ich weiß aber, dass ich die noch brauche.

Ich bekomme das einfach nicht hin, dass er zu einer neuen Position fährt etc.
Vielleicht hat jemand eine rettende Idee für mich! Wäre echt nett, da ich nicht mehr viel Zeit habe.

DANKE.


----------

