# Mit Schleife DB füllen



## htw (2 März 2011)

Hallo zusammen,

ich schreibe gerade meine Bachelorarbeit und dabei muss ich ein Portal konstruieren, dass in X-, Y- und Z- Richtung verfährt, verschied. Positionen anfährt, ect ... und mit SPS gesteuert wird. 

Z.b. sollen man bestimmte Formen abfahren können mit unterschiedlicher Größe.

Dreieck und einfache Geometrien, die mit wenigen Punkten abgefahren werden können, sind kein Problem. 

Anders sieht es mit einem Kreis aus. Hier habe ich mir anfangs gedacht, ich berechne z.b. 500 Koordinatenpunkte mit einem VBA Programm oder auch Taschenrechner und gebe diese manuell in einem DB ein. Je nach dem, wie groß oder an welche Stelle nun dieser Kreis "gemalt" werden soll, werde ich mit Hilfe eines Pointers die DB´s für die verschied. Koordinatenachse auslesen und ihn mit einem Faktor multiplizieren (um ihn zu vergrößern) oder addieren (um eine Verschiebung stattfinden zu lassen) und in neuen DB´s ablegen, die ich verarbeite.

Natürlich ist z.b. das Eingeben manuell von 500 Werten umständlich und meiner Meinung nach wenig professionell. Eleganter wäre es doch, die math. Formel zu Berechnung der Kreiskoordinatenpunkte zu Programmieren und die DB´s mit den Koordinaten zu füllen und anschließend wieder zu verarbeiten. Ich dachte beim Füllen der DB´s evenutell an eine Schleife.

Ist das möglich?

Hoffe ich habe mein Anliegen verständlich geschildert.

VIELEN DANK


----------



## Paule (2 März 2011)

htw schrieb:


> Je nach dem, wie groß oder an welche Stelle nun dieser Kreis "gemalt" werden soll, werde ich mit Hilfe eines Pointers die DB´s für die verschied. Koordinatenachse auslesen und ihn mit einem Faktor multiplizieren (um ihn zu vergrößern) oder addieren (um eine Verschiebung stattfinden zu lassen) und in neuen DB´s ablegen, die ich verarbeite.
> 
> Natürlich ist z.b. das Eingeben manuell von 500 Werten umständlich und meiner Meinung nach wenig professionell. Eleganter wäre es doch, die math. Formel zu Berechnung der Kreiskoordinatenpunkte zu Programmieren und die DB´s mit den Koordinaten zu füllen und anschließend wieder zu verarbeiten. Ich dachte beim Füllen der DB´s evenutell an eine Schleife.
> 
> Ist das möglich?


Ja das geht auf jeden Fall.
Und wie Du selber schon erwähnst, sind die Stichwörter "Schleife" und "Indirekte Adressierung"


----------



## Aventinus (3 März 2011)

Dann kannst Du aber auch gleich in Echtzeit die Kreisbahn berechnen. Ich sehe aber das Problem bei der Synchronisatoin der Achsen... Präzise Geometrieen sind so nicht möglich.


----------



## htw (3 März 2011)

Würdet ihr die X- und Y-Koordinaten in einen DB tun?

DB x und y

0.0   x-Wert 1
2.0   y-Wert 1
4.0   x-Wert 2
6.0   y-Wert 2
8.0 .....


               ODER 2 DB´s


DB x                    ---          DB y

0.0   x-Wert 1       ---         0.0   y-Wert 1
2.0   x-Wert 2       ---         2.0   y-Wert 2
4.0   x-Wert 3       ---         4.0   y-Wert 3

Jedem X-Wert wird ein Y-Wert zugeordnet um eine Position anfahren zu können.

Wie gesagt, es geht um ne Bachelorarbeit und sollte möglichst praxisnah sein. Ich habe leider noch keine Erfahrung in der Industrie.

Vielen Dank nochmals!


----------



## Larry Laffer (3 März 2011)

Hallo,
du könntest dir ein Array in dem DB deklarieren - das geht auch 2dimensional.
Und wenn du es so richtig schön machen willst dann machst du das ganze nicht mit AWL sondern eher mit SCL. Das erspart dir dann auch eine ganze Reihe weiterer Problemchen, die bestimmt noch kommen ...

Gruß
Larry


----------



## Aventinus (3 März 2011)

Trotzdem, ich würde die Werte nicht mit einer Schleife im DB Ablegen und dann wieder mit einer Schleife aus dem DB holen.

Rechne doch die Sollkoordinaten direkt aus.


----------



## htw (3 März 2011)

Meine Idee sah bis jetzt in etwa so aus:

Bsp. Kreis (da das die schwierigste Form ist):

- Ich rechne einen Kreis aus und befülle einen DB mit den x-Werten und einen mit den y-Werten manuell.
- Anschließend lese ich die Werte aus (Pointer) und multipliziere (bei Vergrößerung oder Verkleinerung des Radius) sie oder addiere und subtrahiere sie (Verschiebung).


Zu den Verbesserungen:

- Kreis Formel programmieren und DB (Array) mit den Werten füllen.
- 2 Dimensional 


Meine Fragen:

@ Larry: 
- kannst du mir erklären, wie ein 2D Array aussieht? kann mir noch nichts darunter vorstellen.
- SCL? Hab ich schon mal gehört, aber noch keine Praxiserfahrung bzw. überhaupt Erfahrung damit. Ist die Sprache ähnlich der von AWL?

@ Aventinus:
- Du meinst also, ich sollte die Werte gar nicht in DB´s ablegen?
- Wie kann ich dann verschied. Positionen zeit diskret anfahren?

Nochmals ein großes Dankeschön für eure immer kompetenten und hilfreichen Antworten. Als Student hat man einfach nie die Erfahrung, die ihr alten Hasen habt (Sagt jetzt bitte nicht, ihr seid 19 oder 20 Jahre alt :-D).


----------



## LargoD (3 März 2011)

Um die Kreispositionen zu speichern brauchst Du kein zweidimensionales Array, Du musst nur zwei Positionen pro Stützpunkt speichern. Das kannst Du in zwei DBs oder auch eleganter als "Array of struct" machen, es bleibt aber dabei eindimensional.
Ich würde so vorgehen:
Definiere einen UDT, der einen Punkt über seine x,y und z Koordinaten definiert.
Um Bahnkurven zu speichern, definierst Du in einem DB ein Array dessen Elemente aus diesem UDT bestehen.
Das Vorbesetzen des Arrays und die Datenmanipulationen würde ich in SCL schreiben, dann sparst Du Dir das ganze Pointergerödel. Das wird besonders interessant dann, wenn Deine Kurven nicht in einer Ebene liegen und Du deshalb räumliche Transformationen durchführen musst.
z. B. eine Kreisbahn die räumlich "schräg" im Koordinatebsystem liegt, oder ist das in der Aufgabenstellung ausgeschlossen?

Gruß
Erich


----------



## htw (3 März 2011)

Genau, so wie du es sagst, hab ich mir das auch gedacht.
Schräg muss nichts "gemalt" werden. Aber ich SCL trotzdem mal im Hinterkopf behalten.


----------



## htw (3 März 2011)

Genial, klappt!

sieht so aus:

DB

0.0 STRUCT
+0.0 zeitraster STRUCT
+0.0 werte ARRAY[0..600]
*6.0 "UDT_WERTE"    <-- da X,Y,Z jedesmal also Merkerwort mit 2 Bytes abgelegt
=3606.0 END_STRUCT

Im UDT stehen dann X,Y,Z, die sich wiederholen, bis 600 Werte von jedem drinstehen. Auslesen über Pointer. Das funktioniert auch!

SUPER!!! :-D:-D:-D:-D:-D:-D



Nur beim Befüllen habe ich noch keine elegante Idee, wie man das mit scl oder wie auch immer machen könnte. Natürlich ist es kein Problem per Hand die Werte reinzuhacken.

Kann mir da jmd auf die Sprünge helfen?

Ganz kurz noch:
bei Programmen, die ihr mir eventuell im Forum mitteilt und aus denen ich in meiner Arbeit inhaltlich etwas entnehme, werdet ihr natürlich korrekt zitiert und als Quelle genannt.


----------



## Larry Laffer (3 März 2011)

Ob du es als 2D-Array ( myVar : Array [1..10 , 1..2] of Real ) oder in 2 DB's oder sonstwie machst ist eigentlich egal.
Ich persönlich würde (vor Allem in Verbindung mit SCL) den von mir vorgeschlagenen Weg bevorzugen (ist ja eigentlich auch logisch )

SCL ist eine Hochsprache in der Step7-Welt und im Wesentlichen an Pascal / Delphi angelehnt. Für Berechnungen, wie du sie vorhast eigentlich ein "need to have". Du sparst dir dann das Pointergedrösel (wie schon erwähnt) und du erhälst einen (je nach Können) durchaus übersichtlichen Programmcode.

Gruß
Larry


----------



## M-Ott (3 März 2011)

htw schrieb:


> Ganz kurz noch:
> bei Programmen, die ihr mir eventuell im Forum mitteilt und aus denen ich in meiner Arbeit inhaltlich etwas entnehme, werdet ihr natürlich korrekt zitiert und als Quelle genannt.


Und wenn nicht, kannst Du immer noch in die Politik gehen.


----------



## Larry Laffer (3 März 2011)

htw schrieb:


> ... Nur beim Befüllen habe ich noch keine elegante Idee, wie man das mit scl oder wie auch immer machen könnte. Natürlich ist es kein Problem per Hand die Werte reinzuhacken.
> 
> Kann mir da jmd auf die Sprünge helfen?


 
Jetzt mußt du mir nur vielleicht noch verraten ob es AWL oder SCL werden soll ...

Gruß
Larry


----------



## htw (3 März 2011)

Mit SCL haben ich bis jetzt überhaupt noch keine Erfahrung.

Darum denke ich, das mit AWL wäre der sichere Weg.

Gibt es denn ein Buch oder online Tutorial indem man sich SCL aneignen könnte?


----------



## Larry Laffer (3 März 2011)

Das du damit keine Erfahrung hast habe ich schon heraus gehört. Trotz alledem wäre (ein bißchen Engagement vorausgesetzt) der Weg mit SCL der "sichere Weg" - auch und vor Allem wegen der Berechnungen (z.b. Kreis).

Ich habe das autodidatisch erlernt - ich kann also zu der Qualität der vorhandenen Literatur keine Angaben machen.
Welche Kenntnisse im Hochsprachen-programmieren hast du denn so ?

Wenn du ein bißdhen Basic oder Delphi kannst bekommst du das sehr schnell auf die Reihe (Stichwort Engagement).

Gruß
Larry


----------



## Larry Laffer (3 März 2011)

Ach ja ... in AWL würdest du dir (trotz des Array's) auf jedes Element einen Pointer bilden müssen um damit zu arbeiten. Ich finde das nicht schick ...


----------



## htw (3 März 2011)

OK, das hab ich soweit verstanden.

Die Werte auslesen klappt ja schon mal perfekt (AWL mit Pointer).

Nur das Befüllen ... ne Kombi zwischen SCL und AWL ist nicht möglich? Wahrscheinlich auch nicht elegant zwischen Sprachen zu wechseln...?


----------



## Larry Laffer (3 März 2011)

... das verstehe ich jetzt wiederum nicht.
Wenn du die Werte ausgelesen bekommst dann bekommst du sie in der gleichen Machart auch beschrieben.

Nochmal zu SCL:
SCL hat einen eigenen Editor. Es erzeugt zwar letztlich auch AWL-Code (allerdings Compiler-typisch ggf. ganz schön scheußlichen), aber es läuft erstmal für sich. Du kannst damit dann natürlich einen FB oder eine FC errzeugen, die du in AWL weiterverwenden kannst.

Wie auch immer. Ich verstehe das jetzt mal so, dass du dich für AWL entschieden hast. Wie geht es nun weiter ? Hast du dazu noch Fragen ?


----------



## htw (3 März 2011)

was ich bis jetzt habe mal kurz zusammengefasst:

L TAKTGEBER
L 1
+I
T TAKTGEBER

Schleife um den Pointer hochzuzählen(natürlich ist noch n Blinker und andere Bedingungen integriert)

AUF DB [#DB_Kreis]
L #TAKTGEBER
L 6
*D
SLD 3
T #dbPointer
L DBW [#dbPointer] // X
T #_xKoordinate
L #dbPointer
L P#2.0
+D
T #dbPointer
L DBW [#dbPointer] //y
T #_yKoordinate
L #dbPointer
L P#2.0
+D
T #dbPointer
L DBW [#dbPointer] //z
T #_zKoordinate

damit geh ich in meinen DB rein:

0.0 xKoordinate
2.0 yKoordinate
4.0 zKoordinate

6.0 xKoordinate
...


so würde ich auslesen.


----------



## htw (3 März 2011)

habe auch verscuht, das flexibel aufzubaun ...


was hältst n davon?


----------



## Aventinus (4 März 2011)

htw schrieb:


> @ Aventinus:
> - Du meinst also, ich sollte die Werte gar nicht in DB´s ablegen?
> - Wie kann ich dann verschied. Positionen zeit diskret anfahren?



Du hast ja sicher eine Vorstellung davon wie lange du dir für deine Kreisform Zeit nehmen willst...

Wenn du das Ding in 10s durch haben möchtest kannst du eine Zeit laufen lassen und dir aus dem Zeitwert mit Sinus bzw. Kosinus usw. die aktuellen Positionen der beiden Achsen errechnen. 

Hab aber leider gerade nicht die Zeit, dir das genauer aufzubereiten... evtl. am WE.


----------



## Larry Laffer (4 März 2011)

htw schrieb:


> habe auch verscuht, das flexibel aufzubaun ...
> 
> 
> was hältst n davon?


 
kann man sicherlich so machen.
Eine andere Variante wäre :
	
	



```
AUF DB [#DB_Kreis]
L #TAKTGEBER
L 6
*D
SLD 3
LAR1

L DBW [AR1,p#0.0] // X
T #_xKoordinate
L DBW [AR1,p#2.0] //y
T #_yKoordinate
L DBW [AR1,p#4.0] //z
T #_zKoordinate
```
... spart ein paar Anweisungen ... 

Gruß
Larry


----------



## htw (4 März 2011)

@ Aventinus:

die math. Formeln sind mir klar. Die Schwierigkeiten liegen darin, dass zu Programmieren und die Daten abzulegen. Aber ich werde es einmal so versuchen, wie ich auslese.


----------



## Larry Laffer (4 März 2011)

naja ... das ginge dann so :
	
	



```
AUF DB [#DB_Kreis]
L #Index
L 6
*D
SLD 3
LAR1

L #_xKoordinate
T DBW [AR1,p#0.0] // X
L #_yKoordinate
T DBW [AR1,p#2.0] //y
L #_zKoordinate
T DBW [AR1,p#4.0] //z
```
... wobei du dir vielleicht überlegen solltest, ob es nicht besser wäre mit REAL zu arbeiten ...

Gruß
Larry


----------



## htw (6 März 2011)

stimmt, wäre wohl besser. Voraussichtlich werden viele Zahlen mit Nachkommastellen auftauchen.

Ich werde deine Tipps beherzigen und mal schaun, obs klappt. Ich werd dir dann ne Rückmeldung geben.


----------



## Larry Laffer (6 März 2011)

... aber denk dran ... die REAL's sind nicht 2 Byte sondern 4 Byte breit - aslo den Pointer-Versatz etc. entsprechend berücksichtigen ...


----------



## htw (7 März 2011)

Ist mir klar. Ich weiss noch nicht, was für ein Wegmesssystem verwendet wird  bzw was für Rückmeldungen über die Posi ich bekommen tu.
Falls die Rückmeldung über einem Inkrementalzähler erfolgt, reichen die vorhanden 2 Byte.

Kurz mal eine grundsätzliche Frage:

Sollte ich die Werte überhaupt in deinem DB ablegen? 
Oder in jedem Zyklus den jeweiligen Wert berechnen und direkt verarbeiten? Somit würde ich mir den DB ersparen, dann müsste nicht:
ich meine Werte berechnen - in einem DB ablegen - und die gleichen Werte wieder rauslesen.
...sondern nur berechnen...

Vor- bzw Nachteile? Zu was würdet ihr tendieren?


----------



## Larry Laffer (7 März 2011)

Zur Beantwortung dieser Frage hole ich einfach noch einmal den folgenden Beitrag hervor :


Aventinus schrieb:


> Dann kannst Du aber auch gleich in Echtzeit die Kreisbahn berechnen. Ich sehe aber das Problem bei der Synchronisatoin der Achsen... Präzise Geometrieen sind so nicht möglich.


... ich hatte das Ganze aber ohnehin mehr als eine theoretische Geschichte angesehen.

Gruß
Larry


----------



## htw (9 März 2011)

Es ist mir nun möglich die Werte zu berechnen - abzulegen - und wieder auszulesen.

Um die Werte ein- bzw auszulesen verwende ich, wie gesagt, einen Pointer:

AUF DB 1

L #taktgeber
L 8
*D
SLD 3
LAR1

L  #Kor_x
T DBD [AR1,P#0.0]

L  #Kor_y
T DBD [AR1,P#4.0]


Ich habe nun ein Problem mit meinem Taktgeber. Die Schleife, die ich zum Berechnen meiner Werte benötige, muss als Real deklariert sein um die Punkte berechnen zu können, da diese ebenso also Real deklariert sind.

Aber für den Pointer benötige ich Int oder Word. Ich muss letztendlich mit 2 Schleifen arbeiten, die gleichzeitig hochzählen jedoch einmal die Varibale als Real und einmal als Word.

Gibt es nicht eine Möglichkeit, eine Real in eine Word oder eine Word in eine Real umzuwandeln. Ich weiss, dass die beiden unterschiedlich groß sind, aber gibt es nicht dennoch eine Möglichkeit.


----------



## Larry Laffer (9 März 2011)

Ich verstehe jetzt gerade den Hintergrund nicht ... aber :

ITD : Integer -> DINT
DTR : DINT -> REAL

RND : REAL -> DINT
und um aus einem DINT einen INT zu machen einfach in eine solche variable transferieren (immer vorausgesetzt die Zahlen passen).

Gruß
Larry


----------



## htw (9 März 2011)

der Hintergrund ist wie folgt:


meine Formel für die Kreiskoordinaten:

KREIS

i = i + 1    <-- Schleife, wie folgt programmiert:

L #i (Schleifenvariable)
L 1.0
+R
T #i

winkel = 2*PI/punktanzahl
x-Koordinate = cos(i*winkel)*radius
y-Koordinate = sin(i*winkel)*radius

Hier taucht die Schleife im Argument des cos bzw sin auf. 
​--> Schleifenvariable muss somit als Real vorliegen.


Des weiteren muss ebenfalls mit einer Schleife mein Pointer im DB verschoben werden. Da beide beides zur gleichen Zeit erfolgen soll, dachte ich natürlich daran, alles mit einer Schleife zu machen, was anscheinend nicht möglich ist.

L #Schleifenvariable j
L 8
*D
SLD 3
LAR1
...

Hierbei kann ich ja nicht die oben benutzte Schleifenvariable "i" wählen, da diese als Real deklariert wurde, sondern eine komplett neue Schleife "j".

Mein Programm funktioniert - ist ja schonmal nicht schlecht. 

Kann man das vll eleganter gestalten nur mit einer Schleife?


----------



## Nordischerjung (9 März 2011)

Kannst du dir nicht eine Hilfsvar bilden? ZB #i_TEMP als INT



```
L #i (Schleifenvariable)
L 1.0
+R
T #i

L #i
RND
T #i_TEMP
```


----------



## LargoD (9 März 2011)

htw schrieb:


> KREIS
> 
> i = i + 1    <-- Schleife, wie folgt programmiert:
> 
> ...


Ich muss Dich da mal auf einige prinzipielle Probleme hinweisen.
Mein Eindruck ist, dass Du eine Bahnsteuerung realisieren willst. Dazu gehört auch eine definierte Bahngeschwindigkeit. Bei Deiner Methode ergibt sich eine Bahngeschwindigkeit, die proportional mit dem Radius wächst, da wirst Du bei großen Radien Probleme mit der Mechanik gekommen.
Außerdem hast Du noch nichts über die Antriebe gesagt. Können die Achsen selbständig ihre Bahn korrelieren oder musst Du das per Software machen? Im zweiten Fall musst Du Deine Stützpunkte viel feiner legen, im ersten Fall musst Du eine Funktion einbauen, die wartet bis die Achsen ihren Fahrauftrag abgearbeitet haben.
Sag doch mal was zu den Antrieben.
Gruß
Erich


----------



## htw (9 März 2011)

Bis jetzt kann ich noch keine Aussagen über die Hardware machen. Mein Professor ist gerade daran einige Sponsoren und Geld aufzutreiben. Zusagen hat er schon, aber nichts näheres.

Mein Wunsch wären Servo- oder Schrittmotoren von Festo. Da wären dann auch die Linearantriebe ect dabei ...

Das hört sich jetzt vllt alles n bisschen einfältig an, Software versuchen zu programmieren, wenn noch keine Hardware zu Verfügung steht, aber was soll ich tun außer zu simulieren und mir mal n paar grundlegenden Dinge mir zu erarbeiten. (viel mit euer Hilfe und euren Anregungen ---> Danke)

Warum soll es Probleme mit der Geschwindigkeit geben? Es geht bis jetzt nur um die Position, die bis jetzt noch nichts mit der Geschwindigkeit zu tun hat.
Edel wäre natürlich noch, n bissel Regelungstechnik mit reinzubringen, indem die Geschwindigkeit der Achsen in Abhängigkeit dem Abstand der Koordinaten gesetzt wird und somit x und y Wert gleichzeitig erreicht werden, auch unterschiedlichem Verfahrweg. Aber das ist noch Zukunftsmusik ...


----------



## LargoD (9 März 2011)

htw schrieb:


> Das hört sich jetzt vllt alles n bisschen einfältig an, Software  versuchen zu programmieren, wenn noch keine Hardware zu Verfügung steht,  aber was soll ich tun außer zu simulieren und mir mal n paar  grundlegenden Dinge mir zu erarbeiten.


 Deshalb weise ich Dich ja darauf hin, damit Du nicht viel Arbeit in einen falschen Weg investierst.


htw schrieb:


> Warum soll es Probleme mit der Geschwindigkeit geben? Es geht bis jetzt  nur um die Position, die bis jetzt noch nichts mit der Geschwindigkeit  zu tun hat.


Du willst einen Kreis fahren. In Deinem Kode-Ausschnitt taktest Du den Winkel in konstanten Inkrementen vor, dann ist sowohl die sich ergebende Bahngeschwindigkeit als auch die Beschleunigung in Achsrichtung von Radius des Kreises abhängig. Da Dein Antrieb nur bestimmte Geschwindigkeiten und Beschleunigungen erlauben wird, kannst Du vielleicht nur kleine Kreise fahren, wenn Du das nicht beachtest.


htw schrieb:


> Edel wäre natürlich noch, n bissel Regelungstechnik mit reinzubringen, indem die Geschwindigkeit der Achsen in Abhängigkeit dem Abstand der Koordinaten gesetzt wird und somit x und y Wert gleichzeitig erreicht werden, auch unterschiedlichem Verfahrweg. Aber das ist noch Zukunftsmusik ...


Wenn Du es nicht schaffst dass der x- und der y-Endwert gleichzeitig erreicht werden, kannst Du nur Geraden in Achs-Richtung und unter 45 Grad fahren, alle anderen werden einen Knick haben. Ist das so geplant?


----------



## htw (9 März 2011)

zum deinem letzten Punkt: -Ja, unter 45° wird verfahren, bis eine Koordinate erreicht ist - danach nur noch in x oder y Richtung.

ist natürlich die Frage, ob man das sieht, wenn die Schritte klein gewählt werden!?


Sind meine Ideen verwirklichbar?

Bin ja leider kein Applikateur, der Erfahrung hat (wie Ihr sicher schon bemerkt habt), sondern n Student der kaum praktische erfahrung hat.


----------



## LargoD (9 März 2011)

Du schriebst in Deinem ersten Post


htw schrieb:


> Dreieck und einfache Geometrien, die mit wenigen Punkten abgefahren werden können, sind kein Problem.


Bestehen diese Geometrien auch nur aus 45 Grad und 90 Grad Bewegungen?
Sonst hast Du da auch das Problem mit dem Knick, oder Du zerlegst diese Bewegungen auch in sehr kleine Schritte.


----------



## htw (9 März 2011)

Hätte viele Koordinatenpunkte der Geraden des Dreiecks berechnet ... ohne Regelung gibts ja wohl keine andere Möglichkeit?


----------



## LargoD (9 März 2011)

Der Aufwand liegt weniger in der Regelung, sondern in der Erzeugung der Sollpositionen.
Allein um eine Gerade abzufahren musst Du ein Interpolationsverfahren einsetzen, das zusätzlich zur Geometrie auch noch Beschleunigungs- und Verzögerungsrampen und die gewünschte Bahngeschwindigkeit berücksichtigt.
Mein Tip: Kümmer Dich im Moment noch nicht so sehr um die programmtechnische Realisierung sondern um die mathematischen Verfahren und berechne außerdem aus den gewünschten Genauigkeiten, Geschwindigkeiten, Massen, Übersetzungen, Spindelsteigungen etc die erforderlichen Daten für Deinen Antrieb. Dann suchst Du die Antriebe aus und bis die Maschine gebaut ist, hast Du das Programm geschrieben.
Die ganze Mathematik brauchst Du doch für Deine Bachelorarbeit sowieso oder?
Gruß
Erich


----------



## htw (9 März 2011)

das math. Zeugs ist kein Problem...die Rechnungen stehen.

Problematischer wirds da schon die in AWL zu programmieren, wobei das bei der Kreisinterpolation eig kein Problem war (etwas umständlich aber). Wie gesagt, meine SCL Erfahrungen sind gleich 0, sonst denk ich, dass SCL hier ideal wäre.


----------



## simon86 (9 März 2011)

Hallo htw

Ich habe vor kurzem auch an einem Projekt gearbeitet, bei dem Bahnkurven berechnet werden müssen. Wir haben das dort mit Matlab realisiert. Wenn du willst, kann ich dir die m-Files zukommen lassen. Es ist wichtig, dass du beim Starten und Stoppen Beschleunigungsphasen einbaust. Die Geschwindigkeiten und Beschleunigungen kannst du mit Matlab auch problemlos berechnen. 

Die offline berechneten Daten haben wir dann in folgende Form gebracht:

strecke[1,1]:=30.005;
strecke[1,2]:=0;
strecke[1,3]:=30.0035;
strecke[1,4]:=0;
strecke[2,1]:=30.09;
strecke[2,2]:=212.5;
strecke[2,3]:=30.0635;
strecke[2,4]:=150;

Dieser Code wurde dann in ein FC kopiert und beim Starten den Anlage einmalig ausgeführt.

Gruss
Simon


----------



## htw (9 März 2011)

kannst du mir eine Zeile näher erläutern?

strecke[1,1]:=30.005

Strecke [Kor_x, Kor_y] := Was hat dieser Wert zu bedeuten? ... denk mal nen Beschleunigungsfaktor?


----------



## simon86 (9 März 2011)

Bei dem Array Strecke handelt es sich um ein Array mit 4 Spalten und 400 Zeilen


1: Zeile      x1    ax1     y1     ay1
2: Zeile      x2    ax2     y2     ay2 

strecke[1,1]:=x1;
strecke[1,2]:=ax1;
strecke[1,3]:=y1;
strecke[1,4]:=ay1;
strecke[2,1]:=x2;
strecke[2,2]:=ax2;
strecke[2,3]:=y2;
strecke[2,4]:=ay2;
...
...



in einer Zeile steht immer ein Punktepaar und die Beschleunigung bis zum nächsten Punkt (Vorsteuerung der Regelung).

Der Programmcode ist aus einer Beckhoffsteuerung aber auch in ST geschrieben. Ich denke der Syntax sollte dabei sehr ähnlich sein.

Gruss
Simon


----------



## htw (9 März 2011)

Verstehe.

Die m-Files dazu habt ihr selber entwickelt, oder irgendwoher genommen (du erwähntest Beckhoff)?


----------



## Larry Laffer (10 März 2011)

Hallo,
ich muss mir hier noch einmal an den Beitrag von LargoD ranhängen ...
Ich stimme dem mit dem "Achsen verfahren" uneingeschränkt zu.
Wenn du in der SPS die Positionen quasi als Stützpunkte berechnest und sie "nach Bedarf" zum Servo-Regler überträgst dann wird es dir ggf. möglich sein ein Dreieck zufahren - niemals aber etwas, das einem Kreis auch nur ähnlich sieht - wahrscheinlich nicht einmal ein sinnvolles (symetrisches) Polygon.

Ihr solltet hier darüber nachdenken, die Berechnung in den Servo-Regler zu bringen. Z.B. kannst du bei Bosch-Rexroth (aber auch bei vielen Anderen) so ein Berechnungsprogramm in die Funktionalität einbauen (das wäre dann in ST - also so wie SCL) und du kannst hier auch mehrere Achsen koordinieren - also auch ´ggf. etwas, das einem Kreis nahe kommt, realisieren.

Nur mal so am Rande ...

Gruß
Larry


----------



## htw (10 März 2011)

Du meinst also, es ist gar nicht möglich einen Kreis nachzubilden?

Wenn aber die Geschwindigkeit nicht all zu groß wäre und ich eine sehr kleine Schrittweite nehmen würde, müsste es in die Richtung Kreis gehen (für das Auge sollte schon ein Kreis erkennbar sein)?


Berechnung der Schrittweite bei einer Motorwelle von 1 cm Radius auf der die Zahnkette sitzt:

U = 2 * pi * r = 6,28 * 1 cm = 6,28 cm

kleinste Schrittweite von meinem Beispielmotor von Festo: 1,8°

360 ° --> 62,8 mm
1,8° --> ( 62,8 mm / 360° ) * 1,8° = 0,3 mm


----------



## Larry Laffer (10 März 2011)

... so wie ich dich verstanden habe hast du (oder du planst) eine 2-Achsen X-Y-Steuerung im Grunde ähnlich einem alten Flachbett-Plotter. Ist es so ?
Wenn ja, dann fahren deine beiden Achsen ja nur vor-zurück und da auch nur einen Weg - klar bei Festo wird die Achse in Grad Motorumdrehungen dargestellt, die du sinnvollerweise aber in einen Fahrweg umrechnest.
Z.B. einen Kreis fährst du ja nun über die Sinus-Cosinus-Berechnung wo dann von Punkt zu Punkt manchmal beide Achsen den gleichen WEeg zurückzulegen haben und manchmal nur die eine Achse fährt und die andere gar nicht. Das passiert aber nicht hintereinander sondern sinnvollerweise gleichzeitig und synchron zueinander. Das kann natürlich über die SPS laufen - würde aber wenn es genau werden soll sehr langsam werden oder wenn es schnell (quasi on-the-fly) laufen soll sehr ungenau werden.

Gruß 
Larry


----------



## Aventinus (10 März 2011)

htw schrieb:


> kleinste Schrittweite von meinem Beispielmotor von Festo: 1,8°
> 
> 360 ° --> 62,8 mm
> 1,8° --> ( 62,8 mm / 360° ) * 1,8° = 0,3 mm



Du hast ja sicher nach deinem Motor eine Linearachse (Spindel, Zahnstange oder änliches) und evtl auch noch ein Getriebe mit einer Untersetzung.

Wenn du eine Spindel mit 1mm Steigung direkt an deinen Schrittmotor anflanscht, kannst du viel genauer positionieren:

360° (eine Motorumdrehung) = 1mm linearer Weg
1,8° (Schrittweite) = 0,05mm linearer Weg

Mit Getriebe entsprechend genauer...

Bei deiner Berechung verstehe ich noch nicht wie du die rotatorische in eine lineare Bewegung umbiegst.


----------



## htw (10 März 2011)

Genau.

Natürlich sollen die Achsen synchron zueinander laufen. Je kleiner die Schritte, desto genauer - das ist mir bewusst.
Nun könnte man doch aber die Geschwindigkeit in Abhängigkeit des Abstandes berechnen, so dass beide Achsen gleichzeitig den Folgepunkt erreichen.
Sozusagen versuch ich meine Koordinaten linear zu interpolieren, also Geraden zwischen meinen Punkten reinzulegen ohne Ecken ect .... nuja, zumindest wäre das mein Wunsch =)


----------



## htw (10 März 2011)

der Schrittmotor wird 90° versetzt zur Linearachse und somit treibt seine rotatorische Bewegung den Zahnriemen an.

Getriebe ist ne gute Idee, hatte auch schon darüber nachgedacht.


----------



## Larry Laffer (10 März 2011)

Gut OK ...
Es würde dann also so laufen :
Von einem Koordinatenpunkt "Start" aus berechnest du den nächsten Punkt X und Y. Über die Katheten des Dreiecks weißt du den Abstand und kannst entsprechend daraus die benötigten Geschwindigkeiten errechnen, damit beide etwa zeitgleich im Ziel ankommen. Nun startest du beide Achsen mit dem Weg-Wert und der Geschwindigkeit und der Beschleunigung. Nun mußt du warten, bis die Achsen ihr Ziel erreicht haben und kannst nun den nächsten Zielpunkt übergeben und wieder starten. Das wird dann so genau, wie du deine Auflösung hierbei wählst / wählen kannst. Das wird dann bei einem Kreis sicherlich auch ziemlich kreisförmig (warum auch nicht ?). Allerdings wird es auch dauern - wie lange wage ich jetzt nicht annähernd zu schätzen. Es wird hierbei allerdings die meißte Zeit mit dem Handshake SPS - Servo's verdaddelt. Aber nur um es zu testen - why not ...? Sollte es allerdings Leistung bringen sollen ... 

Gruß
Larry


----------



## LargoD (10 März 2011)

Und wenn Du wirklich Schrittmotore einsetzt und die Ansteuerung selbst machst sieh Dir mal den Bresenham-Algorithmus an.


----------



## htw (10 März 2011)

Dieses Teil wird für ne Art Showroom gebaut. Es soll Schülern und Studien-Interessierte locken. 
Darum sollen auch mit dem Stift Figuren gezeichnet werden (Kreis, Dreieck, ect), um z.b. Spielchen damit zu machen, z.B. einen Kreis versuchen manuell zu fahren. Die Interessierten könnten somit die X und Y Achsen direkt steuern. Eventuell könnte man auch nen Wettbewerb aufziehen, wer den besten Kreis malt (die Aktualwerte vergleichen mit den ideellen die im DB hinterlegt sind und daraus die Abweichung berechnen) ....

Tut mir Leid, hätt ich vllt noch sagen müssen, wobei s an meinen Problemen ja nichts ändert.


----------



## Drutbluck (11 März 2011)

Ich würde mich beim Programmieren mehr am Stand der Technik orientieren, auch wenn es mit Step7 realisiert wird. Wir haben 2011.

Mathematische Berechnungen, Interpolation, Arrayzugriffe manuell nach AWL zu kompilieren und das Ergebnis weiterzuentwickeln ist vor allem ein hoher Zeitaufwand und führt zum Risiko von schwer nachvollziehbaren Fehlern, weil ein Pointer sonstwohin zeigt.

Das ist gerechtfertigt, wenn die Anforderung "AWL oder Assembler" ist oder ausreichend Stunden geschoben werden müssen, damit die Arbeit anerkannt wird.

Andernfalls gilt: Die Formeln so aufschreiben, wie bereits gesehen, ein paar Semikolons hinzufügen, Variablen deklarieren mit "_" statt "-" im Namen und ansonsten die Fehlermeldungen des SCL-Compilers beachten. Ähnlich wie VBA. Das spart sehr viel.

Weiterer Hinweis: Wenn es eine "billige" SPS ist, sollte die Berechnung auch in Echtzeit gehen, die sind nämlich schnell genug. Teure SPSe eines renommierten Herstellers  sind vielleicht zu langsam, dann wird das Array als Zwischenschritt notwendig.

Step7 hat ein Feature "Externe Quelle". Damit lassen sich zB komplette DBs, die als Quellcode vorliegen (zB mit VBA erzeugt), einlesen. Wenn ein DB von außen vorbelegt werden soll, der mehr als ca. 10 Werte enthält, geht das um ein Vielfaches schneller. Mit "Quelle generieren" und "Quelle exportieren" kann man Beispiele erzeugen.

Beim Kreismalwettbewerb werden natürlich die real angefahrenen Positionen in DBs gespeichert und dann "in Ruhe" mit der Berechnung selbst verglichen.

Zur Kommunikation mit den Achsen: Ich weiß nicht, wie man das normalerweise macht, damit es so langsam und schwierig wird. Ich gebe immer einen Analogwert für die Geschwindigkeit vor und bekomme einen Inkrementalgeber-Wert für die Istposition. Damit klappt das Kreise fahren sehr gut, besonders wenn es nur fürs Auge ist, es erfordert aber noch eine Regelung in Software. Wenn immer Stützpunkte an den Regler zu übergeben sind, ist es schwierig, eine konstante Geschwindigkeit zu erreichen. Der Regler ist immer "schon fast da" und fährt variabel langsam an den Punkt heran. Da hilft es vielleicht, immer einen außerhalb des Kreises liegenden Punkt (auf der Tangente vom aktuellen Punkt aus) vorzugeben, damit die Servos sich durchgehend bewegen. Dann natürlich nicht warten, bis der Punkt erreicht ist, sondern sofort den nächsten vorgeben. Damit habe ich keine Erfahrung, ist nur so eine Idee.


----------



## htw (11 März 2011)

Danke. Das ist ein völlig neuer Ansatz. Werde mir dann doch mal SCL anschaun. 
Das Teil sollte am besten über ein Touchpanel gesteuert werden.
Mit SCL die Berechnungen durchzuführen scheint viel "edeler" als alle in AWL zu programmieren und mit verschied Variablen und Lokalvariabeln um sich zu werfen.

Jetzt muss ich aber erstmal schauen, ob wir an der Hochschule überhaupt SCL verwenden. Die Frage ist, wenn nicht, was dann?
Bleibt mir ja nur der AWL Weg.
Außer ich lass meine Berechnungen in VBA stattfinden und Übertrag sie dann per libnodave (damit könnte die Übertragung stattfinden, hab ich gelesen, aber noch keine Erfahrung damit). Damit muss aber immer ein PC angeschlossen sein.


----------



## Drutbluck (11 März 2011)

Wenn SCL nicht verfügbar ist, würde ich es immer noch für sinnvoll halten, geeignete Teile des Programms in einer Hochsprache (zB SCL) zu schreiben und dann schlimmstenfalls manuell nach AWL zu kompilieren. Zumindest ist es dann "in lesbar" vorhanden.

Vielleicht kann der Fachbereich Informatik - Compilerbau eine Semesterarbeit anbieten, Thema "SCL nach AWL Compiler". Oder besser "C nach AWL" 



htw schrieb:


> Außer ich lass meine Berechnungen in VBA stattfinden und Übertrag sie dann per libnodave (damit könnte die Übertragung stattfinden, hab ich gelesen, aber noch keine Erfahrung damit). Damit muss aber immer ein PC angeschlossen sein.



DAS ist mal eine gute Idee. Einerseits kann man in einigen Bedienoberflächen-Erstell-Tools (wie WinCCflex) auch Basic-Funktionen erstellen und mit der SPS kommunizieren.

Aber wenn eine Übertragung mit libnodave zur Laufzeit klappt, sind die Einsatzmöglichkeiten endlos...

Das Touchpanel ist wahrscheinlich ohnehin ein PC. Und wenn der nicht mehr da ist, fährt die Maschine ihre letzte Bewegung fertig, wie wenn es keine neue Eingabe gibt.


----------



## htw (23 Mai 2011)

So ... nach einer lange Zeit hat sich so einiges getan ...

Durch die vielen Beiträge ist mir klar geworden, dass meine ersten Gedanken zu diesem Thema einfach zu naiv waren.
Des Weiteren gibt es schon Baugruppen die interpolieren können. So habe ich dann eine Mail an Siemens geschrieben mit der Bitte um Unterstützung. Es kam prompt eine positive Rückmeldung und einer Einladung direkt zu Siemens.

Der Status Quo sieht nun wie folgt aus:

Siemens sponsert mir eine *D435 Simotion* und die nötigen Antriebe (*Sinamics*).
Derzeit programmiere ich nun an einem Trainings- und Simulationskoffer von Siemens bis die nötigen Komponenten bestellt und die ganze Bürokratie von Tisch ist.

Probleme bestimmte Positionen anzufahren gibts es natürlich nicht mehr, da es schon fertige Bausteine gibt, die alle Rechenarbeit erledigen.

Ich programmiere auch nun in *ST*. Habe mich jetzt 1,5 Wochen reingefitzt und es läuft ganz gut, doch es ergeben sich hin und wieder Fragen, die ihr mir eventuell beantworten könnt!

_Hoffe das passt überhaupt noch in den Threat (von Thema her)._


-Wie kann ich in ST eine Flankenabfrage realisieren?

mit R_TRIG ? leider steht in der Hilfe kein konkretes Beispiel, an welchem ich mich orientieren könnte.


VIELEN DANK an euch!


----------



## Larry Laffer (23 Mai 2011)

htw schrieb:


> Wie kann ich in ST eine Flankenabfrage realisieren?
> 
> mit R_TRIG ? leider steht in der Hilfe kein konkretes Beispiel, an welchem ich mich orientieren könnte.


 
Hallo,
das würde ich so machen :
	
	



```
if myAction and not myAction_OK then
 
... tue, was zu tun ist ...
 
end_if ;
myAction_OK := myAction ;
```
... hierbei wäre myAction_OK dann ein BOOL und im Bereich der VAR-Deklaration (also Statisch) angeordnet.
Dieses Bit könnte nun auch sehr schön die Bestätigung darstellen, dass der Befehl ausgeführt worden ist (möglicherweise als Feedback an das aufrufende Programmteil).

Gruß
Larry


----------



## htw (23 Mai 2011)

die " If- Anweisung" ist mir klar.

Die Syntax mit R_TRIG jedoch nicht.

Trotzdem Danke!


----------



## htw (23 Mai 2011)

ok ... habs =)

Da sucht man ewig und plötzlich gehts ... und es ist einem "clear as crystal".


----------

