Positionsdaten für verschiedene Typen u. Positionen sichern

Alyot

Level-1
Beiträge
12
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Ihr
ich hab ein kleines Problem bei dem ich nicht weiter weis.
Ich habe eine Anlage mit der ich Scheiben mit einem 3 Achs Handling abhole. Das Handling wird über über 3 SEW Servomotoren angesteuert. Mein Problem liegt darin das es ca. 150 Scheibensorten gibt. Für jeden Typ gibt es eigene Abholpositionen. Ich hab jetzt mal einen Datenbaustein angelegt für 10 Typen mit je 50 Postionen pro Achse.

Mein Problem liegt darin das wenn ich eine zu sichernde Position im TP angefahren habe möchte ich diese unter Berücksichtigung des jeweiligen Typs und der Positionsnummer in den richtigen Bereich des schon genannten Bausteins übertragen ohne mir die Finger abtippen zu müssen ( Da ich die Typen ja auf 150 erweitern können muss).

Ich würde mich freuen wenn mir jemand weiterhelfen könnte.
 
Also hast Du aber für jeden Scheibentyp mehr als nur eine Abholposition, wenn ich das richtig verstanden habe?:confused:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich probiers mal einfach so.

Eins vorweg:

Du hast 150 Type mit 50 Positionen, mit 3 Achspositionen pro Position:

Das gibt 150 * 50 * 3 *4Byte (4 byte pro Achspos, da Du wahrscheinlich Rela verwenden möchtest ?!)

Das gibt 90.000 Byte! Also schon mal eine Speicherkarte beiseite schaffen:ROFLMAO:

Wenn Du Typ und Positionsnummer vorgibst, kannst Du wie folgt vorgehen:

Du hast pro Typ 50 Achspositionen mit jeweils 12 Byte (3*4). Dann hat ein Typ einen Speicherbedarf von 600 Byte.

Dann kannst Du die Startadresse Deines Type errechnen:

Startadresse = (Typnummer -1) * 600

Die Startadresse Deiner Positionsnummer ist (Positionsnummer -1)*12

Als Gesamtstartadresse ergibt sich dann

Adresse = ((Typnummer -1) * 600) + ((Positionsnummer -1)*12)

Je nach Position (nenn ich mal X, Y und Z) musst Du auf diese Adresse noch 0, 4 oder 8 Byte addieren und Du hast direkten Zugriff auf Deine Speicheradresse.

Je nach CPU sind die DB's aber nicht unendlich groß. Eine 315 hat eine maximale Größe von 16k (-> glaube ich) Du musst also für dieses Vorgehen Deine Daten auf mehrere DB's verteilen.

Wenn Du SCL - Benutzer bist, wäre das Vorgehen dasselbe, jedoch kannst Du dann einfach per Index auf Deine Arrays zugreifen. -> Einfacher -> übersichtlicher -> lesbarer -> Würde ich an Deiner Stelle machen :ROFLMAO:

Eine andere Möglichkeit wäre, Deine Daten per Rezeptur auf Deinem OP abzulegen. Dazu müsste dann Dein OP aber auch genügend Speicher haben. Dazu müsste man aber wissen, ob und was für ein OP Du verwendest.
 
Danke erst mal für die Antwort. Zu den Abholpositionen ist zu sagen das Sie zwischen 2 u. 18 (je nach Scheibentyp betragen). Als CPU habe ich eine 315-2-DP drin und ein TP177B. Über Rezepturen habe ich auch schon nachgedacht aber ich komme irgenwie auf keinen grünen zweig. Ich könnte höchsten die Pos in den rezepturen hinterlegen das wäre das einzige was mir noch einfällt. und schon ein wenig viel zwecks der übersichtlichkeit.
 
Zuletzt bearbeitet:
Ok, habe mal beim 177B nachgesehen, es hat standardmäßig 32k. Selbst mit 20 (oder 18) Positionen pro Typ liegst Du dann bei knapp über 32k.

Nochmal zur Vorgehensweise:

Du hast eine bestimmte Position angefahren und möchtest diese abspeichern (unter einem Typ und einer Positionsnummer)


Du hast pro Typ nur noch 20 Achspositionen mit jeweils 12 Byte (3*4). Dann hat ein Typ einen Speicherbedarf von 240 Byte.

Startadresse(Typ) = (Typnummer -1) * 240
Startadresse(PosNummer) = (Positionsnummer -1)*12

Adresse = ((Typnummer -1) * 240) + ((Positionsnummer -1)*12)

Beispiel : Typnummer =3, Positionsnummer = 5

Dann bekommst Du: ((3-1)*240) + ((5-1)*12) = 2*240 + 4*12 = 528

Die Position der X-Achse ist dann 528 + 0 = 528
Die Position der Y-Achse ist dann 528 + 4 = 532
Die Position der Z-Achse ist dann 528 + 8 = 536

Dann lädst Du Deine Positionen und speicherst Sie:

Auf (Dein_Daten_DB)
L Aktuelle_Position_der_X_Achse
T DBD[528]
L Aktuelle_Position_der_Y_Achse
T DBD[532]
L Aktuelle_Position_der_Z_Achse
T DBD[536]

Zum Laden dann umgekehrt:

Auf (Dein_Daten_DB)
L DBD[528]
T Aktuelle_Position_der_X_Achse
L DBD[532]
T Aktuelle_Position_der_Y_Achse
L DBD[536]
T Aktuelle_Position_der_Z_Achse

Anstelle der direkten Adressangabe in den eckigen Klammern setzt Du dann jeweils eine Variable ein. (muss ein Doppelwort sein, müsste ich mal nachsehen)

Also z.B.
L DBD[Mein_DW_Mit_Adresse]
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das hört sich so an, als wenn, je nach Scheibengröße, mehrere Scheiben in Position liegen und dann geholt werden.
Kann man die Positionen evtl. mit Hilfe der Scheibengröße und Offsetfaktoren für jede Scheibensorte und Achse berechnen? Damit ließe sich der Variablenaufwand erheblich eindampfen.
 
@Ralle

Zitat:
Das geht so ähnlich leider nur in SCL, nicht aber in AWL. In AWL muß indirekte Adressierung genutzt werden. Siehe dazu in der FAQ.

Doch, das geht so in AWL. Mache ich fast ständig so wenn ich nicht SCl verwenden will.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Einen Fehler gibts aber doch noch:

um die Byte-Adresse zu errechnen muss man die variable Adresse noch mit
8 multiplizieren oder gleich das Pointer-Format verwenden.

Für den Zugriff auf Byte 9 eines DB's z.B.:

L P#9.0
T Mein_DW_Mit_Adresse
L DBD[Mein_DW_Mit_Adresse]

oder

L 72 // (8*9)
T Mein_DW_Mit_Adresse
L DBD[Mein_DW_Mit_Adresse]
 
So hab jetzt schon gemerkt das ich noch a wenig blöd bin.:ROFLMAO:

Im TP177 kann man so viel ich weis noch ne 8MB Speicherkarte einstecken.

Mit berechnen schauts denk ich mal schlecht aus, auf grund der unterschiedlicher lage je nach typ.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Du hast gesagt, das folgendes nicht geht:

L DBD[Mein_DW_Mit_Adresse]

Das funktioniert aber.

Und wenn ich jetzt mal auf die Pointer verzichte (Px.y), und den Wert "Mein_DW_Mit_Adresse" mit 8 multipliziere, funktioniert das auch ohne das ein Pointer verwendet wurde.

Das ist natürlich indirekte Adressierung aber oben genannte Vorgehensweise funktioniert aber.
 
@ Alyot

Zitat:
Im TP177 kann man so viel ich weis noch ne 8MB Speicherkarte einstecken.

Mach Dich doch aber trotzdem schlau, ob Du diesen Speicher als Rezepturspeicher verwenden kannst. Sonst helfen Dir diese 8MB's auch nicht weiter
 
Auf (Dein_Daten_DB)
L DBD[528]
T Aktuelle_Position_der_X_Achse
L DBD[532]
T Aktuelle_Position_der_Y_Achse
L DBD[536]
T Aktuelle_Position_der_Z_Achse

Anstelle der direkten Adressangabe in den eckigen Klammern setzt Du dann jeweils eine Variable ein. (muss ein Doppelwort sein, müsste ich mal nachsehen)

Also z.B.
L DBD[Mein_DW_Mit_Adresse]

Darauf hatte ich mich bezogen, das legte eher nahe, daß er die 532 als Variable an L DBD[...] übergeben soll. Ok, ich hätte halt gleich dazuschreiben müssen, wie man den Pointer bildet ;), aber das hast du ja dann noch nachgeholt.
 
Zurück
Oben